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

equal deleted inserted replaced

-:0ea78d6e0b7b
+:b4b0377b8dba
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.code.Type.UndetVar.InferenceBound;
+import com.sun.tools.javac.comp.DeferredAttr.AttrMode;
 import com.sun.tools.javac.comp.Resolve.InapplicableMethodException;
 import com.sun.tools.javac.comp.Resolve.VerboseResolutionMode;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.JCTree.JCTypeCast;
 import com.sun.tools.javac.tree.TreeInfo;
 Symtab syms;
 Types types;
 Check chk;
 Resolve rs;
+DeferredAttr deferredAttr;
 Log log;
 JCDiagnostic.Factory diags;
 public static Infer instance(Context context) {
 Infer instance = context.get(inferKey);
 protected Infer(Context context) {
 context.put(inferKey, this);
 syms = Symtab.instance(context);
 types = Types.instance(context);
 rs = Resolve.instance(context);
+deferredAttr = DeferredAttr.instance(context);
 log = Log.instance(context);
 chk = Check.instance(context);
 diags = JCDiagnostic.Factory.instance(context);
 inferenceException = new InferenceException(diags);
 }
 InferenceContext inferenceContext,
 MethodType mtype,
 Attr.ResultInfo resultInfo,
 Warner warn) throws InferenceException {
 Type to = resultInfo.pt;
-if (to.tag == NONE) {
+if (to.tag == NONE || resultInfo.checkContext.inferenceContext().free(resultInfo.pt)) {
 to = mtype.getReturnType().tag <= VOID ?
 mtype.getReturnType() : syms.objectType;
 }
 Type qtype1 = inferenceContext.asFree(mtype.getReturnType(), types);
 if (!types.isSubtype(qtype1,
 Attr.ResultInfo resultInfo,
 Symbol 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, this);
 inferenceException.clear();
 try {
-rs.checkRawArgumentsAcceptable(env, inferenceContext, argtypes, mt.getParameterTypes(),
+rs.checkRawArgumentsAcceptable(env, msym, resolveContext.attrMode(), inferenceContext,
-allowBoxing, useVarargs, warn, new InferenceCheckHandler(inferenceContext));
+argtypes, mt.getParameterTypes(), allowBoxing, useVarargs, warn,
+new InferenceCheckHandler(inferenceContext));
 // minimize as yet undetermined type variables
 for (Type t : inferenceContext.undetvars) {
 minimizeInst((UndetVar)t, warn);
 }
 * method signature. The target return type is computed from the immediately
 * enclosing scope surrounding the polymorphic-signature call.
 */
 Type instantiatePolymorphicSignatureInstance(Env<AttrContext> env,
 MethodSymbol spMethod,  // sig. poly. method or null if none
+Resolve.MethodResolutionContext resolveContext,
 List<Type> argtypes) {
 final Type restype;
 //The return type for a polymorphic signature call is computed from
 //the enclosing tree E, as follows: if E is a cast, then use the
 break;
 default:
 restype = syms.objectType;
 }
-List<Type> paramtypes = Type.map(argtypes, implicitArgType);
+List<Type> paramtypes = Type.map(argtypes, new ImplicitArgType(spMethod, resolveContext.step));
 List<Type> exType = spMethod != null ?
 spMethod.getThrownTypes() :
 List.of(syms.throwableType); // make it throw all exceptions
 MethodType mtype = new MethodType(paramtypes,
 exType,
 syms.methodClass);
 return mtype;
 }
 //where
-Mapping implicitArgType = new Mapping ("implicitArgType") {
+class ImplicitArgType extends DeferredAttr.DeferredTypeMap {
-public Type apply(Type t) {
-t = types.erasure(t);
+public ImplicitArgType(Symbol msym, Resolve.MethodResolutionPhase phase) {
-if (t.tag == BOT)
+deferredAttr.super(AttrMode.SPECULATIVE, msym, phase);
-// nulls type as the marker type Null (which has no instances)
+}
-// infer as java.lang.Void for now
-t = types.boxedClass(syms.voidType).type;
+public Type apply(Type t) {
-return t;
+t = types.erasure(super.apply(t));
-}
+if (t.tag == BOT)
-};
+// nulls type as the marker type Null (which has no instances)
+// infer as java.lang.Void for now
+t = types.boxedClass(syms.voidType).type;
+return t;
+}
+}
 /**
 * Mapping that turns inference variables into undet vars
 * (used by inference context)
 */
 //thrown when processing listeners as a single one
 if (thrownEx != null) {
 throw thrownEx;
 }
 }
+void solveAny(List<Type> varsToSolve, Types types, Infer infer) {
+boolean progress = false;
+for (Type t : varsToSolve) {
+UndetVar uv = (UndetVar)asFree(t, types);
+if (uv.inst == null) {
+infer.minimizeInst(uv, Warner.noWarnings);
+if (uv.inst != null) {
+progress = true;
+}
+}
+}
+if (!progress) {
+throw infer.inferenceException.setMessage("cyclic.inference", varsToSolve);
+}
+}
 }
 final InferenceContext emptyContext = new InferenceContext(List.<Type>nil(), this);
 }

changeset 14057	b4b0377b8dba
parent 14048	308d1cf8fe46
child 14058	c7ec7facdd20