jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Infer.java

-:d02e9b7444fe
+:14979dd5e034
 // <editor-fold defaultstate="collapsed" desc="Inference routines">
 /**
 * Main inference entry point - instantiate a generic method type
 * using given argument types and (possibly) an expected target-type.
 */
-public Type instantiateMethod(Env<AttrContext> env,
+Type instantiateMethod( Env<AttrContext> env,
 List<Type> tvars,
 MethodType mt,
 Attr.ResultInfo resultInfo,
-Symbol msym,
+MethodSymbol msym,
 List<Type> argtypes,
 boolean allowBoxing,
 boolean useVarargs,
 Resolve.MethodResolutionContext resolveContext,
 Warner warn) throws InferenceException {
 //-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG
-final InferenceContext inferenceContext = new InferenceContext(tvars);
+final InferenceContext inferenceContext = new InferenceContext(tvars);  //B0
 inferenceException.clear();
 try {
 DeferredAttr.DeferredAttrContext deferredAttrContext =
 resolveContext.deferredAttrContext(msym, inferenceContext, resultInfo, warn);
-resolveContext.methodCheck.argumentsAcceptable(env, deferredAttrContext,
+resolveContext.methodCheck.argumentsAcceptable(env, deferredAttrContext,   //B2
 argtypes, mt.getParameterTypes(), warn);
 if (allowGraphInference &&
 resultInfo != null &&
 !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
 //inject return constraints earlier
 checkWithinBounds(inferenceContext, warn); //propagation
-Type newRestype = generateReturnConstraints(resultInfo, mt, inferenceContext);
+Type newRestype = generateReturnConstraints(env.tree, resultInfo,  //B3
+mt, inferenceContext);
 mt = (MethodType)types.createMethodTypeWithReturn(mt, newRestype);
 //propagate outwards if needed
 if (resultInfo.checkContext.inferenceContext().free(resultInfo.pt)) {
 //propagate inference context outwards and exit
 inferenceContext.dupTo(resultInfo.checkContext.inferenceContext());
 if (!allowGraphInference &&
 inferenceContext.restvars().nonEmpty() &&
 resultInfo != null &&
 !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
-generateReturnConstraints(resultInfo, mt, inferenceContext);
+generateReturnConstraints(env.tree, resultInfo, mt, inferenceContext);
 inferenceContext.solveLegacy(false, warn, LegacyInferenceSteps.EQ_UPPER.steps); //maximizeInst
 mt = (MethodType)inferenceContext.asInstType(mt);
 }
 if (resultInfo != null && rs.verboseResolutionMode.contains(VerboseResolutionMode.DEFERRED_INST)) {
 if (resultInfo != null || !allowGraphInference) {
 inferenceContext.notifyChange();
 } else {
 inferenceContext.notifyChange(inferenceContext.boundedVars());
 }
+if (resultInfo == null) {
+/* if the is no result info then we can clear the capture types
+* cache without affecting any result info check
+*/
+inferenceContext.captureTypeCache.clear();
+}
 }
 }
 /**
 * Generate constraints from the generic method's return type. If the method
 * call occurs in a context where a type T is expected, use the expected
 * type to derive more constraints on the generic method inference variables.
 */
-Type generateReturnConstraints(Attr.ResultInfo resultInfo,
+Type generateReturnConstraints(JCTree tree, Attr.ResultInfo resultInfo,
 MethodType mt, InferenceContext inferenceContext) {
 InferenceContext rsInfoInfContext = resultInfo.checkContext.inferenceContext();
 Type from = mt.getReturnType();
 if (mt.getReturnType().containsAny(inferenceContext.inferencevars) &&
 rsInfoInfContext != emptyContext) {
 if (t.hasTag(TYPEVAR) && ((TypeVar)t).isCaptured()) {
 inferenceContext.addVar((TypeVar)t);
 }
 }
 }
-Type qtype1 = inferenceContext.asUndetVar(from);
+Type qtype = inferenceContext.asUndetVar(from);
-Type to = returnConstraintTarget(qtype1, resultInfo.pt);
+Type to = resultInfo.pt;
+if (qtype.hasTag(VOID)) {
+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(
+tree, (UndetVar)qtype, to, resultInfo, inferenceContext);
+} else {
+if (to.isPrimitive()) {
+to = generateReturnConstraintsPrimitive(tree, (UndetVar)qtype, to,
+resultInfo, inferenceContext);
+}
+}
+}
 Assert.check(allowGraphInference || !rsInfoInfContext.free(to),
 "legacy inference engine cannot handle constraints on both sides of a subtyping assertion");
 //we need to skip capture?
 Warner retWarn = new Warner();
-if (!resultInfo.checkContext.compatible(qtype1, rsInfoInfContext.asUndetVar(to), retWarn) ||
+if (!resultInfo.checkContext.compatible(qtype, rsInfoInfContext.asUndetVar(to), retWarn) ||
 //unchecked conversion is not allowed in source 7 mode
 (!allowGraphInference && retWarn.hasLint(Lint.LintCategory.UNCHECKED))) {
 throw inferenceException
 .setMessage("infer.no.conforming.instance.exists",
 inferenceContext.restvars(), mt.getReturnType(), to);
 }
 return from;
 }
-Type returnConstraintTarget(Type from, Type to) {
+private Type generateReturnConstraintsPrimitive(JCTree tree, UndetVar from,
-if (from.hasTag(VOID)) {
+Type to, Attr.ResultInfo resultInfo, InferenceContext inferenceContext) {
-return syms.voidType;
+if (!allowGraphInference) {
-} else if (to.hasTag(NONE)) {
+//if legacy, just return boxed type
-return from.isPrimitive() ? from : syms.objectType;
-} else if (from.hasTag(UNDETVAR) && to.isPrimitive()) {
-if (!allowGraphInference) {
-//if legacy, just return boxed type
-return types.boxedClass(to).type;
-}
-//if graph inference we need to skip conflicting boxed bounds...
-UndetVar uv = (UndetVar)from;
-for (Type t : uv.getBounds(InferenceBound.EQ, InferenceBound.LOWER)) {
-Type boundAsPrimitive = types.unboxedType(t);
-if (boundAsPrimitive == null) continue;
-if (types.isConvertible(boundAsPrimitive, to)) {
-//effectively skip return-type constraint generation (compatibility)
-return syms.objectType;
-}
-}
 return types.boxedClass(to).type;
-} else {
+}
-return to;
+//if graph inference we need to skip conflicting boxed bounds...
-}
+for (Type t : from.getBounds(InferenceBound.EQ, InferenceBound.UPPER,
+InferenceBound.LOWER)) {
+Type boundAsPrimitive = types.unboxedType(t);
+if (boundAsPrimitive == null || boundAsPrimitive.hasTag(NONE)) {
+continue;
+}
+return generateReferenceToTargetConstraint(tree, from, to,
+resultInfo, inferenceContext);
+}
+return types.boxedClass(to).type;
+}
+private Type generateReturnConstraintsUndetVarToReference(JCTree tree,
+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,
+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
+* parameterizations of the same generic class or interface.
+*/
+for (Type aLowerBound : from.getBounds(InferenceBound.LOWER)) {
+for (Type anotherLowerBound : from.getBounds(InferenceBound.LOWER)) {
+if (aLowerBound != anotherLowerBound &&
+commonSuperWithDiffParameterization(aLowerBound, anotherLowerBound)) {
+/* self comment check if any lower bound may be and undetVar,
+* in that case the result of this call may be a false positive.
+* Should this be restricted to non free types?
+*/
+return generateReferenceToTargetConstraint(tree, from, to,
+resultInfo, inferenceContext);
+}
+}
+}
+}
+/* T is a parameterization of a generic class or interface, G,
+* and B2 contains a bound of one of the forms alpha = S or S <: alpha,
+* where there exists no type of the form G<...> that is a
+* supertype of S, but the raw type G is a supertype of S
+*/
+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,
+resultInfo, inferenceContext);
+}
+}
+}
+return to;
+}
+private boolean commonSuperWithDiffParameterization(Type t, Type s) {
+Pair<Type, Type> supers = getParameterizedSupers(t, s);
+return (supers != null && !types.isSameType(supers.fst, supers.snd));
+}
+private Type generateReferenceToTargetConstraint(JCTree tree, UndetVar from,
+Type to, Attr.ResultInfo resultInfo,
+InferenceContext inferenceContext) {
+inferenceContext.solve(List.of(from.qtype), new Warner());
+Type capturedType = resultInfo.checkContext.inferenceContext()
+.cachedCapture(tree, from.inst, false);
+if (types.isConvertible(capturedType,
+resultInfo.checkContext.inferenceContext().asUndetVar(to))) {
+//effectively skip additional return-type constraint generation (compatibility)
+return syms.objectType;
+}
+return to;
 }
 /**
 * Infer cyclic inference variables as described in 15.12.2.8.
 */
 /**
 * Copy variable in this inference context to the given context
 */
 void dupTo(final InferenceContext that) {
-that.inferencevars = that.inferencevars.appendList(inferencevars);
+that.inferencevars = that.inferencevars.appendList(
-that.undetvars = that.undetvars.appendList(undetvars);
+inferencevars.diff(that.inferencevars));
+that.undetvars = that.undetvars.appendList(
+undetvars.diff(that.undetvars));
 //set up listeners to notify original inference contexts as
 //propagated vars are inferred in new context
 for (Type t : inferencevars) {
 that.freeTypeListeners.put(new FreeTypeListener() {
 public void typesInferred(InferenceContext inferenceContext) {
 @Override
 public String toString() {
 return "Inference vars: " + inferencevars + '\n' +
 "Undet vars: " + undetvars;
 }
+/* Method Types.capture() generates a new type every time it's applied
+* to a wildcard parameterized type. This is intended functionality but
+* there are some cases when what you need is not to generate a new
+* captured type but to check that a previously generated captured type
+* is correct. There are cases when caching a captured type for later
+* reuse is sound. In general two captures from the same AST are equal.
+* This is why the tree is used as the key of the map below. This map
+* stores a Type per AST.
+*/
+Map<JCTree, Type> captureTypeCache = new HashMap<>();
+Type cachedCapture(JCTree tree, Type t, boolean readOnly) {
+Type captured = captureTypeCache.get(tree);
+if (captured != null) {
+return captured;
+}
+Type result = types.capture(t);
+if (result != t && !readOnly) { // then t is a wildcard parameterized type
+captureTypeCache.put(tree, result);
+}
+return result;
+}
 }
 final InferenceContext emptyContext = new InferenceContext(List.<Type>nil());
 // </editor-fold>
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Infer.java

src/share/classes/com/sun/tools/javac/comp/Infer.java