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 2022/02/22 19:29:14 UTC

[groovy] 01/03: GROOVY-7512: add MapStyleConstructorCall override of transformExpression

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

commit 2d61aee432c54c6f51454a6fd3aa374319a79b4c
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Thu Jun 11 17:14:21 2020 -0500

    GROOVY-7512: add MapStyleConstructorCall override of transformExpression
    
    - allow PostTypeCheckingExpressionReplacer to replace closure literals
---
 .../transformers/ConstructorCallTransformer.java   |  13 +++
 .../classgen/asm/sc/bugs/Groovy7242Bug.groovy      | 109 +++++++++++++--------
 2 files changed, 82 insertions(+), 40 deletions(-)

diff --git a/src/main/java/org/codehaus/groovy/transform/sc/transformers/ConstructorCallTransformer.java b/src/main/java/org/codehaus/groovy/transform/sc/transformers/ConstructorCallTransformer.java
index 8a33cdd..7bdcf9f 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/transformers/ConstructorCallTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/transformers/ConstructorCallTransformer.java
@@ -27,6 +27,7 @@ import org.codehaus.groovy.ast.Parameter;
 import org.codehaus.groovy.ast.expr.BinaryExpression;
 import org.codehaus.groovy.ast.expr.ConstructorCallExpression;
 import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.ExpressionTransformer;
 import org.codehaus.groovy.ast.expr.MapEntryExpression;
 import org.codehaus.groovy.ast.expr.MapExpression;
 import org.codehaus.groovy.ast.expr.PropertyExpression;
@@ -121,6 +122,18 @@ public class ConstructorCallTransformer {
         }
 
         @Override
+        public Expression transformExpression(final ExpressionTransformer transformer) {
+            Expression result = new MapStyleConstructorCall(
+                    staticCompilationTransformer, declaringClass,
+                    (MapExpression) map.transformExpression(transformer),
+                    (ConstructorCallExpression) originalCall.transformExpression(transformer)
+            );
+            result.copyNodeMetaData(this);
+            result.setSourcePosition(this);
+            return result;
+        }
+
+        @Override
         public void visit(final GroovyCodeVisitor visitor) {
             if (visitor instanceof AsmClassGenerator) {
                 acg = (AsmClassGenerator) visitor;
diff --git a/src/test/org/codehaus/groovy/classgen/asm/sc/bugs/Groovy7242Bug.groovy b/src/test/org/codehaus/groovy/classgen/asm/sc/bugs/Groovy7242Bug.groovy
index 17e6d62..09c12a5 100644
--- a/src/test/org/codehaus/groovy/classgen/asm/sc/bugs/Groovy7242Bug.groovy
+++ b/src/test/org/codehaus/groovy/classgen/asm/sc/bugs/Groovy7242Bug.groovy
@@ -16,86 +16,115 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
-
-
-
-
-
-
-
 package org.codehaus.groovy.classgen.asm.sc.bugs
 
 import groovy.transform.stc.StaticTypeCheckingTestCase
 import org.codehaus.groovy.classgen.asm.sc.StaticCompilationTestSupport
 
 class Groovy7242Bug extends StaticTypeCheckingTestCase implements StaticCompilationTestSupport {
-    void testCallMethodOfTraitInsideClosure() {
+
+    void testWriteTraitPropertyFromTraitClosure() {
         assertScript '''
-            trait MyTrait {
-                def f() {
-                    ['a'].collect {String it -> f2(it)}
+            trait T {
+                void p() {
+                    [1].each { x = it }
                 }
+                int x
+            }
 
-                def f2(String s) {
-                    s.toUpperCase()
-                }
+            class C implements T {
             }
 
-            class A implements MyTrait {}
-            def a = new A()
-            assert a.f() == ['A']
+            def c = new C()
+            c.p()
+            assert c.x == 1
         '''
     }
 
-    void testCallMethodOfTraitInsideClosureAndClosureParamTypeInference() {
+    void testCallTraitMethodFromTraitClosure() {
         assertScript '''
-            trait MyTrait {
+            trait T {
                 def f() {
-                    ['a'].collect {f2(it)}
+                    ['a'].collect { String s -> g(s) }
                 }
 
-                def f2(String s) {
+                String g(String s) {
                     s.toUpperCase()
                 }
             }
 
-            class A implements MyTrait {}
-            def a = new A()
-            assert a.f() == ['A']
+            class C implements T {
+            }
+
+            def c = new C()
+            assert c.f() == ['A']
         '''
     }
 
-    void testAccessTraitPropertyFromClosureInTrait() {
+    void testCallTraitMethodFromTraitClosure_ImplicitParameter() {
         assertScript '''
-            trait MyTrait {
-                int x
+            trait T {
                 def f() {
-                    [1].each { x = it }
+                    ['a'].collect { g(it) }
+                }
+
+                String g(String s) {
+                    s.toUpperCase()
                 }
             }
-            class A implements MyTrait {}
-            def a = new A()
-            a.f()
-            assert a.x == 1
+
+            class C implements T {
+            }
+
+            def c = new C()
+            assert c.f() == ['A']
         '''
     }
 
-    void testCallPrivateMethodOfTraitInsideClosure() {
+    // GROOVY-7456
+    void testCallPrivateTraitMethodFromTraitClosure() {
         assertScript '''
-            trait MyTrait {
+            trait T {
                 def f() {
-                    ['a'].collect {String it -> f2(it)}
+                    ['a'].collect { String s -> g(s) }
                 }
 
-                private f2(String s) {
+                private String g(String s) {
                     s.toUpperCase()
                 }
             }
 
-            class A implements MyTrait {}
-            def a = new A()
-            assert a.f() == ['A']
+            class C implements T {
+            }
+
+            def c = new C()
+            assert c.f() == ['A']
+        '''
+    }
+
+    // GROOVY-7512
+    void testCallTraitMethodFromTraitClosureInMapConstructor() {
+        assertScript '''
+            class Foo {
+                Closure bar
+            }
+
+            trait T {
+                Foo getFoo() {
+                    new Foo(bar: { ->
+                        baz 'xyz' // ClassCastException: java.lang.Class cannot be cast to T
+                    })
+                }
+                def baz(text) {
+                    text
+                }
+            }
+
+            class C implements T {
+            }
+
+            Foo foo = new C().foo
+            assert foo.bar.call() == 'xyz'
         '''
     }
 }