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

-:6e0f31d61e56
+:4788eb38cac5
 @Override
 public Type visitClassType(ClassType t, Symbol sym) {
 if (t.tsym == sym)
 return t;
-Type base = asSuper(sym.type, t);
+Type base = asSuper(sym.type, t.tsym);
 if (base == null)
 return null;
 ListBuffer<Type> from = new ListBuffer<Type>();
 ListBuffer<Type> to = new ListBuffer<Type>();
 try {
 t.name != names.init &&
 t.name != names.clinit &&
 (t.flags() & SYNTHETIC) == 0;
 }
 };
-private boolean pendingBridges(ClassSymbol origin, TypeSymbol sym) {
+private boolean pendingBridges(ClassSymbol origin, TypeSymbol s) {
 //a symbol will be completed from a classfile if (a) symbol has
 //an associated file object with CLASS kind and (b) the symbol has
 //not been entered
 if (origin.classfile != null &&
 origin.classfile.getKind() == JavaFileObject.Kind.CLASS &&
 enter.getEnv(origin) == null) {
 return false;
 }
-if (origin == sym) {
+if (origin == s) {
 return true;
 }
 for (Type t : interfaces(origin.type)) {
-if (pendingBridges((ClassSymbol)t.tsym, sym)) {
+if (pendingBridges((ClassSymbol)t.tsym, s)) {
 return true;
 }
 }
 return false;
 }
 } else if (isSubtype(t, s)) {
 return true;
 } else if (t.hasTag(TYPEVAR)) {
 return isSubtypeUnchecked(t.getUpperBound(), s, warn);
 } else if (!s.isRaw()) {
-Type t2 = asSuper(t, s);
+Type t2 = asSuper(t, s.tsym);
 if (t2 != null && t2.isRaw()) {
 if (isReifiable(s)) {
 warn.silentWarn(LintCategory.UNCHECKED);
 } else {
 warn.warn(LintCategory.UNCHECKED);
 return t;
 }
 @Override
 public Boolean visitClassType(ClassType t, Type s) {
-Type sup = asSuper(t, s);
+Type sup = asSuper(t, s.tsym);
 return sup != null
 && sup.tsym == s.tsym
 // You're not allowed to write
 //     Vector<Object> vec = new Vector<String>();
 // But with wildcards you can write
 * given symbol.  If none exists, return null.
 *
 * @param t a type
 * @param sym a symbol
 */
-public Type asSuper(Type t, Symbol s) {
+public Type asSuper(Type t, Symbol sym) {
-return asSuper(t, s.type);
+return asSuper.visit(t, sym);
-}
-public Type asSuper(Type t, Type s) {
-return asSuper.visit(t, s);
 }
 // where
-private SimpleVisitor<Type,Type> asSuper = new SimpleVisitor<Type,Type>() {
+private SimpleVisitor<Type,Symbol> asSuper = new SimpleVisitor<Type,Symbol>() {
-public Type visitType(Type t, Type s) {
+public Type visitType(Type t, Symbol sym) {
 return null;
 }
 @Override
-public Type visitClassType(ClassType t, Type s) {
+public Type visitClassType(ClassType t, Symbol sym) {
-if (t.tsym == s.tsym)
+if (t.tsym == sym)
 return t;
 Type st = supertype(t);
+if (st.hasTag(CLASS) || st.hasTag(TYPEVAR) || st.hasTag(ERROR)) {
-switch(st.getTag()) {
+Type x = asSuper(st, sym);
-default: break;
-case CLASS:
-case ARRAY:
-case TYPEVAR:
-case ERROR: {
-Type x = asSuper(st, s);
 if (x != null)
 return x;
-} break;
+}
-}
+if ((sym.flags() & INTERFACE) != 0) {
-if ((s.tsym.flags() & INTERFACE) != 0) {
 for (List<Type> l = interfaces(t); l.nonEmpty(); l = l.tail) {
-Type x = asSuper(l.head, s);
+Type x = asSuper(l.head, sym);
 if (x != null)
 return x;
 }
 }
 return null;
 }
 @Override
-public Type visitArrayType(ArrayType t, Type s) {
+public Type visitArrayType(ArrayType t, Symbol sym) {
-return isSubtype(t, s) ? s : null;
+return isSubtype(t, sym.type) ? sym.type : null;
 }
 @Override
-public Type visitTypeVar(TypeVar t, Type s) {
+public Type visitTypeVar(TypeVar t, Symbol sym) {
-if (t.tsym == s.tsym)
+if (t.tsym == sym)
 return t;
 else
-return asSuper(t.bound, s);
+return asSuper(t.bound, sym);
 }
 @Override
-public Type visitErrorType(ErrorType t, Type s) { return t; }
+public Type visitErrorType(ErrorType t, Symbol sym) {
+return t;
+}
 };
 /**
 * Return the base type of t or any of its outer types that starts
 * with the given symbol.  If none exists, return null.
 //step 2 - compute minimal erased candidate set (MEC)
 List<Type> mec = closureMin(cl);
 //step 3 - for each element G in MEC, compute lci(Inv(G))
 List<Type> candidates = List.nil();
 for (Type erasedSupertype : mec) {
-List<Type> lci = List.of(asSuper(ts.head, erasedSupertype));
+List<Type> lci = List.of(asSuper(ts.head, erasedSupertype.tsym));
 for (Type t : ts) {
-lci = intersect(lci, List.of(asSuper(t, erasedSupertype)));
+lci = intersect(lci, List.of(asSuper(t, erasedSupertype.tsym)));
 }
 candidates = candidates.appendList(lci);
 }
 //step 4 - let MEC be { G1, G2 ... Gn }, then we have that
 //lub = lci(Inv(G1)) & lci(Inv(G2)) & ... & lci(Inv(Gn))
 List<Type> commonSupers = superClosure(to, erasure(from));
 boolean giveWarning = commonSupers.isEmpty();
 // The arguments to the supers could be unified here to
 // get a more accurate analysis
 while (commonSupers.nonEmpty()) {
-Type t1 = asSuper(from, commonSupers.head);
+Type t1 = asSuper(from, commonSupers.head.tsym);
 Type t2 = commonSupers.head; // same as asSuper(to, commonSupers.head.tsym);
 if (disjointTypes(t1.getTypeArguments(), t2.getTypeArguments()))
 return false;
 giveWarning = giveWarning || (reverse ? giveWarning(t2, t1) : giveWarning(t1, t2));
 commonSupers = commonSupers.tail;
 reverse = true;
 to = from;
 from = target;
 }
 Assert.check((from.tsym.flags() & FINAL) != 0);
-Type t1 = asSuper(from, to);
+Type t1 = asSuper(from, to.tsym);
 if (t1 == null) return false;
 Type t2 = to;
 if (disjointTypes(t1.getTypeArguments(), t2.getTypeArguments()))
 return false;
 if (!allowCovariantReturns)

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