jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java

equal deleted inserted replaced

-:ba5503adca64
+:8bdc63ff6961
 resultInfo != null &&
 !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
 //inject return constraints earlier
 doIncorporation(inferenceContext, warn); //propagation
-boolean shouldPropagate = resultInfo.checkContext.inferenceContext().free(resultInfo.pt);
+boolean shouldPropagate = shouldPropagate(mt.getReturnType(), resultInfo, inferenceContext);
 InferenceContext minContext = shouldPropagate ?
 inferenceContext.min(roots(mt, deferredAttrContext), true, warn) :
 inferenceContext;
 }
 dumpGraphsIfNeeded(env.tree, msym, resolveContext);
 }
 }
 //where
+private boolean shouldPropagate(Type restype, Attr.ResultInfo target, InferenceContext inferenceContext) {
+return target.checkContext.inferenceContext() != emptyContext && //enclosing context is a generic method
+inferenceContext.free(restype) && //return type contains inference vars
+(!inferenceContext.inferencevars.contains(restype) || //no eager instantiation is required (as per 18.5.2)
+!needsEagerInstantiation((UndetVar)inferenceContext.asUndetVar(restype), target.pt, inferenceContext));
+}
 private List<Type> roots(MethodType mt, DeferredAttrContext deferredAttrContext) {
 ListBuffer<Type> roots = new ListBuffer<>();
 roots.add(mt.getReturnType());
 if (deferredAttrContext != null && deferredAttrContext.mode == AttrMode.CHECK) {
 roots.addAll(mt.getThrownTypes());
 *  This constraints may pollute the inference context and make it useless in case we
 *  need to use it several times: with several targets.
 */
 saved_undet = inferenceContext.save();
 if (allowGraphInference && !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
-boolean shouldPropagate = resultInfo.checkContext.inferenceContext().free(resultInfo.pt);
+boolean shouldPropagate = shouldPropagate(getReturnType(), resultInfo, inferenceContext);
 InferenceContext minContext = shouldPropagate ?
 inferenceContext.min(roots(asMethodType(), null), false, warn) :
 inferenceContext;
 to = syms.voidType;
 } else if (to.hasTag(NONE)) {
 to = from.isPrimitive() ? from : syms.objectType;
 } else if (qtype.hasTag(UNDETVAR)) {
 if (resultInfo.pt.isReference()) {
-to = generateReturnConstraintsUndetVarToReference(
+if (needsEagerInstantiation((UndetVar)qtype, to, inferenceContext)) {
-tree, (UndetVar)qtype, to, resultInfo, inferenceContext);
+to = generateReferenceToTargetConstraint(tree, (UndetVar)qtype, to, resultInfo, inferenceContext);
+}
 } else {
 if (to.isPrimitive()) {
 to = generateReturnConstraintsPrimitive(tree, (UndetVar)qtype, to,
 resultInfo, inferenceContext);
 }
 resultInfo, inferenceContext);
 }
 return types.boxedClass(to).type;
 }
-private Type generateReturnConstraintsUndetVarToReference(JCTree tree,
+private boolean needsEagerInstantiation(UndetVar from, Type to, InferenceContext inferenceContext) {
-UndetVar from, Type to, Attr.ResultInfo resultInfo,
-InferenceContext inferenceContext) {
 Type captureOfTo = types.capture(to);
 /* T is a reference type, but is not a wildcard-parameterized type, and either
 */
 if (captureOfTo == to) { //not a wildcard parameterized type
 /* i) B2 contains a bound of one of the forms alpha = S or S <: alpha,
 *      where S is a wildcard-parameterized type, or
 */
 for (Type t : from.getBounds(InferenceBound.EQ, InferenceBound.LOWER)) {
 Type captureOfBound = types.capture(t);
 if (captureOfBound != t) {
-return generateReferenceToTargetConstraint(tree, from, to,
+return true;
-resultInfo, inferenceContext);
 }
 }
 /* ii) B2 contains two bounds of the forms S1 <: alpha and S2 <: alpha,
 * where S1 and S2 have supertypes that are two different
 for (Type anotherLowerBound : from.getBounds(InferenceBound.LOWER)) {
 if (aLowerBound != anotherLowerBound &&
 !inferenceContext.free(aLowerBound) &&
 !inferenceContext.free(anotherLowerBound) &&
 commonSuperWithDiffParameterization(aLowerBound, anotherLowerBound)) {
-return generateReferenceToTargetConstraint(tree, from, to,
+return true;
-resultInfo, inferenceContext);
 }
 }
 }
 }
 */
 if (to.isParameterized()) {
 for (Type t : from.getBounds(InferenceBound.EQ, InferenceBound.LOWER)) {
 Type sup = types.asSuper(t, to.tsym);
 if (sup != null && sup.isRaw()) {
-return generateReferenceToTargetConstraint(tree, from, to,
+return true;
-resultInfo, inferenceContext);
+}
 }
 }
-}
+return false;
-return to;
 }
 private boolean commonSuperWithDiffParameterization(Type t, Type s) {
 for (Pair<Type, Type> supers : getParameterizedSupers(t, s)) {
 if (!types.isSameType(supers.fst, supers.snd)) return true;
 public boolean accepts(UndetVar t, InferenceContext inferenceContext) {
 if ((t.qtype.tsym.flags() & Flags.THROWS) == 0) {
 //not a throws undet var
 return false;
 }
-if (t.getBounds(InferenceBound.EQ, InferenceBound.LOWER, InferenceBound.UPPER)
-.diff(t.getDeclaredBounds()).nonEmpty()) {
-//not an unbounded undet var
-return false;
-}
 Infer infer = inferenceContext.infer;
-for (Type db : t.getDeclaredBounds()) {
+for (Type db : t.getBounds(InferenceBound.UPPER)) {
 if (t.isInterface()) continue;
-if (infer.types.asSuper(infer.syms.runtimeExceptionType, db.tsym) != null) {
+if (infer.types.asSuper(infer.syms.runtimeExceptionType, db.tsym) == null) {
-//declared bound is a supertype of RuntimeException
+//upper bound is not a supertype of RuntimeException - give up
-return true;
+return false;
 }
 }
-//declared bound is more specific then RuntimeException - give up
-return false;
+return true;
 }
 @Override
 Type solve(UndetVar uv, InferenceContext inferenceContext) {
 return inferenceContext.infer.syms.runtimeExceptionType;

changeset 38538	8bdc63ff6961
parent 38516	b643c42e9d25
child 38832	759100b68651