GROOVY-10651 (pt.2)

Author: eric-milles

base-test/org.eclipse.jdt.groovy.core.tests.builder/src/org/eclipse/jdt/core/groovy/tests/search/DGMInferencingTests.java

@@ -1012,6 +1012,23 @@ public void testDGMClosure25() {
         assertExprType(contents, "bar", "Bar"); // not "java.lang.Object"
     }
 
+    @Test
+    public void testDGMClosure26() {
+        createJavaUnit("TreeNode",
+            "public abstract class TreeNode<TN extends TreeNode<?>>\n" +
+            "  implements Appendable, Iterable<TN> {\n" +
+            "}\n");
+
+        //@formatter:off
+        String contents =
+            "void test(TreeNode node) {\n" +
+            "  node.each { child ->\n" +
+            "  }\n" +
+            "}\n";
+        //@formatter:on
+        assertExprType(contents, "child", "TreeNode");
+    }
+
     @Test
     public void testDGMDeclaring1() {
         //@formatter:off

base-test/org.eclipse.jdt.groovy.core.tests.builder/src/org/eclipse/jdt/core/groovy/tests/search/InferencingTests.java

@@ -1790,7 +1790,7 @@ public void testSuperInterfaceMethod3() {
             if (!qual.startsWith("C")) {
                 assertUnknown(contents, "naturalOrder");
             } else {
-                assertType(contents, "naturalOrder", "java.util.Comparator<java.lang." + (qual.endsWith(">") ? "String" : "Comparable<? super T>") + ">");
+                assertType(contents, "naturalOrder", "java.util.Comparator<java.lang." + (qual.endsWith(">") ? "String" : "Object") + ">");
             }
         }
     }

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

@@ -5731,15 +5731,15 @@ public void testTypeChecked10651() {
         String[] sources = {
             "Main.groovy",
             "@groovy.transform.TypeChecked\n" +
-            "void test(NodeType node) {\n" +
+            "void test(TreeNode node) {\n" +
             "  node.each { child ->\n" +
             "    test(child)\n" +
             "  }\n" +
             "}\n" +
             "test()\n",
 
-            "NodeType.java",
-            "public abstract class NodeType<T extends NodeType<?>> implements Iterable<T> {\n" +
+            "TreeNode.java",
+            "public abstract class TreeNode<TN extends TreeNode<?>> implements Iterable<TN> {\n" +
             "}\n",
         };
         //@formatter:on

base/org.eclipse.jdt.groovy.core/src/org/eclipse/jdt/groovy/search/GenericsMapper.java

@@ -110,7 +110,7 @@ public static GenericsMapper gatherGenerics(final ClassNode resolvedType, final
             if (resolved == null) resolved = (n > 0 ? new TreeMap<>() : Collections.emptyMap());
             for (int i = 0; i < n; i += 1) {
                 // now try to resolve the parameter in the context of the
-                // most recently visited type. If it doesn't exist, then
+                // most recently visited type; if it does not exist, then
                 // default to the resovled type
                 resolved.put(ugts[i].getName(), mapper.resolveParameter(rgts[i], 0));
             }
@@ -242,7 +242,7 @@ public static GenericsMapper gatherGenerics(final List<ClassNode> argumentTypes,
             return topGT.getType();
         }
 
-        ClassNode theType = findParameter(topGT.getName(), topGT.getType());
+        ClassNode theType = allGenerics.getLast().getOrDefault(topGT.getName(), topGT.getType());
         // recur for type parameters of the type: class Enum<E extends Enum<E>>
         if (theType.redirect().isUsingGenerics()) {
             theType = VariableScope.clone(theType);
@@ -252,7 +252,7 @@ public static GenericsMapper gatherGenerics(final List<ClassNode> argumentTypes,
                 if (genericsType.getName().equals(topGT.getName())) {
                     continue; // avoid infinite loops -- not ideal but better than using a depth counter
                 }
-                genericsType.setType(findParameter(genericsType.getName(), resolveParameter(genericsType, depth + 1)));
+                genericsType.setType(allGenerics.getLast().getOrDefault(genericsType.getName(), resolveParameter(genericsType, depth + 1)));
                 genericsType.setName(genericsType.getType().getName());
                 genericsType.setUpperBounds(null);
                 genericsType.setLowerBound(null);
@@ -299,7 +299,7 @@ protected GenericsMapper fillPlaceholders(final GenericsType[] typeParameters) {
      * @param defaultType type to return if parameter name doesn't exist
      */
     protected ClassNode findParameter(final String parameterName, final ClassNode defaultType) {
-        if (hasGenerics()) {
+        if (!allGenerics.isEmpty()) {
             ClassNode type = allGenerics.getLast().get(parameterName);
             if (type != null) {
                 return type;
@@ -309,10 +309,11 @@ protected ClassNode findParameter(final String parameterName, final ClassNode de
     }
 
     protected static Iterator<ClassNode> getTypeHierarchy(final ClassNode type, final boolean useResolved) {
-        Set<ClassNode> hierarchy = new LinkedHashSet<>();
+        Set<ClassNode> hierarchy = new LinkedHashSet<>(); // keeps order
         VariableScope.createTypeHierarchy(type, hierarchy, useResolved);
-        hierarchy.remove(VariableScope.GROOVY_OBJECT_CLASS_NODE);
         hierarchy.remove(VariableScope.OBJECT_CLASS_NODE);
+        hierarchy.removeIf(cn -> cn.isInterface() &&
+          cn.redirect().getGenericsTypes() == null);
         return hierarchy.iterator();
     }
 

base/org.eclipse.jdt.groovy.core/src/org/eclipse/jdt/groovy/search/TypeInferencingVisitorWithRequestor.java

@@ -979,10 +979,8 @@ public void visitClosureExpression(final ClosureExpression node) {
             if (node.isParameterSpecified()) {
                 Parameter[] parameters = node.getParameters();
                 for (int i = 0, n = parameters.length; i < n; i += 1) {
-                    // only change the parameter's type if it's not declared explicitly
-                    if (parameters[i].isDynamicTyped() && inferredParamTypes[i] != null &&
-                            (!inferredParamTypes[i].equals(VariableScope.OBJECT_CLASS_NODE) || inferredParamTypes[i].isGenericsPlaceHolder())) {
-                        parameters[i].setType(inferredParamTypes[i]);
+                    if (parameters[i].isDynamicTyped() && isNotNullOrObject(inferredParamTypes[i])) {
+                        scope.addVariable(parameters[i].getName(), inferredParamTypes[i], null);
                     }
                 }
                 handleParameters(parameters);
@@ -3249,6 +3247,10 @@ private static boolean isNotEmpty(final Stream<?> stream) {
         return (stream != null && stream.anyMatch(x -> true));
     }
 
+    private static boolean isNotNullOrObject(final ClassNode type) {
+        return (type != null && (!type.equals(VariableScope.OBJECT_CLASS_NODE) || type.isGenericsPlaceHolder()));
+    }
+
     private static VariableExpression isNotNullTest(final Expression node) {
         if (node instanceof CompareToNullExpression) {
             CompareToNullExpression expr = (CompareToNullExpression) node;

base/org.eclipse.jdt.groovy.core/src/org/eclipse/jdt/groovy/search/TypeLookupResult.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2009-2021 the original author or authors.
+ * Copyright 2009-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -168,6 +168,9 @@ public TypeLookupResult resolveTypeParameterization(final ClassNode objExprType,
             }
             if (ClassHelper.isPrimitiveType(objectType)) {
                 objectType = ClassHelper.getWrapper(objectType);
+            } else if (objectType.equals(VariableScope.CLASS_CLASS_NODE) &&
+                   !declaringType.equals(VariableScope.CLASS_CLASS_NODE) && !isGroovy) {
+                objectType = objectType.getGenericsTypes()[0].getType(); // peel Class<>
             }
 
             if (!(declaration instanceof MethodNode)) {