You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by em...@apache.org on 2024/01/30 16:24:47 UTC

(groovy) 01/02: GROOVY-11299: `getSuperClass()` shouldn't return an interface or a trait

This is an automated email from the ASF dual-hosted git repository.

emilles pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git

commit 710ff9e7b4e195b35ec5ff8b506783394221876a
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Tue Jan 30 08:47:21 2024 -0600

    GROOVY-11299: `getSuperClass()` shouldn't return an interface or a trait
    
    GROOVY-8272, GROOVY-10312: super trait static method redesign
---
 .../java/org/codehaus/groovy/ast/ClassNode.java    | 11 ++-
 .../groovy/control/StaticImportVisitor.java        | 45 ++++++-----
 .../transform/stc/TraitTypeCheckingExtension.java  |  6 +-
 .../transform/trait/TraitReceiverTransformer.java  | 86 ++++++++++------------
 .../groovy/transform/traitx/Groovy7214Bug.groovy   | 42 -----------
 .../traitx/TraitASTTransformationTest.groovy       | 22 +++++-
 6 files changed, 94 insertions(+), 118 deletions(-)

diff --git a/src/main/java/org/codehaus/groovy/ast/ClassNode.java b/src/main/java/org/codehaus/groovy/ast/ClassNode.java
index 9d1b65316d..2fe66e16fe 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassNode.java
@@ -51,6 +51,7 @@ import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.toList;
 import static org.apache.groovy.ast.tools.MethodNodeUtils.getCodeAsBlock;
 import static org.codehaus.groovy.transform.RecordTypeASTTransformation.recordNative;
+import static org.codehaus.groovy.transform.trait.Traits.isTrait;
 import static org.objectweb.asm.Opcodes.ACC_ABSTRACT;
 import static org.objectweb.asm.Opcodes.ACC_ANNOTATION;
 import static org.objectweb.asm.Opcodes.ACC_ENUM;
@@ -397,9 +398,13 @@ public class ClassNode extends AnnotatedNode {
         if (!lazyInitDone && !isResolved()) {
             throw new GroovyBugError("ClassNode#getSuperClass for " + getName() + " called before class resolving");
         }
-        ClassNode sn = redirect().getUnresolvedSuperClass();
-        if (sn != null) sn = sn.redirect();
-        return sn;
+        var sc = redirect().getUnresolvedSuperClass();
+        if (sc != null) {
+            sc = sc.redirect();
+            if (isPrimaryClassNode() && (sc.isInterface() || isTrait(sc)))
+                sc = ClassHelper.OBJECT_TYPE; // GROOVY-8272, GROOVY-11299
+        }
+        return sc;
     }
 
     public void setSuperClass(final ClassNode superClass) {
diff --git a/src/main/java/org/codehaus/groovy/control/StaticImportVisitor.java b/src/main/java/org/codehaus/groovy/control/StaticImportVisitor.java
index 99bfaf6a83..999f945231 100644
--- a/src/main/java/org/codehaus/groovy/control/StaticImportVisitor.java
+++ b/src/main/java/org/codehaus/groovy/control/StaticImportVisitor.java
@@ -65,12 +65,12 @@ import static org.apache.groovy.ast.tools.ClassNodeUtils.isInnerClass;
 import static org.apache.groovy.ast.tools.ClassNodeUtils.isValidAccessorName;
 import static org.apache.groovy.ast.tools.ClassNodeUtils.samePackageName;
 import static org.apache.groovy.ast.tools.ExpressionUtils.isSuperExpression;
-import static org.apache.groovy.ast.tools.ExpressionUtils.isThisOrSuper;
 import static org.apache.groovy.ast.tools.ExpressionUtils.transformInlineConstants;
 import static org.apache.groovy.util.BeanUtils.capitalize;
 import static org.codehaus.groovy.ast.tools.ClosureUtils.getParametersSafe;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.getGetterName;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.getSetterName;
+import static org.codehaus.groovy.transform.trait.Traits.isTrait;
 
 /**
  * Visitor to resolve constants and method calls from static imports.
@@ -271,43 +271,42 @@ public class StaticImportVisitor extends ClassCodeExpressionTransformer {
             return result;
         }
 
-        if (method instanceof ConstantExpression && ((ConstantExpression) method).getValue() instanceof String && (mce.isImplicitThis() || isThisOrSuper(object))) {
-            String methodName = (String) ((ConstantExpression) method).getValue();
+        if (method instanceof ConstantExpression && ((ConstantExpression) method).getValue() instanceof String
+                && mce.isImplicitThis() && !isTrait(currentClass)) { // GROOVY-7191, GROOVY-8272, GROOVY-10312
+            String name = mce.getMethodAsString();
 
-            boolean foundInstanceMethod = !staticWrtCurrent && currentClass.hasPossibleMethod(methodName, args);
+            boolean foundInstanceMethod = !staticWrtCurrent && currentClass.hasPossibleMethod(name, args);
 
             Predicate<ClassNode> hasPossibleStaticMember = cn -> {
-                if (hasPossibleStaticMethod(cn, methodName, args, true)) {
+                if (hasPossibleStaticMethod(cn, name, args, true)) {
                     return true;
                 }
-                // GROOVY-9587: don't check for property for non-empty call args
+                // GROOVY-9587: skip property check for non-empty call arguments
                 if (args instanceof TupleExpression && ((TupleExpression) args).getExpressions().isEmpty()
-                        && hasPossibleStaticProperty(cn, methodName)) {
+                        && hasPossibleStaticProperty(cn, name)) {
                     return true;
                 }
                 return false;
             };
 
-            if (mce.isImplicitThis()) {
-                if (isInnerClass(currentClass)) {
-                    if (inSpecialConstructorCall && !foundInstanceMethod) {
-                        // check for reference to outer class method in this(...) or super(...)
-                        if (currentClass.getOuterClass().hasPossibleMethod(methodName, args)) {
-                            object = new PropertyExpression(new ClassExpression(currentClass.getOuterClass()), new ConstantExpression("this"));
-                        } else if (hasPossibleStaticMember.test(currentClass.getOuterClass())) {
-                            Expression result = new StaticMethodCallExpression(currentClass.getOuterClass(), methodName, args);
-                            result.setSourcePosition(mce);
-                            return result;
-                        }
-                    }
-                } else if (inSpecialConstructorCall || (!inClosure && !foundInstanceMethod && !methodName.equals("call"))) {
-                    // check for reference to static method in this(...) or super(...) or when call not resolved
-                    if (hasPossibleStaticMember.test(currentClass)) {
-                        Expression result = new StaticMethodCallExpression(currentClass, methodName, args);
+            if (isInnerClass(currentClass)) {
+                if (inSpecialConstructorCall && !foundInstanceMethod) {
+                    // check for reference to outer class method in this(...) or super(...)
+                    if (currentClass.getOuterClass().hasPossibleMethod(name, args)) {
+                        object = new PropertyExpression(new ClassExpression(currentClass.getOuterClass()), new ConstantExpression("this"));
+                    } else if (hasPossibleStaticMember.test(currentClass.getOuterClass())) {
+                        Expression result = new StaticMethodCallExpression(currentClass.getOuterClass(), name, args);
                         result.setSourcePosition(mce);
                         return result;
                     }
                 }
+            } else if (inSpecialConstructorCall || (!inClosure && !foundInstanceMethod && !name.equals("call"))) {
+                // check for reference to static method in this(...) or super(...) or when call not resolved
+                if (hasPossibleStaticMember.test(currentClass)) {
+                    Expression result = new StaticMethodCallExpression(currentClass, name, args);
+                    result.setSourcePosition(mce);
+                    return result;
+                }
             }
         }
 
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/TraitTypeCheckingExtension.java b/src/main/java/org/codehaus/groovy/transform/stc/TraitTypeCheckingExtension.java
index cb0e316409..f0b2b9157e 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/TraitTypeCheckingExtension.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/TraitTypeCheckingExtension.java
@@ -72,10 +72,10 @@ public class TraitTypeCheckingExtension extends AbstractTypeCheckingExtension {
 
         if (call instanceof MethodCallExpression) {
             MethodCallExpression mce = (MethodCallExpression) call;
-            ClassNode dynamic = mce.getNodeMetaData(TraitASTTransformation.DO_DYNAMIC);
-            if (dynamic != null) return Collections.singletonList(makeDynamic(call, dynamic));
+            ClassNode returnType = mce.getNodeMetaData(TraitASTTransformation.DO_DYNAMIC);
+            if (returnType != null) return Collections.singletonList(makeDynamic(call, returnType));
 
-            // GROOVY-7322, GROOVY-8272, GROOVY-8587, GROOVY-8854: trait: this.m($static$self)
+            // GROOVY-7322, GROOVY-8272, GROOVY-8587, GROOVY-8854, GROOVY-10312: trait: this.m($static$self)
             ClassNode targetClass = isClassClassNodeWrappingConcreteType(receiver)? receiver.getGenericsTypes()[0].getType(): receiver;
             if (Traits.isTrait(targetClass.getOuterClass()) && argumentTypes.length > 0 && ClassHelper.isClassType(argumentTypes[0])) {
                 Parameter[] signature = java.util.Arrays.stream(argumentTypes).map(t -> new Parameter(t,"")).toArray(Parameter[]::new);
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java
index 3e91cb7261..7784ec31be 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java
@@ -37,7 +37,6 @@ import org.codehaus.groovy.ast.expr.Expression;
 import org.codehaus.groovy.ast.expr.FieldExpression;
 import org.codehaus.groovy.ast.expr.MethodCallExpression;
 import org.codehaus.groovy.ast.expr.PropertyExpression;
-import org.codehaus.groovy.ast.expr.StaticMethodCallExpression;
 import org.codehaus.groovy.ast.expr.TupleExpression;
 import org.codehaus.groovy.ast.expr.VariableExpression;
 import org.codehaus.groovy.control.SourceUnit;
@@ -101,31 +100,10 @@ class TraitReceiverTransformer extends ClassCodeExpressionTransformer {
         } else if (exp instanceof MethodCallExpression) {
             MethodCallExpression mce = (MethodCallExpression) exp;
             String obj = mce.getObjectExpression().getText();
-            if (mce.isImplicitThis() || "this".equals(obj)) {
-                return transformMethodCallOnThis(mce); // this.m(p) --> this.m($self, p)
-            } else if ("super".equals(obj)) {
-                return transformSuperMethodCall(mce); // super.m(p) --> $self.Ttrait$super$m(p)
-            }
-        } else if (exp instanceof StaticMethodCallExpression) {
-            StaticMethodCallExpression call = (StaticMethodCallExpression) exp;
-            if (call.getOwnerType().equals(traitClass)) {
-                // GROOVY-7191, GROOVY-8272, GROOVY-8854, GROOVY-10312: T.m(p) --> this.m($static$self, p)
-                Expression staticSelf = varX(weaved);
-                if (!ClassHelper.isClassType(weavedType)) {
-                    staticSelf = callX(staticSelf, "getClass");
-                    ((MethodCallExpression) staticSelf).setImplicitThis(false);
-                    staticSelf = castX(ClassHelper.CLASS_Type.getPlainNodeReference(), staticSelf);
-                }
-                MethodCallExpression mce = callX(
-                        varX("this"),
-                        call.getMethod(),
-                        createArgumentList(staticSelf, call.getArguments())
-                );
-                mce.setSafe(false);
-                mce.setSpreadSafe(false);
-                mce.setImplicitThis(false);
-                mce.setSourcePosition(exp);
-                return mce;
+            if ("super".equals(obj)) {
+                return transformSuperMethodCall(mce); // super.m(x) --> $self.Ttrait$super$m(x)
+            } else if ("this".equals(obj)) {
+                return transformMethodCallOnThis(mce); // this.m(x) --> $self.m(x) or this.m($self, x)
             }
         } else if (exp instanceof FieldExpression) {
             FieldNode fn = ((FieldExpression) exp).getField();
@@ -303,32 +281,25 @@ class TraitReceiverTransformer extends ClassCodeExpressionTransformer {
     }
 
     private Expression transformMethodCallOnThis(final MethodCallExpression call) {
-        Expression method = call.getMethod();
+        Expression method    = call.getMethod();
         Expression arguments = call.getArguments();
-        Expression thisExpr = call.getObjectExpression();
+        Expression thisExpr  = call.getObjectExpression();
 
         if (method instanceof ConstantExpression) {
-            String methodName = call.getMethodAsString();
-            for (MethodNode methodNode : traitClass.getMethods(methodName)) {
-                if (methodName.equals(methodNode.getName()) && (methodNode.isStatic() || methodNode.isPrivate())) {
-                    MethodCallExpression newCall;
-                    if (!inClosure && methodNode.isStatic()) { // GROOVY-10312: $self or $static$self.staticMethod(...)
-                        newCall = callX(varX(weaved), methodName, transform(arguments));
-                        newCall.setImplicitThis(false);
-                        newCall.setSafe(false);
-                    } else {
-                        ArgumentListExpression newArgs = createArgumentList(methodNode.isStatic() ? asClass(thisExpr) : weaved, arguments);
-                        newCall = callX(inClosure ? classX(traitHelperClass) : thisExpr, methodName, newArgs);
-                        newCall.setImplicitThis(true);
-                        newCall.setSafe(call.isSafe());
-                    }
-                    newCall.setSpreadSafe(call.isSpreadSafe());
-                    newCall.setSourcePosition(call);
-                    return newCall;
-                }
+            // GROOVY-7213, GROOVY-7214, GROOVY-8282, GROOVY-8859, GROOVY-10106, GROOVY-10312
+            MethodNode methodNode = findConcreteMethod(traitClass, call.getMethodAsString());
+            if (methodNode != null) {
+                // this.m(x) --> (this or T$Trait$Helper).m($self or $static$self or (Class)$self.getClass(), x)
+                Expression selfClassOrObject = methodNode.isStatic() && !ClassHelper.isClassType(weaved.getOriginType()) ? castX(ClassHelper.CLASS_Type.getPlainNodeReference(), callX(weaved, "getClass")) : weaved;
+                MethodCallExpression newCall = callX(!inClosure ? thisExpr : classX(traitHelperClass), method, createArgumentList(selfClassOrObject, arguments));
+                newCall.setGenericsTypes(call.getGenericsTypes());
+                newCall.setSpreadSafe(call.isSpreadSafe());
+                newCall.setSourcePosition(call);
+                return newCall;
             }
         }
 
+        // this.m(x) --> ($self or $static$self).m(x)
         MethodCallExpression newCall = callX(inClosure ? thisExpr : weaved, method, transform(arguments));
         newCall.setImplicitThis(inClosure ? call.isImplicitThis() : false);
         newCall.setSafe(inClosure ? call.isSafe() : false);
@@ -337,6 +308,29 @@ class TraitReceiverTransformer extends ClassCodeExpressionTransformer {
         return newCall;
     }
 
+    private static MethodNode findConcreteMethod(final ClassNode traitClass, final String methodName) {
+        for (MethodNode methodNode : traitClass.getDeclaredMethods(methodName)) {
+            if (methodNode.isPrivate() || methodNode.isStatic()) {
+                return methodNode;
+            }
+        }
+
+        // GROOVY-8272, GROOVY-10312: public static method from super trait
+        var traits = Traits.findTraits(traitClass); traits.remove(traitClass);
+
+        for (ClassNode superTrait : traits) {
+            for (MethodNode methodNode : Traits.findHelper(superTrait).getDeclaredMethods(methodName)) {
+                if (methodNode.isPublic() && methodNode.isStatic()
+                        // exclude public method with body as it's included in trait interface
+                        && ClassHelper.isClassType(methodNode.getParameters()[0].getType())) {
+                    return methodNode;
+                }
+            }
+        }
+
+        return null;
+    }
+
     private ArgumentListExpression createArgumentList(final Expression self, final Expression arguments) {
         ArgumentListExpression newArgs = new ArgumentListExpression();
         newArgs.addExpression(self);
diff --git a/src/test/org/codehaus/groovy/transform/traitx/Groovy7214Bug.groovy b/src/test/org/codehaus/groovy/transform/traitx/Groovy7214Bug.groovy
deleted file mode 100644
index 68f6c96ad8..0000000000
--- a/src/test/org/codehaus/groovy/transform/traitx/Groovy7214Bug.groovy
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- *  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 groovy.test.GroovyTestCase
-
-class Groovy7214Bug extends GroovyTestCase {
-    void testShouldAllowPrivateStaticMethodCallInTrait() {
-        assertScript '''
-            trait SomeTrait {
-                private static int magic = 0
-
-                static getSomeValue() {
-                    someHelperMethod()
-                    magic
-                }
-
-                private static someHelperMethod() {
-                    magic = 42
-                }
-            }
-            class SomeClass implements SomeTrait {}
-
-            assert SomeClass.someValue == 42'''
-    }
-}
diff --git a/src/test/org/codehaus/groovy/transform/traitx/TraitASTTransformationTest.groovy b/src/test/org/codehaus/groovy/transform/traitx/TraitASTTransformationTest.groovy
index 3b4e555a80..1b9aaf6ac5 100644
--- a/src/test/org/codehaus/groovy/transform/traitx/TraitASTTransformationTest.groovy
+++ b/src/test/org/codehaus/groovy/transform/traitx/TraitASTTransformationTest.groovy
@@ -1687,6 +1687,26 @@ final class TraitASTTransformationTest {
                 assert c.foo() == 1
                 assert c.foo() == 2
             """
+
+            // GROOVY-7214
+            assertScript shell, """
+                $mode
+                trait T {
+                    private static int x = 0
+                    private static initX() {
+                        x = 42
+                    }
+                    static getValue() {
+                        initX()
+                        x
+                    }
+                }
+                $mode
+                class C implements T {
+                }
+
+                assert C.value == 42
+            """
         }
     }
 
@@ -2933,7 +2953,7 @@ final class TraitASTTransformationTest {
             @SelfType(T)
             trait B implements A {
                 void methodB() {
-                    methodA() // Cannot find matching method <UnionType:T+B>#methodA()
+                    methodA() // Cannot find matching method (T & B)#methodA()
                 }
             }
             class C extends T implements B {