Fix 3 layer nested method calls with the return type includes a wildcard

Adopt test & fix from PR 4565

Also-by: coehlrich <[email protected]>

Author: stephan-herrmann

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/InferenceContext18.java

@@ -430,10 +430,9 @@ public BoundSet inferInvocationType(TypeBinding expectedType, InvocationSite inv
 			if (!addConstraintsToC(this.invocationArguments, c, method, this.inferenceKind, invocationSite))
 				return null;
 			// 5. bullet: determine B4 from C
-			List<Set<InferenceVariable>> components;
 			while (!c.isEmpty()) {
 				Map<InferenceVariable,Set<InferenceVariable>> dependencies = collectDependencies(this.currentBounds, false, new boolean[1]);
-				components = new ArrayList<>(dependencies.values());
+				List<Set<InferenceVariable>> components = new ArrayList<>(dependencies.values());
 				// *
 				Set<ConstraintFormula> bottomSet = findBottomSet(c, allOutputVariables(c), components);
 				if (bottomSet.isEmpty()) {
@@ -467,6 +466,12 @@ public BoundSet inferInvocationType(TypeBinding expectedType, InvocationSite inv
 					if (!this.currentBounds.reduceOneConstraint(this, constraint))
 						return null;
 				}
+				for (ConstraintFormula constraint : bottomSet) {
+					// https://bugs.openjdk.org/browse/JDK-8052325
+					if (constraint instanceof ConstraintExpressionFormula expressionFormula && expressionFormula.left instanceof LambdaExpression lambda && lambda.argumentsTypeElided()) {
+						addLambdaConstraintsToC(lambda, c, method, expressionFormula.right);
+					}
+				}
 			}
 			// 6. bullet: solve
 			BoundSet solution = solve();
@@ -652,6 +657,31 @@ private boolean addConstraintsToC(Expression[] exprs, Set<ConstraintFormula> c,
 		return true;
 	}
 
+	private boolean addLambdaConstraintsToC(LambdaExpression lambda, Set<ConstraintFormula> c, MethodBinding method, TypeBinding substF)
+			throws InferenceFailureException
+	{
+		// https://bugs.openjdk.java.net/browse/JDK-8038747
+		BlockScope skope = lambda.enclosingScope;
+		if (substF.isFunctionalInterface(skope)) { // could be an inference variable.
+			ReferenceBinding t = (ReferenceBinding) substF;
+			ParameterizedTypeBinding withWildCards = InferenceContext18.parameterizedWithWildcard(t);
+			if (withWildCards != null) {
+				t = ConstraintExpressionFormula.findGroundTargetType(this, skope, lambda, withWildCards);
+			}
+			MethodBinding functionType;
+			if (t != null && (functionType = t.getSingleAbstractMethod(skope, true)) != null && (lambda = lambda.resolveExpressionExpecting(t, this.scope)) != null) {
+				TypeBinding r = functionType.returnType;
+				Expression[] resultExpressions = lambda.resultExpressions();
+				for (int i = 0, length = resultExpressions == null ? 0 : resultExpressions.length; i < length; i++) {
+					Expression resultExpression = resultExpressions[i];
+					if (!addConstraintsToC_OneExpr(resultExpression, c, r.original(), r, method))
+						return false;
+				}
+			}
+		}
+		return true;
+	}
+
 	private boolean addConstraintsToC_OneExpr(Expression expri, Set<ConstraintFormula> c, TypeBinding fsi, TypeBinding substF, MethodBinding method)
 			throws InferenceFailureException
 	{
@@ -666,27 +696,9 @@ private boolean addConstraintsToC_OneExpr(Expression expri, Set<ConstraintFormul
 		}
 		if (expri instanceof FunctionalExpression) {
 			c.add(new ConstraintExceptionFormula((FunctionalExpression) expri, substF));
-			if (expri instanceof LambdaExpression) {
-				// https://bugs.openjdk.java.net/browse/JDK-8038747
-				LambdaExpression lambda = (LambdaExpression) expri;
-				BlockScope skope = lambda.enclosingScope;
-				if (substF.isFunctionalInterface(skope)) { // could be an inference variable.
-					ReferenceBinding t = (ReferenceBinding) substF;
-					ParameterizedTypeBinding withWildCards = InferenceContext18.parameterizedWithWildcard(t);
-					if (withWildCards != null) {
-						t = ConstraintExpressionFormula.findGroundTargetType(this, skope, lambda, withWildCards);
-					}
-					MethodBinding functionType;
-					if (t != null && (functionType = t.getSingleAbstractMethod(skope, true)) != null && (lambda = lambda.resolveExpressionExpecting(t, this.scope)) != null) {
-						TypeBinding r = functionType.returnType;
-						Expression[] resultExpressions = lambda.resultExpressions();
-						for (int i = 0, length = resultExpressions == null ? 0 : resultExpressions.length; i < length; i++) {
-							Expression resultExpression = resultExpressions[i];
-							if (!addConstraintsToC_OneExpr(resultExpression, c, r.original(), r, method))
-								return false;
-						}
-					}
-				}
+			// https://bugs.openjdk.org/browse/JDK-8052325
+			if (expri instanceof LambdaExpression lambda && !lambda.argumentsTypeElided()) {
+				addLambdaConstraintsToC(lambda, c, method, substF);
 			}
 		} else if (expri instanceof Invocation && expri.isPolyExpression()) {
 
@@ -716,7 +728,6 @@ private boolean addConstraintsToC_OneExpr(Expression expri, Set<ConstraintFormul
 				if (!innerContext.computeB3(invocation, substF, shallowMethod))
 					return false;
 				if (innerContext.addConstraintsToC(arguments, c, innerMethod.genericMethod(), innerContext.inferenceKind, invocation)) {
-					this.currentBounds.addBounds(innerContext.currentBounds, this.environment, false);
 					return true;
 				}
 				return false;

org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest.java

@@ -7058,5 +7058,23 @@ interface C<W> {
 		},
 		"");
 }
+
+public void testGH4557() {
+    runConformTest(new String[] {
+            "Test.java",
+            """
+            import java.util.List;
+            public class Test {
+                public static void main(List<?> l) {
+                    get(get(get(l)));
+                }
+                public static <T> List<?> get(List<T> l) {
+                    return l;
+                }
+            }
+            """
+        },
+        "");
+}
 }