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 2023/09/13 17:33:23 UTC

[groovy] branch master updated: GROOVY-7213, GROOVY-8859: no trait bridge for private methods

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


The following commit(s) were added to refs/heads/master by this push:
     new 032ed6c508 GROOVY-7213, GROOVY-8859: no trait bridge for private methods
032ed6c508 is described below

commit 032ed6c5082f7e45ac4e7dfb6d3e578b61f5956d
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Wed Sep 13 12:32:54 2023 -0500

    GROOVY-7213, GROOVY-8859: no trait bridge for private methods
---
 .../groovy/transform/trait/TraitComposer.java      | 102 ++++++++-------------
 .../groovy/transform/traitx/Groovy7213Bug.groovy   |  40 --------
 .../traitx/TraitASTTransformationTest.groovy       |  42 +++++++--
 3 files changed, 72 insertions(+), 112 deletions(-)

diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
index 9520f59665..6a9091384d 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
@@ -31,16 +31,11 @@ import org.codehaus.groovy.ast.Parameter;
 import org.codehaus.groovy.ast.PropertyNode;
 import org.codehaus.groovy.ast.expr.ArgumentListExpression;
 import org.codehaus.groovy.ast.expr.ArrayExpression;
-import org.codehaus.groovy.ast.expr.BinaryExpression;
-import org.codehaus.groovy.ast.expr.CastExpression;
 import org.codehaus.groovy.ast.expr.ClassExpression;
-import org.codehaus.groovy.ast.expr.ConstantExpression;
 import org.codehaus.groovy.ast.expr.Expression;
 import org.codehaus.groovy.ast.expr.MethodCallExpression;
 import org.codehaus.groovy.ast.expr.StaticMethodCallExpression;
-import org.codehaus.groovy.ast.expr.VariableExpression;
 import org.codehaus.groovy.ast.stmt.EmptyStatement;
-import org.codehaus.groovy.ast.stmt.ExpressionStatement;
 import org.codehaus.groovy.ast.stmt.Statement;
 import org.codehaus.groovy.ast.tools.GeneralUtils;
 import org.codehaus.groovy.ast.tools.GenericsUtils;
@@ -50,8 +45,6 @@ import org.codehaus.groovy.control.SourceUnit;
 import org.codehaus.groovy.runtime.InvokerHelper;
 import org.codehaus.groovy.runtime.MetaClassHelper;
 import org.codehaus.groovy.syntax.SyntaxException;
-import org.codehaus.groovy.syntax.Token;
-import org.codehaus.groovy.syntax.Types;
 import org.codehaus.groovy.transform.ASTTransformationCollectorCodeVisitor;
 import org.codehaus.groovy.transform.sc.StaticCompileTransformation;
 import org.codehaus.groovy.transform.stc.StaticTypesMarker;
@@ -73,6 +66,7 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.assignX;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.block;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.callX;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.castX;
+import static org.codehaus.groovy.ast.tools.GeneralUtils.classX;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.constX;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.ifElseS;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.isInstanceOfX;
@@ -80,7 +74,6 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.nullX;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.returnS;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
-import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpecRecurse;
 
 /**
  * This class contains a static utility method {@link #doExtendTraits(org.codehaus.groovy.ast.ClassNode, org.codehaus.groovy.control.SourceUnit, org.codehaus.groovy.control.CompilationUnit)}
@@ -134,10 +127,10 @@ public abstract class TraitComposer {
             String name = methodNode.getName();
             Parameter[] helperMethodParams = methodNode.getParameters();
             int nParams = helperMethodParams.length;
-            if (nParams > 0 && !methodNode.isAbstract() && ((methodNode.getModifiers() & Opcodes.ACC_STATIC) != 0)
+            if (nParams > 0 && methodNode.isStatic() && !methodNode.isAbstract() && !methodNode.isPrivate() // GROOVY-7213, GROOVY-8859
                     && (!name.contains("$") || (methodNode.getModifiers() & Opcodes.ACC_SYNTHETIC) == 0)) {
                 ArgumentListExpression argList = new ArgumentListExpression();
-                argList.addExpression(new VariableExpression("this"));
+                argList.addExpression(varX("this"));
                 Parameter[] origParams = new Parameter[nParams - 1];
                 Parameter[] params = new Parameter[nParams - 1];
                 System.arraycopy(methodNode.getParameters(), 1, params, 0, params.length);
@@ -149,7 +142,7 @@ public abstract class TraitComposer {
                 for (int i = 1; i < nParams; i += 1) {
                     Parameter parameter = helperMethodParams[i];
                     ClassNode originType = parameter.getOriginType();
-                    ClassNode fixedType = correctToGenericsSpecRecurse(methodGenericsSpec, originType);
+                    ClassNode fixedType = GenericsUtils.correctToGenericsSpecRecurse(methodGenericsSpec, originType);
                     Parameter newParam = new Parameter(fixedType, parameter.getName());
                     List<AnnotationNode> copied = new LinkedList<>();
                     List<AnnotationNode> notCopied = new LinkedList<>();
@@ -157,23 +150,22 @@ public abstract class TraitComposer {
                     newParam.addAnnotations(copied);
                     params[i - 1] = newParam;
                     origParams[i - 1] = parameter;
-                    argList.addExpression(new VariableExpression(newParam));
+                    argList.addExpression(varX(newParam));
                 }
                 createForwarderMethod(trait, cNode, methodNode, originalMethod, helperClassNode, methodGenericsSpec, helperMethodParams, origParams, params, argList, unit);
             }
         }
-        MethodCallExpression staticInitCall = new MethodCallExpression(
-                new ClassExpression(helperClassNode),
+
+        MethodCallExpression staticInitCall = callX(
+                classX(helperClassNode),
                 Traits.STATIC_INIT_METHOD,
-                new ArgumentListExpression(new ClassExpression(cNode)));
+                classX(cNode));
         MethodNode staticInitMethod = new MethodNode(
                 Traits.STATIC_INIT_METHOD, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, ClassHelper.VOID_TYPE,
                 new Parameter[] {new Parameter(ClassHelper.CLASS_Type,"clazz")}, ClassNode.EMPTY_ARRAY, EmptyStatement.INSTANCE);
         staticInitMethod.setDeclaringClass(helperClassNode);
         staticInitCall.setMethodTarget(staticInitMethod);
-        cNode.addStaticInitializerStatements(Collections.singletonList(new ExpressionStatement(
-                staticInitCall
-        )), false);
+        cNode.addStaticInitializerStatements(Collections.singletonList(stmt(staticInitCall)), false);
         if (fieldHelperClassNode != null && !cNode.declaresInterface(fieldHelperClassNode)) {
             // we should implement the field helper interface too
             cNode.addInterface(fieldHelperClassNode);
@@ -205,7 +197,7 @@ public abstract class TraitComposer {
                     fieldName = fieldName.substring(0, suffixIdx);
                     String operation = methodNode.getName().substring(suffixIdx + 1);
                     boolean getter = "get".equals(operation);
-                    ClassNode returnType = correctToGenericsSpecRecurse(genericsSpec, methodNode.getReturnType());
+                    ClassNode returnType = GenericsUtils.correctToGenericsSpecRecurse(genericsSpec, methodNode.getReturnType());
                     int fieldMods = 0;
                     int isStatic = 0;
                     boolean publicField = true;
@@ -261,7 +253,7 @@ public abstract class TraitComposer {
                                     if (isStatic == 0) {
                                         cNode.addObjectInitializerStatements(stmt);
                                     } else {
-                                        List<Statement> staticStatements = new ArrayList<Statement>();
+                                        List<Statement> staticStatements = new ArrayList<>();
                                         staticStatements.add(stmt);
                                         cNode.addStaticInitializerStatements(staticStatements, true);
                                     }
@@ -274,7 +266,7 @@ public abstract class TraitComposer {
                         newParams = Parameter.EMPTY_ARRAY;
                     } else {
                         ClassNode originType = methodNode.getParameters()[0].getOriginType();
-                        ClassNode fixedType = originType.isGenericsPlaceHolder()?ClassHelper.OBJECT_TYPE:correctToGenericsSpecRecurse(genericsSpec, originType);
+                        ClassNode fixedType = originType.isGenericsPlaceHolder()?ClassHelper.OBJECT_TYPE:GenericsUtils.correctToGenericsSpecRecurse(genericsSpec, originType);
                         newParams = new Parameter[]{new Parameter(fixedType, "val")};
                     }
 
@@ -283,9 +275,8 @@ public abstract class TraitComposer {
                     Statement body =
                             getter ? returnS(fieldExpr) :
                                     (finalSetter ? null : stmt(
-                                            new BinaryExpression(
+                                            assignX(
                                                     fieldExpr,
-                                                    Token.newSymbol(Types.EQUAL, 0, 0),
                                                     varX(newParams[0])
                                             )
                                     ));
@@ -306,45 +297,27 @@ public abstract class TraitComposer {
                 }
             }
         }
-        cNode.addObjectInitializerStatements(new ExpressionStatement(
-                new MethodCallExpression(
-                        new ClassExpression(helperClassNode),
-                        Traits.INIT_METHOD,
-                        new ArgumentListExpression(new VariableExpression("this")))
+        cNode.addObjectInitializerStatements(stmt(
+                callX(classX(helperClassNode), Traits.INIT_METHOD, varX("this"))
         ));
     }
 
     private static void createForwarderMethod(
-            ClassNode trait,
-            ClassNode targetNode,
-            MethodNode helperMethod,
-            MethodNode originalMethod,
-            ClassNode helperClassNode,
-            Map<String, ClassNode> genericsSpec,
-            Parameter[] helperMethodParams,
-            Parameter[] traitMethodParams,
-            Parameter[] forwarderParams,
-            ArgumentListExpression helperMethodArgList, SourceUnit unit) {
-        MethodCallExpression mce = new MethodCallExpression(
-                new ClassExpression(helperClassNode),
+            ClassNode trait, ClassNode targetNode, MethodNode helperMethod, MethodNode originalMethod, ClassNode helperClassNode, Map<String, ClassNode> genericsSpec,
+            Parameter[] helperMethodParams, Parameter[] traitMethodParams, Parameter[] forwarderParams, ArgumentListExpression helperMethodArgList, SourceUnit unit) {
+        MethodCallExpression mce = callX(
+                classX(helperClassNode),
                 helperMethod.getName(),
                 helperMethodArgList
         );
         mce.setImplicitThis(false);
 
-        ClassNode[] exceptionNodes = correctToGenericsSpecRecurse(genericsSpec, copyExceptions(helperMethod.getExceptions()));
-        ClassNode fixedReturnType = correctToGenericsSpecRecurse(genericsSpec, helperMethod.getReturnType());
-        boolean noCastRequired = genericsSpec.isEmpty() || fixedReturnType.getName().equals(ClassHelper.VOID_TYPE.getName());
-        Expression forwardExpression = noCastRequired ? mce : new CastExpression(fixedReturnType,mce);
-        // we could rely on the first parameter name ($static$self) but that information is not
-        // guaranteed to be always present
-        boolean isHelperForStaticMethod = ClassHelper.isClassType(helperMethodParams[0].getOriginType());
-        if (helperMethod.isPrivate() && !isHelperForStaticMethod) {
-            // GROOVY-7213: do not create forwarder for private methods
-            return;
-        }
+        ClassNode[] exceptionTypes = GenericsUtils.correctToGenericsSpecRecurse(genericsSpec, copyExceptions(helperMethod.getExceptions()));
+        ClassNode returnType = GenericsUtils.correctToGenericsSpecRecurse(genericsSpec, helperMethod.getReturnType());
+        boolean castRequired = !genericsSpec.isEmpty() && !helperMethod.isVoidMethod();
+
         int modifiers = helperMethod.getModifiers();
-        if (!isHelperForStaticMethod) {
+        if (!ClassHelper.isClassType(helperMethodParams[0].getOriginType())) {
             modifiers &= ~Opcodes.ACC_STATIC;
         }
         // GROOVY-10467: added by classgen
@@ -353,10 +326,10 @@ public abstract class TraitComposer {
         MethodNode forwarder = new MethodNode(
                 helperMethod.getName(),
                 modifiers,
-                fixedReturnType,
+                returnType,
                 forwarderParams,
-                exceptionNodes,
-                new ExpressionStatement(forwardExpression)
+                exceptionTypes,
+                stmt(castRequired ? castX(returnType, mce) : mce)
         );
         List<AnnotationNode> copied = new LinkedList<>();
         List<AnnotationNode> notCopied = Collections.emptyList(); // at this point, should *always* stay empty
@@ -379,8 +352,8 @@ public abstract class TraitComposer {
         }
         // add a helper annotation indicating that it is a bridge method
         AnnotationNode bridgeAnnotation = new AnnotationNode(Traits.TRAITBRIDGE_CLASSNODE);
-        bridgeAnnotation.addMember("traitClass", new ClassExpression(trait));
-        bridgeAnnotation.addMember("desc", new ConstantExpression(BytecodeHelper.getMethodDescriptor(helperMethod.getReturnType(), traitMethodParams)));
+        bridgeAnnotation.addMember("traitClass", classX(trait));
+        bridgeAnnotation.addMember("desc", constX(BytecodeHelper.getMethodDescriptor(helperMethod.getReturnType(), traitMethodParams)));
         forwarder.addAnnotation(bridgeAnnotation);
 
         MethodNode existingMethod = findExistingMethod(targetNode, forwarder);
@@ -411,8 +384,7 @@ public abstract class TraitComposer {
             if (bridgeAnno != null) {
                 Expression traitClass = bridgeAnno.getMember("traitClass");
                 if (traitClass instanceof ClassExpression) {
-                    ClassExpression ce = (ClassExpression) traitClass;
-                    fromTrait = ce.getType().getNameWithoutPackage();
+                    fromTrait = traitClass.getType().getNameWithoutPackage();
                 }
             }
             middle = "in '" + targetNode.getNameWithoutPackage();
@@ -430,7 +402,7 @@ public abstract class TraitComposer {
 
     private static GenericsType[] removeNonPlaceHolders(GenericsType[] oldTypes) {
         if (oldTypes==null || oldTypes.length==0) return oldTypes;
-        ArrayList<GenericsType> l = new ArrayList<GenericsType>(Arrays.asList(oldTypes));
+        ArrayList<GenericsType> l = new ArrayList<>(Arrays.asList(oldTypes));
         Iterator<GenericsType> it = l.iterator();
         boolean modified = false;
         while (it.hasNext()) {
@@ -451,11 +423,11 @@ public abstract class TraitComposer {
      * @param genericsSpec
      */
     private static void createSuperForwarder(ClassNode targetNode, MethodNode forwarder, final Map<String,ClassNode> genericsSpec) {
-        List<ClassNode> interfaces = new ArrayList<ClassNode>(Traits.collectAllInterfacesReverseOrder(targetNode, new LinkedHashSet<ClassNode>()));
+        List<ClassNode> interfaces = new ArrayList<>(Traits.collectAllInterfacesReverseOrder(targetNode, new LinkedHashSet<>()));
         String name = forwarder.getName();
         Parameter[] forwarderParameters = forwarder.getParameters();
-        LinkedHashSet<ClassNode> traits = new LinkedHashSet<ClassNode>();
-        List<MethodNode> superForwarders = new LinkedList<MethodNode>();
+        LinkedHashSet<ClassNode> traits = new LinkedHashSet<>();
+        List<MethodNode> superForwarders = new LinkedList<>();
         for (ClassNode node : interfaces) {
             if (Traits.isTrait(node)) {
                 MethodNode method = node.getDeclaredMethod(name, forwarderParameters);
@@ -490,14 +462,14 @@ public abstract class TraitComposer {
         for (int i = 0; i < parameters.length; i++) {
             Parameter parameter = parameters[i];
             ClassNode originType = parameter.getOriginType();
-            superForwarderParams[i] = new Parameter(correctToGenericsSpecRecurse(genericsSpec, originType), parameter.getName());
+            superForwarderParams[i] = new Parameter(GenericsUtils.correctToGenericsSpecRecurse(genericsSpec, originType), parameter.getName());
         }
         for (int i = 0; i < interfacesToGenerateForwarderFor.length; i++) {
             final ClassNode current = interfacesToGenerateForwarderFor[i];
             final ClassNode next = i < interfacesToGenerateForwarderFor.length - 1 ? interfacesToGenerateForwarderFor[i + 1] : null;
             String forwarderName = Traits.getSuperTraitMethodName(current, forwarderMethod.getName());
             if (targetNode.getDeclaredMethod(forwarderName, superForwarderParams) == null) {
-                ClassNode returnType = correctToGenericsSpecRecurse(genericsSpec, forwarderMethod.getReturnType());
+                ClassNode returnType = GenericsUtils.correctToGenericsSpecRecurse(genericsSpec, forwarderMethod.getReturnType());
                 Statement delegate = next == null ? createSuperFallback(forwarderMethod, returnType) : createDelegatingForwarder(forwarderMethod, next);
 
                 MethodNode methodNode = addGeneratedMethod(targetNode, forwarderName, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, returnType, superForwarderParams, ClassNode.EMPTY_ARRAY, delegate);
diff --git a/src/test/org/codehaus/groovy/transform/traitx/Groovy7213Bug.groovy b/src/test/org/codehaus/groovy/transform/traitx/Groovy7213Bug.groovy
deleted file mode 100644
index cab527a0e5..0000000000
--- a/src/test/org/codehaus/groovy/transform/traitx/Groovy7213Bug.groovy
+++ /dev/null
@@ -1,40 +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 Groovy7213Bug extends GroovyTestCase {
-    void testShouldAllowPrivateMethodInTraitEvenIfUseCompileStatic() {
-        assertScript '''
-trait Foo {
-   private int f(int x) { x }
-   int foo() { f(2) }
-}
-
-@groovy.transform.CompileStatic
-class A implements Foo {}
-assert new A().foo() == 2
-'''
-    }
-}
diff --git a/src/test/org/codehaus/groovy/transform/traitx/TraitASTTransformationTest.groovy b/src/test/org/codehaus/groovy/transform/traitx/TraitASTTransformationTest.groovy
index 1bba90274c..ad19c8a223 100644
--- a/src/test/org/codehaus/groovy/transform/traitx/TraitASTTransformationTest.groovy
+++ b/src/test/org/codehaus/groovy/transform/traitx/TraitASTTransformationTest.groovy
@@ -222,8 +222,9 @@ final class TraitASTTransformationTest {
                 void setLabel3(String val) { this.@name = val }
                 String getName() { name }
             }
+            class Person implements Named {
+            }
 
-            class Person implements Named {}
             def p = new Person()
             assert p.name == null
             p.setLabel('label')
@@ -298,6 +299,7 @@ final class TraitASTTransformationTest {
             })
             class Bob implements Foo {
             }
+
             def b = new Bob()
             assert b.sum(1) == 1
             b.index = 5
@@ -315,9 +317,10 @@ final class TraitASTTransformationTest {
                public String foo() { bar()+msg }
 
             }
-
             @CompileStatic
-            class A implements Foo { String bar() {'bar'}}
+            class A implements Foo {
+                String bar() {'bar'}
+            }
 
             assert new A().foo() == 'barfoo'
         '''
@@ -909,7 +912,9 @@ final class TraitASTTransformationTest {
                 String blah() { message }
                 void update(String msg ) { message = msg}
             }
-            class Foo implements TestTrait{}
+            class Foo implements TestTrait {
+            }
+
             def foo = new Foo()
             assert foo.message == 'Hello'
             assert foo.blah() == 'Hello'
@@ -926,7 +931,9 @@ final class TraitASTTransformationTest {
                 void update(String msg ) { message = msg}
             }
             @CompileStatic
-            class Foo implements TestTrait{}
+            class Foo implements TestTrait{
+            }
+
             @CompileStatic
             void test() {
                 def foo = new Foo()
@@ -1649,12 +1656,14 @@ final class TraitASTTransformationTest {
             trait Trait1 { private int v = 111; int getValueFromTrait1() { v } }
             trait Trait2 { private int v = 222; int getValueFromTrait2() { v } }
             class Impl implements Trait1,Trait2 {}
+
             def t = new Impl()
             assert t.valueFromTrait1 == 111
             assert t.valueFromTrait2 == 222
         '''
     }
 
+    // GROOVY-7213, GROOVY-8859
     @Test
     void testPrivateMethodInTrait() {
         for (mode in ['','@TypeChecked','@CompileStatic']) {
@@ -1668,8 +1677,27 @@ final class TraitASTTransformationTest {
                 class C implements T {
                 }
 
-                def c = new C()
-                assert c.foo() == 'secret'
+                assert new C().foo() == 'secret'
+            """
+
+            shouldFail shell, """
+                $mode
+                trait T {
+                    public String bar() {
+                        'public'
+                    }
+                    private String baz() {
+                        'private'
+                    }
+                }
+                $mode
+                class C implements T {
+                    def foo() {
+                        bar() + baz()
+                    }
+                }
+
+                assert new C().foo() == 'publicprivate'
             """
         }
     }