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

-:c35b158e2290
+:6f0ed5a89c25
 import com.sun.tools.javac.tree.TreeInfo;
 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.Type.ForAll.ConstraintKind;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.comp.Resolve.InapplicableMethodException;
 import com.sun.tools.javac.comp.Resolve.VerboseResolutionMode;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 * Auxiliary type values and classes
 ***************************************************************************/
 /** A mapping that turns type variables into undetermined type variables.
 */
-Mapping fromTypeVarFun = new Mapping("fromTypeVarFun") {
+List<Type> makeUndetvars(List<Type> tvars) {
-public Type apply(Type t) {
+List<Type> undetvars = Type.map(tvars, fromTypeVarFun);
-if (t.tag == TYPEVAR) return new UndetVar(t);
+for (Type t : undetvars) {
-else return t.map(this);
+UndetVar uv = (UndetVar)t;
-}
+uv.hibounds = types.getBounds((TypeVar)uv.qtype);
-};
+}
+return undetvars;
-/** A mapping that returns its type argument with every UndetVar replaced
+}
-*  by its `inst' field. Throws a NoInstanceException
+//where
-*  if this not possible because an `inst' field is null.
+Mapping fromTypeVarFun = new Mapping("fromTypeVarFun") {
-*  Note: mutually referring undertvars will be left uninstantiated
+public Type apply(Type t) {
-*  (that is, they will be replaced by the underlying type-variable).
+if (t.tag == TYPEVAR) return new UndetVar(t);
-*/
+else return t.map(this);
+}
-Mapping getInstFun = new Mapping("getInstFun") {
+};
-public Type apply(Type t) {
-switch (t.tag) {
-case UNKNOWN:
-throw ambiguousNoInstanceException
-.setMessage("undetermined.type");
-case UNDETVAR:
-UndetVar that = (UndetVar) t;
-if (that.inst == null)
-throw ambiguousNoInstanceException
-.setMessage("type.variable.has.undetermined.type",
-that.qtype);
-return isConstraintCyclic(that) ?
-that.qtype :
-apply(that.inst);
-default:
-return t.map(this);
-}
-}
-private boolean isConstraintCyclic(UndetVar uv) {
-Types.UnaryVisitor<Boolean> constraintScanner =
-new Types.UnaryVisitor<Boolean>() {
-List<Type> seen = List.nil();
-Boolean visit(List<Type> ts) {
-for (Type t : ts) {
-if (visit(t)) return true;
-}
-return false;
-}
-public Boolean visitType(Type t, Void ignored) {
-return false;
-}
-@Override
-public Boolean visitClassType(ClassType t, Void ignored) {
-if (t.isCompound()) {
-return visit(types.supertype(t)) ||
-visit(types.interfaces(t));
-} else {
-return visit(t.getTypeArguments());
-}
-}
-@Override
-public Boolean visitWildcardType(WildcardType t, Void ignored) {
-return visit(t.type);
-}
-@Override
-public Boolean visitUndetVar(UndetVar t, Void ignored) {
-if (seen.contains(t)) {
-return true;
-} else {
-seen = seen.prepend(t);
-return visit(t.inst);
-}
-}
-};
-return constraintScanner.visit(uv);
-}
-};
 /***************************************************************************
 * Mini/Maximization of UndetVars
 ***************************************************************************/
 /** Instantiate undetermined type variable to its minimal upper bound.
 *  Throw a NoInstanceException if this not possible.
 */
 void maximizeInst(UndetVar that, Warner warn) throws NoInstanceException {
 List<Type> hibounds = Type.filter(that.hibounds, errorFilter);
-if (that.inst == null) {
+if (that.eq.isEmpty()) {
 if (hibounds.isEmpty())
 that.inst = syms.objectType;
 else if (hibounds.tail.isEmpty())
 that.inst = hibounds.head;
 else
 that.inst = types.glb(hibounds);
+} else {
+that.inst = that.eq.head;
 }
 if (that.inst == null ||
 that.inst.isErroneous())
 throw ambiguousNoInstanceException
 .setMessage("no.unique.maximal.instance.exists",
 that.qtype, hibounds);
 }
-//where
-private boolean isSubClass(Type t, final List<Type> ts) {
-t = t.baseType();
-if (t.tag == TYPEVAR) {
-List<Type> bounds = types.getBounds((TypeVar)t);
-for (Type s : ts) {
-if (!types.isSameType(t, s.baseType())) {
-for (Type bound : bounds) {
-if (!isSubClass(bound, List.of(s.baseType())))
-return false;
-}
-}
-}
-} else {
-for (Type s : ts) {
-if (!t.tsym.isSubClass(s.baseType().tsym, types))
-return false;
-}
-}
-return true;
-}
 private Filter<Type> errorFilter = new Filter<Type>() {
 @Override
 public boolean accepts(Type t) {
 return !t.isErroneous();
 /** Instantiate undetermined type variable to the lub of all its lower bounds.
 *  Throw a NoInstanceException if this not possible.
 */
 void minimizeInst(UndetVar that, Warner warn) throws NoInstanceException {
 List<Type> lobounds = Type.filter(that.lobounds, errorFilter);
-if (that.inst == null) {
+if (that.eq.isEmpty()) {
 if (lobounds.isEmpty())
 that.inst = syms.botType;
 else if (lobounds.tail.isEmpty())
 that.inst = lobounds.head.isPrimitive() ? syms.errType : lobounds.head;
 else {
 }
 if (that.inst == null || that.inst.tag == ERROR)
 throw ambiguousNoInstanceException
 .setMessage("no.unique.minimal.instance.exists",
 that.qtype, lobounds);
-// VGJ: sort of inlined maximizeInst() below.  Adding
+} else {
-// bounds can cause lobounds that are above hibounds.
+that.inst = that.eq.head;
-List<Type> hibounds = Type.filter(that.hibounds, errorFilter);
-Type hb = null;
-if (hibounds.isEmpty())
-hb = syms.objectType;
-else if (hibounds.tail.isEmpty())
-hb = hibounds.head;
-else
-hb = types.glb(hibounds);
-if (hb == null ||
-hb.isErroneous())
-throw ambiguousNoInstanceException
-.setMessage("incompatible.upper.bounds",
-that.qtype, hibounds);
 }
 }
 Type asUndetType(Type t, List<Type> undetvars) {
 return types.subst(t, inferenceVars(undetvars), undetvars);
 *  best instantiations exist throw a NoInstanceException.
 */
 public Type instantiateExpr(ForAll that,
 Type to,
 Warner warn) throws InferenceException {
-List<Type> undetvars = Type.map(that.tvars, fromTypeVarFun);
+List<Type> undetvars = that.undetvars();
-for (List<Type> l = undetvars; l.nonEmpty(); l = l.tail) {
-UndetVar uv = (UndetVar) l.head;
-TypeVar tv = (TypeVar)uv.qtype;
-ListBuffer<Type> hibounds = new ListBuffer<Type>();
-for (Type t : that.getConstraints(tv, ConstraintKind.EXTENDS)) {
-hibounds.append(types.subst(t, that.tvars, undetvars));
-}
-List<Type> inst = that.getConstraints(tv, ConstraintKind.EQUAL);
-if (inst.nonEmpty() && inst.head.tag != BOT) {
-uv.inst = inst.head;
-}
-uv.hibounds = hibounds.toList();
-}
 Type qtype1 = types.subst(that.qtype, that.tvars, undetvars);
 if (!types.isSubtype(qtype1,
 qtype1.tag == UNDETVAR ? types.boxedTypeOrType(to) : to)) {
 throw unambiguousNoInstanceException
 .setMessage("infer.no.conforming.instance.exists",
 that.tvars, that.qtype, to);
 }
-for (List<Type> l = undetvars; l.nonEmpty(); l = l.tail)
-maximizeInst((UndetVar) l.head, warn);
+List<Type> insttypes;
-// System.out.println(" = " + qtype1.map(getInstFun));//DEBUG
+while (true) {
+boolean stuck = true;
-// check bounds
+insttypes = List.nil();
-List<Type> targs = Type.map(undetvars, getInstFun);
+for (Type t : undetvars) {
-if (Type.containsAny(targs, that.tvars)) {
+UndetVar uv = (UndetVar)t;
-//replace uninferred type-vars
+if (uv.inst == null && (uv.eq.nonEmpty() || !Type.containsAny(uv.hibounds, that.tvars))) {
-targs = types.subst(targs,
+maximizeInst((UndetVar)t, warn);
+stuck = false;
+}
+insttypes = insttypes.append(uv.inst == null ? uv.qtype : uv.inst);
+}
+if (!Type.containsAny(insttypes, that.tvars)) {
+//all variables have been instantiated - exit
+break;
+} else if (stuck) {
+//some variables could not be instantiated because of cycles in
+//upper bounds - provide a (possibly recursive) default instantiation
+insttypes = types.subst(insttypes,
 that.tvars,
 instantiateAsUninferredVars(undetvars, that.tvars));
-}
+break;
-return that.inst(targs, types);
+} else {
-}
+//some variables have been instantiated - replace newly instantiated
-//where
+//variables in remaining upper bounds and continue
+for (Type t : undetvars) {
+UndetVar uv = (UndetVar)t;
+uv.hibounds = types.subst(uv.hibounds, that.tvars, insttypes);
+}
+}
+}
+return that.inst(insttypes, types);
+}
+/**
+* Infer cyclic inference variables as described in 15.12.2.8.
+*/
 private List<Type> instantiateAsUninferredVars(List<Type> undetvars, List<Type> tvars) {
 Assert.check(undetvars.length() == tvars.length());
-ListBuffer<Type> new_targs = ListBuffer.lb();
+ListBuffer<Type> insttypes = ListBuffer.lb();
-//step 1 - create synthetic captured vars
+ListBuffer<Type> todo = ListBuffer.lb();
+//step 1 - create fresh tvars
 for (Type t : undetvars) {
 UndetVar uv = (UndetVar)t;
-Type newArg = new CapturedType(t.tsym.name, t.tsym, uv.inst, syms.botType, null);
+if (uv.inst == null) {
-new_targs = new_targs.append(newArg);
+TypeSymbol fresh_tvar = new TypeSymbol(Flags.SYNTHETIC, uv.qtype.tsym.name, null, uv.qtype.tsym.owner);
-}
+fresh_tvar.type = new TypeVar(fresh_tvar, types.makeCompoundType(uv.hibounds), null);
-//step 2 - replace synthetic vars in their bounds
+todo.append(uv);
+uv.inst = fresh_tvar.type;
+}
+insttypes.append(uv.inst);
+}
+//step 2 - replace fresh tvars in their bounds
 List<Type> formals = tvars;
-for (Type t : new_targs.toList()) {
+for (Type t : todo) {
-CapturedType ct = (CapturedType)t;
+UndetVar uv = (UndetVar)t;
-ct.bound = types.subst(ct.bound, tvars, new_targs.toList());
+TypeVar ct = (TypeVar)uv.inst;
-WildcardType wt = new WildcardType(syms.objectType, BoundKind.UNBOUND, syms.boundClass);
+ct.bound = types.glb(types.subst(types.getBounds(ct), tvars, insttypes.toList()));
-wt.bound = (TypeVar)formals.head;
+if (ct.bound.isErroneous()) {
-ct.wildcard = wt;
+//report inference error if glb fails
+reportBoundError(uv, BoundErrorKind.BAD_UPPER);
+}
 formals = formals.tail;
 }
-return new_targs.toList();
+return insttypes.toList();
 }
 /** Instantiate method type `mt' by finding instantiations of
 *  `tvars' so that method can be applied to `argtypes'.
 */
 final List<Type> argtypes,
 final boolean allowBoxing,
 final boolean useVarargs,
 final Warner warn) throws InferenceException {
 //-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG
-List<Type> undetvars = Type.map(tvars, fromTypeVarFun);
+final List<Type> undetvars =  makeUndetvars(tvars);
 final List<Type> capturedArgs =
 rs.checkRawArgumentsAcceptable(env, undetvars, argtypes, mt.getParameterTypes(),
 allowBoxing, useVarargs, warn, new InferenceCheckHandler(undetvars));
 } else {
 insttypes.append(uv.inst);
 undettypes.append(uv.inst);
 }
 }
-checkWithinBounds(tvars, undettypes.toList(), warn);
+checkWithinBounds(tvars, undetvars, insttypes.toList(), warn);
 mt = (MethodType)types.subst(mt, tvars, insttypes.toList());
 if (!restvars.isEmpty()) {
 // if there are uninstantiated variables,
 // quantify result type with them
 final List<Type> inferredTypes = insttypes.toList();
 final List<Type> all_tvars = tvars; //this is the wrong tvars
 return new UninferredMethodType(env.tree.pos(), msym, mt, restvars.toList()) {
 @Override
-List<Type> getConstraints(TypeVar tv, ConstraintKind ck) {
+List<Type> undetvars() {
-for (Type t : restundet.toList()) {
+return restundet.toList();
-UndetVar uv = (UndetVar)t;
-if (uv.qtype == tv) {
-switch (ck) {
-case EXTENDS: return uv.hibounds.appendList(types.subst(types.getBounds(tv), all_tvars, inferredTypes));
-case SUPER: return uv.lobounds;
-case EQUAL: return uv.inst != null ? List.of(uv.inst) : List.<Type>nil();
-}
-}
-}
-return List.nil();
 }
 @Override
 void instantiateReturnType(Type restype, List<Type> inferred, Types types) throws NoInstanceException {
 Type owntype = new MethodType(types.subst(getParameterTypes(), tvars, inferred),
 restype,
 qtype.tsym);
 // check that actuals conform to inferred formals
 warn.clear();
 checkArgumentsAcceptable(env, capturedArgs, owntype.getParameterTypes(), allowBoxing, useVarargs, warn);
 // check that inferred bounds conform to their bounds
-checkWithinBounds(all_tvars,
+checkWithinBounds(all_tvars, undetvars,
 types.subst(inferredTypes, tvars, inferred), warn);
 qtype = chk.checkMethod(owntype, msym, env, TreeInfo.args(env.tree), capturedArgs, useVarargs, warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED));
 }
 };
 }
 return qtype.map(f);
 }
 abstract void instantiateReturnType(Type restype, List<Type> inferred, Types types);
-abstract List<Type> getConstraints(TypeVar tv, ConstraintKind ck);
+abstract List<Type> undetvars();
 class UninferredReturnType extends ForAll {
 public UninferredReturnType(List<Type> tvars, Type restype) {
 super(tvars, restype);
 }
 log.note(pos, "deferred.method.inst", msym, UninferredMethodType.this.qtype, newRestype);
 }
 return UninferredMethodType.this.qtype.getReturnType();
 }
 @Override
-public List<Type> getConstraints(TypeVar tv, ConstraintKind ck) {
+public List<Type> undetvars() {
-return UninferredMethodType.this.getConstraints(tv, ck);
+return UninferredMethodType.this.undetvars();
 }
 }
 }
 private void checkArgumentsAcceptable(Env<AttrContext> env, List<Type> actuals, List<Type> formals,
 // inferred method is not applicable
 throw invalidInstanceException.setMessage(ex.getDiagnostic());
 }
 }
-/** Try to instantiate argument type `that' to given type `to'.
-*  If this fails, try to insantiate `that' to `to' where
-*  every occurrence of a type variable in `tvars' is replaced
-*  by an unknown type.
-*/
-private Type instantiateArg(ForAll that,
-Type to,
-List<Type> tvars,
-Warner warn) throws InferenceException {
-List<Type> targs;
-try {
-return instantiateExpr(that, to, warn);
-} catch (NoInstanceException ex) {
-Type to1 = to;
-for (List<Type> l = tvars; l.nonEmpty(); l = l.tail)
-to1 = types.subst(to1, List.of(l.head), List.of(syms.unknownType));
-return instantiateExpr(that, to1, warn);
-}
-}
 /** check that type parameters are within their bounds.
 */
 void checkWithinBounds(List<Type> tvars,
-List<Type> arguments,
+List<Type> undetvars,
-Warner warn)
+List<Type> arguments,
+Warner warn)
 throws InvalidInstanceException {
-for (List<Type> tvs = tvars, args = arguments;
+List<Type> args = arguments;
-tvs.nonEmpty();
+for (Type t : undetvars) {
-tvs = tvs.tail, args = args.tail) {
+UndetVar uv = (UndetVar)t;
-if (args.head instanceof UndetVar ||
+uv.hibounds = types.subst(uv.hibounds, tvars, arguments);
-tvars.head.getUpperBound().isErroneous()) continue;
+uv.lobounds = types.subst(uv.lobounds, tvars, arguments);
-List<Type> bounds = types.subst(types.getBounds((TypeVar)tvs.head), tvars, arguments);
+uv.eq = types.subst(uv.eq, tvars, arguments);
-if (!types.isSubtypeUnchecked(args.head, bounds, warn))
+checkCompatibleUpperBounds(uv, tvars);
-throw invalidInstanceException
+if (args.head.tag != TYPEVAR || !args.head.containsAny(tvars)) {
-.setMessage("inferred.do.not.conform.to.bounds",
+Type inst = args.head;
-args.head, bounds);
+for (Type u : uv.hibounds) {
-}
+if (!types.isSubtypeUnchecked(inst, types.subst(u, tvars, undetvars), warn)) {
+reportBoundError(uv, BoundErrorKind.UPPER);
+}
+}
+for (Type l : uv.lobounds) {
+if (!types.isSubtypeUnchecked(types.subst(l, tvars, undetvars), inst, warn)) {
+reportBoundError(uv, BoundErrorKind.LOWER);
+}
+}
+for (Type e : uv.eq) {
+if (!types.isSameType(inst, types.subst(e, tvars, undetvars))) {
+reportBoundError(uv, BoundErrorKind.EQ);
+}
+}
+}
+args = args.tail;
+}
+}
+void checkCompatibleUpperBounds(UndetVar uv, List<Type> tvars) {
+// VGJ: sort of inlined maximizeInst() below.  Adding
+// bounds can cause lobounds that are above hibounds.
+ListBuffer<Type> hiboundsNoVars = ListBuffer.lb();
+for (Type t : Type.filter(uv.hibounds, errorFilter)) {
+if (!t.containsAny(tvars)) {
+hiboundsNoVars.append(t);
+}
+}
+List<Type> hibounds = hiboundsNoVars.toList();
+Type hb = null;
+if (hibounds.isEmpty())
+hb = syms.objectType;
+else if (hibounds.tail.isEmpty())
+hb = hibounds.head;
+else
+hb = types.glb(hibounds);
+if (hb == null || hb.isErroneous())
+reportBoundError(uv, BoundErrorKind.BAD_UPPER);
+}
+enum BoundErrorKind {
+BAD_UPPER() {
+@Override
+InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+return ex.setMessage("incompatible.upper.bounds", uv.qtype, uv.hibounds);
+}
+},
+UPPER() {
+@Override
+InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+return ex.setMessage("inferred.do.not.conform.to.upper.bounds", uv.inst, uv.hibounds);
+}
+},
+LOWER() {
+@Override
+InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+return ex.setMessage("inferred.do.not.conform.to.lower.bounds", uv.inst, uv.lobounds);
+}
+},
+EQ() {
+@Override
+InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+return ex.setMessage("inferred.do.not.conform.to.eq.bounds", uv.inst, uv.eq);
+}
+};
+abstract InapplicableMethodException setMessage(InferenceException ex, UndetVar uv);
+}
+//where
+void reportBoundError(UndetVar uv, BoundErrorKind bk) {
+throw bk.setMessage(uv.inst == null ? ambiguousNoInstanceException : invalidInstanceException, uv);
 }
 /**
 * Compute a synthetic method type corresponding to the requested polymorphic
 * method signature. The target return type is computed from the immediately

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