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

-:0384683c64be
+:ddb4a2bfcd82
 */
 package com.sun.tools.javac.code;
 import java.lang.ref.SoftReference;
-import java.util.Comparator;
 import java.util.HashSet;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.WeakHashMap;
-import javax.lang.model.type.TypeKind;
 import com.sun.tools.javac.code.Attribute.RetentionPolicy;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Type.UndetVar.InferenceBound;
 import com.sun.tools.javac.comp.Check;
 List<Type> args = t.allparams();
 while (parms.nonEmpty()) {
 WildcardType unb = new WildcardType(syms.objectType,
 BoundKind.UNBOUND,
 syms.boundClass,
-(TypeVar)parms.head);
+(TypeVar)parms.head.unannotatedType());
 if (!containsType(args.head, unb))
 return false;
 parms = parms.tail;
 args = args.tail;
 }
 } else {
 // Unbound type arguments default to ?
 List<Type> opens = openVars.toList();
 ListBuffer<Type> qs = new ListBuffer<Type>();
 for (List<Type> iter = opens; iter.nonEmpty(); iter = iter.tail) {
-qs.append(new WildcardType(syms.objectType, BoundKind.UNBOUND, syms.boundClass, (TypeVar) iter.head));
+qs.append(new WildcardType(syms.objectType, BoundKind.UNBOUND, syms.boundClass, (TypeVar) iter.head.unannotatedType()));
 }
 res = subst(res, opens, qs.toList());
 }
 }
 return res;
 List<Type> actualTypeargs = site.getTypeArguments();
 List<Type> capturedTypeargs = capturedSite.getTypeArguments();
 //simply replace the wildcards with its bound
 for (Type t : formalInterface.getTypeArguments()) {
 if (actualTypeargs.head.hasTag(WILDCARD)) {
-WildcardType wt = (WildcardType)actualTypeargs.head;
+WildcardType wt = (WildcardType)actualTypeargs.head.unannotatedType();
 Type bound;
 switch (wt.kind) {
 case EXTENDS:
 case UNBOUND:
-CapturedType capVar = (CapturedType)capturedTypeargs.head;
+CapturedType capVar = (CapturedType)capturedTypeargs.head.unannotatedType();
 //use declared bound if it doesn't depend on formal type-args
 bound = capVar.bound.containsAny(capturedSite.getTypeArguments()) ?
 wt.type : capVar.bound;
 break;
 default:
 public boolean isSameType(Type t, Type s, boolean strict) {
 return strict ?
 isSameTypeStrict.visit(t, s) :
 isSameTypeLoose.visit(t, s);
 }
+public boolean isSameAnnotatedType(Type t, Type s) {
+return isSameAnnotatedType.visit(t, s);
+}
 // where
 abstract class SameTypeVisitor extends TypeRelation {
 public Boolean visitType(Type t, Type s) {
 if (t == s)
 return t.tag == s.tag;
 case TYPEVAR: {
 if (s.tag == TYPEVAR) {
 //type-substitution does not preserve type-var types
 //check that type var symbols and bounds are indeed the same
-return sameTypeVars((TypeVar)t, (TypeVar)s);
+return sameTypeVars((TypeVar)t.unannotatedType(), (TypeVar)s.unannotatedType());
 }
 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() &&
 /**
 * Standard type-equality relation - type variables are considered
 * equals if they share the same type symbol.
 */
-TypeRelation isSameTypeLoose = new SameTypeVisitor() {
+TypeRelation isSameTypeLoose = new LooseSameTypeVisitor();
+private class LooseSameTypeVisitor extends SameTypeVisitor {
 @Override
 boolean sameTypeVars(TypeVar tv1, TypeVar tv2) {
 return tv1.tsym == tv2.tsym && visit(tv1.getUpperBound(), tv2.getUpperBound());
 }
 @Override
 @Override
 public Boolean visitWildcardType(WildcardType t, Type s) {
 if (!s.hasTag(WILDCARD)) {
 return false;
 } else {
-WildcardType t2 = (WildcardType)s;
+WildcardType t2 = (WildcardType)s.unannotatedType();
 return t.kind == t2.kind &&
 isSameType(t.type, t2.type, true);
 }
+}
+};
+/**
+* A version of LooseSameTypeVisitor that takes AnnotatedTypes
+* into account.
+*/
+TypeRelation isSameAnnotatedType = new LooseSameTypeVisitor() {
+@Override
+public Boolean visitAnnotatedType(AnnotatedType t, Type s) {
+if (!s.isAnnotated())
+return false;
+if (!t.getAnnotationMirrors().containsAll(s.getAnnotationMirrors()))
+return false;
+if (!s.getAnnotationMirrors().containsAll(t.getAnnotationMirrors()))
+return false;
+return visit(t.underlyingType, s);
 }
 };
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="Contains Type">
 public boolean containedBy(Type t, Type s) {
 switch (t.tag) {
 case UNDETVAR:
 if (s.tag == WILDCARD) {
 UndetVar undetvar = (UndetVar)t;
-WildcardType wt = (WildcardType)s;
+WildcardType wt = (WildcardType)s.unannotatedType();
 switch(wt.kind) {
 case UNBOUND: //similar to ? extends Object
 case EXTENDS: {
 Type bound = upperBound(s);
 undetvar.addBound(InferenceBound.UPPER, bound, this);
 // where
 private TypeRelation containsType = new TypeRelation() {
 private Type U(Type t) {
 while (t.tag == WILDCARD) {
-WildcardType w = (WildcardType)t;
+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.tag == WILDCARD) {
-WildcardType w = (WildcardType)t;
+WildcardType w = (WildcardType)t.unannotatedType();
 if (w.isExtendsBound())
 return syms.botType;
 else
 t = w.type;
 }
 return true;
 }
 };
 public boolean isCaptureOf(Type s, WildcardType t) {
-if (s.tag != TYPEVAR || !((TypeVar)s).isCaptured())
+if (s.tag != TYPEVAR || !((TypeVar)s.unannotatedType()).isCaptured())
 return false;
-return isSameWildcard(t, ((CapturedType)s).wildcard);
+return isSameWildcard(t, ((CapturedType)s.unannotatedType()).wildcard);
 }
 public boolean isSameWildcard(WildcardType t, Type s) {
 if (s.tag != WILDCARD)
 return false;
-WildcardType w = (WildcardType)s;
+WildcardType w = (WildcardType)s.unannotatedType();
 return w.kind == t.kind && w.type == t.type;
 }
 public boolean containsTypeEquivalent(List<Type> ts, List<Type> ss) {
 while (ts.nonEmpty() && ss.nonEmpty()
 }
 }
 if (t.isCompound() || s.isCompound()) {
 return !t.isCompound() ?
-visitIntersectionType((IntersectionClassType)s, t, true) :
+visitIntersectionType((IntersectionClassType)s.unannotatedType(), t, true) :
-visitIntersectionType((IntersectionClassType)t, s, false);
+visitIntersectionType((IntersectionClassType)t.unannotatedType(), s, false);
 }
 if (s.tag == CLASS || s.tag == ARRAY) {
 boolean upcast;
 if ((upcast = isSubtype(erasure(t), erasure(s)))
 s.append('<');
 boolean first = true;
 for (Type t : tvars) {
 if (!first) s.append(", ");
 first = false;
-appendTyparamString(((TypeVar)t), s);
+appendTyparamString(((TypeVar)t.unannotatedType()), s);
 }
 s.append('>');
 return s.toString();
 }
 private void appendTyparamString(TypeVar t, StringBuilder buf) {
 while (!currentA.isEmpty() &&
 !currentT.isEmpty() &&
 !currentS.isEmpty()) {
 if (currentS.head != currentT.head) {
 captured = true;
-WildcardType Ti = (WildcardType)currentT.head;
+WildcardType Ti = (WildcardType)currentT.head.unannotatedType();
 Type Ui = currentA.head.getUpperBound();
-CapturedType Si = (CapturedType)currentS.head;
+CapturedType Si = (CapturedType)currentS.head.unannotatedType();
 if (Ui == null)
 Ui = syms.objectType;
 switch (Ti.kind) {
 case UNBOUND:
 Si.bound = subst(Ui, A, S);
 // where
 public List<Type> freshTypeVariables(List<Type> types) {
 ListBuffer<Type> result = lb();
 for (Type t : types) {
 if (t.tag == WILDCARD) {
+t = t.unannotatedType();
 Type bound = ((WildcardType)t).getExtendsBound();
 if (bound == null)
 bound = syms.objectType;
 result.append(new CapturedType(capturedName,
 syms.noSymbol,
 return true;
 }
 private boolean giveWarning(Type from, Type to) {
 List<Type> bounds = to.isCompound() ?
-((IntersectionClassType)to).getComponents() : List.of(to);
+((IntersectionClassType)to.unannotatedType()).getComponents() : List.of(to);
 for (Type b : bounds) {
 Type subFrom = asSub(from, b.tsym);
 if (b.isParameterized() &&
 (!(isUnbounded(b) ||
 isSubtype(from, b) ||
 }
 }
 Type B(Type t) {
 while (t.tag == WILDCARD) {
-WildcardType w = (WildcardType)t;
+WildcardType w = (WildcardType)t.unannotatedType();
 t = high ?
 w.getExtendsBound() :
 w.getSuperBound();
 if (t == null) {
 t = high ? syms.objectType : syms.botType;
 return types.hashCode(type);
 }
 public boolean equals(Object obj) {
 return (obj instanceof UniqueType) &&
-types.isSameType(type, ((UniqueType)obj).type);
+types.isSameAnnotatedType(type, ((UniqueType)obj).type);
 }
 public String toString() {
 return type.toString();
 }

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