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

-:f4254623c54e
+:0e026d3f2786
 functionDescriptorLookupError = new FunctionDescriptorLookupError();
 noWarnings = new Warner(null);
 }
 // </editor-fold>
-// <editor-fold defaultstate="collapsed" desc="upperBound">
+// <editor-fold defaultstate="collapsed" desc="bounds">
 /**
-* The "rvalue conversion".<br>
+* Get a wildcard's upper bound, returning non-wildcards unchanged.
-* The upper 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 wildUpperBound(Type t) {
-* @param t a type
+if (t.hasTag(WILDCARD)) {
-* @return the upper bound of the given type
+WildcardType w = (WildcardType) t.unannotatedType();
-*/
+if (w.isSuperBound())
-public Type upperBound(Type t) {
+return w.bound == null ? syms.objectType : w.bound.bound;
-return upperBound.visit(t).unannotatedType();
+else
-}
+return wildUpperBound(w.type);
-// where
+}
-private final MapVisitor<Void> upperBound = new MapVisitor<Void>() {
+else return t;
+}
-@Override
-public Type visitWildcardType(WildcardType t, Void ignored) {
+/**
-if (t.isSuperBound())
+* Get a capture variable's upper bound, returning other types unchanged.
-return t.bound == null ? syms.objectType : t.bound.bound;
+* @param t a type
-else
+*/
-return visit(t.type);
+public Type cvarUpperBound(Type t) {
-}
+if (t.hasTag(TYPEVAR)) {
+TypeVar v = (TypeVar) t.unannotatedType();
-@Override
+return v.isCaptured() ? cvarUpperBound(v.bound) : v;
-public Type visitCapturedType(CapturedType t, Void ignored) {
+}
-return visit(t.bound);
+else return t;
 }
-};
-// </editor-fold>
-// <editor-fold defaultstate="collapsed" desc="wildLowerBound">
 /**
 * Get a wildcard's lower bound, returning non-wildcards unchanged.
 * @param t a type argument, either a wildcard or a type
 */
 public Type wildLowerBound(Type t) {
 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
 */
 public Type cvarLowerBound(Type t) {
 s = new WildcardType(syms.objectType,
 BoundKind.UNBOUND,
 syms.boundClass);
 changed = true;
 } else if (s != orig) {
-s = new WildcardType(upperBound(s),
+s = new WildcardType(wildUpperBound(s),
 BoundKind.EXTENDS,
 syms.boundClass);
 changed = true;
 }
 rewrite.append(s);
 else {
 //special case for s == ? super X, where upper(s) = u
 //check that u == t, where u has been set by Type.withTypeVar
 return s.isSuperBound() &&
 !s.isExtendsBound() &&
-visit(t, upperBound(s));
+visit(t, wildUpperBound(s));
 }
 }
 default:
 throw new AssertionError("isSameType " + t.getTag());
 }
 if (s.isPartial())
 return visit(s, t);
 if (s.isSuperBound() && !s.isExtendsBound())
-return visit(t, upperBound(s)) && visit(t, wildLowerBound(s));
+return visit(t, wildUpperBound(s)) && visit(t, wildLowerBound(s));
 if (t.isCompound() && s.isCompound()) {
 if (!visit(supertype(t), supertype(s)))
 return false;
 UndetVar undetvar = (UndetVar)t;
 WildcardType wt = (WildcardType)s.unannotatedType();
 switch(wt.kind) {
 case UNBOUND: //similar to ? extends Object
 case EXTENDS: {
-Type bound = upperBound(s);
+Type bound = wildUpperBound(s);
 undetvar.addBound(InferenceBound.UPPER, bound, this);
 break;
 }
 case SUPER: {
 Type bound = wildLowerBound(s);
 return containsType.visit(t, s);
 }
 // where
 private TypeRelation containsType = new TypeRelation() {
-private Type U(Type t) {
-while (t.hasTag(WILDCARD)) {
-WildcardType w = (WildcardType)t.unannotatedType();
-if (w.isSuperBound())
-return w.bound == null ? syms.objectType : w.bound.bound;
-else
-t = w.type;
-}
-return t;
-}
-private Type L(Type t) {
-while (t.hasTag(WILDCARD)) {
-WildcardType w = (WildcardType)t.unannotatedType();
-if (w.isExtendsBound())
-return syms.botType;
-else
-t = w.type;
-}
-return t;
-}
 public Boolean visitType(Type t, Type s) {
 if (s.isPartial())
 return containedBy(s, t);
 else
 return isSameType(t, s);
 //            void debugContainsType(WildcardType t, Type s) {
 //                System.err.println();
 //                System.err.format(" does %s contain %s?%n", t, s);
 //                System.err.format(" %s U(%s) <: U(%s) %s = %s%n",
-//                                  upperBound(s), s, t, U(t),
+//                                  wildUpperBound(s), s, t, wildUpperBound(t),
 //                                  t.isSuperBound()
-//                                  || isSubtypeNoCapture(upperBound(s), U(t)));
+//                                  || isSubtypeNoCapture(wildUpperBound(s), wildUpperBound(t)));
 //                System.err.format(" %s L(%s) <: L(%s) %s = %s%n",
-//                                  L(t), t, s, wildLowerBound(s),
+//                                  wildLowerBound(t), t, s, wildLowerBound(s),
 //                                  t.isExtendsBound()
-//                                  || isSubtypeNoCapture(L(t), wildLowerBound(s)));
+//                                  || isSubtypeNoCapture(wildLowerBound(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), wildLowerBound(s))) &&
+|| ((t.isExtendsBound() || isSubtypeNoCapture(wildLowerBound(t), wildLowerBound(s))) &&
-(t.isSuperBound() || isSubtypeNoCapture(upperBound(s), U(t))));
+// TODO: JDK-8039214, cvarUpperBound call here is incorrect
+(t.isSuperBound() || isSubtypeNoCapture(cvarUpperBound(wildUpperBound(s)), wildUpperBound(t))));
 }
 }
 @Override
 public Boolean visitUndetVar(UndetVar t, Type s) {
 }
 }
 @Override
 public Boolean visitWildcardType(WildcardType t, Type s) {
-return isCastable(upperBound(t), s, warnStack.head);
+return isCastable(wildUpperBound(t), s, warnStack.head);
 }
 @Override
 public Boolean visitClassType(ClassType t, Type s) {
 if (s.hasTag(ERROR) || s.hasTag(BOT))
 if (s.isUnbound())
 return false;
 if (t.isExtendsBound()) {
 if (s.isExtendsBound())
-return !isCastableRecursive(t.type, upperBound(s));
+return !isCastableRecursive(t.type, wildUpperBound(s));
 else if (s.isSuperBound())
 return notSoftSubtypeRecursive(wildLowerBound(s), t.type);
 } else if (t.isSuperBound()) {
 if (s.isExtendsBound())
-return notSoftSubtypeRecursive(t.type, upperBound(s));
+return notSoftSubtypeRecursive(t.type, wildUpperBound(s));
 }
 return false;
 }
 };
 // </editor-fold>
 return !isCastable(tv.bound,
 relaxBound(s),
 noWarnings);
 }
 if (!s.hasTag(WILDCARD))
-s = upperBound(s);
+s = cvarUpperBound(s);
 return !isSubtype(t, relaxBound(s));
 }
 private Type relaxBound(Type t) {
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="Array Utils">
 public boolean isArray(Type t) {
 while (t.hasTag(WILDCARD))
-t = upperBound(t);
+t = wildUpperBound(t);
 return t.hasTag(ARRAY);
 }
 /**
 * The element type of an array.
 */
 public Type elemtype(Type t) {
 switch (t.getTag()) {
 case WILDCARD:
-return elemtype(upperBound(t));
+return elemtype(wildUpperBound(t));
 case ARRAY:
 t = t.unannotatedType();
 return ((ArrayType)t).elemtype;
 case FORALL:
 return elemtype(((ForAll)t).qtype);
 return sym.type;
 }
 @Override
 public Type visitWildcardType(WildcardType t, Symbol sym) {
-return memberType(upperBound(t), sym);
+return memberType(wildUpperBound(t), sym);
 }
 @Override
 public Type visitClassType(ClassType t, Symbol sym) {
 Symbol owner = sym.owner;
 return t.map(recurse ? erasureRecFun : erasureFun);
 }
 @Override
 public Type visitWildcardType(WildcardType t, Boolean recurse) {
-return erasure(upperBound(t), recurse);
+return erasure(wildUpperBound(t), recurse);
 }
 @Override
 public Type visitClassType(ClassType t, Boolean recurse) {
 Type erased = t.tsym.erasure(Types.this);
 List<Type> actuals = t.allparams();
 List<Type> formals = t.tsym.type.allparams();
 if (t.hasErasedSupertypes()) {
 t.interfaces_field = erasureRecursive(interfaces);
 } else if (formals.nonEmpty()) {
-t.interfaces_field =
+t.interfaces_field = subst(interfaces, formals, actuals);
-upperBounds(subst(interfaces, formals, actuals));
 }
 else {
 t.interfaces_field = interfaces;
 }
 }
 return t;
 else
 return new ClassType(outer1, typarams1, t.tsym);
 } else {
 Type st = subst(supertype(t));
-List<Type> is = upperBounds(subst(interfaces(t)));
+List<Type> is = subst(interfaces(t));
 if (st == supertype(t) && is == interfaces(t))
 return t;
 else
 return makeCompoundType(is.prepend(st));
 }
 bound = subst(bound);
 if (bound == t.type) {
 return t;
 } else {
 if (t.isExtendsBound() && bound.isExtendsBound())
-bound = upperBound(bound);
+bound = wildUpperBound(bound);
 return new WildcardType(bound, t.kind, syms.boundClass, t.bound);
 }
 }
 @Override
 merged.append(act2.head);
 } else {
 TypePair pair = new TypePair(c1, c2);
 Type m;
 if (mergeCache.add(pair)) {
-m = new WildcardType(lub(upperBound(act1.head),
+m = new WildcardType(lub(wildUpperBound(act1.head),
-upperBound(act2.head)),
+wildUpperBound(act2.head)),
 BoundKind.EXTENDS,
 syms.boundClass);
 mergeCache.remove(pair);
 } else {
 m = new WildcardType(syms.objectType,
 return result.toList();
 }
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="Internal utility methods">
-private List<Type> upperBounds(List<Type> ss) {
-if (ss.isEmpty()) return ss;
-Type head = upperBound(ss.head);
-List<Type> tail = upperBounds(ss.tail);
-if (head != ss.head || tail != ss.tail)
-return tail.prepend(head);
-else
-return ss;
-}
 private boolean sideCast(Type from, Type to, Warner warn) {
 // We are casting from type $from$ to type $to$, which are
 // non-final unrelated types.  This method
 // tries to reject a cast by transferring type parameters
 // from $to$ to $from$ by common superinterfaces.
 }
 @Override
 public Void visitWildcardType(WildcardType source, Type target) throws AdaptFailure {
 if (source.isExtendsBound())
-adaptRecursive(upperBound(source), upperBound(target));
+adaptRecursive(wildUpperBound(source), wildUpperBound(target));
 else if (source.isSuperBound())
 adaptRecursive(wildLowerBound(source), wildLowerBound(target));
 return null;
 }
 if (val != null) {
 if (val.isSuperBound() && target.isSuperBound()) {
 val = isSubtype(wildLowerBound(val), wildLowerBound(target))
 ? target : val;
 } else if (val.isExtendsBound() && target.isExtendsBound()) {
-val = isSubtype(upperBound(val), upperBound(target))
+val = isSubtype(wildUpperBound(val), wildUpperBound(target))
 ? val : target;
 } else if (!isSameType(val, target)) {
 throw new AdaptFailure();
 }
 } else {
 else
 return t;
 }
 public Type visitType(Type t, Void s) {
-return high ? upperBound(t) : t;
+return t;
 }
 @Override
 public Type visitCapturedType(CapturedType t, Void s) {
 Type w_bound = t.wildcard.type;

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/code/Types.java

src/share/classes/com/sun/tools/javac/code/Types.java