jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.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 MemberEnter extends JCTree.Visitor implements Completer {
-protected static final Context.Key<MemberEnter> memberEnterKey =
+protected static final Context.Key<MemberEnter> memberEnterKey = new Context.Key<>();
-new Context.Key<MemberEnter>();
 /** A switch to determine whether we check for package/class conflicts
 */
 final static boolean checkClash = true;
 boolean allowRepeatedAnnos;
 /** A queue for classes whose members still need to be entered into the
 *  symbol table.
 */
-ListBuffer<Env<AttrContext>> halfcompleted = new ListBuffer<Env<AttrContext>>();
+ListBuffer<Env<AttrContext>> halfcompleted = new ListBuffer<>();
 /** Set to true only when the first of a set of classes is
 *  processed from the half completed queue.
 */
 boolean isFirst = true;
 final PackageSymbol packge = env.toplevel.packge;
 final TypeSymbol origin = tsym;
 // enter imported types immediately
 new Object() {
-Set<Symbol> processed = new HashSet<Symbol>();
+Set<Symbol> processed = new HashSet<>();
 void importFrom(TypeSymbol tsym) {
 if (tsym == null || !processed.add(tsym))
 return;
 // also import inherited names
 }
 }.importFrom(tsym);
 // enter non-types before annotations that might use them
 annotate.earlier(new Annotate.Worker() {
-Set<Symbol> processed = new HashSet<Symbol>();
+Set<Symbol> processed = new HashSet<>();
 public String toString() {
 return "import static " + tsym + ".*" + " in " + sourcefile;
 }
 void importFrom(TypeSymbol tsym) {
 final PackageSymbol packge = env.toplevel.packge;
 final TypeSymbol origin = tsym;
 // enter imported types immediately
 new Object() {
-Set<Symbol> processed = new HashSet<Symbol>();
+Set<Symbol> processed = new HashSet<>();
 void importFrom(TypeSymbol tsym) {
 if (tsym == null || !processed.add(tsym))
 return;
 // also import inherited names
 }
 }.importFrom(tsym);
 // enter non-types before annotations that might use them
 annotate.earlier(new Annotate.Worker() {
-Set<Symbol> processed = new HashSet<Symbol>();
+Set<Symbol> processed = new HashSet<>();
 boolean found = false;
 public String toString() {
 return "import static " + tsym + "." + name;
 }
 // Enter and attribute type parameters.
 List<Type> tvars = enter.classEnter(typarams, env);
 attr.attribTypeVariables(typarams, env);
 // Enter and attribute value parameters.
-ListBuffer<Type> argbuf = new ListBuffer<Type>();
+ListBuffer<Type> argbuf = new ListBuffer<>();
 for (List<JCVariableDecl> l = params; l.nonEmpty(); l = l.tail) {
 memberEnter(l.head, env);
 argbuf.append(l.head.vartype.type);
 }
 } else {
 recvtype = null;
 }
 // Attribute thrown exceptions.
-ListBuffer<Type> thrownbuf = new ListBuffer<Type>();
+ListBuffer<Type> thrownbuf = new ListBuffer<>();
 for (List<JCExpression> l = thrown; l.nonEmpty(); l = l.tail) {
 Type exc = attr.attribType(l.head, env);
 if (!exc.hasTag(TYPEVAR)) {
 exc = chk.checkClassType(l.head.pos(), exc);
 } else if (exc.tsym.owner == msym) {
 if (types.isSignaturePolymorphic(m)) {
 m.flags_field |= SIGNATURE_POLYMORPHIC;
 }
 // Set m.params
-ListBuffer<VarSymbol> params = new ListBuffer<VarSymbol>();
+ListBuffer<VarSymbol> params = new ListBuffer<>();
 JCVariableDecl lastParam = null;
 for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
 JCVariableDecl param = lastParam = l.head;
 params.append(Assert.checkNonNull(param.sym));
 }
 /** Enter a set of annotations. */
 private void actualEnterAnnotations(List<JCAnnotation> annotations,
 Env<AttrContext> env,
 Symbol s) {
-Map<TypeSymbol, ListBuffer<Attribute.Compound>> annotated =
+Map<TypeSymbol, ListBuffer<Attribute.Compound>> annotated = new LinkedHashMap<>();
-new LinkedHashMap<TypeSymbol, ListBuffer<Attribute.Compound>>();
+Map<Attribute.Compound, DiagnosticPosition> pos = new HashMap<>();
-Map<Attribute.Compound, DiagnosticPosition> pos =
-new HashMap<Attribute.Compound, DiagnosticPosition>();
 for (List<JCAnnotation> al = annotations; !al.isEmpty(); al = al.tail) {
 JCAnnotation a = al.head;
 Attribute.Compound c = annotate.enterAnnotation(a,
 syms.annotationType,
 s.flags_field |= Flags.DEPRECATED;
 }
 }
 s.setDeclarationAttributesWithCompletion(
-annotate.new AnnotateRepeatedContext<Attribute.Compound>(env, annotated, pos, log, false));
+annotate.new AnnotateRepeatedContext<>(env, annotated, pos, log, false));
 }
 /** Queue processing of an attribute default value. */
 void annotateDefaultValueLater(final JCExpression defaultValue,
 final Env<AttrContext> localEnv,
 ? Type.noType
 : syms.objectType;
 ct.supertype_field = modelMissingTypes(supertype, tree.extending, false);
 // Determine interfaces.
-ListBuffer<Type> interfaces = new ListBuffer<Type>();
+ListBuffer<Type> interfaces = new ListBuffer<>();
 ListBuffer<Type> all_interfaces = null; // lazy init
-Set<Type> interfaceSet = new HashSet<Type>();
+Set<Type> interfaceSet = new HashSet<>();
 List<JCExpression> interfaceTrees = tree.implementing;
 for (JCExpression iface : interfaceTrees) {
 Type i = attr.attribBase(iface, baseEnv, false, true, true);
 if (i.hasTag(CLASS)) {
 interfaces.append(i);
 * If the symbol is non-null, attach the type annotation to it.
 */
 private void actualEnterTypeAnnotations(final List<JCAnnotation> annotations,
 final Env<AttrContext> env,
 final Symbol s) {
-Map<TypeSymbol, ListBuffer<Attribute.TypeCompound>> annotated =
+Map<TypeSymbol, ListBuffer<Attribute.TypeCompound>> annotated = new LinkedHashMap<>();
-new LinkedHashMap<TypeSymbol, ListBuffer<Attribute.TypeCompound>>();
+Map<Attribute.TypeCompound, DiagnosticPosition> pos = new HashMap<>();
-Map<Attribute.TypeCompound, DiagnosticPosition> pos =
-new HashMap<Attribute.TypeCompound, DiagnosticPosition>();
 for (List<JCAnnotation> al = annotations; !al.isEmpty(); al = al.tail) {
 JCAnnotation a = al.head;
 Attribute.TypeCompound tc = annotate.enterTypeAnnotation(a,
 syms.annotationType,
 }
 }
 if (s != null) {
 s.appendTypeAttributesWithCompletion(
-annotate.new AnnotateRepeatedContext<Attribute.TypeCompound>(env, annotated, pos, log, true));
+annotate.new AnnotateRepeatedContext<>(env, annotated, pos, log, true));
 }
 }
 public void typeAnnotate(final JCTree tree, final Env<AttrContext> env, final Symbol sym, DiagnosticPosition deferPos) {
 if (allowTypeAnnos) {
 tree.accept(this);
 return result;
 }
 List<Type> visit(List<? extends JCTree> trees) {
-ListBuffer<Type> lb = new ListBuffer<Type>();
+ListBuffer<Type> lb = new ListBuffer<>();
 for (JCTree t: trees)
 lb.append(visit(t));
 return lb.toList();
 }

changeset 22163	3651128c74eb
parent 21498	58c2486db8d0
child 22442	8fd30fc4e3a3