jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Lower.java

equal deleted inserted replaced

-:36468b5fa7f4
+:cce89649f958
 // synthetic static final int[] $SwitchMap$Color = new int[Color.values().length];
 MethodSymbol valuesMethod = lookupMethod(pos,
 names.values,
 forEnum.type,
-List.<Type>nil());
+List.nil());
 JCExpression size = make // Color.values().length
 .Select(make.App(make.QualIdent(valuesMethod)),
 syms.lengthVar);
 JCExpression mapVarInit = make
 .NewArray(make.Type(syms.intType), List.of(size), null)
 // try { $SwitchMap$Color[red.ordinal()] = 1; } catch (java.lang.NoSuchFieldError ex) {}
 ListBuffer<JCStatement> stmts = new ListBuffer<>();
 Symbol ordinalMethod = lookupMethod(pos,
 names.ordinal,
 forEnum.type,
-List.<Type>nil());
+List.nil());
 List<JCCatch> catcher = List.<JCCatch>nil()
 .prepend(make.Catch(make.VarDef(new VarSymbol(PARAMETER, names.ex,
 syms.noSuchFieldErrorType,
 syms.noSymbol),
 null),
-make.Block(0, List.<JCStatement>nil())));
+make.Block(0, List.nil())));
 for (Map.Entry<VarSymbol,Integer> e : values.entrySet()) {
 VarSymbol enumerator = e.getKey();
 Integer mappedValue = e.getValue();
 JCExpression assign = make
 .Assign(make.Indexed(mapVar,
 */
 JCNewClass makeNewClass(Type ctype, List<JCExpression> args) {
 JCNewClass tree = make.NewClass(null,
 null, make.QualIdent(ctype.tsym), args, null);
 tree.constructor = rs.resolveConstructor(
-make_pos, attrEnv, ctype, TreeInfo.types(args), List.<Type>nil());
+make_pos, attrEnv, ctype, TreeInfo.types(args), List.nil());
 tree.type = ctype;
 return tree;
 }
 /** Make an attributed unary expression.
 chk.putCompiled(c);
 // Create class definition tree.
 JCClassDecl cdef = make.ClassDef(
 make.Modifiers(flags), names.empty,
-List.<JCTypeParameter>nil(),
+List.nil(),
-null, List.<JCExpression>nil(), List.<JCTree>nil());
+null, List.nil(), List.nil());
 cdef.sym = c;
 cdef.type = c.type;
 // Append class definition tree to owner's definitions.
 if (addToDefs) odef.defs = odef.defs.prepend(cdef);
 }
 /** Look up a method in a given scope.
 */
 private MethodSymbol lookupMethod(DiagnosticPosition pos, Name name, Type qual, List<Type> args) {
-return rs.resolveInternalMethod(pos, attrEnv, qual, name, args, List.<Type>nil());
+return rs.resolveInternalMethod(pos, attrEnv, qual, name, args, List.nil());
 }
 /** Look up a constructor.
 */
 private MethodSymbol lookupConstructor(DiagnosticPosition pos, Type qual, List<Type> args) {
 null);
 JCIdent callee = make.Ident(names._this);
 callee.sym = constr;
 callee.type = constr.type;
 md.body =
-make.Block(0, List.<JCStatement>of(
+make.Block(0, List.of(
 make.Call(
 make.App(
 callee,
 make.Idents(md.params.reverse().tail.reverse())))));
 return md;
 syms.throwableType,
 currentMethodSym);
 JCVariableDecl paramTree = make.VarDef(param, null);
 JCStatement assign = make.Assignment(primaryException, make.Ident(param));
 JCStatement rethrowStat = make.Throw(make.Ident(param));
-JCBlock catchBlock = make.Block(0L, List.<JCStatement>of(assign, rethrowStat));
+JCBlock catchBlock = make.Block(0L, List.of(assign, rethrowStat));
 JCCatch catchClause = make.Catch(paramTree, catchBlock);
 int oldPos = make.pos;
 make.at(TreeInfo.endPos(block));
 JCBlock finallyClause = makeTwrFinallyClause(primaryException, expr, resourceNonNull);
 make.at(oldPos);
 JCTry outerTry = make.Try(makeTwrBlock(resources.tail, block,
 finallyCanCompleteNormally, depth + 1),
-List.<JCCatch>of(catchClause),
+List.of(catchClause),
 finallyClause);
 outerTry.finallyCanCompleteNormally = finallyCanCompleteNormally;
 stats.add(outerTry);
 JCBlock newBlock = make.Block(0L, stats.toList());
 return newBlock;
 PRIVATE | STATIC | SYNTHETIC,
 dollarCloseResource,
 new MethodType(
 List.of(syms.throwableType, syms.autoCloseableType),
 syms.voidType,
-List.<Type>nil(),
+List.nil(),
 syms.methodClass),
 currentClass);
 enterSynthetic(resource.pos(), closeResource, currentClass.members());
 JCMethodDecl md = make.MethodDef(closeResource, null);
 List<JCVariableDecl> params = md.getParameters();
-md.body = make.Block(0, List.<JCStatement>of(makeTwrCloseStatement(params.get(0).sym,
+md.body = make.Block(0, List.of(makeTwrCloseStatement(params.get(0).sym,
 make.Ident(params.get(1)))));
 JCClassDecl currentClassDecl = classDef(currentClass);
 currentClassDecl.defs = currentClassDecl.defs.prepend(md);
 }
 JCStatement closeStatement;
 if (closeResource != null) {
 //$closeResource(#primaryException, #resource)
-closeStatement = make.Exec(make.Apply(List.<JCExpression>nil(),
+closeStatement = make.Exec(make.Apply(List.nil(),
 make.Ident(closeResource),
 List.of(make.Ident(primaryException),
 resource)
 ).setType(syms.voidType));
 } else {
 closeStatement,
 null);
 }
 return make.Block(0L,
-List.<JCStatement>of(finallyStatement));
+List.of(finallyStatement));
 }
 //where:
 private boolean shouldUseCloseResourceMethod() {
 class TryFinder extends TreeScanner {
 int closeCount;
 syms.throwableType,
 currentMethodSym);
 JCStatement addSuppressionStatement =
 make.Exec(makeCall(make.Ident(primaryException),
 names.addSuppressed,
-List.<JCExpression>of(make.Ident(catchException))));
+List.of(make.Ident(catchException))));
 // try { resource.close(); } catch (e) { primaryException.addSuppressed(e); }
 JCBlock tryBlock =
-make.Block(0L, List.<JCStatement>of(makeResourceCloseInvocation(resource)));
+make.Block(0L, List.of(makeResourceCloseInvocation(resource)));
 JCVariableDecl catchExceptionDecl = make.VarDef(catchException, null);
-JCBlock catchBlock = make.Block(0L, List.<JCStatement>of(addSuppressionStatement));
+JCBlock catchBlock = make.Block(0L, List.of(addSuppressionStatement));
-List<JCCatch> catchClauses = List.<JCCatch>of(make.Catch(catchExceptionDecl, catchBlock));
+List<JCCatch> catchClauses = List.of(make.Catch(catchExceptionDecl, catchBlock));
 JCTry tryTree = make.Try(tryBlock, catchClauses, null);
 tryTree.finallyCanCompleteNormally = true;
 // if (primaryException != null) {try...} else resourceClose;
 JCIf closeIfStatement = make.If(makeNonNullCheck(make.Ident(primaryException)),
 }
 // create resource.close() method invocation
 JCExpression resourceClose = makeCall(resource,
 names.close,
-List.<JCExpression>nil());
+List.nil());
 return make.Exec(resourceClose);
 }
 private JCExpression makeNonNullCheck(JCExpression expression) {
 return makeBinary(NE, expression, makeNull());
 STATIC | SYNTHETIC,
 classDollar,
 new MethodType(
 List.of(syms.stringType),
 types.erasure(syms.classType),
-List.<Type>nil(),
+List.nil(),
 syms.methodClass),
 outerCacheClass);
 enterSynthetic(pos, classDollarSym, outerCacheClass.members());
 JCMethodDecl md = make.MethodDef(classDollarSym, null);
 try {
 md.body = classDollarSymBody(pos, md);
 } catch (CompletionFailure ex) {
-md.body = make.Block(0, List.<JCStatement>nil());
+md.body = make.Block(0, List.nil());
 chk.completionError(pos, ex);
 }
 JCClassDecl outerCacheClassDef = classDef(outerCacheClass);
 outerCacheClassDef.defs = outerCacheClassDef.defs.prepend(md);
 }
 JCClassDecl outerCacheClassDef = classDef(outerCacheClass);
 outerCacheClassDef.defs = outerCacheClassDef.defs.prepend(cldef);
 // newcache := "new cache$1[0]"
 JCNewArray newcache = make.NewArray(make.Type(outerCacheClass.type),
-List.<JCExpression>of(make.Literal(INT, 0).setType(syms.intType)),
+List.of(make.Literal(INT, 0).setType(syms.intType)),
 null);
 newcache.type = new ArrayType(types.erasure(outerCacheClass.type),
 syms.arrayClass);
 // forNameSym := java.lang.Class.forName(
 makeBinary(EQ, make.Ident(clsym), makeNull()),
 make.Assign(make.Ident(clsym),
 makeCall(
 makeCall(makeCall(newcache,
 names.getClass,
-List.<JCExpression>nil()),
+List.nil()),
 names.getComponentType,
-List.<JCExpression>nil()),
+List.nil()),
 names.getClassLoader,
-List.<JCExpression>nil())).setType(syms.classLoaderType),
+List.nil())).setType(syms.classLoaderType),
 make.Ident(clsym)).setType(syms.classLoaderType);
 // returnResult := "{ return Class.forName(param1, false, cl$); }"
 List<JCExpression> args = List.of(make.Ident(md.params.head.sym),
 makeLit(syms.booleanType, 0),
 clvalue);
-returnResult = make.Block(0, List.<JCStatement>of(make.Call(make.App(make.Ident(forNameSym), args))));
+returnResult = make.Block(0, List.of(make.Call(make.App(make.Ident(forNameSym), args))));
 // catchParam := ClassNotFoundException e1
 VarSymbol catchParam =
 new VarSymbol(SYNTHETIC, make.paramName(1),
 syms.classNotFoundExceptionType,
 JCStatement rethrow;
 // rethrow = "throw new NoClassDefFoundError().initCause(e);
 JCExpression throwExpr =
 makeCall(makeNewClass(syms.noClassDefFoundErrorType,
-List.<JCExpression>nil()),
+List.nil()),
 names.initCause,
-List.<JCExpression>of(make.Ident(catchParam)));
+List.of(make.Ident(catchParam)));
 rethrow = make.Throw(throwExpr);
 // rethrowStmt := "( $rethrow )"
 JCBlock rethrowStmt = make.Block(0, List.of(rethrow));
 container);
 enterSynthetic(pos, assertDisabledSym, container.members());
 Symbol desiredAssertionStatusSym = lookupMethod(pos,
 names.desiredAssertionStatus,
 types.erasure(syms.classType),
-List.<Type>nil());
+List.nil());
 JCClassDecl containerDef = classDef(container);
 make_at(containerDef.pos());
 JCExpression notStatus = makeUnary(NOT, make.App(make.Select(
 classOfType(types.erasure(outermostClass.type),
 containerDef.pos()),
 //need to load the assertions enabled/disabled state while
 //initializing the interface:
 JCClassDecl currentClassDef = classDef(currentClass);
 make_at(currentClassDef.pos());
 JCStatement dummy = make.If(make.QualIdent(assertDisabledSym), make.Skip(), null);
-JCBlock clinit = make.Block(STATIC, List.<JCStatement>of(dummy));
+JCBlock clinit = make.Block(STATIC, List.of(dummy));
 currentClassDef.defs = currentClassDef.defs.prepend(clinit);
 }
 }
 make_at(pos);
 return makeUnary(NOT, make.Ident(assertDisabledSym));
 public void visitModuleDef(JCModuleDecl tree) {
 ModuleSymbol msym = tree.sym;
 ClassSymbol c = msym.module_info;
 c.setAttributes(msym);
 c.flags_field |= Flags.MODULE;
-createInfoClass(List.<JCAnnotation>nil(), tree.sym.module_info);
+createInfoClass(List.nil(), tree.sym.module_info);
 }
 private void createInfoClass(List<JCAnnotation> annots, ClassSymbol c) {
 long flags = Flags.ABSTRACT | Flags.INTERFACE;
 JCClassDecl infoClass =
 make.ClassDef(make.Modifiers(flags, annots),
-c.name, List.<JCTypeParameter>nil(),
+c.name, List.nil(),
-null, List.<JCExpression>nil(), List.<JCTree>nil());
+null, List.nil(), List.nil());
 infoClass.sym = c;
 translated.append(infoClass);
 }
 public void visitClassDef(JCClassDecl tree) {
 attrEnv = prevEnv;
 currentClass = currentClassPrev;
 currentMethodSym = currentMethodSymPrev;
 // Return empty block {} as a placeholder for an inner class.
-result = make_at(tree.pos()).Block(SYNTHETIC, List.<JCStatement>nil());
+result = make_at(tree.pos()).Block(SYNTHETIC, List.nil());
 }
 /** Translate an enum class. */
 private void visitEnumDef(JCClassDecl tree) {
 make_at(tree.pos());
 VarSymbol valuesVar = new VarSymbol(PRIVATE|FINAL|STATIC|SYNTHETIC,
 valuesName,
 arrayType,
 tree.type.tsym);
 JCNewArray newArray = make.NewArray(make.Type(types.erasure(tree.type)),
-List.<JCExpression>nil(),
+List.nil(),
 values.toList());
 newArray.type = arrayType;
 enumDefs.append(make.VarDef(valuesVar, newArray));
 tree.sym.members().enter(valuesVar);
 Symbol valuesSym = lookupMethod(tree.pos(), names.values,
-tree.type, List.<Type>nil());
+tree.type, List.nil());
 List<JCStatement> valuesBody;
 if (useClone()) {
 // return (T[]) $VALUES.clone();
 JCTypeCast valuesResult =
 make.TypeCast(valuesSym.type.getReturnType(),
 make.App(make.Select(make.Ident(valuesVar),
 syms.arrayCloneMethod)));
-valuesBody = List.<JCStatement>of(make.Return(valuesResult));
+valuesBody = List.of(make.Return(valuesResult));
 } else {
 // template: T[] $result = new T[$values.length];
 Name resultName = names.fromString(target.syntheticNameChar() + "result");
 while (tree.sym.members().findFirst(resultName) != null) // avoid name clash
 resultName = names.fromString(resultName + "" + target.syntheticNameChar());
 // template: System.arraycopy($VALUES, 0, $result, 0, $VALUES.length);
 if (systemArraycopyMethod == null) {
 systemArraycopyMethod =
 new MethodSymbol(PUBLIC | STATIC,
 names.fromString("arraycopy"),
-new MethodType(List.<Type>of(syms.objectType,
+new MethodType(List.of(syms.objectType,
 syms.intType,
 syms.objectType,
 syms.intType,
 syms.intType),
 syms.voidType,
-List.<Type>nil(),
+List.nil(),
 syms.methodClass),
 syms.systemType.tsym);
 }
 JCStatement copy =
 make.Exec(make.App(make.Select(make.Ident(syms.systemType.tsym),
 make.Ident(resultVar), make.Literal(0),
 make.Select(make.Ident(valuesVar), syms.lengthVar))));
 // template: return $result;
 JCStatement ret = make.Return(make.Ident(resultVar));
-valuesBody = List.<JCStatement>of(decl, copy, ret);
+valuesBody = List.of(decl, copy, ret);
 }
 JCMethodDecl valuesDef =
 make.MethodDef((MethodSymbol)valuesSym, make.Block(0, valuesBody));
 DiagnosticPosition detailPos = (tree.detail == null) ? tree.pos() : tree.detail.pos();
 tree.cond = translate(tree.cond, syms.booleanType);
 if (!tree.cond.type.isTrue()) {
 JCExpression cond = assertFlagTest(tree.pos());
 List<JCExpression> exnArgs = (tree.detail == null) ?
-List.<JCExpression>nil() : List.of(translate(tree.detail));
+List.nil() : List.of(translate(tree.detail));
 if (!tree.cond.type.isFalse()) {
 cond = makeBinary
 (AND,
 cond,
 makeUnary(NOT, tree.cond));
 JCExpression arg = translate(args.head, varargsElement);
 elems.append(arg);
 args = args.tail;
 }
 JCNewArray boxedArgs = make.NewArray(make.Type(varargsElement),
-List.<JCExpression>nil(),
+List.nil(),
 elems.toList());
 boxedArgs.type = new ArrayType(varargsElement, syms.arrayClass);
 result.append(boxedArgs);
 } else {
 if (args.length() != 1) throw new AssertionError(args);
 }
 make_at(tree.pos());
 Symbol valueSym = lookupMethod(tree.pos(),
 unboxedType.tsym.name.append(names.Value), // x.intValue()
 tree.type,
-List.<Type>nil());
+List.nil());
 return make.App(make.Select(tree, valueSym));
 }
 /** Visitor method for parenthesized expressions.
 *  If the subexpression has changed, omit the parens.
 if (eType.isCompound())
 tree.expr = make.TypeCast(types.erasure(iterableType), tree.expr);
 Symbol iterator = lookupMethod(tree.expr.pos(),
 names.iterator,
 eType,
-List.<Type>nil());
+List.nil());
 VarSymbol itvar = new VarSymbol(SYNTHETIC, names.fromString("i" + target.syntheticNameChar()),
 types.erasure(types.asSuper(iterator.type.getReturnType(), syms.iteratorType.tsym)),
 currentMethodSym);
 JCStatement init = make.
 .setType(types.erasure(iterator.type))));
 Symbol hasNext = lookupMethod(tree.expr.pos(),
 names.hasNext,
 itvar.type,
-List.<Type>nil());
+List.nil());
 JCMethodInvocation cond = make.App(make.Select(make.Ident(itvar), hasNext));
 Symbol next = lookupMethod(tree.expr.pos(),
 names.next,
 itvar.type,
-List.<Type>nil());
+List.nil());
 JCExpression vardefinit = make.App(make.Select(make.Ident(itvar), next));
 if (tree.var.type.isPrimitive())
 vardefinit = make.TypeCast(types.cvarUpperBound(iteratorTarget), vardefinit);
 else
 vardefinit = make.TypeCast(tree.var.type, vardefinit);
 JCBlock body = make.Block(0, List.of(indexDef, tree.body));
 body.endpos = TreeInfo.endPos(tree.body);
 result = translate(make.
 ForLoop(List.of(init),
 cond,
-List.<JCExpressionStatement>nil(),
+List.nil(),
 body));
 patchTargets(body, tree, result);
 }
 public void visitVarDef(JCVariableDecl tree) {
 EnumMapping map = mapForEnum(tree.pos(), enumSym);
 make_at(tree.pos());
 Symbol ordinalMethod = lookupMethod(tree.pos(),
 names.ordinal,
 tree.selector.type,
-List.<Type>nil());
+List.nil());
 JCArrayAccess selector = make.Indexed(map.mapVar,
 make.App(make.Select(tree.selector,
 ordinalMethod)));
 ListBuffer<JCCase> cases = new ListBuffer<>();
 for (JCCase c : tree.cases) {
 stmtList.append(dollar_tmp_def);
 ListBuffer<JCCase> caseBuffer = new ListBuffer<>();
 // hashCode will trigger nullcheck on original switch expression
 JCMethodInvocation hashCodeCall = makeCall(make.Ident(dollar_s),
 names.hashCode,
-List.<JCExpression>nil()).setType(syms.intType);
+List.nil()).setType(syms.intType);
 JCSwitch switch1 = make.Switch(hashCodeCall,
 caseBuffer.toList());
 for(Map.Entry<Integer, Set<String>> entry : hashToString.entrySet()) {
 int hashCode = entry.getKey();
 Set<String> stringsWithHashCode = entry.getValue();
 JCStatement elsepart = null;
 for(String caseLabel : stringsWithHashCode ) {
 JCMethodInvocation stringEqualsCall = makeCall(make.Ident(dollar_s),
 names.equals,
-List.<JCExpression>of(make.Literal(caseLabel)));
+List.of(make.Literal(caseLabel)));
 elsepart = make.If(stringEqualsCall,
 make.Exec(make.Assign(make.Ident(dollar_tmp),
 make.Literal(caseLabelToPosition.get(caseLabel))).
 setType(dollar_tmp.type)),
 elsepart);

changeset 42828	cce89649f958
parent 42827	36468b5fa7f4
child 44230	6f46f350a21b