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/02/03 19:12:07 UTC

[groovy] branch GROOVY_2_5_X updated: GROOVY-10238: `@CompileDynamic` outer class `@CompileStatic` inner class

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

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


The following commit(s) were added to refs/heads/GROOVY_2_5_X by this push:
     new 3636a25341 GROOVY-10238: `@CompileDynamic` outer class `@CompileStatic` inner class
3636a25341 is described below

commit 3636a25341e3cb67b76a31575af3b7ba70b41c8b
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Fri Feb 3 11:48:49 2023 -0600

    GROOVY-10238: `@CompileDynamic` outer class `@CompileStatic` inner class
    
    2_5_X backport
---
 .../codehaus/groovy/ast/expr/FieldExpression.java  |  2 +-
 .../transform/sc/StaticCompilationVisitor.java     | 61 +++++++++++-----------
 .../classgen/asm/sc/StaticCompileDGMTest.groovy    | 34 +++++++++---
 3 files changed, 58 insertions(+), 39 deletions(-)

diff --git a/src/main/java/org/codehaus/groovy/ast/expr/FieldExpression.java b/src/main/java/org/codehaus/groovy/ast/expr/FieldExpression.java
index ff974e59a3..67350ff2e1 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/FieldExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/FieldExpression.java
@@ -82,6 +82,6 @@ public class FieldExpression extends Expression {
 
     @Override
     public String toString() {
-        return "field(" + getType() + " " + getFieldName() + ")";
+        return "field(" + getType().toString(false) + " " + getFieldName() + ")";
     }
 }
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java b/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
index 0337c40a76..5103578958 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
@@ -43,7 +43,6 @@ import org.codehaus.groovy.ast.expr.MethodCallExpression;
 import org.codehaus.groovy.ast.expr.PropertyExpression;
 import org.codehaus.groovy.ast.expr.SpreadExpression;
 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.ForStatement;
 import org.codehaus.groovy.ast.stmt.Statement;
@@ -68,7 +67,9 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import static org.apache.groovy.ast.tools.AnnotatedNodeUtils.hasAnnotation;
 import static org.codehaus.groovy.ast.ClassHelper.Character_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.OBJECT_TYPE;
 import static org.codehaus.groovy.ast.ClassHelper.STRING_TYPE;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.assignS;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.attrX;
@@ -111,18 +112,13 @@ import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
  * visitor.
  */
 public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
+
     private static final ClassNode TYPECHECKED_CLASSNODE = ClassHelper.make(TypeChecked.class);
     private static final ClassNode COMPILESTATIC_CLASSNODE = ClassHelper.make(CompileStatic.class);
-    private static final ClassNode[] TYPECHECKED_ANNOTATIONS = {TYPECHECKED_CLASSNODE, COMPILESTATIC_CLASSNODE};
-
-    public static final ClassNode ARRAYLIST_CLASSNODE = ClassHelper.make(ArrayList.class);
-    public static final MethodNode ARRAYLIST_CONSTRUCTOR;
-    public static final MethodNode ARRAYLIST_ADD_METHOD = ARRAYLIST_CLASSNODE.getMethod("add", new Parameter[]{new Parameter(ClassHelper.OBJECT_TYPE, "o")});
 
-    static {
-        ARRAYLIST_CONSTRUCTOR = new ConstructorNode(ACC_PUBLIC, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, EmptyStatement.INSTANCE);
-        ARRAYLIST_CONSTRUCTOR.setDeclaringClass(StaticCompilationVisitor.ARRAYLIST_CLASSNODE);
-    }
+    public static final ClassNode  ARRAYLIST_CLASSNODE = ClassHelper.make(ArrayList.class);
+    public static final MethodNode ARRAYLIST_ADD_METHOD = ARRAYLIST_CLASSNODE.getMethod("add", new Parameter[]{new Parameter(OBJECT_TYPE, "o")});
+    public static final MethodNode ARRAYLIST_CONSTRUCTOR = ARRAYLIST_CLASSNODE.getDeclaredConstructor(Parameter.EMPTY_ARRAY); // no-arg variation
 
     private final TypeChooser typeChooser = new StaticTypesTypeChooser();
 
@@ -134,7 +130,7 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
 
     @Override
     protected ClassNode[] getTypeCheckingAnnotations() {
-        return TYPECHECKED_ANNOTATIONS;
+        return new ClassNode[]{TYPECHECKED_CLASSNODE, COMPILESTATIC_CLASSNODE};
     }
 
     public static boolean isStaticallyCompiled(final AnnotatedNode node) {
@@ -152,11 +148,10 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
         return false;
     }
 
-    private void addPrivateFieldAndMethodAccessors(ClassNode node) {
+    private void addPrivateFieldAndMethodAccessors(final ClassNode node) {
         addPrivateBridgeMethods(node);
         addPrivateFieldsAccessors(node);
-        Iterator<InnerClassNode> it = node.getInnerClasses();
-        while (it.hasNext()) {
+        for (Iterator<InnerClassNode> it = node.getInnerClasses(); it.hasNext(); ) {
             addPrivateFieldAndMethodAccessors(it.next());
         }
     }
@@ -185,22 +180,26 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
         if (!skip && !anyMethodSkip(node)) {
             node.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY);
         }
-        ClassNode oldCN = classNode;
-        classNode = node;
-        Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses();
-        while (innerClasses.hasNext()) {
-            InnerClassNode innerClassNode = innerClasses.next();
-            boolean innerStaticCompile = !(skip || isSkippedInnerClass(innerClassNode));
-            innerClassNode.putNodeMetaData(STATIC_COMPILE_NODE, innerStaticCompile);
-            innerClassNode.putNodeMetaData(WriterControllerFactory.class, node.getNodeMetaData(WriterControllerFactory.class));
-            if (innerStaticCompile && !anyMethodSkip(innerClassNode)) {
-                innerClassNode.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY);
+
+        ClassNode previousClassNode = classNode; classNode = node;
+
+        for (Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses(); innerClasses.hasNext(); ) { ClassNode innerClass = innerClasses.next();
+            boolean isSC = !isSkipMode(innerClass) && (isStaticallyCompiled(node) || hasAnnotation(innerClass, COMPILESTATIC_CLASSNODE));
+            // GROOVY-10238: @CompileDynamic outer class, @CompileStatic inner class ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+            innerClass.putNodeMetaData(STATIC_COMPILE_NODE, Boolean.valueOf(isSC));
+            if (isSC && !anyMethodSkip(innerClass)) {
+                innerClass.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY);
             }
+            innerClass.putNodeMetaData(WriterControllerFactory.class, node.getNodeMetaData(WriterControllerFactory.class));
         }
         super.visitClass(node);
         addPrivateFieldAndMethodAccessors(node);
-        if (isStaticallyCompiled(node)) addDynamicOuterClassAccessorsCallback(node.getOuterClass());
-        classNode = oldCN;
+        if (isStaticallyCompiled(node)) {
+            ClassNode outerClass = node.getOuterClass();
+            addDynamicOuterClassAccessorsCallback(outerClass);
+        }
+
+        classNode = previousClassNode;
     }
 
     private boolean anyMethodSkip(final ClassNode node) {
@@ -251,9 +250,9 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
     }
 
     /**
-     * Adds special accessors and mutators for private fields so that inner classes can get/set them
+     * Adds special accessors and mutators for private fields so that inner classes can get/set them.
      */
-    private static void addPrivateFieldsAccessors(ClassNode node) {
+    private static void addPrivateFieldsAccessors(final ClassNode node) {
         Map<String, MethodNode> privateFieldAccessors = (Map<String, MethodNode>) node.getNodeMetaData(PRIVATE_FIELDS_ACCESSORS);
         Map<String, MethodNode> privateFieldMutators = (Map<String, MethodNode>) node.getNodeMetaData(PRIVATE_FIELDS_MUTATORS);
         if (privateFieldAccessors != null || privateFieldMutators != null) {
@@ -305,9 +304,9 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
     }
 
     /**
-     * This method is used to add "bridge" methods for private methods of an inner/outer
-     * class, so that the outer class is capable of calling them. It does basically
-     * the same job as access$000 like methods in Java.
+     * Adds "bridge" methods for private methods of an inner/outer class so that
+     * the outer class is capable of calling them.  It does basically the same
+     * job as access$000 like methods in Java.
      *
      * @param node an inner/outer class node for which to generate bridge methods
      */
diff --git a/src/test/org/codehaus/groovy/classgen/asm/sc/StaticCompileDGMTest.groovy b/src/test/org/codehaus/groovy/classgen/asm/sc/StaticCompileDGMTest.groovy
index 732497866e..ad0dd6899a 100644
--- a/src/test/org/codehaus/groovy/classgen/asm/sc/StaticCompileDGMTest.groovy
+++ b/src/test/org/codehaus/groovy/classgen/asm/sc/StaticCompileDGMTest.groovy
@@ -21,13 +21,34 @@ package org.codehaus.groovy.classgen.asm.sc
 import groovy.transform.stc.DefaultGroovyMethodsSTCTest
 
 /**
- * Unit tests for static compilation: DGM method calls.
+ * Unit tests for static compilation: default groovy methods.
  */
-class StaticCompileDGMTest extends DefaultGroovyMethodsSTCTest implements StaticCompilationTestSupport {
+final class StaticCompileDGMTest extends DefaultGroovyMethodsSTCTest implements StaticCompilationTestSupport {
+
+    // GROOVY-10238
+    void testMapWithDefault() {
+        assertScript '''
+            import groovy.transform.*
+
+            @CompileDynamic
+            class Outer {
+                @Canonical
+                @CompileStatic
+                static class Inner {
+                    Map map = [:].withDefault { new Object() } // NoSuchMethodError: java.util.Map.withDefault(Lgroovy/lang/Closure;)
+                }
+            }
+
+            def obj = new Outer.Inner()
+            assert obj.toString() == 'Outer$Inner([:])'
+            assert obj.map['foo'] != null
+            assert obj.toString() != 'Outer$Inner([:])'
+        '''
+    }
 
     void testThreadDotStart() {
         assertScript '''
-            @ASTTest(phase = INSTRUCTION_SELECTION, value = {
+            @ASTTest(phase=INSTRUCTION_SELECTION, value={
                 lookup('start').each {
                     def target = it.expression.target
                     assert target instanceof org.codehaus.groovy.transform.stc.ExtensionMethodNode
@@ -37,14 +58,13 @@ class StaticCompileDGMTest extends DefaultGroovyMethodsSTCTest implements Static
                     assert target.returnType.nameWithoutPackage == 'Thread'
                 }
             })
-            void foo() {
-                start:
+            void test() {
+              start:
                 Thread.start {
                     println 'ok'
                 }
             }
-            foo()
+            test()
         '''
     }
 }
-