Align inference resolution with javac by applying hints from Maurizio

remove our own tweak from commit ad3653e

Author: stephan-herrmann

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

@@ -315,7 +315,7 @@ else if (type.hasNullTypeAnnotations())
 	 * <dl>
 	 * <dt>captures<dd>IC18.resumeSuspendedInference() will reset these to avoid captures from nested
 	 * 	inference spilling blindly into the current inference.<br>
-	 *  {@link InferenceContext18#collectDependencies(BoundSet, boolean, boolean[])} considers only "local" {@link #captures}.
+	 *  {@link InferenceContext18#collectDependencies(BoundSet)} considers only "local" {@link #captures}.
 	 * <dt>allCaptures<dd>Still {@link #hasCaptureBound(Set)} and {@link #incorporate(InferenceContext18)} will
 	 * 	operate on {@link #allCaptures}.
 	 */

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

@@ -430,7 +430,7 @@ public BoundSet inferInvocationType(TypeBinding expectedType, InvocationSite inv
 				return null;
 			// 5. bullet: determine B4 from C
 			while (!c.isEmpty()) {
-				Map<InferenceVariable,Set<InferenceVariable>> dependencies = collectDependencies(this.currentBounds, false, new boolean[1]);
+				Map<InferenceVariable,Set<InferenceVariable>> dependencies = collectDependencies(this.currentBounds);
 				List<Set<InferenceVariable>> components = new ArrayList<>(dependencies.values());
 				// *
 				Set<ConstraintFormula> bottomSet = findBottomSet(c, allOutputVariables(c), components);
@@ -1152,13 +1152,6 @@ public boolean reduceAndIncorporate(ConstraintFormula constraint) throws Inferen
 	private /*@Nullable*/ BoundSet resolve(
 			InferenceVariable[] toResolve,
 			boolean isRecordPatternTypeInference) throws InferenceFailureException {
-		return resolve(toResolve, isRecordPatternTypeInference, true);
-	}
-	private /*@Nullable*/ BoundSet resolve(
-			InferenceVariable[] toResolve,
-			boolean isRecordPatternTypeInference,
-			boolean maySkipSuperBound) throws InferenceFailureException {
-
 		this.captureId = 0;
 		// NOTE: 18.5.2 ...
 		// "(While it was necessary to demonstrate that the inference variables in B1 could be resolved
@@ -1169,8 +1162,7 @@ public boolean reduceAndIncorporate(ConstraintFormula constraint) throws Inferen
 			Set<InferenceVariable> toResolveSet = new LinkedHashSet<>(Arrays.asList(toResolve));
 			// find a minimal set of dependent variables:
 			Set<InferenceVariable> variableSet;
-			boolean[] hasSkippedSuperBound = { false };
-			while ((variableSet = getSmallestVariableSet(tmpBoundSet, toResolveSet, false, hasSkippedSuperBound)) != null) {
+			while ((variableSet = getSmallestVariableSet(tmpBoundSet, toResolveSet)) != null) {
 				int oldNumUninstantiated = tmpBoundSet.numUninstantiatedVariables(this.inferenceVariables);
 				List<InferenceVariable> ofRank;
 				while ((ofRank = pickIvarsByRank(variableSet, tmpBoundSet)) != null) {
@@ -1239,9 +1231,6 @@ public boolean reduceAndIncorporate(ConstraintFormula constraint) throws Inferen
 							continue;
 						tmpBoundSet = prevBoundSet;// clean-up for second attempt
 					}
-
-					if (maySkipSuperBound && hasSkippedSuperBound[0])
-						return resolve(toResolve, isRecordPatternTypeInference, false);
 					// Otherwise, a second attempt is made...
 					Sorting.sortInferenceVariables(variables); // ensure stability of capture IDs
 					final CaptureBinding18[] zs = new CaptureBinding18[numVars];
@@ -1432,11 +1421,11 @@ public int compare(TypeBinding o1, TypeBinding o2) {
 	 * Find the smallest set of uninstantiated inference variables not depending
 	 * on any uninstantiated variable outside the set.
 	 */
-	public Set<InferenceVariable> getSmallestVariableSet(BoundSet bounds, Set<InferenceVariable> subSet, boolean maySkipSuperBound, boolean[] hasSkippedSuperBound) {
+	public Set<InferenceVariable> getSmallestVariableSet(BoundSet bounds, Set<InferenceVariable> subSet) {
 		// "Given a set of inference variables to resolve, let V be the union of this set and
 		//  all variables upon which the resolution of at least one variable in this set depends."
 		Set<InferenceVariable> v = new LinkedHashSet<>(subSet);
-		Map<InferenceVariable,Set<InferenceVariable>> dependencies = collectDependencies(bounds, maySkipSuperBound, hasSkippedSuperBound);
+		Map<InferenceVariable,Set<InferenceVariable>> dependencies = collectDependencies(bounds);
 		for (InferenceVariable iv : subSet) {
 			Set<InferenceVariable> tmp = dependencies.get(iv);
 			if (tmp != null)
@@ -1497,11 +1486,9 @@ static List<InferenceVariable> pickIvarsByRank(Set<InferenceVariable> variableSe
 	/**
 	 * Collect dependencies of all our ivars based on TypeBounds of 'bounds'
 	 * @param bounds consider all its TypeBounds
-	 * @param maySkipSuperBound if true, then α :> β bounds will not be treated as a dependency from α to β (only the inverse)
-	 * @param hasSkippedSuperBound output parameter to signal to the caller if maySkipSuperBound has been used
 	 * @return a map from an ivar to the set of all its dependencies including itself.
 	 */
-	Map<InferenceVariable,Set<InferenceVariable>> collectDependencies(BoundSet bounds, boolean maySkipSuperBound, boolean[] hasSkippedSuperBound) {
+	Map<InferenceVariable,Set<InferenceVariable>> collectDependencies(BoundSet bounds) {
 		// Implements the definition of dependencies from JLS §18.4:
 		Map<InferenceVariable,Set<InferenceVariable>> dependsOn = new LinkedHashMap<>();
 		// "An inference variable α depends on the resolution of itself."
@@ -1517,38 +1504,31 @@ Map<InferenceVariable,Set<InferenceVariable>> collectDependencies(BoundSet bound
 			// T = α  -- encoded as α = T
 			// T <: α -- encoded as α :> T
 			for (int i=0; i<2; i++) { // 2 attempts, reading the bound left-to-right, then right-to-left
-				if (maySkipSuperBound && typeBound.relation == ReductionResult.SUPERTYPE && typeBound.right instanceof InferenceVariable) {
-					// NON-JLS: first try to ignore any dependencies resulting from a supertype bound,
-					// i.e., given α :> β do not consider α to depend on β
-					hasSkippedSuperBound[0] = true; // signal the application of this tweak to upstream,
-													// so they can retry with the tweak disabled (maySkip=false)
-				} else {
-					Set<InferenceVariable> betas = new LinkedHashSet<>();
-					typeBound.right.collectInferenceVariables(betas);
-					if (!betas.isEmpty()) {
-						InferenceVariable alpha = typeBound.left;
-						// Determine the direction of dependencies to add:
-						// "If α appears on the left-hand side of another bound of the form G<..., α, ...> = capture(G<...>),
-						// then β depends on the resolution of α. Otherwise, α depends on the resolution of β."
-						boolean alphaDependsOnBeta = true;
-						captureTest: for (ParameterizedTypeBinding gCap : bounds.captures.keySet()) {
-							for (TypeBinding arg : gCap.arguments) {
-								if (TypeBinding.equalsEquals(arg, alpha)) {
-									alphaDependsOnBeta = false;
-									break captureTest;
-								}
+				Set<InferenceVariable> betas = new LinkedHashSet<>();
+				typeBound.right.collectInferenceVariables(betas);
+				if (!betas.isEmpty()) {
+					InferenceVariable alpha = typeBound.left;
+					// Determine the direction of dependencies to add:
+					// "If α appears on the left-hand side of another bound of the form G<..., α, ...> = capture(G<...>),
+					// then β depends on the resolution of α. Otherwise, α depends on the resolution of β."
+					boolean alphaDependsOnBeta = true;
+					captureTest: for (ParameterizedTypeBinding gCap : bounds.captures.keySet()) {
+						for (TypeBinding arg : gCap.arguments) {
+							if (TypeBinding.equalsEquals(arg, alpha)) {
+								alphaDependsOnBeta = false;
+								break captureTest;
 							}
 						}
-						if (alphaDependsOnBeta) {
-							Set<InferenceVariable> deps = dependsOn.computeIfAbsent(alpha, iv -> new LinkedHashSet<>());
-							deps.addAll(betas);
-							deps.add(alpha); // add self-dependency, alpha might not yet be recorded if its from inner inference
-						} else {
-							for (InferenceVariable beta : betas) {
-								Set<InferenceVariable> deps = dependsOn.computeIfAbsent(beta, iv -> new LinkedHashSet<>());
-								deps.add(alpha);
-								deps.add(beta); // add self-dependency, beta might not yet be recorded if its from inner inference
-							}
+					}
+					if (alphaDependsOnBeta) {
+						Set<InferenceVariable> deps = dependsOn.computeIfAbsent(alpha, iv -> new LinkedHashSet<>());
+						deps.addAll(betas);
+						deps.add(alpha); // add self-dependency, alpha might not yet be recorded if its from inner inference
+					} else {
+						for (InferenceVariable beta : betas) {
+							Set<InferenceVariable> deps = dependsOn.computeIfAbsent(beta, iv -> new LinkedHashSet<>());
+							deps.add(alpha);
+							deps.add(beta); // add self-dependency, beta might not yet be recorded if its from inner inference
 						}
 					}
 				}