Combined inference improvements (#5129)

Align inference resolution with javac by applying hints from Maurizio
See https://mail.openjdk.org/archives/list/compiler-dev@openjdk.org/message/GN6RTCGMME6I5JVLSFZRIR32XY6QKOI2/
+ rank ivars for processing in smaller batches
+ remove our own tweak from commit ad3653e

Make most ivar-ivar dependencies bidirectional (see also next)

Opportunistically fine tune usage of same bounds:
+ only during regular inference:
  + record inverse of same-bounds for use by rankIVar()
+ only during record pattern inference:
  + workaround for inverse same-bounds in rankIVar()

Reacting to failure:
+ propagate failures during resolution of capture bounds
+ let unsuccessful glb proceed to 2nd attempt rather than failing

Improve "softness" of type bounds:
+ opportunistically mark constraints from capture bounds "soft" to refix
  - GenericsRegressionTest.test434118
  - GenericsRegressionTest_9.testIssue4864
+ more propagation of isSoft flag (for consistency)
+ Revert part of commit dd34c06 from #4635:
  ARGUMENT_CONSTRAINTS_ARE_SOFT is back to false as recommended

Minor fixes here and there

run.javac improvements:
+ more documentation for JavacHasABug.JavacBug6573446
+ new constant JavacHasABug.JavacBugIvarInterning
+ new constant JavacHasABug.JavacBug8297428
At this point GenericsRegressionTest_9 is ready to opt in to this mode

Fixed and new tests:
+ #4937
+ #3351

For individual commits see #5129

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}.
 	 */
@@ -327,6 +327,7 @@ else if (type.hasNullTypeAnnotations())
 	private TypeBound[] unincorporatedBounds = new TypeBound[8];
 	private int unincorporatedBoundsCount = 0;
 	private final TypeBound[] mostRecentBounds = new TypeBound[4]; // for quick & dirty duplicate elimination
+	public boolean isRecordPatternInference;
 
 	public BoundSet() {}
 
@@ -427,12 +428,17 @@ else if (boundNullBits != 0) // combine bits from both sources, even if this cre
 				three.setInstantiation(typeBinding, variable, environment);
 			if (bound.right instanceof InferenceVariable) {
 				// for a dependency between two IVs make a note about the inverse bound.
-				// this should be needed to determine IV dependencies independent of direction.
-				// TODO: so far no test could be identified which actually needs it ...
-				InferenceVariable rightIV = (InferenceVariable) bound.right.prototype();
-				three = this.boundsPerVariable.get(rightIV);
-				if (three == null)
-					this.boundsPerVariable.put(rightIV, (three = new ThreeSets()));
+				int relation = switch (bound.relation) {
+					case ReductionResult.SUBTYPE -> ReductionResult.SUPERTYPE;
+					case ReductionResult.SUPERTYPE -> ReductionResult.SUBTYPE;
+					case ReductionResult.SAME -> this.isRecordPatternInference ? -1 : ReductionResult.SAME;
+					default -> -1;
+				};
+				if (relation != -1) {
+					InferenceVariable rightIV = (InferenceVariable) bound.right.prototype();
+					three = this.boundsPerVariable.computeIfAbsent(rightIV, k -> new ThreeSets());
+					three.addBound(new TypeBound(rightIV, bound.left, relation, bound.isSoft));
+				}
 			}
 		}
 	}
@@ -696,7 +702,10 @@ protected TypeBinding getP(int i) {
 										System.arraycopy(otherBounds, 0, allBounds, 1, n-1);
 										bi = context.environment.createIntersectionType18(allBounds);
 									}
-									if (addTypeBoundsFromWildcardBound(context, theta, wildcardBinding.boundKind, t, r, bi))
+									ReductionResult result = addTypeBoundsFromWildcardBound(context, theta, wildcardBinding.boundKind, t, r, bi);
+									if (result == ReductionResult.FALSE)
+										return false;
+									else if (result == ReductionResult.TRUE)
 										capturesToRemove.add(gAlpha);
 								}
 							}
@@ -709,7 +718,8 @@ protected TypeBinding getP(int i) {
 								TypeBound bound = it.next();
 								if (!(bound.right instanceof InferenceVariable)) {
 									if (wildcardBinding.boundKind == Wildcard.SUPER) {
-										reduceOneConstraint(context, ConstraintTypeFormula.create(bound.right, t, ReductionResult.SUBTYPE));
+										if (!reduceOneConstraint(context, ConstraintTypeFormula.create(bound.right, t, ReductionResult.SUBTYPE)))
+											return false;
 										capturesToRemove.add(gAlpha);
 									} else {
 										return false;
@@ -739,23 +749,24 @@ protected TypeBinding getP(int i) {
 	}
 
 	// try to infer and reduce a new constraint based on details of a given capture bound
-	// return true iff a new constraint has been added indeed
-	boolean addTypeBoundsFromWildcardBound(InferenceContext18 context, InferenceSubstitution theta, int boundKind, TypeBinding t,
+	// return TRUE or FALSE iff a new constraint has been added indeed
+	ReductionResult addTypeBoundsFromWildcardBound(InferenceContext18 context, InferenceSubstitution theta, int boundKind, TypeBinding t,
 			TypeBinding r, TypeBinding bi) throws InferenceFailureException {
 		ConstraintFormula formula = null;
 		if (boundKind == Wildcard.EXTENDS) {
 			if (bi.id == TypeIds.T_JavaLangObject)
-				formula = ConstraintTypeFormula.create(t, r, ReductionResult.SUBTYPE);
+				formula = ConstraintTypeFormula.create(t, r, ReductionResult.SUBTYPE, true);
 			if (t.id == TypeIds.T_JavaLangObject)
-				formula = ConstraintTypeFormula.create(theta.substitute(theta, bi), r, ReductionResult.SUBTYPE);
+				formula = ConstraintTypeFormula.create(theta.substitute(theta, bi), r, ReductionResult.SUBTYPE, true);
 		} else {
-			formula = ConstraintTypeFormula.create(theta.substitute(theta, bi), r, ReductionResult.SUBTYPE);
+			formula = ConstraintTypeFormula.create(theta.substitute(theta, bi), r, ReductionResult.SUBTYPE, true);
 		}
 		if (formula != null) {
-			reduceOneConstraint(context, formula);
-			return true;
+			if (!reduceOneConstraint(context, formula))
+				return ReductionResult.FALSE;
+			return ReductionResult.TRUE;
 		}
-		return false;
+		return null;
 	}
 
 	private ConstraintTypeFormula combineSameSame(TypeBound boundS, TypeBound boundT, Map<InferenceVariable,TypeBound> properTypesByInferenceVariable) {
@@ -881,7 +892,7 @@ private ConstraintTypeFormula combineEqualSupers(TypeBound boundS, TypeBound bou
 			innerSame = true; // came in as: S REL α and α REL T imply ⟨S REL T⟩
 		if (outerSame) {
 			if (innerSame) // NON-JLS bidirectional subtyping implies equality:
-				return ConstraintTypeFormula.create(boundS.left, boundS.right, ReductionResult.SAME, false);
+				return ConstraintTypeFormula.create(boundS.left, boundS.right, ReductionResult.SAME, boundT.isSoft||boundS.isSoft);
 			return ConstraintTypeFormula.create(boundT.left, boundS.right, boundS.relation, boundT.isSoft||boundS.isSoft);
 		} else if (innerSame) {
 			return ConstraintTypeFormula.create(boundS.left, boundT.right, boundS.relation, boundT.isSoft||boundS.isSoft);
@@ -1082,6 +1093,32 @@ public boolean hasOnlyTrivialExceptionBounds(InferenceVariable variable, TypeBin
 		return true;
 	}
 
+	public int rankIVar(InferenceVariable ivar) {
+		// implements the ranking of ivars according to their bounds as explained in
+		// https://mail.openjdk.org/archives/list/compiler-dev@openjdk.org/message/GN6RTCGMME6I5JVLSFZRIR32XY6QKOI2/
+		ThreeSets three = this.boundsPerVariable.get(ivar.prototype());
+		if (three != null) {
+			if (three.sameBounds != null)
+				if (!three.sameBounds.isEmpty())
+					return 1;
+			if (this.isRecordPatternInference) {
+				// workaround for not having inverse bounds of type SAME (see addBound(TypeBound, LookupEnvironment)):
+				for (ThreeSets dep3 : this.boundsPerVariable.values()) {
+					if (dep3 != null && dep3.sameBounds != null) {
+						for (TypeBound depBound : dep3.sameBounds) {
+							if (depBound.right.equals(ivar))
+								return 1;
+						}
+					}
+				}
+			}
+			if (three.superBounds != null)
+				if (!three.superBounds.isEmpty())
+						return 2;
+		}
+		return 3;
+	}
+
 	/**
 	 * JLS 18.1.3:
 	 * Answer all upper bounds for the given inference variable as defined by any bounds in this set.