GROOVY-10325

Author: eric-milles

base-test/org.eclipse.jdt.groovy.core.tests.compiler/src/org/eclipse/jdt/groovy/core/tests/xform/TypeCheckedTests.java

@@ -4183,4 +4183,27 @@ public void testTypeChecked10320() {
 
         runConformTest(sources, "3.3");
     }
+
+    @Test
+    public void testTypeChecked10325() {
+        //@formatter:off
+        String[] sources = {
+            "Main.groovy",
+            "@groovy.transform.TypeChecked\n" +
+            "void test(Map<String,Object> map) {\n" +
+            "  @groovy.transform.ASTTest(phase=INSTRUCTION_SELECTION, value={\n" +
+            "    def type = node.getNodeMetaData(org.codehaus.groovy.transform.stc.StaticTypesMarker.INFERRED_TYPE)\n" +
+            "    assert type.toString(false) == 'java.util.List<java.lang.Object>'\n" + // should not change
+            "  })\n" +
+            "  def values = map*.value\n" +
+            "  map.entrySet()[0].value = 'baz'\n" +
+            "  map*.value = 'baz!'\n" + // Cannot assign java.util.List<java.lang.String> to: java.util.List<java.lang.Object>
+            "  print map\n" +
+            "}\n" +
+            "test(foo:'bar')\n",
+        };
+        //@formatter:on
+
+        runConformTest(sources, "[foo:baz!]");
+    }
 }

base/org.codehaus.groovy25/src/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java

@@ -2105,9 +2105,17 @@ private ClassNode getTypeForMapPropertyExpression(ClassNode testClass, ClassNode
                 listKey.setGenericsTypes(new GenericsType[]{types[0]});
                 return listKey;
             } else if ("value".equals(pexp.getPropertyAsString())) {
+                /* GRECLIPSE edit -- GROOVY-10325
                 ClassNode listValue = LIST_TYPE.getPlainNodeReference();
                 listValue.setGenericsTypes(new GenericsType[]{types[1]});
                 return listValue;
+                */
+                GenericsType v = types[1];
+                if (!v.isWildcard() && !Modifier.isFinal(v.getType().getModifiers()) && isLHSOfEnclosingAssignment(pexp)) {
+                    v = GenericsUtils.buildWildcardType(v.getType());
+                }
+                return GenericsUtils.makeClassSafe0(LIST_TYPE, v);
+                // GRECLIPSE end
             } else {
                 addStaticTypeError("Spread operator on map only allows one of [key,value]", pexp);
             }

base/org.codehaus.groovy30/src/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java

@@ -1982,9 +1982,19 @@ private ClassNode getTypeForMapPropertyExpression(final ClassNode testClass, fin
                     keyList.setGenericsTypes(new GenericsType[]{gts[0]});
                     return keyList;
                 case "value":
+                    /* GRECLIPSE edit
                     ClassNode valueList = LIST_TYPE.getPlainNodeReference();
                     valueList.setGenericsTypes(new GenericsType[]{gts[1]});
                     return valueList;
+                    */
+                    GenericsType v = gts[1];
+                    if (!v.isWildcard()
+                            && !Modifier.isFinal(v.getType().getModifiers())
+                            && typeCheckingContext.isTargetOfEnclosingAssignment(pexp)) {
+                        v = GenericsUtils.buildWildcardType(v.getType()); // GROOVY-10325
+                    }
+                    return GenericsUtils.makeClassSafe0(LIST_TYPE, v);
+                    // GRECLIPSE end
                 default:
                     addStaticTypeError("Spread operator on map only allows one of [key,value]", pexp);
                 }

base/org.codehaus.groovy40/src/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java

@@ -220,6 +220,7 @@
 import static org.codehaus.groovy.ast.tools.GeneralUtils.propX;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.thisPropX;
 import static org.codehaus.groovy.ast.tools.GeneralUtils.varX;
+import static org.codehaus.groovy.ast.tools.GenericsUtils.makeClassSafe0;
 import static org.codehaus.groovy.ast.tools.WideningCategories.isBigDecCategory;
 import static org.codehaus.groovy.ast.tools.WideningCategories.isBigIntCategory;
 import static org.codehaus.groovy.ast.tools.WideningCategories.isDouble;
@@ -1204,14 +1205,12 @@ private boolean typeCheckMultipleAssignmentAndContinue(final Expression leftExpr
         return true;
     }
 
-    private ClassNode adjustTypeForSpreading(final ClassNode inferredRightExpressionType, final Expression leftExpression) {
-        // imagine we have: list*.foo = 100
-        // then the assignment must be checked against [100], not 100
-        ClassNode wrappedRHS = inferredRightExpressionType;
+    private ClassNode adjustTypeForSpreading(final ClassNode rightExpressionType, final Expression leftExpression) {
+        // given "list*.foo = 100" or "map*.value = 100", then the assignment must be checked against [100], not 100
         if (leftExpression instanceof PropertyExpression && ((PropertyExpression) leftExpression).isSpreadSafe()) {
-            wrappedRHS = extension.buildListType(inferredRightExpressionType);
+            return extension.buildListType(rightExpressionType);
         }
-        return wrappedRHS;
+        return rightExpressionType;
     }
 
     private boolean addedReadOnlyPropertyError(final Expression expr) {
@@ -1789,13 +1788,15 @@ private ClassNode getTypeForMapPropertyExpression(final ClassNode testClass, fin
                 // map*.property syntax acts on Entry
                 switch (pexp.getPropertyAsString()) {
                 case "key":
-                    ClassNode keyList = LIST_TYPE.getPlainNodeReference();
-                    keyList.setGenericsTypes(new GenericsType[]{gts[0]});
-                    return keyList;
+                    return makeClassSafe0(LIST_TYPE, gts[0]);
                 case "value":
-                    ClassNode valueList = LIST_TYPE.getPlainNodeReference();
-                    valueList.setGenericsTypes(new GenericsType[]{gts[1]});
-                    return valueList;
+                    GenericsType v = gts[1];
+                    if (!v.isWildcard()
+                            && !Modifier.isFinal(v.getType().getModifiers())
+                            && typeCheckingContext.isTargetOfEnclosingAssignment(pexp)) {
+                        v = GenericsUtils.buildWildcardType(v.getType()); // GROOVY-10325
+                    }
+                    return makeClassSafe0(LIST_TYPE, v);
                 default:
                     addStaticTypeError("Spread operator on map only allows one of [key,value]", pexp);
                 }