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

-:3ac205ad1f05
+:22872b24d38c
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Type.*;
+import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.util.JCDiagnostic;
 import static com.sun.tools.javac.code.TypeTags.*;
 /** Helper class for type parameter inference, used by the attribution phase.
 /** A value for prototypes that admit any type, including polymorphic ones. */
 public static final Type anyPoly = new Type(NONE, null);
 Symtab syms;
 Types types;
+Resolve rs;
 JCDiagnostic.Factory diags;
 public static Infer instance(Context context) {
 Infer instance = context.get(inferKey);
 if (instance == null)
 protected Infer(Context context) {
 context.put(inferKey, this);
 syms = Symtab.instance(context);
 types = Types.instance(context);
+rs = Resolve.instance(context);
 diags = JCDiagnostic.Factory.instance(context);
 ambiguousNoInstanceException =
 new NoInstanceException(true, diags);
 unambiguousNoInstanceException =
 new NoInstanceException(false, diags);
-}
+invalidInstanceException =
+new InvalidInstanceException(diags);
-public static class NoInstanceException extends RuntimeException {
+}
+public static class InferenceException extends RuntimeException {
 private static final long serialVersionUID = 0;
-boolean isAmbiguous; // exist several incomparable best instances?
 JCDiagnostic diagnostic;
 JCDiagnostic.Factory diags;
+InferenceException(JCDiagnostic.Factory diags) {
+this.diagnostic = null;
+this.diags = diags;
+}
+InferenceException setMessage(String key, Object... args) {
+this.diagnostic = diags.fragment(key, args);
+return this;
+}
+public JCDiagnostic getDiagnostic() {
+return diagnostic;
+}
+}
+public static class NoInstanceException extends InferenceException {
+private static final long serialVersionUID = 1;
+boolean isAmbiguous; // exist several incomparable best instances?
 NoInstanceException(boolean isAmbiguous, JCDiagnostic.Factory diags) {
-this.diagnostic = null;
+super(diags);
 this.isAmbiguous = isAmbiguous;
-this.diags = diags;
+}
 }
-NoInstanceException setMessage(String key) {
-this.diagnostic = diags.fragment(key);
+public static class InvalidInstanceException extends InferenceException {
-return this;
+private static final long serialVersionUID = 2;
-}
-NoInstanceException setMessage(String key, Object arg1) {
+InvalidInstanceException(JCDiagnostic.Factory diags) {
-this.diagnostic = diags.fragment(key, arg1);
+super(diags);
-return this;
+}
 }
-NoInstanceException setMessage(String key, Object arg1, Object arg2) {
-this.diagnostic = diags.fragment(key, arg1, arg2);
-return this;
-}
-NoInstanceException setMessage(String key, Object arg1, Object arg2, Object arg3) {
-this.diagnostic = diags.fragment(key, arg1, arg2, arg3);
-return this;
-}
-public JCDiagnostic getDiagnostic() {
-return diagnostic;
-}
-}
 private final NoInstanceException ambiguousNoInstanceException;
 private final NoInstanceException unambiguousNoInstanceException;
+private final InvalidInstanceException invalidInstanceException;
 /***************************************************************************
 * Auxiliary type values and classes
 ***************************************************************************/
 *  If no instantiation exists, or if several incomparable
 *  best instantiations exist throw a NoInstanceException.
 */
 public Type instantiateExpr(ForAll that,
 Type to,
-Warner warn) throws NoInstanceException {
+Warner warn) throws InferenceException {
 List<Type> undetvars = Type.map(that.tvars, fromTypeVarFun);
 for (List<Type> l = undetvars; l.nonEmpty(); l = l.tail) {
 UndetVar v = (UndetVar) l.head;
 ListBuffer<Type> hibounds = new ListBuffer<Type>();
 for (List<Type> l1 = types.getBounds((TypeVar) v.qtype); l1.nonEmpty(); l1 = l1.tail) {
 // check bounds
 List<Type> targs = Type.map(undetvars, getInstFun);
 targs = types.subst(targs, that.tvars, targs);
 checkWithinBounds(that.tvars, targs, warn);
+return that.inst(targs, types);
-return getInstFun.apply(qtype1);
 }
 /** Instantiate method type `mt' by finding instantiations of
 *  `tvars' so that method can be applied to `argtypes'.
 */
 public Type instantiateMethod(List<Type> tvars,
 MethodType mt,
-List<Type> argtypes,
+final List<Type> argtypes,
-boolean allowBoxing,
+final boolean allowBoxing,
-boolean useVarargs,
+final boolean useVarargs,
-Warner warn) throws NoInstanceException {
+final Warner warn) throws InferenceException {
 //-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG
 List<Type> undetvars = Type.map(tvars, fromTypeVarFun);
 List<Type> formals = mt.argtypes;
+//need to capture exactly once - otherwise subsequent
+//applicability checks might fail
+final List<Type> capturedArgs = types.capture(argtypes);
+List<Type> actuals = capturedArgs;
+List<Type> actualsNoCapture = argtypes;
 // instantiate all polymorphic argument types and
 // set up lower bounds constraints for undetvars
 Type varargsFormal = useVarargs ? formals.last() : null;
-while (argtypes.nonEmpty() && formals.head != varargsFormal) {
+while (actuals.nonEmpty() && formals.head != varargsFormal) {
-Type ft = formals.head;
+Type formal = formals.head;
-Type at = argtypes.head.baseType();
+Type actual = actuals.head.baseType();
-if (at.tag == FORALL)
+Type actualNoCapture = actualsNoCapture.head.baseType();
-at = instantiateArg((ForAll) at, ft, tvars, warn);
+if (actual.tag == FORALL)
-Type sft = types.subst(ft, tvars, undetvars);
+actual = instantiateArg((ForAll)actual, formal, tvars, warn);
+Type undetFormal = types.subst(formal, tvars, undetvars);
 boolean works = allowBoxing
-? types.isConvertible(at, sft, warn)
+? types.isConvertible(actual, undetFormal, warn)
-: types.isSubtypeUnchecked(at, sft, warn);
+: types.isSubtypeUnchecked(actual, undetFormal, warn);
 if (!works) {
 throw unambiguousNoInstanceException
 .setMessage("no.conforming.assignment.exists",
-tvars, at, ft);
+tvars, actualNoCapture, formal);
 }
 formals = formals.tail;
-argtypes = argtypes.tail;
+actuals = actuals.tail;
+actualsNoCapture = actualsNoCapture.tail;
 }
 if (formals.head != varargsFormal || // not enough args
-!useVarargs && argtypes.nonEmpty()) { // too many args
+!useVarargs && actuals.nonEmpty()) { // too many args
 // argument lists differ in length
 throw unambiguousNoInstanceException
 .setMessage("arg.length.mismatch");
 }
 // for varargs arguments as well
 if (useVarargs) {
-Type elt = types.elemtype(varargsFormal);
+Type elemType = types.elemtype(varargsFormal);
-Type sft = types.subst(elt, tvars, undetvars);
+Type elemUndet = types.subst(elemType, tvars, undetvars);
-while (argtypes.nonEmpty()) {
+while (actuals.nonEmpty()) {
-Type ft = sft;
+Type actual = actuals.head.baseType();
-Type at = argtypes.head.baseType();
+Type actualNoCapture = actualsNoCapture.head.baseType();
-if (at.tag == FORALL)
+if (actual.tag == FORALL)
-at = instantiateArg((ForAll) at, ft, tvars, warn);
+actual = instantiateArg((ForAll)actual, elemType, tvars, warn);
-boolean works = types.isConvertible(at, sft, warn);
+boolean works = types.isConvertible(actual, elemUndet, warn);
 if (!works) {
 throw unambiguousNoInstanceException
 .setMessage("no.conforming.assignment.exists",
-tvars, at, ft);
+tvars, actualNoCapture, elemType);
 }
-argtypes = argtypes.tail;
+actuals = actuals.tail;
+actualsNoCapture = actualsNoCapture.tail;
 }
 }
 // minimize as yet undetermined type variables
 for (Type t : undetvars)
 undettypes.append(uv.inst);
 }
 }
 checkWithinBounds(tvars, undettypes.toList(), warn);
+mt = (MethodType)types.subst(mt, tvars, insttypes.toList());
 if (!restvars.isEmpty()) {
 // if there are uninstantiated variables,
 // quantify result type with them
-mt = new MethodType(mt.argtypes,
+final List<Type> inferredTypes = insttypes.toList();
-new ForAll(restvars.toList(), mt.restype),
+final List<Type> all_tvars = tvars; //this is the wrong tvars
-mt.thrown, syms.methodClass);
+final MethodType mt2 = new MethodType(mt.argtypes, null, mt.thrown, syms.methodClass);
-}
+mt2.restype = new ForAll(restvars.toList(), mt.restype) {
+@Override
-// return instantiated version of method type
+public Type inst(List<Type> inferred, Types types) throws NoInstanceException {
-return types.subst(mt, tvars, insttypes.toList());
+List<Type> formals = types.subst(mt2.argtypes, tvars, inferred);
+if (!rs.argumentsAcceptable(capturedArgs, formals,
+allowBoxing, useVarargs, warn)) {
+// inferred method is not applicable
+throw invalidInstanceException.setMessage("inferred.do.not.conform.to.params", formals, argtypes);
+}
+// check that inferred bounds conform to their bounds
+checkWithinBounds(all_tvars,
+types.subst(inferredTypes, tvars, inferred), warn);
+return super.inst(inferred, types);
+}};
+return mt2;
+}
+else if (!rs.argumentsAcceptable(capturedArgs, mt.getParameterTypes(), allowBoxing, useVarargs, warn)) {
+// inferred method is not applicable
+throw invalidInstanceException.setMessage("inferred.do.not.conform.to.params", mt.getParameterTypes(), argtypes);
+}
+else {
+// return instantiated version of method type
+return mt;
+}
 }
 //where
 /** Try to instantiate argument type `that' to given type `to'.
 *  If this fails, try to insantiate `that' to `to' where
 *  by an unknown type.
 */
 private Type instantiateArg(ForAll that,
 Type to,
 List<Type> tvars,
-Warner warn) throws NoInstanceException {
+Warner warn) throws InferenceException {
 List<Type> targs;
 try {
 return instantiateExpr(that, to, warn);
 } catch (NoInstanceException ex) {
 Type to1 = to;
 /** check that type parameters are within their bounds.
 */
 private void checkWithinBounds(List<Type> tvars,
 List<Type> arguments,
 Warner warn)
-throws NoInstanceException {
+throws InvalidInstanceException {
 for (List<Type> tvs = tvars, args = arguments;
 tvs.nonEmpty();
 tvs = tvs.tail, args = args.tail) {
 if (args.head instanceof UndetVar) continue;
 List<Type> bounds = types.subst(types.getBounds((TypeVar)tvs.head), tvars, arguments);
 if (!types.isSubtypeUnchecked(args.head, bounds, warn))
-throw unambiguousNoInstanceException
+throw invalidInstanceException
 .setMessage("inferred.do.not.conform.to.bounds",
-arguments, tvars);
+args.head, bounds);
 }
 }
 }

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