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

equal deleted inserted replaced

-:3b3e23e67329
+:3651128c74eb
 * 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 Types {
-protected static final Context.Key<Types> typesKey =
+protected static final Context.Key<Types> typesKey = new Context.Key<>();
-new Context.Key<Types>();
 final Symtab syms;
 final JavacMessages messages;
 final Names names;
 final boolean allowBoxing;
 if (t.tsym == sym)
 return t;
 Type base = asSuper(sym.type, t.tsym);
 if (base == null)
 return null;
-ListBuffer<Type> from = new ListBuffer<Type>();
+ListBuffer<Type> from = new ListBuffer<>();
-ListBuffer<Type> to = new ListBuffer<Type>();
+ListBuffer<Type> to = new ListBuffer<>();
 try {
 adapt(base, t, from, to);
 } catch (AdaptFailure ex) {
 return null;
 }
 Type res = subst(sym.type, from.toList(), to.toList());
 if (!isSubtype(res, t))
 return null;
-ListBuffer<Type> openVars = new ListBuffer<Type>();
+ListBuffer<Type> openVars = new ListBuffer<>();
 for (List<Type> l = sym.type.allparams();
 l.nonEmpty(); l = l.tail)
 if (res.contains(l.head) && !t.contains(l.head))
 openVars.append(l.head);
 if (openVars.nonEmpty()) {
 // The subtype of a raw type is raw
 res = erasure(res);
 } else {
 // Unbound type arguments default to ?
 List<Type> opens = openVars.toList();
-ListBuffer<Type> qs = new ListBuffer<Type>();
+ListBuffer<Type> qs = new ListBuffer<>();
 for (List<Type> iter = opens; iter.nonEmpty(); iter = iter.tail) {
 qs.append(new WildcardType(syms.objectType, BoundKind.UNBOUND, syms.boundClass, (TypeVar) iter.head.unannotatedType()));
 }
 res = subst(res, opens, qs.toList());
 }
 * A cache that keeps track of function descriptors associated with given
 * functional interfaces.
 */
 class DescriptorCache {
-private WeakHashMap<TypeSymbol, Entry> _map = new WeakHashMap<TypeSymbol, Entry>();
+private WeakHashMap<TypeSymbol, Entry> _map = new WeakHashMap<>();
 class FunctionDescriptor {
 Symbol descSym;
 FunctionDescriptor(Symbol descSym) {
 return sym.kind == Kinds.MTH &&
 (sym.flags() & (ABSTRACT | DEFAULT)) == ABSTRACT &&
 !overridesObjectMethod(origin, sym) &&
 (interfaceCandidates(origin.type, (MethodSymbol)sym).head.flags() & DEFAULT) == 0;
 }
-};
+}
 // <editor-fold defaultstate="collapsed" desc="isSubtype">
 /**
 * Is t an unchecked subtype of s?
 */
 default:
 throw new AssertionError("isSubtype " + t.getTag());
 }
 }
-private Set<TypePair> cache = new HashSet<TypePair>();
+private Set<TypePair> cache = new HashSet<>();
 private boolean containsTypeRecursive(Type t, Type s) {
 TypePair pair = new TypePair(t, s);
 if (cache.add(pair)) {
 try {
 if (t.isCompound() && s.isCompound()) {
 if (!visit(supertype(t), supertype(s)))
 return false;
-HashSet<UniqueType> set = new HashSet<UniqueType>();
+HashSet<UniqueType> set = new HashSet<>();
 for (Type x : interfaces(t))
 set.add(new UniqueType(x.unannotatedType(), Types.this));
 for (Type x : interfaces(s)) {
 if (!set.remove(new UniqueType(x.unannotatedType(), Types.this)))
 return false;
 }
 @Override
 protected boolean containsTypes(List<Type> ts1, List<Type> ts2) {
 return containsTypeEquivalent(ts1, ts2);
 }
-};
+}
 /**
 * Strict type-equality relation - type variables are considered
 * equals if they share the same object identity.
 */
 TypeRelation isSameTypeStrict = new SameTypeVisitor() {
 @Override
 return disjointType.visit(t, s);
 }
 // where
 private TypeRelation disjointType = new TypeRelation() {
-private Set<TypePair> cache = new HashSet<TypePair>();
+private Set<TypePair> cache = new HashSet<>();
 @Override
 public Boolean visitType(Type t, Type s) {
 if (s.hasTag(WILDCARD))
 return visit(s, t);
 return false;
 }
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="isDerivedRaw">
-Map<Type,Boolean> isDerivedRawCache = new HashMap<Type,Boolean>();
+Map<Type,Boolean> isDerivedRawCache = new HashMap<>();
 public boolean isDerivedRaw(Type t) {
 Boolean result = isDerivedRawCache.get(t);
 if (result == null) {
 result = isDerivedRawInternal(t);
 }
 // <editor-fold defaultstate="collapsed" desc="Determining method implementation in given site">
 class ImplementationCache {
-private WeakHashMap<MethodSymbol, SoftReference<Map<TypeSymbol, Entry>>> _map =
+private WeakHashMap<MethodSymbol, SoftReference<Map<TypeSymbol, Entry>>> _map = new WeakHashMap<>();
-new WeakHashMap<MethodSymbol, SoftReference<Map<TypeSymbol, Entry>>>();
 class Entry {
 final MethodSymbol cachedImpl;
 final Filter<Symbol> implFilter;
 final boolean checkResult;
 MethodSymbol get(MethodSymbol ms, TypeSymbol origin, boolean checkResult, Filter<Symbol> implFilter) {
 SoftReference<Map<TypeSymbol, Entry>> ref_cache = _map.get(ms);
 Map<TypeSymbol, Entry> cache = ref_cache != null ? ref_cache.get() : null;
 if (cache == null) {
-cache = new HashMap<TypeSymbol, Entry>();
+cache = new HashMap<>();
-_map.put(ms, new SoftReference<Map<TypeSymbol, Entry>>(cache));
+_map.put(ms, new SoftReference<>(cache));
 }
 Entry e = cache.get(origin);
 CompoundScope members = membersClosure(origin.type, true);
 if (e == null ||
 !e.matches(implFilter, checkResult, members.getMark())) {
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="compute transitive closure of all members in given site">
 class MembersClosureCache extends SimpleVisitor<CompoundScope, Boolean> {
-private WeakHashMap<TypeSymbol, Entry> _map =
+private WeakHashMap<TypeSymbol, Entry> _map = new WeakHashMap<>();
-new WeakHashMap<TypeSymbol, Entry>();
 class Entry {
 final boolean skipInterfaces;
 final CompoundScope compoundScope;
 s.name == msym.name &&
 (s.flags() & SYNTHETIC) == 0 &&
 s.isInheritedIn(site.tsym, Types.this) &&
 overrideEquivalent(memberType(site, s), memberType(site, msym));
 }
-};
+}
 // </editor-fold>
 /**
 * Does t have the same arguments as s?  It is assumed that both
 * types are (possibly polymorphic) method types.  Monomorphic
 @Override
 public Boolean visitErrorType(ErrorType t, Type s) {
 return false;
 }
-};
+}
 TypeRelation hasSameArgs_strict = new HasSameArgs(true);
 TypeRelation hasSameArgs_nonstrict = new HasSameArgs(false);
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="subst">
 * <p>A closure is a list of all the supertypes and interfaces of
 * a class or interface type, ordered by ClassSymbol.precedes
 * (that is, subclasses come first, arbitrary but fixed
 * otherwise).
 */
-private Map<Type,List<Type>> closureCache = new HashMap<Type,List<Type>>();
+private Map<Type,List<Type>> closureCache = new HashMap<>();
 /**
 * Returns the closure of a class or interface type.
 */
 public List<Type> closure(Type t) {
 TypePair typePair = (TypePair)obj;
 return isSameType(t1, typePair.t1)
 && isSameType(t2, typePair.t2);
 }
 }
-Set<TypePair> mergeCache = new HashSet<TypePair>();
+Set<TypePair> mergeCache = new HashSet<>();
 private Type merge(Type c1, Type c2) {
 ClassType class1 = (ClassType) c1;
 List<Type> act1 = class1.getTypeArguments();
 ClassType class2 = (ClassType) c2;
 List<Type> act2 = class2.getTypeArguments();
-ListBuffer<Type> merged = new ListBuffer<Type>();
+ListBuffer<Type> merged = new ListBuffer<>();
 List<Type> typarams = class1.tsym.type.getTypeArguments();
 while (act1.nonEmpty() && act2.nonEmpty() && typarams.nonEmpty()) {
 if (containsType(act1.head, act2.head)) {
 merged.append(act1.head);
 Map<Symbol,Type> mapping;
 Adapter(ListBuffer<Type> from, ListBuffer<Type> to) {
 this.from = from;
 this.to = to;
-mapping = new HashMap<Symbol,Type>();
+mapping = new HashMap<>();
 }
 public void adapt(Type source, Type target) throws AdaptFailure {
 visit(source, target);
 List<Type> fromList = from.toList();
 @Override
 public Void visitType(Type source, Type target) {
 return null;
 }
-private Set<TypePair> cache = new HashSet<TypePair>();
+private Set<TypePair> cache = new HashSet<>();
 private void adaptRecursive(Type source, Type target) {
 TypePair pair = new TypePair(source, target);
 if (cache.add(pair)) {
 try {
 this.rewriteTypeVars = rewriteTypeVars;
 }
 @Override
 public Type visitClassType(ClassType t, Void s) {
-ListBuffer<Type> rewritten = new ListBuffer<Type>();
+ListBuffer<Type> rewritten = new ListBuffer<>();
 boolean changed = false;
 for (Type arg : t.allparams()) {
 Type bound = visit(arg);
 if (arg != bound) {
 changed = true;

changeset 22163	3651128c74eb
parent 21712	d363f367d4c0
child 22167	e0ba35f27975