8007464: Add graph inference support
Summary: Add support for more aggressive type-inference scheme
Reviewed-by: jjg
--- a/langtools/src/share/classes/com/sun/tools/javac/code/Source.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/src/share/classes/com/sun/tools/javac/code/Source.java Tue Feb 12 19:25:09 2013 +0000
@@ -221,7 +221,7 @@
public boolean allowIntersectionTypesInCast() {
return compareTo(JDK1_8) >= 0;
}
- public boolean allowEarlyReturnConstraints() {
+ public boolean allowGraphInference() {
return compareTo(JDK1_8) >= 0;
}
public boolean allowStructuralMostSpecific() {
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java Tue Feb 12 19:25:09 2013 +0000
@@ -4152,7 +4152,9 @@
}
private Type capture(Type type) {
- return types.capture(type);
+ //do not capture free types
+ return resultInfo.checkContext.inferenceContext().free(type) ?
+ type : types.capture(type);
}
private void validateTypeAnnotations(JCTree tree) {
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java Tue Feb 12 19:25:09 2013 +0000
@@ -234,7 +234,7 @@
dt.speculativeCache.put(deferredAttrContext.msym, speculativeTree, deferredAttrContext.phase);
return speculativeTree.type;
case CHECK:
- Assert.check(dt.mode == AttrMode.SPECULATIVE);
+ Assert.check(dt.mode != null);
return attr.attribTree(dt.tree, dt.env, resultInfo);
}
Assert.error();
@@ -242,6 +242,13 @@
}
};
+ DeferredTypeCompleter dummyCompleter = new DeferredTypeCompleter() {
+ public Type complete(DeferredType dt, ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) {
+ Assert.check(deferredAttrContext.mode == AttrMode.CHECK);
+ return dt.tree.type = Type.noType;
+ }
+ };
+
/**
* The 'mode' in which the deferred type is to be type-checked
*/
@@ -382,7 +389,7 @@
if (!progress) {
//remove all variables that have already been instantiated
//from the list of stuck variables
- inferenceContext.solveAny(inferenceContext.freeVarsIn(List.from(stuckVars)));
+ inferenceContext.solveAny(List.from(stuckVars), warn);
inferenceContext.notifyChange();
}
}
@@ -431,7 +438,15 @@
return true;
case CHECK:
if (stuckVars.nonEmpty()) {
- return false;
+ //stuck expression - see if we can propagate
+ if (deferredAttrContext.parent != emptyDeferredAttrContext &&
+ Type.containsAny(deferredAttrContext.parent.inferenceContext.inferencevars, List.from(stuckVars))) {
+ deferredAttrContext.parent.deferredAttrNodes.add(this);
+ dt.check(resultInfo, List.<Type>nil(), dummyCompleter);
+ return true;
+ } else {
+ return false;
+ }
} else {
dt.check(resultInfo, stuckVars, basicCompleter);
return true;
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -25,22 +25,30 @@
package com.sun.tools.javac.comp;
-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;
import com.sun.tools.javac.util.*;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
import com.sun.tools.javac.util.List;
-import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+import com.sun.tools.javac.code.*;
+import com.sun.tools.javac.code.Type.*;
+import com.sun.tools.javac.code.Type.UndetVar.InferenceBound;
+import com.sun.tools.javac.code.Symbol.*;
+import com.sun.tools.javac.comp.DeferredAttr.AttrMode;
+import com.sun.tools.javac.comp.Infer.GraphSolver.InferenceGraph;
+import com.sun.tools.javac.comp.Infer.GraphSolver.InferenceGraph.Node;
+import com.sun.tools.javac.comp.Resolve.InapplicableMethodException;
+import com.sun.tools.javac.comp.Resolve.VerboseResolutionMode;
import java.util.HashMap;
import java.util.Map;
+import java.util.Set;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashSet;
import static com.sun.tools.javac.code.TypeTag.*;
@@ -55,19 +63,15 @@
protected static final Context.Key<Infer> inferKey =
new Context.Key<Infer>();
- /** A value for prototypes that admit any type, including polymorphic ones. */
- public static final Type anyPoly = new Type(NONE, null);
-
+ Resolve rs;
+ Check chk;
Symtab syms;
Types types;
- Check chk;
- Resolve rs;
- DeferredAttr deferredAttr;
+ JCDiagnostic.Factory diags;
Log log;
- JCDiagnostic.Factory diags;
- /** Should we inject return-type constraints earlier? */
- boolean allowEarlyReturnConstraints;
+ /** should the graph solver be used? */
+ boolean allowGraphInference;
public static Infer instance(Context context) {
Infer instance = context.get(inferKey);
@@ -78,17 +82,22 @@
protected Infer(Context context) {
context.put(inferKey, this);
+
+ rs = Resolve.instance(context);
+ chk = Check.instance(context);
syms = Symtab.instance(context);
types = Types.instance(context);
- rs = Resolve.instance(context);
- deferredAttr = DeferredAttr.instance(context);
+ diags = JCDiagnostic.Factory.instance(context);
log = Log.instance(context);
- chk = Check.instance(context);
- diags = JCDiagnostic.Factory.instance(context);
inferenceException = new InferenceException(diags);
- allowEarlyReturnConstraints = Source.instance(context).allowEarlyReturnConstraints();
+ Options options = Options.instance(context);
+ allowGraphInference = Source.instance(context).allowGraphInference()
+ && options.isUnset("useLegacyInference");
}
+ /** A value for prototypes that admit any type, including polymorphic ones. */
+ public static final Type anyPoly = new Type(NONE, null);
+
/**
* This exception class is design to store a list of diagnostics corresponding
* to inference errors that can arise during a method applicability check.
@@ -118,140 +127,12 @@
}
}
- final InferenceException inferenceException;
-
-/***************************************************************************
- * 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 InferenceException {
- List<Type> hibounds = Type.filter(that.getBounds(InferenceBound.UPPER), boundFilter);
- if (that.getBounds(InferenceBound.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.getBounds(InferenceBound.EQ).head;
- }
- if (that.inst == null ||
- that.inst.isErroneous())
- throw inferenceException
- .setMessage("no.unique.maximal.instance.exists",
- that.qtype, hibounds);
- }
+ protected final InferenceException inferenceException;
- private Filter<Type> boundFilter = new Filter<Type>() {
- @Override
- public boolean accepts(Type t) {
- return !t.isErroneous() && !t.hasTag(BOT);
- }
- };
-
- /** 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 InferenceException {
- List<Type> lobounds = Type.filter(that.getBounds(InferenceBound.LOWER), boundFilter);
- if (that.getBounds(InferenceBound.EQ).isEmpty()) {
- if (lobounds.isEmpty()) {
- //do nothing - the inference variable is under-constrained
- return;
- } else if (lobounds.tail.isEmpty())
- that.inst = lobounds.head.isPrimitive() ? syms.errType : lobounds.head;
- else {
- that.inst = types.lub(lobounds);
- }
- if (that.inst == null || that.inst.hasTag(ERROR))
- throw inferenceException
- .setMessage("no.unique.minimal.instance.exists",
- that.qtype, lobounds);
- } else {
- that.inst = that.getBounds(InferenceBound.EQ).head;
- }
- }
-
-/***************************************************************************
- * Exported Methods
- ***************************************************************************/
-
+ // <editor-fold defaultstate="collapsed" desc="Inference routines">
/**
- * Instantiate uninferred inference variables (JLS 15.12.2.8). First
- * if the method return type is non-void, we derive constraints from the
- * expected type - then we use declared bound well-formedness to derive additional
- * constraints. If no instantiation exists, or if several incomparable
- * best instantiations exist throw a NoInstanceException.
- */
- public void instantiateUninferred(DiagnosticPosition pos,
- InferenceContext inferenceContext,
- MethodType mtype,
- Attr.ResultInfo resultInfo,
- Warner warn) throws InferenceException {
- while (true) {
- boolean stuck = true;
- for (Type t : inferenceContext.undetvars) {
- UndetVar uv = (UndetVar)t;
- if (uv.inst == null && (uv.getBounds(InferenceBound.EQ).nonEmpty() ||
- !inferenceContext.free(uv.getBounds(InferenceBound.UPPER)))) {
- maximizeInst((UndetVar)t, warn);
- stuck = false;
- }
- }
- if (inferenceContext.restvars().isEmpty()) {
- //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
- instantiateAsUninferredVars(inferenceContext);
- break;
- } else {
- //some variables have been instantiated - replace newly instantiated
- //variables in remaining upper bounds and continue
- for (Type t : inferenceContext.undetvars) {
- UndetVar uv = (UndetVar)t;
- uv.substBounds(inferenceContext.inferenceVars(), inferenceContext.instTypes(), types);
- }
- }
- }
- }
-
- /**
- * Infer cyclic inference variables as described in 15.12.2.8.
- */
- private void instantiateAsUninferredVars(InferenceContext inferenceContext) {
- ListBuffer<Type> todo = ListBuffer.lb();
- //step 1 - create fresh tvars
- for (Type t : inferenceContext.undetvars) {
- UndetVar uv = (UndetVar)t;
- if (uv.inst == null) {
- 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.getBounds(InferenceBound.UPPER)), null);
- todo.append(uv);
- uv.inst = fresh_tvar.type;
- }
- }
- //step 2 - replace fresh tvars in their bounds
- List<Type> formals = inferenceContext.inferenceVars();
- for (Type t : todo) {
- UndetVar uv = (UndetVar)t;
- TypeVar ct = (TypeVar)uv.inst;
- ct.bound = types.glb(inferenceContext.asInstTypes(types.getBounds(ct)));
- if (ct.bound.isErroneous()) {
- //report inference error if glb fails
- reportBoundError(uv, BoundErrorKind.BAD_UPPER);
- }
- formals = formals.tail;
- }
- }
-
- /** Instantiate a generic method type by finding instantiations for all its
- * inference variables so that it can be applied to a given argument type list.
+ * 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,
List<Type> tvars,
@@ -267,259 +148,144 @@
//-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG
final InferenceContext inferenceContext = new InferenceContext(tvars);
inferenceException.clear();
+ try {
+ DeferredAttr.DeferredAttrContext deferredAttrContext =
+ resolveContext.deferredAttrContext(msym, inferenceContext, resultInfo, warn);
- DeferredAttr.DeferredAttrContext deferredAttrContext =
- resolveContext.deferredAttrContext(msym, inferenceContext, resultInfo, warn);
+ methodCheck.argumentsAcceptable(env, deferredAttrContext,
+ argtypes, mt.getParameterTypes(), warn);
- try {
- methodCheck.argumentsAcceptable(env, deferredAttrContext, argtypes, mt.getParameterTypes(), warn);
-
- if (resultInfo != null && allowEarlyReturnConstraints &&
+ if (allowGraphInference &&
+ resultInfo != null &&
!warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
- generateReturnConstraints(mt, inferenceContext, resultInfo);
+ //inject return constraints earlier
+ checkWithinBounds(inferenceContext, warn); //propagation
+ generateReturnConstraints(resultInfo, mt, inferenceContext);
+ //propagate outwards if needed
+ if (resultInfo.checkContext.inferenceContext().free(resultInfo.pt)) {
+ //propagate inference context outwards and exit
+ inferenceContext.dupTo(resultInfo.checkContext.inferenceContext());
+ deferredAttrContext.complete();
+ return mt;
+ }
}
deferredAttrContext.complete();
// minimize as yet undetermined type variables
- for (Type t : inferenceContext.undetvars) {
- minimizeInst((UndetVar)t, warn);
+ if (allowGraphInference) {
+ inferenceContext.solve(warn);
+ } else {
+ inferenceContext.solveLegacy(true, warn, LegacyInferenceSteps.EQ_LOWER.steps); //minimizeInst
}
- checkWithinBounds(inferenceContext, warn);
-
mt = (MethodType)inferenceContext.asInstType(mt);
- List<Type> restvars = inferenceContext.restvars();
+ if (!allowGraphInference &&
+ inferenceContext.restvars().nonEmpty() &&
+ resultInfo != null &&
+ !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
+ generateReturnConstraints(resultInfo, mt, inferenceContext);
+ inferenceContext.solveLegacy(false, warn, LegacyInferenceSteps.EQ_UPPER.steps); //maximizeInst
+ mt = (MethodType)inferenceContext.asInstType(mt);
+ }
- 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);
- if (rs.verboseResolutionMode.contains(VerboseResolutionMode.DEFERRED_INST)) {
- log.note(env.tree.pos, "deferred.method.inst", msym, mt, resultInfo.pt);
- }
- }
+ if (resultInfo != null && rs.verboseResolutionMode.contains(VerboseResolutionMode.DEFERRED_INST)) {
+ log.note(env.tree.pos, "deferred.method.inst", msym, mt, resultInfo.pt);
}
// return instantiated version of method type
return mt;
} finally {
- inferenceContext.notifyChange();
- }
- }
- //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());
- Warner retWarn = new Warner();
- if (!resultInfo.checkContext.compatible(qtype1, qtype1.hasTag(UNDETVAR) ? types.boxedTypeOrType(to) : to, retWarn) ||
- //unchecked conversion is not allowed
- retWarn.hasLint(Lint.LintCategory.UNCHECKED)) {
- 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 {
- //step 1 - check compatibility of instantiated type w.r.t. initial bounds
- for (Type t : inferenceContext.undetvars) {
- UndetVar uv = (UndetVar)t;
- uv.substBounds(inferenceContext.inferenceVars(), inferenceContext.instTypes(), types);
- checkCompatibleUpperBounds(uv, inferenceContext.inferenceVars());
- if (!inferenceContext.restvars().contains(uv.qtype)) {
- Type inst = inferenceContext.asInstType(t);
- for (Type u : uv.getBounds(InferenceBound.UPPER)) {
- if (!types.isSubtypeUnchecked(inst, inferenceContext.asFree(u), warn)) {
- reportBoundError(uv, BoundErrorKind.UPPER);
- }
- }
- for (Type l : uv.getBounds(InferenceBound.LOWER)) {
- Assert.check(!inferenceContext.free(l));
- if (!types.isSubtypeUnchecked(l, inst, warn)) {
- reportBoundError(uv, BoundErrorKind.LOWER);
- }
- }
- for (Type e : uv.getBounds(InferenceBound.EQ)) {
- Assert.check(!inferenceContext.free(e));
- if (!types.isSameType(inst, e)) {
- reportBoundError(uv, BoundErrorKind.EQ);
- }
- }
- }
- }
-
- //step 2 - check that eq bounds are consistent w.r.t. eq/lower bounds
- for (Type t : inferenceContext.undetvars) {
- UndetVar uv = (UndetVar)t;
- //check eq bounds consistency
- Type eq = null;
- for (Type e : uv.getBounds(InferenceBound.EQ)) {
- Assert.check(!inferenceContext.free(e));
- if (eq != null && !types.isSameType(e, eq)) {
- reportBoundError(uv, BoundErrorKind.EQ);
- }
- eq = e;
- for (Type l : uv.getBounds(InferenceBound.LOWER)) {
- Assert.check(!inferenceContext.free(l));
- if (!types.isSubtypeUnchecked(l, e, warn)) {
- reportBoundError(uv, BoundErrorKind.BAD_EQ_LOWER);
- }
- }
- for (Type u : uv.getBounds(InferenceBound.UPPER)) {
- if (inferenceContext.free(u)) continue;
- if (!types.isSubtypeUnchecked(e, u, warn)) {
- reportBoundError(uv, BoundErrorKind.BAD_EQ_UPPER);
- }
- }
+ if (resultInfo != null || !allowGraphInference) {
+ inferenceContext.notifyChange();
+ } else {
+ inferenceContext.notifyChange(inferenceContext.boundedVars());
}
}
}
- 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.getBounds(InferenceBound.UPPER), boundFilter)) {
- if (!t.containsAny(tvars)) {
- hiboundsNoVars.append(t);
+ /**
+ * 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.
+ */
+ void generateReturnConstraints(Attr.ResultInfo resultInfo,
+ MethodType mt, InferenceContext inferenceContext) {
+ Type qtype1 = inferenceContext.asFree(mt.getReturnType());
+ Type to = returnConstraintTarget(qtype1, resultInfo.pt);
+ Assert.check(allowGraphInference || !resultInfo.checkContext.inferenceContext().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, resultInfo.checkContext.inferenceContext().asFree(to), retWarn) ||
+ //unchecked conversion is not allowed
+ retWarn.hasLint(Lint.LintCategory.UNCHECKED)) {
+ throw inferenceException
+ .setMessage("infer.no.conforming.instance.exists",
+ inferenceContext.restvars(), mt.getReturnType(), to);
+ }
+ }
+ //where
+ private Type returnConstraintTarget(Type from, Type to) {
+ if (from.hasTag(VOID)) {
+ return syms.voidType;
+ } else if (to.hasTag(NONE)) {
+ 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;
}
}
- 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.getBounds(InferenceBound.UPPER));
- }
- },
- BAD_EQ_UPPER() {
- @Override
- InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
- return ex.setMessage("incompatible.eq.upper.bounds", uv.qtype,
- uv.getBounds(InferenceBound.EQ), uv.getBounds(InferenceBound.UPPER));
- }
- },
- BAD_EQ_LOWER() {
- @Override
- InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
- return ex.setMessage("incompatible.eq.lower.bounds", uv.qtype,
- uv.getBounds(InferenceBound.EQ), uv.getBounds(InferenceBound.LOWER));
- }
- },
- UPPER() {
- @Override
- InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
- return ex.setMessage("inferred.do.not.conform.to.upper.bounds", uv.inst,
- uv.getBounds(InferenceBound.UPPER));
- }
- },
- LOWER() {
- @Override
- InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
- return ex.setMessage("inferred.do.not.conform.to.lower.bounds", uv.inst,
- uv.getBounds(InferenceBound.LOWER));
- }
- },
- EQ() {
- @Override
- InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
- return ex.setMessage("inferred.do.not.conform.to.eq.bounds", uv.inst,
- uv.getBounds(InferenceBound.EQ));
+ /**
+ * Infer cyclic inference variables as described in 15.12.2.8.
+ */
+ private void instantiateAsUninferredVars(List<Type> vars, InferenceContext inferenceContext) {
+ ListBuffer<Type> todo = ListBuffer.lb();
+ //step 1 - create fresh tvars
+ for (Type t : vars) {
+ UndetVar uv = (UndetVar)inferenceContext.asFree(t);
+ List<Type> upperBounds = uv.getBounds(InferenceBound.UPPER);
+ if (Type.containsAny(upperBounds, vars)) {
+ 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.getBounds(InferenceBound.UPPER)), null);
+ todo.append(uv);
+ uv.inst = fresh_tvar.type;
+ } else if (upperBounds.nonEmpty()) {
+ uv.inst = types.glb(upperBounds);
+ } else {
+ uv.inst = syms.objectType;
}
- };
-
- abstract InapplicableMethodException setMessage(InferenceException ex, UndetVar uv);
- }
- //where
- void reportBoundError(UndetVar uv, BoundErrorKind bk) {
- throw bk.setMessage(inferenceException, uv);
- }
-
- // <editor-fold desc="functional interface instantiation">
- /**
- * This method is used to infer a suitable target functional interface in case
- * the original parameterized interface contains wildcards. An inference process
- * is applied so that wildcard bounds, as well as explicit lambda/method ref parameters
- * (where applicable) are used to constraint the solution.
- */
- public Type instantiateFunctionalInterface(DiagnosticPosition pos, Type funcInterface,
- List<Type> paramTypes, Check.CheckContext checkContext) {
- if (types.capture(funcInterface) == funcInterface) {
- //if capture doesn't change the type then return the target unchanged
- //(this means the target contains no wildcards!)
- return funcInterface;
- } else {
- Type formalInterface = funcInterface.tsym.type;
- InferenceContext funcInterfaceContext =
- new InferenceContext(funcInterface.tsym.type.getTypeArguments());
- 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);
+ }
+ //step 2 - replace fresh tvars in their bounds
+ List<Type> formals = vars;
+ for (Type t : todo) {
+ UndetVar uv = (UndetVar)t;
+ TypeVar ct = (TypeVar)uv.inst;
+ ct.bound = types.glb(inferenceContext.asInstTypes(types.getBounds(ct)));
+ if (ct.bound.isErroneous()) {
+ //report inference error if glb fails
+ reportBoundError(uv, BoundErrorKind.BAD_UPPER);
}
- for (Type p : descParameterTypes) {
- if (!types.isSameType(funcInterfaceContext.asFree(p), paramTypes.head)) {
- checkContext.report(pos, diags.fragment("no.suitable.functional.intf.inst", funcInterface));
- return types.createErrorType(funcInterface);
- }
- paramTypes = paramTypes.tail;
- }
- List<Type> actualTypeargs = funcInterface.getTypeArguments();
- for (Type t : funcInterfaceContext.undetvars) {
- UndetVar uv = (UndetVar)t;
- if (funcInterfaceContext.boundedVars().contains(uv.qtype)) {
- minimizeInst(uv, types.noWarnings);
- if (uv.inst == null &&
- Type.filter(uv.getBounds(InferenceBound.UPPER), boundFilter).nonEmpty()) {
- maximizeInst(uv, types.noWarnings);
- }
- } else {
- uv.inst = actualTypeargs.head;
- }
- Assert.check(uv.inst != null);
- actualTypeargs = actualTypeargs.tail;
- }
- Type owntype = funcInterfaceContext.asInstType(formalInterface);
- 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 owntype;
+ formals = formals.tail;
}
}
- // </editor-fold>
/**
* Compute a synthetic method type corresponding to the requested polymorphic
@@ -573,7 +339,7 @@
class ImplicitArgType extends DeferredAttr.DeferredTypeMap {
public ImplicitArgType(Symbol msym, Resolve.MethodResolutionPhase phase) {
- deferredAttr.super(AttrMode.SPECULATIVE, msym, phase);
+ rs.deferredAttr.super(AttrMode.SPECULATIVE, msym, phase);
}
public Type apply(Type t) {
@@ -587,6 +353,920 @@
}
/**
+ * This method is used to infer a suitable target SAM in case the original
+ * SAM type contains one or more wildcards. An inference process is applied
+ * so that wildcard bounds, as well as explicit lambda/method ref parameters
+ * (where applicable) are used to constraint the solution.
+ */
+ public Type instantiateFunctionalInterface(DiagnosticPosition pos, Type funcInterface,
+ List<Type> paramTypes, Check.CheckContext checkContext) {
+ if (types.capture(funcInterface) == funcInterface) {
+ //if capture doesn't change the type then return the target unchanged
+ //(this means the target contains no wildcards!)
+ return funcInterface;
+ } else {
+ Type formalInterface = funcInterface.tsym.type;
+ InferenceContext funcInterfaceContext =
+ new InferenceContext(funcInterface.tsym.type.getTypeArguments());
+
+ 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), paramTypes.head)) {
+ checkContext.report(pos, diags.fragment("no.suitable.functional.intf.inst", funcInterface));
+ return types.createErrorType(funcInterface);
+ }
+ paramTypes = paramTypes.tail;
+ }
+
+ try {
+ funcInterfaceContext.solve(funcInterfaceContext.boundedVars(), types.noWarnings);
+ } catch (InferenceException ex) {
+ checkContext.report(pos, diags.fragment("no.suitable.functional.intf.inst", funcInterface));
+ }
+
+ List<Type> actualTypeargs = funcInterface.getTypeArguments();
+ for (Type t : funcInterfaceContext.undetvars) {
+ UndetVar uv = (UndetVar)t;
+ if (uv.inst == null) {
+ uv.inst = actualTypeargs.head;
+ }
+ actualTypeargs = actualTypeargs.tail;
+ }
+
+ Type owntype = funcInterfaceContext.asInstType(formalInterface);
+ 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 owntype;
+ }
+ }
+ // </editor-fold>
+
+ // <editor-fold defaultstate="collapsed" desc="Bound checking">
+ /**
+ * Check bounds and perform incorporation
+ */
+ void checkWithinBounds(InferenceContext inferenceContext,
+ Warner warn) throws InferenceException {
+ MultiUndetVarListener mlistener = new MultiUndetVarListener(inferenceContext.undetvars);
+ try {
+ while (true) {
+ mlistener.reset();
+ if (!allowGraphInference) {
+ //in legacy mode we lack of transitivity, so bound check
+ //cannot be run in parallel with other incoprporation rounds
+ for (Type t : inferenceContext.undetvars) {
+ UndetVar uv = (UndetVar)t;
+ IncorporationStep.CHECK_BOUNDS.apply(uv, inferenceContext, warn);
+ }
+ }
+ for (Type t : inferenceContext.undetvars) {
+ UndetVar uv = (UndetVar)t;
+ //bound incorporation
+ EnumSet<IncorporationStep> incorporationSteps = allowGraphInference ?
+ incorporationStepsGraph : incorporationStepsLegacy;
+ for (IncorporationStep is : incorporationSteps) {
+ is.apply(uv, inferenceContext, warn);
+ }
+ }
+ if (!mlistener.changed || !allowGraphInference) break;
+ }
+ }
+ finally {
+ mlistener.detach();
+ }
+ }
+ //where
+ /**
+ * This listener keeps track of changes on a group of inference variable
+ * bounds. Note: the listener must be detached (calling corresponding
+ * method) to make sure that the underlying inference variable is
+ * left in a clean state.
+ */
+ class MultiUndetVarListener implements UndetVar.UndetVarListener {
+
+ int rounds;
+ boolean changed;
+ List<Type> undetvars;
+
+ public MultiUndetVarListener(List<Type> undetvars) {
+ this.undetvars = undetvars;
+ for (Type t : undetvars) {
+ UndetVar uv = (UndetVar)t;
+ uv.listener = this;
+ }
+ }
+
+ public void varChanged(UndetVar uv, Set<InferenceBound> ibs) {
+ //avoid non-termination
+ if (rounds < MAX_INCORPORATION_STEPS) {
+ changed = true;
+ }
+ }
+
+ void reset() {
+ rounds++;
+ changed = false;
+ }
+
+ void detach() {
+ for (Type t : undetvars) {
+ UndetVar uv = (UndetVar)t;
+ uv.listener = null;
+ }
+ }
+ };
+
+ /** max number of incorporation rounds */
+ static final int MAX_INCORPORATION_STEPS = 100;
+
+ /**
+ * This enumeration defines an entry point for doing inference variable
+ * bound incorporation - it can be used to inject custom incorporation
+ * logic into the basic bound checking routine
+ */
+ enum IncorporationStep {
+ /**
+ * Performs basic bound checking - i.e. is the instantiated type for a given
+ * inference variable compatible with its bounds?
+ */
+ CHECK_BOUNDS() {
+ public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
+ Infer infer = inferenceContext.infer();
+ uv.substBounds(inferenceContext.inferenceVars(), inferenceContext.instTypes(), infer.types);
+ infer.checkCompatibleUpperBounds(uv, inferenceContext);
+ if (uv.inst != null) {
+ Type inst = uv.inst;
+ for (Type u : uv.getBounds(InferenceBound.UPPER)) {
+ if (!infer.types.isSubtypeUnchecked(inst, inferenceContext.asFree(u), warn)) {
+ infer.reportBoundError(uv, BoundErrorKind.UPPER);
+ }
+ }
+ for (Type l : uv.getBounds(InferenceBound.LOWER)) {
+ if (!infer.types.isSubtypeUnchecked(inferenceContext.asFree(l), inst, warn)) {
+ infer.reportBoundError(uv, BoundErrorKind.LOWER);
+ }
+ }
+ for (Type e : uv.getBounds(InferenceBound.EQ)) {
+ if (!infer.types.isSameType(inst, inferenceContext.asFree(e))) {
+ infer.reportBoundError(uv, BoundErrorKind.EQ);
+ }
+ }
+ }
+ }
+ },
+ /**
+ * Check consistency of equality constraints. This is a slightly more aggressive
+ * inference routine that is designed as to maximize compatibility with JDK 7.
+ * Note: this is not used in graph mode.
+ */
+ EQ_CHECK_LEGACY() {
+ public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
+ Infer infer = inferenceContext.infer();
+ Type eq = null;
+ for (Type e : uv.getBounds(InferenceBound.EQ)) {
+ Assert.check(!inferenceContext.free(e));
+ if (eq != null && !infer.types.isSameType(e, eq)) {
+ infer.reportBoundError(uv, BoundErrorKind.EQ);
+ }
+ eq = e;
+ for (Type l : uv.getBounds(InferenceBound.LOWER)) {
+ Assert.check(!inferenceContext.free(l));
+ if (!infer.types.isSubtypeUnchecked(l, e, warn)) {
+ infer.reportBoundError(uv, BoundErrorKind.BAD_EQ_LOWER);
+ }
+ }
+ for (Type u : uv.getBounds(InferenceBound.UPPER)) {
+ if (inferenceContext.free(u)) continue;
+ if (!infer.types.isSubtypeUnchecked(e, u, warn)) {
+ infer.reportBoundError(uv, BoundErrorKind.BAD_EQ_UPPER);
+ }
+ }
+ }
+ }
+ },
+ /**
+ * Check consistency of equality constraints.
+ */
+ EQ_CHECK() {
+ public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
+ Infer infer = inferenceContext.infer();
+ for (Type e : uv.getBounds(InferenceBound.EQ)) {
+ if (e.containsAny(inferenceContext.inferenceVars())) continue;
+ for (Type u : uv.getBounds(InferenceBound.UPPER)) {
+ if (!infer.types.isSubtypeUnchecked(e, inferenceContext.asFree(u), warn)) {
+ infer.reportBoundError(uv, BoundErrorKind.BAD_EQ_UPPER);
+ }
+ }
+ for (Type l : uv.getBounds(InferenceBound.LOWER)) {
+ if (!infer.types.isSubtypeUnchecked(inferenceContext.asFree(l), e, warn)) {
+ infer.reportBoundError(uv, BoundErrorKind.BAD_EQ_LOWER);
+ }
+ }
+ }
+ }
+ },
+ /**
+ * Given a bound set containing {@code alpha <: T} and {@code alpha :> S}
+ * perform {@code S <: T} (which could lead to new bounds).
+ */
+ CROSS_UPPER_LOWER() {
+ public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
+ Infer infer = inferenceContext.infer();
+ for (Type b1 : uv.getBounds(InferenceBound.UPPER)) {
+ for (Type b2 : uv.getBounds(InferenceBound.LOWER)) {
+ if (!inferenceContext.inferenceVars().contains(b1) &&
+ !inferenceContext.inferenceVars().contains(b2) &&
+ infer.types.asSuper(b2, b1.tsym) != null) {
+ infer.types.isSubtypeUnchecked(inferenceContext.asFree(b2), inferenceContext.asFree(b1));
+ }
+ }
+ }
+ }
+ },
+ /**
+ * Given a bound set containing {@code alpha <: T} and {@code alpha == S}
+ * perform {@code S <: T} (which could lead to new bounds).
+ */
+ CROSS_UPPER_EQ() {
+ public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
+ Infer infer = inferenceContext.infer();
+ for (Type b1 : uv.getBounds(InferenceBound.UPPER)) {
+ for (Type b2 : uv.getBounds(InferenceBound.EQ)) {
+ if (!inferenceContext.inferenceVars().contains(b1) &&
+ !inferenceContext.inferenceVars().contains(b2) &&
+ infer.types.asSuper(b2, b1.tsym) != null) {
+ infer.types.isSubtypeUnchecked(inferenceContext.asFree(b2), inferenceContext.asFree(b1));
+ }
+ }
+ }
+ }
+ },
+ /**
+ * Given a bound set containing {@code alpha :> S} and {@code alpha == T}
+ * perform {@code S <: T} (which could lead to new bounds).
+ */
+ CROSS_EQ_LOWER() {
+ public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
+ Infer infer = inferenceContext.infer();
+ for (Type b1 : uv.getBounds(InferenceBound.EQ)) {
+ for (Type b2 : uv.getBounds(InferenceBound.LOWER)) {
+ if (!inferenceContext.inferenceVars().contains(b1) &&
+ !inferenceContext.inferenceVars().contains(b2) &&
+ infer.types.asSuper(b2, b1.tsym) != null) {
+ infer.types.isSubtypeUnchecked(inferenceContext.asFree(b2), inferenceContext.asFree(b1));
+ }
+ }
+ }
+ }
+ },
+ /**
+ * Given a bound set containing {@code alpha <: beta} propagate lower bounds
+ * from alpha to beta; also propagate upper bounds from beta to alpha.
+ */
+ PROP_UPPER() {
+ public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
+ Infer infer = inferenceContext.infer();
+ for (Type b : uv.getBounds(InferenceBound.UPPER)) {
+ if (inferenceContext.inferenceVars().contains(b)) {
+ UndetVar uv2 = (UndetVar)inferenceContext.asFree(b);
+ //alpha <: beta
+ //1. copy alpha's lower to beta's
+ for (Type l : uv.getBounds(InferenceBound.LOWER)) {
+ uv2.addBound(InferenceBound.LOWER, inferenceContext.asInstType(l), infer.types);
+ }
+ //2. copy beta's upper to alpha's
+ for (Type u : uv2.getBounds(InferenceBound.UPPER)) {
+ uv.addBound(InferenceBound.UPPER, inferenceContext.asInstType(u), infer.types);
+ }
+ }
+ }
+ }
+ },
+ /**
+ * Given a bound set containing {@code alpha :> beta} propagate lower bounds
+ * from beta to alpha; also propagate upper bounds from alpha to beta.
+ */
+ PROP_LOWER() {
+ public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
+ Infer infer = inferenceContext.infer();
+ for (Type b : uv.getBounds(InferenceBound.LOWER)) {
+ if (inferenceContext.inferenceVars().contains(b)) {
+ UndetVar uv2 = (UndetVar)inferenceContext.asFree(b);
+ //alpha :> beta
+ //1. copy alpha's upper to beta's
+ for (Type u : uv.getBounds(InferenceBound.UPPER)) {
+ uv2.addBound(InferenceBound.UPPER, inferenceContext.asInstType(u), infer.types);
+ }
+ //2. copy beta's lower to alpha's
+ for (Type l : uv2.getBounds(InferenceBound.LOWER)) {
+ uv.addBound(InferenceBound.LOWER, inferenceContext.asInstType(l), infer.types);
+ }
+ }
+ }
+ }
+ },
+ /**
+ * Given a bound set containing {@code alpha == beta} propagate lower/upper
+ * bounds from alpha to beta and back.
+ */
+ PROP_EQ() {
+ public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
+ Infer infer = inferenceContext.infer();
+ for (Type b : uv.getBounds(InferenceBound.EQ)) {
+ if (inferenceContext.inferenceVars().contains(b)) {
+ UndetVar uv2 = (UndetVar)inferenceContext.asFree(b);
+ //alpha == beta
+ //1. copy all alpha's bounds to beta's
+ for (InferenceBound ib : InferenceBound.values()) {
+ for (Type b2 : uv.getBounds(ib)) {
+ if (b2 != uv2) {
+ uv2.addBound(ib, inferenceContext.asInstType(b2), infer.types);
+ }
+ }
+ }
+ //2. copy all beta's bounds to alpha's
+ for (InferenceBound ib : InferenceBound.values()) {
+ for (Type b2 : uv2.getBounds(ib)) {
+ if (b2 != uv) {
+ uv.addBound(ib, inferenceContext.asInstType(b2), infer.types);
+ }
+ }
+ }
+ }
+ }
+ }
+ };
+
+ abstract void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn);
+ }
+
+ /** incorporation steps to be executed when running in legacy mode */
+ EnumSet<IncorporationStep> incorporationStepsLegacy = EnumSet.of(IncorporationStep.EQ_CHECK_LEGACY);
+
+ /** incorporation steps to be executed when running in graph mode */
+ EnumSet<IncorporationStep> incorporationStepsGraph =
+ EnumSet.complementOf(EnumSet.of(IncorporationStep.EQ_CHECK_LEGACY));
+
+ /**
+ * Make sure that the upper bounds we got so far lead to a solvable inference
+ * variable by making sure that a glb exists.
+ */
+ void checkCompatibleUpperBounds(UndetVar uv, InferenceContext inferenceContext) {
+ List<Type> hibounds =
+ Type.filter(uv.getBounds(InferenceBound.UPPER), new BoundFilter(inferenceContext));
+ 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);
+ }
+ //where
+ protected static class BoundFilter implements Filter<Type> {
+
+ InferenceContext inferenceContext;
+
+ public BoundFilter(InferenceContext inferenceContext) {
+ this.inferenceContext = inferenceContext;
+ }
+
+ @Override
+ public boolean accepts(Type t) {
+ return !t.isErroneous() && !inferenceContext.free(t) &&
+ !t.hasTag(BOT);
+ }
+ };
+
+ /**
+ * This enumeration defines all possible bound-checking related errors.
+ */
+ enum BoundErrorKind {
+ /**
+ * The (uninstantiated) inference variable has incompatible upper bounds.
+ */
+ BAD_UPPER() {
+ @Override
+ InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+ return ex.setMessage("incompatible.upper.bounds", uv.qtype,
+ uv.getBounds(InferenceBound.UPPER));
+ }
+ },
+ /**
+ * An equality constraint is not compatible with an upper bound.
+ */
+ BAD_EQ_UPPER() {
+ @Override
+ InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+ return ex.setMessage("incompatible.eq.upper.bounds", uv.qtype,
+ uv.getBounds(InferenceBound.EQ), uv.getBounds(InferenceBound.UPPER));
+ }
+ },
+ /**
+ * An equality constraint is not compatible with a lower bound.
+ */
+ BAD_EQ_LOWER() {
+ @Override
+ InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+ return ex.setMessage("incompatible.eq.lower.bounds", uv.qtype,
+ uv.getBounds(InferenceBound.EQ), uv.getBounds(InferenceBound.LOWER));
+ }
+ },
+ /**
+ * Instantiated inference variable is not compatible with an upper bound.
+ */
+ UPPER() {
+ @Override
+ InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+ return ex.setMessage("inferred.do.not.conform.to.upper.bounds", uv.inst,
+ uv.getBounds(InferenceBound.UPPER));
+ }
+ },
+ /**
+ * Instantiated inference variable is not compatible with a lower bound.
+ */
+ LOWER() {
+ @Override
+ InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+ return ex.setMessage("inferred.do.not.conform.to.lower.bounds", uv.inst,
+ uv.getBounds(InferenceBound.LOWER));
+ }
+ },
+ /**
+ * Instantiated inference variable is not compatible with an equality constraint.
+ */
+ EQ() {
+ @Override
+ InapplicableMethodException setMessage(InferenceException ex, UndetVar uv) {
+ return ex.setMessage("inferred.do.not.conform.to.eq.bounds", uv.inst,
+ uv.getBounds(InferenceBound.EQ));
+ }
+ };
+
+ abstract InapplicableMethodException setMessage(InferenceException ex, UndetVar uv);
+ }
+
+ /**
+ * Report a bound-checking error of given kind
+ */
+ void reportBoundError(UndetVar uv, BoundErrorKind bk) {
+ throw bk.setMessage(inferenceException, uv);
+ }
+ // </editor-fold>
+
+ // <editor-fold defaultstate="collapsed" desc="Inference engine">
+ /**
+ * Graph inference strategy - act as an input to the inference solver; a strategy is
+ * composed of two ingredients: (i) find a node to solve in the inference graph,
+ * and (ii) tell th engine when we are done fixing inference variables
+ */
+ interface GraphStrategy {
+ /**
+ * Pick the next node (leaf) to solve in the graph
+ */
+ Node pickNode(InferenceGraph g);
+ /**
+ * Is this the last step?
+ */
+ boolean done();
+ }
+
+ /**
+ * Simple solver strategy class that locates all leaves inside a graph
+ * and picks the first leaf as the next node to solve
+ */
+ abstract class LeafSolver implements GraphStrategy {
+ public Node pickNode(InferenceGraph g) {
+ Assert.check(!g.nodes.isEmpty(), "No nodes to solve!");
+ return g.nodes.get(0);
+ }
+ }
+
+ /**
+ * This solver uses an heuristic to pick the best leaf - the heuristic
+ * tries to select the node that has maximal probability to contain one
+ * or more inference variables in a given list
+ */
+ abstract class BestLeafSolver extends LeafSolver {
+
+ List<Type> varsToSolve;
+
+ BestLeafSolver(List<Type> varsToSolve) {
+ this.varsToSolve = varsToSolve;
+ }
+
+ /**
+ * Computes the cost associated with a given node; the cost is computed
+ * as the total number of type-variables that should be eagerly instantiated
+ * in order to get to some of the variables in {@code varsToSolve} from
+ * a given node
+ */
+ void computeCostIfNeeded(Node n, Map<Node, Integer> costMap) {
+ if (costMap.containsKey(n)) {
+ return;
+ } else if (!Collections.disjoint(n.data, varsToSolve)) {
+ costMap.put(n, n.data.size());
+ } else {
+ int subcost = Integer.MAX_VALUE;
+ costMap.put(n, subcost); //avoid loops
+ for (Node n2 : n.getDependencies()) {
+ computeCostIfNeeded(n2, costMap);
+ subcost = Math.min(costMap.get(n2), subcost);
+ }
+ //update cost map to reflect real cost
+ costMap.put(n, subcost == Integer.MAX_VALUE ?
+ Integer.MAX_VALUE :
+ n.data.size() + subcost);
+ }
+ }
+
+ /**
+ * Pick the leaf that minimize cost
+ */
+ @Override
+ public Node pickNode(final InferenceGraph g) {
+ final Map<Node, Integer> costMap = new HashMap<Node, Integer>();
+ ArrayList<Node> leaves = new ArrayList<Node>();
+ for (Node n : g.nodes) {
+ computeCostIfNeeded(n, costMap);
+ if (n.isLeaf(n)) {
+ leaves.add(n);
+ }
+ }
+ Assert.check(!leaves.isEmpty(), "No nodes to solve!");
+ Collections.sort(leaves, new java.util.Comparator<Node>() {
+ public int compare(Node n1, Node n2) {
+ return costMap.get(n1) - costMap.get(n2);
+ }
+ });
+ return leaves.get(0);
+ }
+ }
+
+ /**
+ * The inference process can be thought of as a sequence of steps. Each step
+ * instantiates an inference variable using a subset of the inference variable
+ * bounds, if certain condition are met. Decisions such as the sequence in which
+ * steps are applied, or which steps are to be applied are left to the inference engine.
+ */
+ enum InferenceStep {
+
+ /**
+ * Instantiate an inference variables using one of its (ground) equality
+ * constraints
+ */
+ EQ(InferenceBound.EQ) {
+ @Override
+ Type solve(UndetVar uv, InferenceContext inferenceContext) {
+ return filterBounds(uv, inferenceContext).head;
+ }
+ },
+ /**
+ * Instantiate an inference variables using its (ground) lower bounds. Such
+ * bounds are merged together using lub().
+ */
+ LOWER(InferenceBound.LOWER) {
+ @Override
+ Type solve(UndetVar uv, InferenceContext inferenceContext) {
+ Infer infer = inferenceContext.infer();
+ List<Type> lobounds = filterBounds(uv, inferenceContext);
+ Type owntype = infer.types.lub(lobounds);
+ if (owntype.hasTag(ERROR)) {
+ throw infer.inferenceException
+ .setMessage("no.unique.minimal.instance.exists",
+ uv.qtype, lobounds);
+ } else {
+ return owntype;
+ }
+ }
+ },
+ /**
+ * Instantiate an inference variables using its (ground) upper bounds. Such
+ * bounds are merged together using glb().
+ */
+ UPPER(InferenceBound.UPPER) {
+ @Override
+ Type solve(UndetVar uv, InferenceContext inferenceContext) {
+ Infer infer = inferenceContext.infer();
+ List<Type> hibounds = filterBounds(uv, inferenceContext);
+ Type owntype = infer.types.glb(hibounds);
+ if (owntype.isErroneous()) {
+ throw infer.inferenceException
+ .setMessage("no.unique.maximal.instance.exists",
+ uv.qtype, hibounds);
+ } else {
+ return owntype;
+ }
+ }
+ },
+ /**
+ * Like the former; the only difference is that this step can only be applied
+ * if all upper bounds are ground.
+ */
+ UPPER_LEGACY(InferenceBound.UPPER) {
+ @Override
+ public boolean accepts(UndetVar t, InferenceContext inferenceContext) {
+ return !inferenceContext.free(t.getBounds(ib));
+ }
+
+ @Override
+ Type solve(UndetVar uv, InferenceContext inferenceContext) {
+ return UPPER.solve(uv, inferenceContext);
+ }
+ };
+
+ final InferenceBound ib;
+
+ InferenceStep(InferenceBound ib) {
+ this.ib = ib;
+ }
+
+ /**
+ * Find an instantiated type for a given inference variable within
+ * a given inference context
+ */
+ abstract Type solve(UndetVar uv, InferenceContext inferenceContext);
+
+ /**
+ * Can the inference variable be instantiated using this step?
+ */
+ public boolean accepts(UndetVar t, InferenceContext inferenceContext) {
+ return filterBounds(t, inferenceContext).nonEmpty();
+ }
+
+ /**
+ * Return the subset of ground bounds in a given bound set (i.e. eq/lower/upper)
+ */
+ List<Type> filterBounds(UndetVar uv, InferenceContext inferenceContext) {
+ return Type.filter(uv.getBounds(ib), new BoundFilter(inferenceContext));
+ }
+ }
+
+ /**
+ * This enumeration defines the sequence of steps to be applied when the
+ * solver works in legacy mode. The steps in this enumeration reflect
+ * the behavior of old inference routine (see JLS SE 7 15.12.2.7/15.12.2.8).
+ */
+ enum LegacyInferenceSteps {
+
+ EQ_LOWER(EnumSet.of(InferenceStep.EQ, InferenceStep.LOWER)),
+ EQ_UPPER(EnumSet.of(InferenceStep.EQ, InferenceStep.UPPER_LEGACY));
+
+ final EnumSet<InferenceStep> steps;
+
+ LegacyInferenceSteps(EnumSet<InferenceStep> steps) {
+ this.steps = steps;
+ }
+ }
+
+ /**
+ * This enumeration defines the sequence of steps to be applied when the
+ * graph solver is used. This order is defined so as to maximize compatibility
+ * w.r.t. old inference routine (see JLS SE 7 15.12.2.7/15.12.2.8).
+ */
+ enum GraphInferenceSteps {
+
+ EQ(EnumSet.of(InferenceStep.EQ)),
+ EQ_LOWER(EnumSet.of(InferenceStep.EQ, InferenceStep.LOWER)),
+ EQ_LOWER_UPPER(EnumSet.of(InferenceStep.EQ, InferenceStep.LOWER, InferenceStep.UPPER));
+
+ final EnumSet<InferenceStep> steps;
+
+ GraphInferenceSteps(EnumSet<InferenceStep> steps) {
+ this.steps = steps;
+ }
+ }
+
+ /**
+ * This is the graph inference solver - the solver organizes all inference variables in
+ * a given inference context by bound dependencies - in the general case, such dependencies
+ * would lead to a cyclic directed graph (hence the name); the dependency info is used to build
+ * an acyclic graph, where all cyclic variables are bundled together. An inference
+ * step corresponds to solving a node in the acyclic graph - this is done by
+ * relying on a given strategy (see GraphStrategy).
+ */
+ class GraphSolver {
+
+ InferenceContext inferenceContext;
+ Warner warn;
+
+ GraphSolver(InferenceContext inferenceContext, Warner warn) {
+ this.inferenceContext = inferenceContext;
+ this.warn = warn;
+ }
+
+ /**
+ * Solve variables in a given inference context. The amount of variables
+ * to be solved, and the way in which the underlying acyclic graph is explored
+ * depends on the selected solver strategy.
+ */
+ void solve(GraphStrategy sstrategy) {
+ checkWithinBounds(inferenceContext, warn); //initial propagation of bounds
+ InferenceGraph inferenceGraph = new InferenceGraph();
+ while (!sstrategy.done()) {
+ InferenceGraph.Node nodeToSolve = sstrategy.pickNode(inferenceGraph);
+ List<Type> varsToSolve = List.from(nodeToSolve.data);
+ inferenceContext.save();
+ try {
+ //repeat until all variables are solved
+ outer: while (Type.containsAny(inferenceContext.restvars(), varsToSolve)) {
+ //for each inference phase
+ for (GraphInferenceSteps step : GraphInferenceSteps.values()) {
+ if (inferenceContext.solveBasic(varsToSolve, step.steps)) {
+ checkWithinBounds(inferenceContext, warn);
+ continue outer;
+ }
+ }
+ //no progress
+ throw inferenceException;
+ }
+ }
+ catch (InferenceException ex) {
+ inferenceContext.rollback();
+ instantiateAsUninferredVars(varsToSolve, inferenceContext);
+ checkWithinBounds(inferenceContext, warn);
+ }
+ inferenceGraph.deleteNode(nodeToSolve);
+ }
+ }
+
+ /**
+ * The dependencies between the inference variables that need to be solved
+ * form a (possibly cyclic) graph. This class reduces the original dependency graph
+ * to an acyclic version, where cyclic nodes are folded into a single 'super node'.
+ */
+ class InferenceGraph {
+
+ /**
+ * This class represents a node in the graph. Each node corresponds
+ * to an inference variable and has edges (dependencies) on other
+ * nodes. The node defines an entry point that can be used to receive
+ * updates on the structure of the graph this node belongs to (used to
+ * keep dependencies in sync).
+ */
+ class Node extends GraphUtils.TarjanNode<ListBuffer<Type>> {
+
+ Set<Node> deps;
+
+ Node(Type ivar) {
+ super(ListBuffer.of(ivar));
+ this.deps = new HashSet<Node>();
+ }
+
+ @Override
+ public Iterable<? extends Node> getDependencies() {
+ return deps;
+ }
+
+ @Override
+ public String printDependency(GraphUtils.Node<ListBuffer<Type>> to) {
+ StringBuilder buf = new StringBuilder();
+ String sep = "";
+ for (Type from : data) {
+ UndetVar uv = (UndetVar)inferenceContext.asFree(from);
+ for (Type bound : uv.getBounds(InferenceBound.values())) {
+ if (bound.containsAny(List.from(to.data))) {
+ buf.append(sep);
+ buf.append(bound);
+ sep = ",";
+ }
+ }
+ }
+ return buf.toString();
+ }
+
+ boolean isLeaf(Node n) {
+ //no deps, or only one self dep
+ return (n.deps.isEmpty() ||
+ n.deps.size() == 1 && n.deps.contains(n));
+ }
+
+ void mergeWith(List<? extends Node> nodes) {
+ for (Node n : nodes) {
+ Assert.check(n.data.length() == 1, "Attempt to merge a compound node!");
+ data.appendList(n.data);
+ deps.addAll(n.deps);
+ }
+ //update deps
+ Set<Node> deps2 = new HashSet<Node>();
+ for (Node d : deps) {
+ if (data.contains(d.data.first())) {
+ deps2.add(this);
+ } else {
+ deps2.add(d);
+ }
+ }
+ deps = deps2;
+ }
+
+ void graphChanged(Node from, Node to) {
+ if (deps.contains(from)) {
+ deps.remove(from);
+ if (to != null) {
+ deps.add(to);
+ }
+ }
+ }
+ }
+
+ /** the nodes in the inference graph */
+ ArrayList<Node> nodes;
+
+ InferenceGraph() {
+ initNodes();
+ }
+
+ /**
+ * Delete a node from the graph. This update the underlying structure
+ * of the graph (including dependencies) via listeners updates.
+ */
+ public void deleteNode(Node n) {
+ Assert.check(nodes.contains(n));
+ nodes.remove(n);
+ notifyUpdate(n, null);
+ }
+
+ /**
+ * Notify all nodes of a change in the graph. If the target node is
+ * {@code null} the source node is assumed to be removed.
+ */
+ void notifyUpdate(Node from, Node to) {
+ for (Node n : nodes) {
+ n.graphChanged(from, to);
+ }
+ }
+
+ /**
+ * Create the graph nodes. First a simple node is created for every inference
+ * variables to be solved. Then Tarjan is used to found all connected components
+ * in the graph. For each component containing more than one node, a super node is
+ * created, effectively replacing the original cyclic nodes.
+ */
+ void initNodes() {
+ ArrayList<Node> nodes = new ArrayList<Node>();
+ for (Type t : inferenceContext.restvars()) {
+ nodes.add(new Node(t));
+ }
+ for (Node n_i : nodes) {
+ Type i = n_i.data.first();
+ for (Node n_j : nodes) {
+ Type j = n_j.data.first();
+ UndetVar uv_i = (UndetVar)inferenceContext.asFree(i);
+ if (Type.containsAny(uv_i.getBounds(InferenceBound.values()), List.of(j))) {
+ //update i's deps
+ n_i.deps.add(n_j);
+ //update j's deps - only if i's bounds contain _exactly_ j
+ if (uv_i.getBounds(InferenceBound.values()).contains(j)) {
+ n_j.deps.add(n_i);
+ }
+ }
+ }
+ }
+ this.nodes = new ArrayList<Node>();
+ for (List<? extends Node> conSubGraph : GraphUtils.tarjan(nodes)) {
+ if (conSubGraph.length() > 1) {
+ Node root = conSubGraph.head;
+ root.mergeWith(conSubGraph.tail);
+ for (Node n : conSubGraph) {
+ notifyUpdate(n, root);
+ }
+ }
+ this.nodes.add(conSubGraph.head);
+ }
+ }
+
+ /**
+ * Debugging: dot representation of this graph
+ */
+ String toDot() {
+ StringBuilder buf = new StringBuilder();
+ for (Type t : inferenceContext.undetvars) {
+ UndetVar uv = (UndetVar)t;
+ buf.append(String.format("var %s - upper bounds = %s, lower bounds = %s, eq bounds = %s\\n",
+ uv.qtype, uv.getBounds(InferenceBound.UPPER), uv.getBounds(InferenceBound.LOWER),
+ uv.getBounds(InferenceBound.EQ)));
+ }
+ return GraphUtils.toDot(nodes, "inferenceGraph" + hashCode(), buf.toString());
+ }
+ }
+ }
+ // </editor-fold>
+
+ // <editor-fold defaultstate="collapsed" desc="Inference context">
+ /**
* Functional interface for defining inference callbacks. Certain actions
* (i.e. subtyping checks) might need to be redone after all inference variables
* have been fixed.
@@ -603,7 +1283,7 @@
* it can be used as an entry point for performing upper/lower bound inference
* (see InferenceKind).
*/
- class InferenceContext {
+ class InferenceContext {
/** list of inference vars as undet vars */
List<Type> undetvars;
@@ -611,6 +1291,9 @@
/** list of inference vars in this context */
List<Type> inferencevars;
+ /** backed up inference variables */
+ List<Type> saved_undet;
+
java.util.Map<FreeTypeListener, List<Type>> freeTypeListeners =
new java.util.HashMap<FreeTypeListener, List<Type>>();
@@ -782,10 +1465,14 @@
* of all deferred checks.
*/
void notifyChange() {
+ notifyChange(inferencevars.diff(restvars()));
+ }
+
+ void notifyChange(List<Type> inferredVars) {
InferenceException thrownEx = null;
for (Map.Entry<FreeTypeListener, List<Type>> entry :
new HashMap<FreeTypeListener, List<Type>>(freeTypeListeners).entrySet()) {
- if (!Type.containsAny(entry.getValue(), restvars())) {
+ if (!Type.containsAny(entry.getValue(), inferencevars.diff(inferredVars))) {
try {
entry.getKey().typesInferred(this);
freeTypeListeners.remove(entry.getKey());
@@ -803,20 +1490,153 @@
}
}
- void solveAny(List<Type> varsToSolve) {
- boolean progress = false;
- for (Type t : varsToSolve) {
+ /**
+ * Save the state of this inference context
+ */
+ void save() {
+ ListBuffer<Type> buf = ListBuffer.lb();
+ for (Type t : undetvars) {
+ UndetVar uv = (UndetVar)t;
+ UndetVar uv2 = new UndetVar((TypeVar)uv.qtype, types);
+ for (InferenceBound ib : InferenceBound.values()) {
+ for (Type b : uv.getBounds(ib)) {
+ uv2.addBound(ib, b, types);
+ }
+ }
+ uv2.inst = uv.inst;
+ buf.add(uv2);
+ }
+ saved_undet = buf.toList();
+ }
+
+ /**
+ * Restore the state of this inference context to the previous known checkpoint
+ */
+ void rollback() {
+ Assert.check(saved_undet != null && saved_undet.length() == undetvars.length());
+ undetvars = saved_undet;
+ saved_undet = null;
+ }
+
+ /**
+ * Copy variable in this inference context to the given context
+ */
+ void dupTo(final InferenceContext that) {
+ that.inferencevars = that.inferencevars.appendList(inferencevars);
+ that.undetvars = that.undetvars.appendList(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) {
+ InferenceContext.this.notifyChange();
+ }
+ }, List.of(t));
+ }
+ }
+
+ /**
+ * Solve with given graph strategy.
+ */
+ private void solve(GraphStrategy ss, Warner warn) {
+ GraphSolver s = new GraphSolver(this, warn);
+ s.solve(ss);
+ }
+
+ /**
+ * Solve all variables in this context.
+ */
+ public void solve(Warner warn) {
+ solve(new LeafSolver() {
+ public boolean done() {
+ return restvars().isEmpty();
+ }
+ }, warn);
+ }
+
+ /**
+ * Solve all variables in the given list.
+ */
+ public void solve(final List<Type> vars, Warner warn) {
+ solve(new BestLeafSolver(vars) {
+ public boolean done() {
+ return !free(asInstTypes(vars));
+ }
+ }, warn);
+ }
+
+ /**
+ * Solve at least one variable in given list.
+ */
+ public void solveAny(List<Type> varsToSolve, Warner warn) {
+ checkWithinBounds(this, warn); //propagate bounds
+ List<Type> boundedVars = boundedVars().intersect(restvars()).intersect(varsToSolve);
+ if (boundedVars.isEmpty()) {
+ throw inferenceException.setMessage("cyclic.inference",
+ freeVarsIn(varsToSolve));
+ }
+ solve(new BestLeafSolver(boundedVars) {
+ public boolean done() {
+ return instvars().intersect(varsToSolve).nonEmpty();
+ }
+ }, warn);
+ }
+
+ /**
+ * Apply a set of inference steps
+ */
+ private boolean solveBasic(EnumSet<InferenceStep> steps) {
+ return solveBasic(inferencevars, steps);
+ }
+
+ private boolean solveBasic(List<Type> varsToSolve, EnumSet<InferenceStep> steps) {
+ boolean changed = false;
+ for (Type t : varsToSolve.intersect(restvars())) {
UndetVar uv = (UndetVar)asFree(t);
- if (uv.inst == null) {
- minimizeInst(uv, types.noWarnings);
- if (uv.inst != null) {
- progress = true;
+ for (InferenceStep step : steps) {
+ if (step.accepts(uv, this)) {
+ uv.inst = step.solve(uv, this);
+ changed = true;
+ break;
}
}
}
- if (!progress) {
- throw inferenceException.setMessage("cyclic.inference", varsToSolve);
+ return changed;
+ }
+
+ /**
+ * Instantiate inference variables in legacy mode (JLS 15.12.2.7, 15.12.2.8).
+ * During overload resolution, instantiation is done by doing a partial
+ * inference process using eq/lower bound instantiation. During check,
+ * we also instantiate any remaining vars by repeatedly using eq/upper
+ * instantiation, until all variables are solved.
+ */
+ public void solveLegacy(boolean partial, Warner warn, EnumSet<InferenceStep> steps) {
+ while (true) {
+ boolean stuck = !solveBasic(steps);
+ if (restvars().isEmpty() || partial) {
+ //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
+ instantiateAsUninferredVars(restvars(), this);
+ break;
+ } else {
+ //some variables have been instantiated - replace newly instantiated
+ //variables in remaining upper bounds and continue
+ for (Type t : undetvars) {
+ UndetVar uv = (UndetVar)t;
+ uv.substBounds(inferenceVars(), instTypes(), types);
+ }
+ }
}
+ checkWithinBounds(this, warn);
+ }
+
+ private Infer infer() {
+ //back-door to infer
+ return Infer.this;
}
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/share/classes/com/sun/tools/javac/util/GraphUtils.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.sun.tools.javac.util;
+
+/** <p><b>This is NOT part of any supported API.
+ * If you write code that depends on this, you do so at your own risk.
+ * This code and its internal interfaces are subject to change or
+ * deletion without notice.</b>
+ */
+public class GraphUtils {
+
+ /**
+ * This class is a basic abstract class for representing a node.
+ * A node is associated with a given data.
+ */
+ public static abstract class Node<D> {
+ public final D data;
+
+ public Node(D data) {
+ this.data = data;
+ }
+
+ public abstract Iterable<? extends Node<D>> getDependencies();
+
+ public abstract String printDependency(Node<D> to);
+
+ @Override
+ public String toString() {
+ return data.toString();
+ }
+ }
+
+ /**
+ * This class specialized Node, by adding elements that are required in order
+ * to perform Tarjan computation of strongly connected components.
+ */
+ public static abstract class TarjanNode<D> extends Node<D> implements Comparable<TarjanNode<D>> {
+ int index = -1;
+ int lowlink;
+ boolean active;
+
+ public TarjanNode(D data) {
+ super(data);
+ }
+
+ public abstract Iterable<? extends TarjanNode<D>> getDependencies();
+
+ public int compareTo(TarjanNode<D> o) {
+ return (index < o.index) ? -1 : (index == o.index) ? 0 : 1;
+ }
+ }
+
+ /**
+ * Tarjan's algorithm to determine strongly connected components of a
+ * directed graph in linear time. Works on TarjanNode.
+ */
+ public static <D, N extends TarjanNode<D>> List<? extends List<? extends N>> tarjan(Iterable<? extends N> nodes) {
+ ListBuffer<List<N>> cycles = ListBuffer.lb();
+ ListBuffer<N> stack = ListBuffer.lb();
+ int index = 0;
+ for (N node: nodes) {
+ if (node.index == -1) {
+ index += tarjan(node, index, stack, cycles);
+ }
+ }
+ return cycles.toList();
+ }
+
+ private static <D, N extends TarjanNode<D>> int tarjan(N v, int index, ListBuffer<N> stack, ListBuffer<List<N>> cycles) {
+ v.index = index;
+ v.lowlink = index;
+ index++;
+ stack.prepend(v);
+ v.active = true;
+ for (TarjanNode<D> nd: v.getDependencies()) {
+ @SuppressWarnings("unchecked")
+ N n = (N)nd;
+ if (n.index == -1) {
+ tarjan(n, index, stack, cycles);
+ v.lowlink = Math.min(v.lowlink, n.lowlink);
+ } else if (stack.contains(n)) {
+ v.lowlink = Math.min(v.lowlink, n.index);
+ }
+ }
+ if (v.lowlink == v.index) {
+ N n;
+ ListBuffer<N> cycle = ListBuffer.lb();
+ do {
+ n = stack.remove();
+ n.active = false;
+ cycle.add(n);
+ } while (n != v);
+ cycles.add(cycle.toList());
+ }
+ return index;
+ }
+
+ /**
+ * Debugging: dot representation of a set of connected nodes. The resulting
+ * dot representation will use {@code Node.toString} to display node labels
+ * and {@code Node.printDependency} to display edge labels. The resulting
+ * representation is also customizable with a graph name and a header.
+ */
+ public static <D> String toDot(Iterable<? extends TarjanNode<D>> nodes, String name, String header) {
+ StringBuilder buf = new StringBuilder();
+ buf.append(String.format("digraph %s {\n", name));
+ buf.append(String.format("label = \"%s\";\n", header));
+ //dump nodes
+ for (TarjanNode<D> n : nodes) {
+ buf.append(String.format("%s [label = \"%s\"];\n", n.hashCode(), n.toString()));
+ }
+ //dump arcs
+ for (TarjanNode<D> from : nodes) {
+ for (TarjanNode<D> to : from.getDependencies()) {
+ buf.append(String.format("%s -> %s [label = \" %s \"];\n",
+ from.hashCode(), to.hashCode(), from.printDependency(to)));
+ }
+ }
+ buf.append("}\n");
+ return buf.toString();
+ }
+}
--- a/langtools/test/tools/javac/6758789/T6758789b.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/6758789/T6758789b.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,4 +1,4 @@
-T6758789b.java:16:11: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), T6758789a.Foo, T6758789a.Foo<X>
+T6758789b.java:16:11: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), T6758789a.Foo, T6758789a.Foo<java.lang.Object>
T6758789b.java:16:10: compiler.warn.unchecked.meth.invocation.applied: kindname.method, m, T6758789a.Foo<X>, T6758789a.Foo, kindname.class, T6758789a
- compiler.err.warnings.and.werror
1 error
--- a/langtools/test/tools/javac/Diagnostics/6799605/T6799605.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/Diagnostics/6799605/T6799605.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,4 +1,4 @@
-T6799605.java:17:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.inferred.do.not.conform.to.upper.bounds: compiler.misc.type.captureof: 1, ?, T6799605<compiler.misc.type.captureof: 1, ?>)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T))}
+T6799605.java:17:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.incompatible.eq.upper.bounds: T, compiler.misc.type.captureof: 1, ?, T6799605<T>)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T))}
T6799605.java:18:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,T6799605<compiler.misc.type.captureof: 2, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.inferred.do.not.conform.to.eq.bounds: compiler.misc.type.captureof: 2, ?, compiler.misc.type.captureof: 2, ?,compiler.misc.type.captureof: 1, ?)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T))}
T6799605.java:19:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,T6799605<compiler.misc.type.captureof: 2, ?>,T6799605<compiler.misc.type.captureof: 3, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.inferred.do.not.conform.to.eq.bounds: compiler.misc.type.captureof: 3, ?, compiler.misc.type.captureof: 3, ?,compiler.misc.type.captureof: 2, ?,compiler.misc.type.captureof: 1, ?))}
3 errors
--- a/langtools/test/tools/javac/diags/examples/CantApplyDiamond1.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/diags/examples/CantApplyDiamond1.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -23,7 +23,7 @@
// key: compiler.err.prob.found.req
// key: compiler.misc.cant.apply.diamond.1
-// key: compiler.misc.inferred.do.not.conform.to.upper.bounds
+// key: compiler.misc.incompatible.eq.upper.bounds
// key: compiler.misc.diamond
class CantApplyDiamond1<X> {
--- a/langtools/test/tools/javac/diags/examples/InferredDoNotConformToEq.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/diags/examples/InferredDoNotConformToEq.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -23,6 +23,7 @@
// key: compiler.err.cant.apply.symbol
// key: compiler.misc.inferred.do.not.conform.to.eq.bounds
+// options: -source 7 -Xlint:-options
import java.util.*;
--- a/langtools/test/tools/javac/diags/examples/InferredDoNotConformToUpper.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/diags/examples/InferredDoNotConformToUpper.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -23,6 +23,7 @@
// key: compiler.err.cant.apply.symbol
// key: compiler.misc.inferred.do.not.conform.to.upper.bounds
+// options: -source 7 -Xlint:-options
import java.util.*;
--- a/langtools/test/tools/javac/diags/examples/WhereFreshTvar.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/diags/examples/WhereFreshTvar.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -24,7 +24,7 @@
// key: compiler.misc.where.fresh.typevar
// key: compiler.misc.where.description.typevar
// key: compiler.err.prob.found.req
-// key: compiler.misc.inferred.do.not.conform.to.upper.bounds
+// key: compiler.misc.inconvertible.types
// options: -XDdiags=where,simpleNames
// run: simple
@@ -33,5 +33,5 @@
class WhereFreshTvar {
<T extends List<T>> T m() {}
- { List<String> ls = m(); }
+ { Object o = (List<String>)m(); }
}
--- a/langtools/test/tools/javac/generics/7015430/T7015430.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/7015430/T7015430.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,14 +1,14 @@
-T7015430.java:41:15: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.lang.Iterable, java.lang.Iterable<E>
+T7015430.java:41:15: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.lang.Iterable, java.lang.Iterable<java.lang.Exception>
T7015430.java:41:14: compiler.warn.unchecked.meth.invocation.applied: kindname.method, empty, java.lang.Iterable<E>, java.lang.Iterable, kindname.class, T7015430
T7015430.java:50:42: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.lang.Iterable, java.lang.Iterable<java.lang.RuntimeException>
T7015430.java:50:41: compiler.warn.unchecked.meth.invocation.applied: kindname.method, empty, java.lang.Iterable<E>, java.lang.Iterable, kindname.class, T7015430
-T7015430.java:68:22: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.lang.Iterable, java.lang.Iterable<E>
+T7015430.java:68:22: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.lang.Iterable, java.lang.Iterable<java.lang.Exception>
T7015430.java:68:9: compiler.warn.unchecked.meth.invocation.applied: kindname.constructor, <init>, java.lang.Iterable<E>, java.lang.Iterable, kindname.class, T7015430
T7015430.java:77:40: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.lang.Iterable, java.lang.Iterable<java.lang.RuntimeException>
T7015430.java:77:9: compiler.warn.unchecked.meth.invocation.applied: kindname.constructor, <init>, java.lang.Iterable<E>, java.lang.Iterable, kindname.class, T7015430
T7015430.java:104:41: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.lang.Iterable, java.lang.Iterable<java.lang.RuntimeException>
T7015430.java:104:9: compiler.warn.unchecked.meth.invocation.applied: kindname.constructor, <init>, java.lang.Iterable<E>, java.lang.Iterable, kindname.class, T7015430
-T7015430.java:113:22: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.lang.Iterable, java.lang.Iterable<E>
+T7015430.java:113:22: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.lang.Iterable, java.lang.Iterable<java.lang.Exception>
T7015430.java:113:9: compiler.warn.unchecked.meth.invocation.applied: kindname.constructor, <init>, java.lang.Iterable<E>, java.lang.Iterable, kindname.class, T7015430
T7015430.java:41:14: compiler.err.unreported.exception.need.to.catch.or.throw: java.lang.Exception
T7015430.java:68:9: compiler.err.unreported.exception.need.to.catch.or.throw: java.lang.Exception
--- a/langtools/test/tools/javac/generics/7151802/T7151802.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/7151802/T7151802.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,5 +1,5 @@
T7151802.java:14:31: compiler.warn.unchecked.meth.invocation.applied: kindname.method, get1, Z, T7151802.Foo, kindname.class, T7151802
-T7151802.java:22:31: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), T7151802.Foo, T7151802.Foo<Z>
+T7151802.java:22:31: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), T7151802.Foo, T7151802.Foo<java.lang.Object>
T7151802.java:22:30: compiler.warn.unchecked.meth.invocation.applied: kindname.method, get3, T7151802.Foo<Z>, T7151802.Foo, kindname.class, T7151802
T7151802.java:30:36: compiler.warn.unchecked.meth.invocation.applied: kindname.method, get5, compiler.misc.no.args, compiler.misc.no.args, kindname.class, T7151802
T7151802.java:38:32: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), T7151802.Foo, T7151802.Foo<java.lang.String>
--- a/langtools/test/tools/javac/generics/diamond/neg/Neg06.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/diamond/neg/Neg06.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,2 +1,2 @@
-Neg06.java:16:37: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg06.CFoo), (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.String, java.lang.Number))
+Neg06.java:16:37: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg06.CFoo), (compiler.misc.incompatible.eq.upper.bounds: X, java.lang.String, java.lang.Number))
1 error
--- a/langtools/test/tools/javac/generics/inference/6278587/T6278587Neg.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/inference/6278587/T6278587Neg.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -23,10 +23,11 @@
/*
* @test
- * @bug 6278587
+ * @bug 6278587 8007464
* @summary Inference broken for subtypes of subtypes of F-bounded types
* @author Peter von der Ah\u00e9
- * @compile/fail T6278587Neg.java
+ * @compile/fail -source 7 T6278587Neg.java
+ * @compile T6278587Neg.java
*/
public abstract class T6278587Neg {
--- a/langtools/test/tools/javac/generics/inference/6638712/T6638712d.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712d.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,2 +1,2 @@
-T6638712d.java:16:9: compiler.err.cant.apply.symbol: kindname.method, m, U,java.util.List<java.util.List<U>>, int,java.util.List<java.util.List<java.lang.String>>, kindname.class, T6638712d, (compiler.misc.inferred.do.not.conform.to.lower.bounds: java.lang.String, java.lang.Integer)
+T6638712d.java:16:9: compiler.err.cant.apply.symbol: kindname.method, m, U,java.util.List<java.util.List<U>>, int,java.util.List<java.util.List<java.lang.String>>, kindname.class, T6638712d, (compiler.misc.incompatible.eq.lower.bounds: U, java.lang.String, java.lang.Integer)
1 error
--- a/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,2 +1,2 @@
-T6638712e.java:17:27: compiler.err.prob.found.req: (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.Object, java.lang.Boolean,java.lang.Object)
+T6638712e.java:17:27: compiler.err.prob.found.req: (compiler.misc.incompatible.eq.upper.bounds: X, java.lang.Object, java.lang.Boolean,java.lang.Object)
1 error
--- a/langtools/test/tools/javac/generics/inference/7154127/T7154127.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/inference/7154127/T7154127.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,8 +1,9 @@
/**
* @test /nodynamiccopyright/
- * @bug 7154127
+ * @bug 7154127 8007464
* @summary Inference cleanup: remove bound check analysis from visitors in Types.java
- * @compile/fail/ref=T7154127.out -XDrawDiagnostics T7154127.java
+ * @compile/fail/ref=T7154127.out -Xlint:-options -source 7 -XDrawDiagnostics T7154127.java
+ * @compile T7154127.java
*/
class T7154127 {
--- a/langtools/test/tools/javac/generics/inference/7154127/T7154127.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/inference/7154127/T7154127.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,2 +1,2 @@
-T7154127.java:19:49: compiler.err.prob.found.req: (compiler.misc.incompatible.upper.bounds: Y, T7154127.B<U>,T7154127.D)
+T7154127.java:20:49: compiler.err.prob.found.req: (compiler.misc.incompatible.upper.bounds: Y, T7154127.B<U>,T7154127.D)
1 error
--- a/langtools/test/tools/javac/generics/inference/7177306/T7177306a.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/inference/7177306/T7177306a.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,4 +1,4 @@
-T7177306a.java:13:34: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.util.List, java.util.List<E>
+T7177306a.java:13:34: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), java.util.List, java.util.List<java.lang.Object>
T7177306a.java:13:33: compiler.warn.unchecked.meth.invocation.applied: kindname.method, m, java.util.List<E>, java.util.List, kindname.class, T7177306a
T7177306a.java:13:33: compiler.warn.prob.found.req: (compiler.misc.unchecked.assign), T7177306a, T7177306a<java.lang.Object>
- compiler.err.warnings.and.werror
--- a/langtools/test/tools/javac/generics/inference/7177306/T7177306e.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/inference/7177306/T7177306e.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,8 +1,9 @@
/**
* @test /nodynamiccopyright/
- * @bug 7177306
+ * @bug 7177306 8007464
* @summary Regression: unchecked method call does not erase return type
- * @compile/fail/ref=T7177306e.out -XDrawDiagnostics T7177306e.java
+ * @compile/fail/ref=T7177306e.out -source 7 -Xlint:-options -XDrawDiagnostics T7177306e.java
+ * @compile/fail T7177306e.java
*/
import java.util.List;
--- a/langtools/test/tools/javac/generics/inference/7177306/T7177306e.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/inference/7177306/T7177306e.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,2 +1,2 @@
-T7177306e.java:15:9: compiler.err.prob.found.req: (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.util.List<?>, java.util.List<compiler.misc.type.captureof: 1, ?>)
+T7177306e.java:16:9: compiler.err.prob.found.req: (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.util.List<?>, java.util.List<compiler.misc.type.captureof: 1, ?>)
1 error
--- a/langtools/test/tools/javac/generics/odersky/BadTest4.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/generics/odersky/BadTest4.java Tue Feb 12 19:25:09 2013 +0000
@@ -23,11 +23,12 @@
/*
* @test
- * @ bug
+ * @bug 8007464
* @summary Negative regression test from odersky
* @author odersky
*
- * @compile/fail BadTest4.java
+ * @compile/fail -source 7 BadTest4.java
+ * @compile BadTest4.java
*/
class BadTest4 {
--- a/langtools/test/tools/javac/lambda/TargetType14.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType14.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,2 +1,2 @@
-TargetType14.java:20:29: compiler.err.prob.found.req: (compiler.misc.inferred.do.not.conform.to.lower.bounds: java.lang.Integer, java.lang.String)
+TargetType14.java:20:29: compiler.err.prob.found.req: (compiler.misc.incompatible.eq.lower.bounds: X, java.lang.Integer, java.lang.String)
1 error
--- a/langtools/test/tools/javac/lambda/TargetType20.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType20.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,10 +1,33 @@
/*
- * @test /nodynamiccopyright/
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
* @bug 8003280
* @summary Add lambda tests
* complex case of lambda return type that depends on generic method
* inference variable
- * @compile/fail/ref=TargetType20.out -XDrawDiagnostics TargetType20.java
+ * @compile -XDrawDiagnostics TargetType20.java
*/
import java.util.*;
--- a/langtools/test/tools/javac/lambda/TargetType20.out Tue Feb 12 13:36:56 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-TargetType20.java:19:10: compiler.err.cant.apply.symbol: kindname.method, call, TargetType20.SAM2<Z>,TargetType20.SAM2<Z>, @428,@459, kindname.class, TargetType20.Test, (compiler.misc.inferred.do.not.conform.to.eq.bounds: java.lang.String, java.lang.String,java.lang.Object)
-1 error
--- a/langtools/test/tools/javac/lambda/TargetType28.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType28.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,3 +1,2 @@
-TargetType28.java:20:32: compiler.err.prob.found.req: (compiler.misc.inferred.do.not.conform.to.eq.bounds: java.lang.Number, java.lang.Number,java.lang.String)
-TargetType28.java:21:33: compiler.err.prob.found.req: (compiler.misc.inferred.do.not.conform.to.eq.bounds: java.lang.Number, java.lang.Number,java.lang.Integer)
-2 errors
+TargetType28.java:20:32: compiler.err.prob.found.req: (compiler.misc.incompatible.eq.upper.bounds: X, java.lang.String,X, java.lang.Object,java.lang.Number)
+1 error
--- a/langtools/test/tools/javac/lambda/TargetType50.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType50.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,9 +1,32 @@
/*
- * @test /nodynamiccopyright/
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
* @bug 8003280
* @summary Add lambda tests
* bad stuck check for method reference leads to javac crash
- * @compile/fail/ref=TargetType50.out -XDrawDiagnostics TargetType50.java
+ * @compile TargetType50.java
*/
import java.util.*;
@@ -17,7 +40,7 @@
static <Z> Sink<Z> make() { return null; }
}
- <Y, S extends Sink<Y>> List<Y> m(Factory<S> factory) { }
+ <Y, S extends Sink<Y>> List<Y> m(Factory<S> factory) { return null; }
void test() {
List<?> l1 = m(Sink::new);
--- a/langtools/test/tools/javac/lambda/TargetType50.out Tue Feb 12 13:36:56 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-TargetType50.java:25:28: compiler.err.prob.found.req: (compiler.misc.inferred.do.not.conform.to.upper.bounds: TargetType50.Sink<java.lang.Object>, TargetType50.Sink<java.lang.String>)
-TargetType50.java:26:28: compiler.err.prob.found.req: (compiler.misc.inferred.do.not.conform.to.upper.bounds: TargetType50.Sink<java.lang.Object>, TargetType50.Sink<java.lang.String>)
-2 errors
--- a/langtools/test/tools/javac/lambda/TargetType51.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType51.java Tue Feb 12 19:25:09 2013 +0000
@@ -23,7 +23,9 @@
/*
* @test
- * @summary smoke test for combinator-like stuck analysis
+ * @bug 8005244
+ * @summary Implement overload resolution as per latest spec EDR
+ * smoke test for combinator-like stuck analysis
* @author Maurizio Cimadamore
* @compile TargetType51.java
*/
--- a/langtools/test/tools/javac/lambda/TargetType52.java Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType52.java Tue Feb 12 19:25:09 2013 +0000
@@ -1,6 +1,8 @@
/*
* @test /nodynamiccopyright/
- * @summary uncatched sam conversion failure exception lead to javac crash
+ * @bug 8005244
+ * @summary Implement overload resolution as per latest spec EDR
+ * uncatched sam conversion failure exception lead to javac crash
* @compile/fail/ref=TargetType52.out -XDrawDiagnostics TargetType52.java
*/
class TargetType52 {
--- a/langtools/test/tools/javac/lambda/TargetType52.out Tue Feb 12 13:36:56 2013 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType52.out Tue Feb 12 19:25:09 2013 +0000
@@ -1,2 +1,2 @@
-TargetType52.java:15:9: compiler.err.cant.apply.symbol: kindname.method, m, TargetType52.FI<? extends java.lang.CharSequence,? extends java.util.ArrayList<? extends java.lang.CharSequence>>, @444, kindname.class, TargetType52, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.no.suitable.functional.intf.inst: TargetType52.FI<java.lang.CharSequence,java.util.ArrayList<? extends java.lang.CharSequence>>))
+TargetType52.java:17:9: compiler.err.cant.apply.symbol: kindname.method, m, TargetType52.FI<? extends java.lang.CharSequence,? extends java.util.ArrayList<? extends java.lang.CharSequence>>, @525, kindname.class, TargetType52, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.no.suitable.functional.intf.inst: TargetType52.FI<java.lang.CharSequence,java.util.ArrayList<? extends java.lang.CharSequence>>))
1 error
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType53.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8007464
+ * @summary Add graph inference support
+ * smoke test for graph inference
+ * @ignore awaits stream API: 800NNNN
+ * @compile TargetType53.java
+ */
+import java.util.*;
+import java.util.stream.*;
+import java.util.function.*;
+
+class TargetType53 {
+
+ <P> List<List<P>> perm(List<P> l) { return null; }
+
+ void g(List<List<UnaryOperator<IntStream>>> l) { }
+
+ void test() {
+ List<List<UnaryOperator<IntStream>>> l =
+ perm(Arrays.asList(s -> s.sorted()));
+ g(perm(Arrays.asList(s -> s.sorted())));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType54.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8007464
+ * @summary Add graph inference support
+ * smoke test for graph inference
+ * @ignore awaits stream API: 800NNNN
+ * @compile TargetType54.java
+ */
+import java.util.stream.*;
+import java.util.*;
+import static java.util.stream.Collectors.*;
+
+class TargetType54 {
+ void test(Stream<Integer> si) {
+ List<Integer> l1 = si.collect(toList());
+ List<Integer> l2 = si.collect(toCollection(ArrayList::new));
+ m(si.collect(toList()));
+ m(si.collect(toCollection(ArrayList::new)));
+ }
+
+ void m(List<Integer> l) { }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType55.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8007464
+ * @summary Add graph inference
+ * support smoke test for graph inference
+ * @compile TargetType55.java
+ */
+import java.util.function.*;
+
+class TargetType55 {
+
+ <R> void m(Function<Integer, R> collector) { }
+
+ <T, D> Function<T, Integer> g(D d, BinaryOperator<D> reducer) { return null; }
+
+ public void test() {
+ m(g((Integer)null, (x,y)->1));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType56.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8007464
+ * @summary Add graph inference support
+ * smoke test for graph inference
+ * @compile TargetType56.java
+ */
+class TargetType56 {
+ <Z> Z m(Z z) { return null; }
+
+ void test() {
+ double d1 = m(1);
+ double d2 = m((Integer)null);
+ double d3 = m(m(1));
+ double d4 = m(m((Integer)null));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType57.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,20 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8007464
+ * @summary Add graph inference support
+ * more smoke tests for graph inference
+ * @compile/fail/ref=TargetType57.out -XDrawDiagnostics TargetType57.java
+ */
+import java.util.*;
+import java.util.function.*;
+
+class TargetType57 {
+
+ void test(List<Integer> list) {
+ m(list, s -> s.intValue(), s -> s.nonExistentMethod());
+ }
+
+ <U, R, S_IN, S_OUT> R m(List<S_IN> list,
+ Function<S_IN, S_OUT> f1,
+ Function<S_OUT, R> f2) { return null; }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType57.out Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,2 @@
+TargetType57.java:14:42: compiler.err.cant.resolve.location.args: kindname.method, nonExistentMethod, , , (compiler.misc.location.1: kindname.variable, s, java.lang.Integer)
+1 error
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType58.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8007464
+ * @summary Add graph inference support
+ * more smoke tests for graph inference
+ * @ignore awaits stream API: 800NNNN
+ * @compile TargetType58.java
+ */
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
+class TargetType58 {
+
+ void test(List<Integer> li) {
+ g(li, s -> s.substream(200), Collections.emptyList());
+ }
+
+ <T, U, S_OUT extends Stream<U>,
+ I extends Iterable<U>> Collection<U> g(Collection<T> coll, Function<Stream<T>, S_OUT> f, I i) {
+ return null;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType59.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8007464
+ * @summary Add graph inference support
+ * more smoke tests for graph inference
+ * @ignore awaits stream API: 800NNNN
+ * @compile TargetType59.java
+ */
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
+class TargetType59 {
+
+ <T, R> Collector<T, R> m(Supplier<? extends R> supplier, BiConsumer<R, T> accumulator) {
+ return null;
+ }
+
+ <T, C extends Collection<T>> Collector<T,C> test1(Supplier<C> collectionFactory) {
+ return m(collectionFactory, Collection::add);
+ }
+
+ Collector<String, StringBuilder> test2(Supplier<StringBuilder> sb) {
+ return m(sb, StringBuilder::append);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType61.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8007464
+ * @summary Add graph inference support
+ * check that new wildcards inference strategy doesn't run into 7190296
+ * @compile TargetType61.java
+ */
+class TargetType61 {
+
+ interface Stream<T> {
+ void forEach(Sink<? super T> sink);
+ }
+
+ interface Sink<T> {
+ void put(T t);
+ }
+
+ public boolean add(CharSequence s) { return false; }
+
+ public void addAll(Stream<? extends CharSequence> stream) {
+ stream.forEach(this::add);
+ stream.forEach(e -> { add(e); });
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/TargetType62.java Tue Feb 12 19:25:09 2013 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8007464
+ * @summary Add graph inference support
+ * check that new wildcards inference strategy doesn't run into 7190296
+ * @ignore awaits stream API: 800NNNN
+ * @compile TargetType62.java
+ */
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
+class TargetType61 {
+
+ Collector test(Function<Integer, Integer> classifier) {
+ return g(classifier, TreeMap::new, m(HashSet::new));
+ }
+
+ <R> Collector<Integer, R> m(Supplier<R> s) { return null; }
+
+ <T, K, D, M extends Map<K, D>>
+ Collector<T, M> g(Function<T, K> classifier, Supplier<M> mapFactory, Collector<T, D> downstream) { return null; }
+}