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 cffdc8e  GROOVY-10291: STC: fix diamond inference for property object 
expression
cffdc8e is described below

commit cffdc8eda40be102eba6de33d13c4d9179b844ad
Author: Eric Milles <[email protected]>
AuthorDate: Mon Nov 1 19:55:00 2021 -0500

    GROOVY-10291: STC: fix diamond inference for property object expression
---
 .../transform/stc/StaticTypeCheckingVisitor.java   | 33 +++++++++++-----------
 .../groovy/transform/stc/GenericsSTCTest.groovy    | 25 ++++++++++++++--
 2 files changed, 39 insertions(+), 19 deletions(-)

diff --git 
a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
 
b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
index 83689c2..e4b753d 100644
--- 
a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ 
b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -1084,24 +1084,22 @@ public class StaticTypeCheckingVisitor extends 
ClassCodeVisitorSupport {
             if (!argumentList.getExpressions().isEmpty() && constructor != 
null) {
                 ClassNode type = GenericsUtils.parameterizeType(cceType, 
cceType);
                 type = inferReturnTypeGenerics(type, constructor, 
argumentList);
-                if (type.isUsingGenerics()) {
-                    // GROOVY-6232, GROOVY-9956: if cce not assignment 
compatible, process target as additional type witness
-                    if (GenericsUtils.hasUnresolvedGenerics(type) || 
checkCompatibleAssignmentTypes(lType, type, cce)
-                            && 
!GenericsUtils.buildWildcardType(lType).isCompatibleWith(type)) {
-                        // allow covariance of each type parameter, but 
maintain semantics for nested generics
-
-                        ClassNode pType = 
GenericsUtils.parameterizeType(lType, type);
-                        GenericsType[] lhs = pType.getGenericsTypes(), rhs = 
type.getGenericsTypes();
-                        if (lhs == null || rhs == null || lhs.length != 
rhs.length) throw new GroovyBugError(
-                                "Parameterization failed: " + 
prettyPrintType(pType) + " ~ " + prettyPrintType(type));
-
-                        if (java.util.stream.IntStream.range(0, 
lhs.length).allMatch(i ->
-                                
GenericsUtils.buildWildcardType(getCombinedBoundType(lhs[i])).isCompatibleWith(getCombinedBoundType(rhs[i]))))
 {
-                            type = pType; // lType proved to be a viable type 
witness
-                        }
+                if (type.toString(false).indexOf('#') > 0 // GROOVY-9983, 
GROOVY-10291
+                        // GROOVY-6232, GROOVY-9956: if cce not assignment 
compatible, process target as additional type witness
+                        || checkCompatibleAssignmentTypes(lType, type, cce) && 
!GenericsUtils.buildWildcardType(lType).isCompatibleWith(type)) {
+                    // allow covariance of each type parameter, but maintain 
semantics for nested generics
+
+                    ClassNode pType = GenericsUtils.parameterizeType(lType, 
type);
+                    GenericsType[] lhs = pType.getGenericsTypes(), rhs = 
type.getGenericsTypes();
+                    if (lhs == null || rhs == null || lhs.length != 
rhs.length) throw new GroovyBugError(
+                            "Parameterization failed: " + 
prettyPrintType(pType) + " ~ " + prettyPrintType(type));
+
+                    if (java.util.stream.IntStream.range(0, 
lhs.length).allMatch(i ->
+                            
GenericsUtils.buildWildcardType(getCombinedBoundType(lhs[i])).isCompatibleWith(getCombinedBoundType(rhs[i]))))
 {
+                        type = pType; // lType proved to be a viable type 
witness
                     }
-                    inferredType = type;
                 }
+                inferredType = type;
             }
             adjustGenerics(inferredType, cceType);
             storeType(cce, cceType);
@@ -1475,7 +1473,8 @@ public class StaticTypeCheckingVisitor extends 
ClassCodeVisitorSupport {
         Expression objectExpression = pexp.getObjectExpression();
         ClassNode objectExpressionType = getType(objectExpression);
         if (objectExpression instanceof ConstructorCallExpression) {
-            inferDiamondType((ConstructorCallExpression) objectExpression, 
objectExpressionType);
+            ClassNode rawType = objectExpressionType.getPlainNodeReference();
+            inferDiamondType((ConstructorCallExpression) objectExpression, 
rawType);
         }
         List<ClassNode> enclosingTypes = 
typeCheckingContext.getEnclosingClassNodes();
 
diff --git a/src/test/groovy/transform/stc/GenericsSTCTest.groovy 
b/src/test/groovy/transform/stc/GenericsSTCTest.groovy
index cc08e6f..13b7d4c 100644
--- a/src/test/groovy/transform/stc/GenericsSTCTest.groovy
+++ b/src/test/groovy/transform/stc/GenericsSTCTest.groovy
@@ -979,9 +979,30 @@ class GenericsSTCTest extends StaticTypeCheckingTestCase {
         '''
     }
 
-    // GROOVY-10323
+    // GROOVY-10291
     void testDiamondInferrenceFromConstructor17() {
         assertScript '''
+            @groovy.transform.TupleConstructor(defaults=false)
+            class A<X> {
+                X x
+            }
+            class B<Y> {
+                def m(Y y) { null }
+                def test() {
+                    def c = { Y yy -> null }
+
+                    Y y = null
+                    m(new A<>(y).x) // works
+                    c(new A<>(y).x) // fails
+                }
+            }
+            new B().test()
+        '''
+    }
+
+    // GROOVY-10323
+    void testDiamondInferrenceFromConstructor18() {
+        assertScript '''
             class C<T> {
             }
             def <T,T> T m(C<T> c) {
@@ -991,7 +1012,7 @@ class GenericsSTCTest extends StaticTypeCheckingTestCase {
     }
 
     // GROOVY-10324
-    void testDiamondInferrenceFromConstructor18() {
+    void testDiamondInferrenceFromConstructor19() {
         assertScript '''
             class C<T> {
             }

Reply via email to