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

equal deleted inserted replaced

-:0c72984b7a4d
+:93f8eae31092
 import static com.sun.tools.javac.code.Scope.*;
 import static com.sun.tools.javac.code.Symbol.*;
 import static com.sun.tools.javac.code.Type.*;
 import static com.sun.tools.javac.code.TypeTag.*;
 import static com.sun.tools.javac.jvm.ClassFile.externalize;
-import static com.sun.tools.javac.util.ListBuffer.lb;
 /**
 * Utility class containing various operations on types.
 *
 * <p>Unless other names are more illustrative, the following naming
 if (!origin.isInterface() || (origin.flags() & ANNOTATION) != 0) {
 //t must be an interface
 throw failure("not.a.functional.intf", origin);
 }
-final ListBuffer<Symbol> abstracts = ListBuffer.lb();
+final ListBuffer<Symbol> abstracts = new ListBuffer<>();
 for (Symbol sym : membersCache.getElements(new DescriptorFilter(origin))) {
 Type mtype = memberType(origin.type, sym);
 if (abstracts.isEmpty() ||
 (sym.name == abstracts.first().name &&
 overrideEquivalent(mtype, memberType(origin.type, abstracts.first())))) {
 return new FunctionDescriptor(abstracts.first());
 } else { // size > 1
 FunctionDescriptor descRes = mergeDescriptors(origin, abstracts.toList());
 if (descRes == null) {
 //we can get here if the functional interface is ill-formed
-ListBuffer<JCDiagnostic> descriptors = ListBuffer.lb();
+ListBuffer<JCDiagnostic> descriptors = new ListBuffer<>();
 for (Symbol desc : abstracts) {
 String key = desc.type.getThrownTypes().nonEmpty() ?
 "descriptor.throws" : "descriptor";
 descriptors.append(diags.fragment(key, desc.name,
 desc.type.getParameterTypes(),
 public Type removeWildcards(Type site) {
 Type capturedSite = capture(site);
 if (capturedSite != site) {
 Type formalInterface = site.tsym.type;
-ListBuffer<Type> typeargs = ListBuffer.lb();
+ListBuffer<Type> typeargs = new ListBuffer<>();
 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)) {
 */
 public List<Symbol> functionalInterfaceBridges(TypeSymbol origin) {
 Assert.check(isFunctionalInterface(origin));
 Symbol descSym = findDescriptorSymbol(origin);
 CompoundScope members = membersClosure(origin.type, false);
-ListBuffer<Symbol> overridden = ListBuffer.lb();
+ListBuffer<Symbol> overridden = new ListBuffer<>();
 outer: for (Symbol m2 : members.getElementsByName(descSym.name, bridgeFilter)) {
 if (m2 == descSym) continue;
 else if (descSym.overrides(m2, origin, Types.this, false)) {
 for (Symbol m3 : overridden) {
 if (isSameType(m3.erasure(Types.this), m2.erasure(Types.this)) ||
 }
 private Type rewriteSupers(Type t) {
 if (!t.isParameterized())
 return t;
-ListBuffer<Type> from = lb();
+ListBuffer<Type> from = new ListBuffer<>();
-ListBuffer<Type> to = lb();
+ListBuffer<Type> to = new ListBuffer<>();
 adaptSelf(t, from, to);
 if (from.isEmpty())
 return t;
-ListBuffer<Type> rewrite = lb();
+ListBuffer<Type> rewrite = new ListBuffer<>();
 boolean changed = false;
 for (Type orig : to.toList()) {
 Type s = rewriteSupers(orig);
 if (s.isSuperBound() && !s.isExtendsBound()) {
 s = new WildcardType(syms.objectType,
 }
 return prune(candidates);
 }
 public List<MethodSymbol> prune(List<MethodSymbol> methods) {
-ListBuffer<MethodSymbol> methodsMin = ListBuffer.lb();
+ListBuffer<MethodSymbol> methodsMin = new ListBuffer<>();
 for (MethodSymbol m1 : methods) {
 boolean isMin_m1 = true;
 for (MethodSymbol m2 : methods) {
 if (m1 == m2) continue;
 if (m2.owner != m1.owner &&
 public List<Type> substBounds(List<Type> tvars,
 List<Type> from,
 List<Type> to) {
 if (tvars.isEmpty())
 return tvars;
-ListBuffer<Type> newBoundsBuf = lb();
+ListBuffer<Type> newBoundsBuf = new ListBuffer<>();
 boolean changed = false;
 // calculate new bounds
 for (Type t : tvars) {
 TypeVar tv = (TypeVar) t;
 Type bound = subst(tv.bound, from, to);
 changed = true;
 newBoundsBuf.append(bound);
 }
 if (!changed)
 return tvars;
-ListBuffer<Type> newTvars = lb();
+ListBuffer<Type> newTvars = new ListBuffer<>();
 // create new type variables without bounds
 for (Type t : tvars) {
 newTvars.append(new TypeVar(t.tsym, null, syms.botType));
 }
 // the new bounds should use the new type variables in place
 /**
 * Return the minimum types of a closure, suitable for computing
 * compoundMin or glb.
 */
 private List<Type> closureMin(List<Type> cl) {
-ListBuffer<Type> classes = lb();
+ListBuffer<Type> classes = new ListBuffer<>();
-ListBuffer<Type> interfaces = lb();
+ListBuffer<Type> interfaces = new ListBuffer<>();
 while (!cl.isEmpty()) {
 Type current = cl.head;
 if (current.isInterface())
 interfaces.append(current);
 else
 classes.append(current);
-ListBuffer<Type> candidates = lb();
+ListBuffer<Type> candidates = new ListBuffer<>();
 for (Type t : cl.tail) {
 if (!isSubtypeNoCapture(current, t))
 candidates.append(t);
 }
 cl = candidates.toList();
 return lub(classes);
 }
 }
 // where
 List<Type> erasedSupertypes(Type t) {
-ListBuffer<Type> buf = lb();
+ListBuffer<Type> buf = new ListBuffer<>();
 for (Type sup : closure(t)) {
 if (sup.hasTag(TYPEVAR)) {
 buf.append(sup);
 } else {
 buf.append(erasure(sup));
 else
 return t;
 }
 // where
 public List<Type> freshTypeVariables(List<Type> types) {
-ListBuffer<Type> result = lb();
+ListBuffer<Type> result = new ListBuffer<>();
 for (Type t : types) {
 if (t.hasTag(WILDCARD)) {
 t = t.unannotatedType();
 Type bound = ((WildcardType)t).getExtendsBound();
 if (bound == null)

changeset 20249	93f8eae31092
parent 19914	d86271bd430a
child 20252	fae5c47ba7a4