GROOVY-12105: Unqualified super.m(...) from a static trait method throws MissingMethodException — should be a compile error

Author: paulk-asert

src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java

@@ -30,6 +30,7 @@
 import org.codehaus.groovy.ast.Variable;
 import org.codehaus.groovy.ast.expr.ArgumentListExpression;
 import org.codehaus.groovy.ast.expr.BinaryExpression;
+import org.codehaus.groovy.ast.expr.ClassExpression;
 import org.codehaus.groovy.ast.expr.ClosureExpression;
 import org.codehaus.groovy.ast.expr.ConstantExpression;
 import org.codehaus.groovy.ast.expr.DeclarationExpression;
@@ -119,6 +120,28 @@ public Expression transform(final Expression exp) {
             return transformBinaryExpression((BinaryExpression) exp);
         } else if (exp instanceof MethodCallExpression mce) {
             String obj = mce.getObjectExpression().getText();
+            // GROOVY-12105: in a static trait method, the parser/resolver
+            // rewrites `super.m(...)` to a static call on the trait's
+            // declared superclass (typically Object) before we see it. Reject
+            // that pattern at compile time, pointing at `T.super.m(...)` as
+            // the supported explicit form. The discriminator is
+            // `mce.isImplicitThis()`: the rewritten super call carries
+            // `isImplicitThis=true` (because the user wrote no explicit
+            // receiver — the ClassExpression was synthesised by the
+            // resolver), while an explicit `ClassName.m()` call from
+            // user source has `isImplicitThis=false`. The synthesised
+            // ClassExpression also has no source position (line=-1), an
+            // independent signal of the same fact.
+            if (ClassHelper.isClassType(weaved.getOriginType())
+                    && mce.isImplicitThis()
+                    && mce.getObjectExpression() instanceof ClassExpression ce
+                    && traitClass.getSuperClass() != null
+                    && ce.getType().equals(traitClass.getSuperClass())) {
+                unit.addError(new SyntaxException(
+                        "'super' is not allowed in a static trait method; use '" + traitClass.getNameWithoutPackage() + ".super." + mce.getMethodAsString() + "(...)' for explicit trait-anchored dispatch",
+                        mce.getLineNumber(), mce.getColumnNumber()));
+                return mce;
+            }
             if ("super".equals(obj)) {
                 return transformSuperMethodCall(mce); // super.m(x) --> $self.Ttrait$super$m(x)
             } else if ("this".equals(obj)) {

src/test/groovy/org/codehaus/groovy/transform/traitx/Groovy12105.groovy

@@ -0,0 +1,150 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.codehaus.groovy.transform.traitx
+
+import org.codehaus.groovy.control.MultipleCompilationErrorsException
+import org.junit.Test
+
+import static groovy.test.GroovyAssert.assertScript
+import static groovy.test.GroovyAssert.shouldFail
+
+/**
+ * Unqualified {@code super.m(...)} from a static trait method is rejected
+ * at compile time (GROOVY-12105). Without the reject, the call previously
+ * compiled successfully and threw {@code MissingMethodException} at
+ * runtime — the trait helper does not walk the trait chain for statics.
+ * The supported explicit form is {@code T.super.m(...)} (GEP-22 § this,
+ * super, and stackable traits item 3).
+ *
+ * <p>This restriction applies to <em>trait</em> static methods only.
+ * Groovy continues to permit unqualified {@code super.m(...)} in static
+ * methods of plain classes, where it dispatches to the superclass's
+ * static method (Java-conventional behaviour for class hierarchies) —
+ * see {@link #unqualifiedSuper_inPlainClassStatic_stillWorks()}.
+ */
+final class Groovy12105 {
+
+    /** Unqualified super in static trait method → compile error. */
+    @Test
+    void unqualifiedSuper_inStaticTraitMethod_isCompileError() {
+        def err = shouldFail(MultipleCompilationErrorsException) {
+            assertScript '''
+                trait Base {
+                    static String m() { 'Base' }
+                }
+                trait V extends Base {
+                    static String m() { 'V' }
+                    static callSuper() { super.m() }   // <-- rejected
+                }
+                class Impl implements V { }
+                Impl.callSuper()
+            '''
+        }
+        assert err.message.contains("'super' is not allowed in a static trait method")
+        assert err.message.contains('V.super.m(')
+    }
+
+    /** Unqualified super in static trait method, no super-trait → compile error. */
+    @Test
+    void unqualifiedSuper_inStaticTraitMethod_noSuperTrait_isCompileError() {
+        def err = shouldFail(MultipleCompilationErrorsException) {
+            assertScript '''
+                trait V {
+                    static String m() { 'V' }
+                    static callSuper() { super.m() }   // <-- rejected even without a super-trait
+                }
+                class Impl implements V { }
+                Impl.callSuper()
+            '''
+        }
+        assert err.message.contains("'super' is not allowed in a static trait method")
+    }
+
+    /** The supported explicit form T.super.m() still works for static methods. */
+    @Test
+    void traitQualifiedSuper_inStaticTraitMethod_works() {
+        assertScript '''
+            trait V {
+                static String m() { 'V' }
+                static callTSuper() { V.super.m() }    // explicit, supported
+            }
+            class Impl implements V { }
+            assert Impl.callTSuper() == 'V'
+        '''
+    }
+
+    /** Unqualified super in an INSTANCE trait method is unaffected (regression guard). */
+    @Test
+    void unqualifiedSuper_inInstanceTraitMethod_stillWorks() {
+        assertScript '''
+            trait Base {
+                def m() { 'Base' }
+            }
+            trait V extends Base {
+                def m() { 'V' }
+                def callSuper() { super.m() }   // instance method, walks chain → 'Base'
+            }
+            class Impl implements V { }
+            assert new Impl().callSuper() == 'Base'
+        '''
+    }
+
+    /** Plain (non-trait) class static super.m() is unaffected (the reject is trait-only). */
+    @Test
+    void unqualifiedSuper_inPlainClassStatic_stillWorks() {
+        assertScript '''
+            class Base {
+                static String m() { 'Base' }
+            }
+            class Sub extends Base {
+                static String m() { 'Sub' }
+                static String callSuper() { super.m() }
+            }
+            assert Sub.callSuper() == 'Base'
+        '''
+    }
+
+    /**
+     * Explicit class-qualified static calls in a trait static body — even
+     * to the trait's own declared superclass — must NOT be rejected. The
+     * reject heuristic relies on {@code isImplicitThis()} being true (set
+     * by the resolver when it rewrites {@code super.m()} into a
+     * synthesised {@code ClassExpression}); explicit user-written
+     * {@code ClassName.m()} calls have {@code isImplicitThis()} false and
+     * are left alone.
+     */
+    @Test
+    void explicitObjectStaticCall_inTraitStatic_isAllowed() {
+        // Object.toString() is technically a method-not-found at runtime (it's
+        // an instance method), but the static-analysis surface that matters
+        // here is whether the call is REJECTED BY THE TRAIT TRANSFORM. It
+        // must reach the runtime, where MOP behaviour takes over.
+        assertScript '''
+            trait V {
+                static String describe() {
+                    try { Object.toString() } catch (any) { 'mop-not-found' }
+                }
+            }
+            class Impl implements V { }
+            // No compile error — the heuristic distinguishes this from
+            // a rewritten super.m() call via mce.isImplicitThis().
+            assert Impl.describe() in ['java.lang.Object', 'class java.lang.Object', 'mop-not-found']
+        '''
+    }
+}

src/test/groovy/org/codehaus/groovy/transform/traitx/TraitStaticDispatchMatrix.groovy

@@ -538,17 +538,15 @@ class TraitStaticDispatchMatrix {
         }
     }
 
-    // ---- Row 15 — unqualified super.m() from trait STATIC method (proposed compile error) ----
-    // Companion to row 14, same workstream. Unqualified `super.m()` inside a
-    // trait instance method walks the trait chain (spec item 2); from a trait
-    // STATIC method the chain is not walked and the call throws
-    // MissingMethodException at runtime. GEP-22 item 4 proposes rejecting
-    // the static-context use at compile time, leaving `T.super.m()` as the
-    // explicit form. NYI until the fix lands; flips red on a build that
-    // implements the rejection.
+    // ---- Row 15 — unqualified super.m() from trait STATIC method (GROOVY-12105) ----
+    // Unqualified `super.m()` inside a trait instance method walks the trait
+    // chain (spec item 2); from a trait STATIC method the chain is not
+    // walked. GROOVY-12105 rejects the static-context use at compile time,
+    // pointing at `T.super.m()` as the explicit form. See Groovy12105.groovy
+    // for focused coverage (regression-guards for the instance-method and
+    // plain-class super-call cases). This row is the matrix-level anchor.
     @Test
-    @NotYetImplemented
-    void row15_unqualified_static_super_inTrait_shouldBeCompileError_PROPOSED() {
+    void row15_unqualified_static_super_inTrait_isCompileError() {
         GroovyAssert.shouldFail(MultipleCompilationErrorsException) {
             ev '''
                 trait Base { static String m() { 'Base' } }