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

-:1985e35e97b2
+:7873d37f5b37
 Resolve rs;
 DeferredAttr deferredAttr;
 Log log;
 JCDiagnostic.Factory diags;
+/** Should we inject return-type constraints earlier? */
+boolean allowEarlyReturnConstraints;
 public static Infer instance(Context context) {
 Infer instance = context.get(inferKey);
 if (instance == null)
 instance = new Infer(context);
 return instance;
 deferredAttr = DeferredAttr.instance(context);
 log = Log.instance(context);
 chk = Check.instance(context);
 diags = JCDiagnostic.Factory.instance(context);
 inferenceException = new InferenceException(diags);
+allowEarlyReturnConstraints = Source.instance(context).allowEarlyReturnConstraints();
 }
 /**
 * This exception class is design to store a list of diagnostics corresponding
 * to inference errors that can arise during a method applicability check.
 public void instantiateUninferred(DiagnosticPosition pos,
 InferenceContext inferenceContext,
 MethodType mtype,
 Attr.ResultInfo resultInfo,
 Warner warn) throws InferenceException {
-Type to = resultInfo.pt;
-if (to.hasTag(NONE) || resultInfo.checkContext.inferenceContext().free(resultInfo.pt)) {
-to = mtype.getReturnType().isPrimitiveOrVoid() ?
-mtype.getReturnType() : syms.objectType;
-}
-Type qtype1 = inferenceContext.asFree(mtype.getReturnType(), types);
-if (!types.isSubtype(qtype1,
-qtype1.hasTag(UNDETVAR) ? types.boxedTypeOrType(to) : to)) {
-throw inferenceException
-.setMessage("infer.no.conforming.instance.exists",
-inferenceContext.restvars(), mtype.getReturnType(), to);
-}
 while (true) {
 boolean stuck = true;
 for (Type t : inferenceContext.undetvars) {
 UndetVar uv = (UndetVar)t;
 if (uv.inst == null && (uv.getBounds(InferenceBound.EQ).nonEmpty() ||
 resolveContext.deferredAttrContext(msym, inferenceContext);
 try {
 methodCheck.argumentsAcceptable(env, deferredAttrContext, argtypes, mt.getParameterTypes(), warn);
+if (resultInfo != null && allowEarlyReturnConstraints &&
+!warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
+generateReturnConstraints(mt, inferenceContext, resultInfo);
+}
 deferredAttrContext.complete();
 // minimize as yet undetermined type variables
 for (Type t : inferenceContext.undetvars) {
 minimizeInst((UndetVar)t, warn);
 List<Type> restvars = inferenceContext.restvars();
 if (!restvars.isEmpty()) {
 if (resultInfo != null && !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
+if (!allowEarlyReturnConstraints) {
+generateReturnConstraints(mt, inferenceContext, resultInfo);
+}
 instantiateUninferred(env.tree.pos(), inferenceContext, mt, resultInfo, warn);
 checkWithinBounds(inferenceContext, warn);
 mt = (MethodType)inferenceContext.asInstType(mt, types);
 if (rs.verboseResolutionMode.contains(VerboseResolutionMode.DEFERRED_INST)) {
 log.note(env.tree.pos, "deferred.method.inst", msym, mt, resultInfo.pt);
 return mt;
 } finally {
 inferenceContext.notifyChange(types);
 }
 }
+//where
+void generateReturnConstraints(Type mt, InferenceContext inferenceContext, Attr.ResultInfo resultInfo) {
+if (resultInfo != null) {
+Type to = resultInfo.pt;
+if (to.hasTag(NONE) || resultInfo.checkContext.inferenceContext().free(resultInfo.pt)) {
+to = mt.getReturnType().isPrimitiveOrVoid() ?
+mt.getReturnType() : syms.objectType;
+}
+Type qtype1 = inferenceContext.asFree(mt.getReturnType(), types);
+if (!types.isSubtype(qtype1,
+qtype1.hasTag(UNDETVAR) ? types.boxedTypeOrType(to) : to)) {
+throw inferenceException
+.setMessage("infer.no.conforming.instance.exists",
+inferenceContext.restvars(), mt.getReturnType(), to);
+}
+}
+}
 /** check that type parameters are within their bounds.
 */
 void checkWithinBounds(InferenceContext inferenceContext,
 Warner warn) throws InferenceException {
 return funcInterface;
 } else {
 Type formalInterface = funcInterface.tsym.type;
 InferenceContext funcInterfaceContext =
 new InferenceContext(funcInterface.tsym.type.getTypeArguments(), this, false);
-if (paramTypes != null) {
+Assert.check(paramTypes != null);
 //get constraints from explicit params (this is done by
 //checking that explicit param types are equal to the ones
 //in the functional interface descriptors)
 List<Type> descParameterTypes = types.findDescriptorType(formalInterface).getParameterTypes();
 if (descParameterTypes.size() != paramTypes.size()) {
 checkContext.report(pos, diags.fragment("incompatible.arg.types.in.lambda"));
+return types.createErrorType(funcInterface);
+}
+for (Type p : descParameterTypes) {
+if (!types.isSameType(funcInterfaceContext.asFree(p, types), paramTypes.head)) {
+checkContext.report(pos, diags.fragment("no.suitable.functional.intf.inst", funcInterface));
 return types.createErrorType(funcInterface);
 }
-for (Type p : descParameterTypes) {
+paramTypes = paramTypes.tail;
-if (!types.isSameType(funcInterfaceContext.asFree(p, types), paramTypes.head)) {
+}
-checkContext.report(pos, diags.fragment("no.suitable.functional.intf.inst", funcInterface));
-return types.createErrorType(funcInterface);
-}
-paramTypes = paramTypes.tail;
-}
-for (Type t : funcInterfaceContext.undetvars) {
-UndetVar uv = (UndetVar)t;
-minimizeInst(uv, types.noWarnings);
-if (uv.inst == null &&
-Type.filter(uv.getBounds(InferenceBound.UPPER), boundFilter).nonEmpty()) {
-maximizeInst(uv, types.noWarnings);
-}
-}
-formalInterface = funcInterfaceContext.asInstType(formalInterface, types);
-}
-ListBuffer<Type> typeargs = ListBuffer.lb();
 List<Type> actualTypeargs = funcInterface.getTypeArguments();
-//for remaining uninferred type-vars in the functional interface type,
+for (Type t : funcInterfaceContext.undetvars) {
-//simply replace the wildcards with its bound
+UndetVar uv = (UndetVar)t;
-for (Type t : formalInterface.getTypeArguments()) {
+minimizeInst(uv, types.noWarnings);
-if (actualTypeargs.head.hasTag(WILDCARD)) {
+if (uv.inst == null &&
-WildcardType wt = (WildcardType)actualTypeargs.head;
+Type.filter(uv.getBounds(InferenceBound.UPPER), boundFilter).nonEmpty()) {
-typeargs.append(wt.type);
+maximizeInst(uv, types.noWarnings);
-} else {
+}
-typeargs.append(actualTypeargs.head);
+if (uv.inst == null) {
+uv.inst = actualTypeargs.head;
 }
 actualTypeargs = actualTypeargs.tail;
 }
-Type owntype = types.subst(formalInterface, funcInterfaceContext.inferenceVars(), typeargs.toList());
+Type owntype = funcInterfaceContext.asInstType(formalInterface, types);
 if (!chk.checkValidGenericType(owntype)) {
 //if the inferred functional interface type is not well-formed,
 //or if it's not a subtype of the original target, issue an error
 checkContext.report(pos, diags.fragment("no.suitable.functional.intf.inst", funcInterface));
-return types.createErrorType(funcInterface);
 }
 return owntype;
 }
 }
 // </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