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

equal deleted inserted replaced

-:12414a72f8d2
+:0d889f759fac
 return visit(t.bound);
 }
 };
 // </editor-fold>
-// <editor-fold defaultstate="collapsed" desc="lowerBound">
+// <editor-fold defaultstate="collapsed" desc="wildLowerBound">
 /**
-* The "lvalue conversion".<br>
+* Get a wildcard's lower bound, returning non-wildcards unchanged.
-* The lower bound of most types is the type
+* @param t a type argument, either a wildcard or a type
-* itself.  Wildcards, on the other hand have upper
+*/
-* and lower bounds.
+public Type wildLowerBound(Type t) {
+if (t.hasTag(WILDCARD)) {
+WildcardType w = (WildcardType) t;
+return w.isExtendsBound() ? syms.botType : wildLowerBound(w.type);
+}
+else return t;
+}
+// </editor-fold>
+// <editor-fold defaultstate="collapsed" desc="cvarLowerBound">
+/**
+* Get a capture variable's lower bound, returning other types unchanged.
 * @param t a type
-* @return the lower bound of the given type
+*/
-*/
+public Type cvarLowerBound(Type t) {
-public Type lowerBound(Type t) {
+if (t.hasTag(TYPEVAR) && ((TypeVar) t).isCaptured()) {
-return lowerBound.visit(t);
+return cvarLowerBound(t.getLowerBound());
 }
-// where
+else return t;
-private final MapVisitor<Void> lowerBound = new MapVisitor<Void>() {
+}
-@Override
-public Type visitWildcardType(WildcardType t, Void ignored) {
-return t.isExtendsBound() ? syms.botType : visit(t.type);
-}
-@Override
-public Type visitCapturedType(CapturedType t, Void ignored) {
-return visit(t.getLowerBound());
-}
-};
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="isUnbounded">
 /**
 * Checks that all the arguments to a class are unbounded
 return false;
 }
 return true;
 }
-Type lower = lowerBound(s);
+// Generally, if 's' is a type variable, recur on lower bound; but
-if (s != lower)
+// for alpha <: CAP, alpha should get upper bound CAP
-return isSubtype(capture ? capture(t) : t, lower, false);
+if (!t.hasTag(UNDETVAR)) {
+// TODO: JDK-8039198, bounds checking sometimes passes in a wildcard as s
+Type lower = cvarLowerBound(wildLowerBound(s));
+if (s != lower)
+return isSubtype(capture ? capture(t) : t, lower, false);
+}
 return isSubtype.visit(capture ? capture(t) : t, s);
 }
 // where
 private TypeRelation isSubtype = new TypeRelation()
 if (s.isPartial())
 return visit(s, t);
 if (s.isSuperBound() && !s.isExtendsBound())
-return visit(t, upperBound(s)) && visit(t, lowerBound(s));
+return visit(t, upperBound(s)) && visit(t, wildLowerBound(s));
 if (t.isCompound() && s.isCompound()) {
 if (!visit(supertype(t), supertype(s)))
 return false;
 Type bound = upperBound(s);
 undetvar.addBound(InferenceBound.UPPER, bound, this);
 break;
 }
 case SUPER: {
-Type bound = lowerBound(s);
+Type bound = wildLowerBound(s);
 undetvar.addBound(InferenceBound.LOWER, bound, this);
 break;
 }
 }
 return true;
 //                System.err.format(" %s U(%s) <: U(%s) %s = %s%n",
 //                                  upperBound(s), s, t, U(t),
 //                                  t.isSuperBound()
 //                                  || isSubtypeNoCapture(upperBound(s), U(t)));
 //                System.err.format(" %s L(%s) <: L(%s) %s = %s%n",
-//                                  L(t), t, s, lowerBound(s),
+//                                  L(t), t, s, wildLowerBound(s),
 //                                  t.isExtendsBound()
-//                                  || isSubtypeNoCapture(L(t), lowerBound(s)));
+//                                  || isSubtypeNoCapture(L(t), wildLowerBound(s)));
 //                System.err.println();
 //            }
 @Override
 public Boolean visitWildcardType(WildcardType t, Type s) {
 return containedBy(s, t);
 else {
 //                    debugContainsType(t, s);
 return isSameWildcard(t, s)
 || isCaptureOf(s, t)
-|| ((t.isExtendsBound() || isSubtypeNoCapture(L(t), lowerBound(s))) &&
+|| ((t.isExtendsBound() || isSubtypeNoCapture(L(t), wildLowerBound(s))) &&
 (t.isSuperBound() || isSubtypeNoCapture(upperBound(s), U(t))));
 }
 }
 @Override
 if (t.isExtendsBound()) {
 if (s.isExtendsBound())
 return !isCastableRecursive(t.type, upperBound(s));
 else if (s.isSuperBound())
-return notSoftSubtypeRecursive(lowerBound(s), t.type);
+return notSoftSubtypeRecursive(wildLowerBound(s), t.type);
 } else if (t.isSuperBound()) {
 if (s.isExtendsBound())
 return notSoftSubtypeRecursive(t.type, upperBound(s));
 }
 return false;
 }
 };
 // </editor-fold>
-// <editor-fold defaultstate="collapsed" desc="lowerBoundArgtypes">
+// <editor-fold defaultstate="collapsed" desc="cvarLowerBounds">
-/**
+public List<Type> cvarLowerBounds(List<Type> ts) {
-* Returns the lower bounds of the formals of a method.
+return map(ts, cvarLowerBoundMapping);
-*/
+}
-public List<Type> lowerBoundArgtypes(Type t) {
+private final Mapping cvarLowerBoundMapping = new Mapping("cvarLowerBound") {
-return lowerBounds(t.getParameterTypes());
-}
-public List<Type> lowerBounds(List<Type> ts) {
-return map(ts, lowerBoundMapping);
-}
-private final Mapping lowerBoundMapping = new Mapping("lowerBound") {
 public Type apply(Type t) {
-return lowerBound(t);
+return cvarLowerBound(t);
 }
 };
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="notSoftSubtype">
 }
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="makeCompoundType">
 /**
-* Make a compound type from non-empty list of types
+* Make a compound type from non-empty list of types.  The list should be
+* ordered according to {@link Symbol#precedes(TypeSymbol,Types)}.
 *
 * @param bounds            the types from which the compound type is formed
 * @param supertype         is objectType if all bounds are interfaces,
 *                          null otherwise.
 */
 /**
 * Insert a type in a closure
 */
 public List<Type> insert(List<Type> cl, Type t) {
-if (cl.isEmpty() || t.tsym.precedes(cl.head.tsym, this)) {
+if (cl.isEmpty()) {
 return cl.prepend(t);
-} else if (cl.head.tsym.precedes(t.tsym, this)) {
+} else if (t.tsym == cl.head.tsym) {
+return cl;
+} else if (t.tsym.precedes(cl.head.tsym, this)) {
+return cl.prepend(t);
+} else {
+// t comes after head, or the two are unrelated
 return insert(cl.tail, t).prepend(cl.head);
-} else {
-return cl;
 }
 }
 /**
 * Form the union of two closures
 public List<Type> union(List<Type> cl1, List<Type> cl2) {
 if (cl1.isEmpty()) {
 return cl2;
 } else if (cl2.isEmpty()) {
 return cl1;
+} else if (cl1.head.tsym == cl2.head.tsym) {
+return union(cl1.tail, cl2.tail).prepend(cl1.head);
 } else if (cl1.head.tsym.precedes(cl2.head.tsym, this)) {
 return union(cl1.tail, cl2).prepend(cl1.head);
 } else if (cl2.head.tsym.precedes(cl1.head.tsym, this)) {
 return union(cl1, cl2.tail).prepend(cl2.head);
 } else {
-return union(cl1.tail, cl2.tail).prepend(cl1.head);
+// unrelated types
+return union(cl1.tail, cl2).prepend(cl1.head);
 }
 }
 /**
 * Intersect two closures
 * compoundMin or glb.
 */
 private List<Type> closureMin(List<Type> cl) {
 ListBuffer<Type> classes = new ListBuffer<>();
 ListBuffer<Type> interfaces = new ListBuffer<>();
+Set<Type> toSkip = new HashSet<>();
 while (!cl.isEmpty()) {
 Type current = cl.head;
-if (current.isInterface())
+boolean keep = !toSkip.contains(current);
-interfaces.append(current);
+if (keep && current.hasTag(TYPEVAR)) {
-else
+// skip lower-bounded variables with a subtype in cl.tail
-classes.append(current);
+for (Type t : cl.tail) {
-ListBuffer<Type> candidates = new ListBuffer<>();
+if (isSubtypeNoCapture(t, current)) {
-for (Type t : cl.tail) {
+keep = false;
-if (!isSubtypeNoCapture(current, t))
+break;
-candidates.append(t);
+}
 }
-cl = candidates.toList();
+}
+if (keep) {
+if (current.isInterface())
+interfaces.append(current);
+else
+classes.append(current);
+for (Type t : cl.tail) {
+// skip supertypes of 'current' in cl.tail
+if (isSubtypeNoCapture(current, t))
+toSkip.add(t);
+}
+}
+cl = cl.tail;
 }
 return classes.appendList(interfaces).toList();
 }
 /**
 return t;
 else if (isSubtypeNoCapture(s, t))
 return s;
 List<Type> closure = union(closure(t), closure(s));
-List<Type> bounds = closureMin(closure);
+return glbFlattened(closure, t);
+}
+//where
+/**
+* Perform glb for a list of non-primitive, non-error, non-compound types;
+* redundant elements are removed.  Bounds should be ordered according to
+* {@link Symbol#precedes(TypeSymbol,Types)}.
+*
+* @param flatBounds List of type to glb
+* @param errT Original type to use if the result is an error type
+*/
+private Type glbFlattened(List<Type> flatBounds, Type errT) {
+List<Type> bounds = closureMin(flatBounds);
 if (bounds.isEmpty()) {             // length == 0
 return syms.objectType;
 } else if (bounds.tail.isEmpty()) { // length == 1
 return bounds.head;
 } else {                            // length > 1
 int classCount = 0;
-for (Type bound : bounds)
+List<Type> lowers = List.nil();
-if (!bound.isInterface())
+for (Type bound : bounds) {
+if (!bound.isInterface()) {
 classCount++;
-if (classCount > 1)
+Type lower = cvarLowerBound(bound);
-return createErrorType(t);
+if (bound != lower && !lower.hasTag(BOT))
+lowers = insert(lowers, lower);
+}
+}
+if (classCount > 1) {
+if (lowers.isEmpty())
+return createErrorType(errT);
+else
+return glbFlattened(union(bounds, lowers), errT);
+}
 }
 return makeCompoundType(bounds);
 }
 // </editor-fold>
 @Override
 public Void visitWildcardType(WildcardType source, Type target) throws AdaptFailure {
 if (source.isExtendsBound())
 adaptRecursive(upperBound(source), upperBound(target));
 else if (source.isSuperBound())
-adaptRecursive(lowerBound(source), lowerBound(target));
+adaptRecursive(wildLowerBound(source), wildLowerBound(target));
 return null;
 }
 @Override
 public Void visitTypeVar(TypeVar source, Type target) throws AdaptFailure {
 // already a mapping for $source$, in which case
 // the old mapping will be merged with the new
 Type val = mapping.get(source.tsym);
 if (val != null) {
 if (val.isSuperBound() && target.isSuperBound()) {
-val = isSubtype(lowerBound(val), lowerBound(target))
+val = isSubtype(wildLowerBound(val), wildLowerBound(target))
 ? target : val;
 } else if (val.isExtendsBound() && target.isExtendsBound()) {
 val = isSubtype(upperBound(val), upperBound(target))
 ? val : target;
 } else if (!isSameType(val, target)) {
 else
 return t;
 }
 public Type visitType(Type t, Void s) {
-return high ? upperBound(t) : lowerBound(t);
+return high ? upperBound(t) : t;
 }
 @Override
 public Type visitCapturedType(CapturedType t, Void s) {
 Type w_bound = t.wildcard.type;

changeset 24293	0d889f759fac
parent 24291	440746208be7
child 24396	3c36c6afcbca