jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/comp/Lower.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 Lower extends TreeTranslator {
-protected static final Context.Key<Lower> lowerKey =
+protected static final Context.Key<Lower> lowerKey = new Context.Key<>();
-new Context.Key<Lower>();
 public static Lower instance(Context context) {
 Lower instance = context.get(lowerKey);
 if (instance == null)
 instance = new Lower(context);
 */
 Map<ClassSymbol, JCClassDecl> classdefs;
 /** A hash table mapping local classes to a list of pruned trees.
 */
-public Map<ClassSymbol, List<JCTree>> prunedTree = new WeakHashMap<ClassSymbol, List<JCTree>>();
+public Map<ClassSymbol, List<JCTree>> prunedTree = new WeakHashMap<>();
 /** A hash table mapping virtual accessed symbols in outer subclasses
 *  to the actually referred symbol in superclasses.
 */
 Map<Symbol,Symbol> actualSymbols;
 return List.nil();
 }
 }
 }
-Map<TypeSymbol,EnumMapping> enumSwitchMap = new LinkedHashMap<TypeSymbol,EnumMapping>();
+Map<TypeSymbol,EnumMapping> enumSwitchMap = new LinkedHashMap<>();
 EnumMapping mapForEnum(DiagnosticPosition pos, TypeSymbol enumClass) {
 EnumMapping map = enumSwitchMap.get(enumClass);
 if (map == null)
 enumSwitchMap.put(enumClass, map = new EnumMapping(pos, enumClass));
 *  class EnumMapping provides mapping data and support methods for this translation.
 */
 class EnumMapping {
 EnumMapping(DiagnosticPosition pos, TypeSymbol forEnum) {
 this.forEnum = forEnum;
-this.values = new LinkedHashMap<VarSymbol,Integer>();
+this.values = new LinkedHashMap<>();
 this.pos = pos;
 Name varName = names
 .fromString(target.syntheticNameChar() +
 "SwitchMap" +
 target.syntheticNameChar() +
 JCExpression mapVarInit = make
 .NewArray(make.Type(syms.intType), List.of(size), null)
 .setType(new ArrayType(syms.intType, syms.arrayClass));
 // try { $SwitchMap$Color[red.ordinal()] = 1; } catch (java.lang.NoSuchFieldError ex) {}
-ListBuffer<JCStatement> stmts = new ListBuffer<JCStatement>();
+ListBuffer<JCStatement> stmts = new ListBuffer<>();
 Symbol ordinalMethod = lookupMethod(pos,
 names.ordinal,
 forEnum.type,
 List.<Type>nil());
 List<JCCatch> catcher = List.<JCCatch>nil()
 boolean finallyCanCompleteNormally, int depth) {
 if (resources.isEmpty())
 return block;
 // Add resource declaration or expression to block statements
-ListBuffer<JCStatement> stats = new ListBuffer<JCStatement>();
+ListBuffer<JCStatement> stats = new ListBuffer<>();
 JCTree resource = resources.head;
 JCExpression expr = null;
 if (resource instanceof JCVariableDecl) {
 JCVariableDecl var = (JCVariableDecl) resource;
 expr = make.Ident(var.sym).setType(resource.type);
 JCExpression e_class = classOfType(tree.sym.type, tree.pos()).
 setType(types.erasure(syms.classType));
 // process each enumeration constant, adding implicit constructor parameters
 int nextOrdinal = 0;
-ListBuffer<JCExpression> values = new ListBuffer<JCExpression>();
+ListBuffer<JCExpression> values = new ListBuffer<>();
-ListBuffer<JCTree> enumDefs = new ListBuffer<JCTree>();
+ListBuffer<JCTree> enumDefs = new ListBuffer<>();
-ListBuffer<JCTree> otherDefs = new ListBuffer<JCTree>();
+ListBuffer<JCTree> otherDefs = new ListBuffer<>();
 for (List<JCTree> defs = tree.defs;
 defs.nonEmpty();
 defs=defs.tail) {
 if (defs.head.hasTag(VARDEF) && (((JCVariableDecl) defs.head).mods.flags & ENUM) != 0) {
 JCVariableDecl var = (JCVariableDecl)defs.head;
 }
 result = tree;
 }
 //where
 private Map<Symbol, Symbol> makeTranslationMap(JCMethodDecl tree) {
-Map<Symbol, Symbol> translationMap = new HashMap<Symbol,Symbol>();
+Map<Symbol, Symbol> translationMap = new HashMap<>();
 for (JCVariableDecl vd : tree.params) {
 Symbol p = vd.sym;
 if (p != p.baseSymbol()) {
 translationMap.put(p.baseSymbol(), p);
 }
 List<JCExpression> boxArgs(List<Type> parameters, List<JCExpression> _args, Type varargsElement) {
 List<JCExpression> args = _args;
 if (parameters.isEmpty()) return args;
 boolean anyChanges = false;
-ListBuffer<JCExpression> result = new ListBuffer<JCExpression>();
+ListBuffer<JCExpression> result = new ListBuffer<>();
 while (parameters.tail.nonEmpty()) {
 JCExpression arg = translate(args.head, parameters.head);
 anyChanges |= (arg != args.head);
 result.append(arg);
 args = args.tail;
 parameters = parameters.tail;
 }
 Type parameter = parameters.head;
 if (varargsElement != null) {
 anyChanges = true;
-ListBuffer<JCExpression> elems = new ListBuffer<JCExpression>();
+ListBuffer<JCExpression> elems = new ListBuffer<>();
 while (args.nonEmpty()) {
 JCExpression arg = translate(args.head, varargsElement);
 elems.append(arg);
 args = args.tail;
 }
 tree.selector.type,
 List.<Type>nil());
 JCArrayAccess selector = make.Indexed(map.mapVar,
 make.App(make.Select(tree.selector,
 ordinalMethod)));
-ListBuffer<JCCase> cases = new ListBuffer<JCCase>();
+ListBuffer<JCCase> cases = new ListBuffer<>();
 for (JCCase c : tree.cases) {
 if (c.pat != null) {
 VarSymbol label = (VarSymbol)TreeInfo.symbol(c.pat);
 JCLiteral pat = map.forConstant(label);
 cases.append(make.Case(pat, c.stats));
 * strings or a perfect hashing algorithm over the
 * particular set of case labels, could potentially be
 * used instead of String.hashCode.
 */
-ListBuffer<JCStatement> stmtList = new ListBuffer<JCStatement>();
+ListBuffer<JCStatement> stmtList = new ListBuffer<>();
 // Map from String case labels to their original position in
 // the list of case labels.
-Map<String, Integer> caseLabelToPosition =
+Map<String, Integer> caseLabelToPosition = new LinkedHashMap<>(alternatives + 1, 1.0f);
-new LinkedHashMap<String, Integer>(alternatives + 1, 1.0f);
 // Map of hash codes to the string case labels having that hashCode.
-Map<Integer, Set<String>> hashToString =
+Map<Integer, Set<String>> hashToString = new LinkedHashMap<>(alternatives + 1, 1.0f);
-new LinkedHashMap<Integer, Set<String>>(alternatives + 1, 1.0f);
 int casePosition = 0;
 for(JCCase oneCase : caseList) {
 JCExpression expression = oneCase.getExpression();
 Assert.checkNull(mapping);
 int hashCode = labelExpr.hashCode();
 Set<String> stringSet = hashToString.get(hashCode);
 if (stringSet == null) {
-stringSet = new LinkedHashSet<String>(1, 1.0f);
+stringSet = new LinkedHashSet<>(1, 1.0f);
 stringSet.add(labelExpr);
 hashToString.put(hashCode, stringSet);
 } else {
 boolean added = stringSet.add(labelExpr);
 Assert.check(added);
 endPosTable = env.toplevel.endPositions;
 currentClass = null;
 currentMethodDef = null;
 outermostClassDef = (cdef.hasTag(CLASSDEF)) ? (JCClassDecl)cdef : null;
 outermostMemberDef = null;
-this.translated = new ListBuffer<JCTree>();
+this.translated = new ListBuffer<>();
-classdefs = new HashMap<ClassSymbol,JCClassDecl>();
+classdefs = new HashMap<>();
-actualSymbols = new HashMap<Symbol,Symbol>();
+actualSymbols = new HashMap<>();
-freevarCache = new HashMap<ClassSymbol,List<VarSymbol>>();
+freevarCache = new HashMap<>();
 proxies = new Scope(syms.noSymbol);
 twrVars = new Scope(syms.noSymbol);
 outerThisStack = List.nil();
-accessNums = new HashMap<Symbol,Integer>();
+accessNums = new HashMap<>();
-accessSyms = new HashMap<Symbol,MethodSymbol[]>();
+accessSyms = new HashMap<>();
-accessConstrs = new HashMap<Symbol,MethodSymbol>();
+accessConstrs = new HashMap<>();
 accessConstrTags = List.nil();
-accessed = new ListBuffer<Symbol>();
+accessed = new ListBuffer<>();
 translate(cdef, (JCExpression)null);
 for (List<Symbol> l = accessed.toList(); l.nonEmpty(); l = l.tail)
 makeAccessible(l.head);
 for (EnumMapping map : enumSwitchMap.values())
 map.translate();

changeset 22163	3651128c74eb
parent 21897	ba025087b9f9
child 22442	8fd30fc4e3a3