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

equal deleted inserted replaced

-:36468b5fa7f4
+:cce89649f958
 nextToken();
 }
 }
 protected JCErroneous syntaxError(int pos, String key, TokenKind... args) {
-return syntaxError(pos, List.<JCTree>nil(), key, args);
+return syntaxError(pos, List.nil(), key, args);
 }
 protected JCErroneous syntaxError(int pos, List<JCTree> errs, String key, TokenKind... args) {
 setErrorEndPos(pos);
 JCErroneous err = F.at(pos).Erroneous(errs);
 break;
 }
 return args.toList();
 }
 } else {
-return List.<JCExpression>of(syntaxError(token.pos, "expected", LT));
+return List.of(syntaxError(token.pos, "expected", LT));
 }
 }
 /**
 *  {@literal
 }
 /** BracketsOpt = [ "[" "]" { [Annotations] "[" "]"} ]
 */
 private JCExpression bracketsOpt(JCExpression t) {
-return bracketsOpt(t, List.<JCAnnotation>nil());
+return bracketsOpt(t, List.nil());
 }
 private JCExpression bracketsOptCont(JCExpression t, int pos,
 List<JCAnnotation> annotations) {
 accept(RBRACKET);
 }
 return newClass;
 } else {
 setErrorEndPos(token.pos);
 reportSyntaxError(token.pos, "expected2", LPAREN, LBRACKET);
-t = toP(F.at(newpos).NewClass(null, typeArgs, t, List.<JCExpression>nil(), null));
+t = toP(F.at(newpos).NewClass(null, typeArgs, t, List.nil(), null));
 return toP(F.at(newpos).Erroneous(List.<JCTree>of(t)));
 }
 }
 /** InnerCreator = [Annotations] Ident [TypeArguments] ClassCreatorRest
 na.annotations = annotated.annotations;
 na.elemtype = annotated.underlyingType;
 }
 return na;
 } else {
-JCExpression t = toP(F.at(newpos).NewArray(elemtype, List.<JCExpression>nil(), null));
+JCExpression t = toP(F.at(newpos).NewArray(elemtype, List.nil(), null));
-return syntaxError(token.pos, List.<JCTree>of(t), "array.dimension.missing");
+return syntaxError(token.pos, List.of(t), "array.dimension.missing");
 }
 } else {
 ListBuffer<JCExpression> dims = new ListBuffer<>();
 // maintain array dimension type annotations
 if (token.kind == RBRACE) break;
 elems.append(variableInitializer());
 }
 }
 accept(RBRACE);
-return toP(F.at(newpos).NewArray(t, List.<JCExpression>nil(), elems.toList()));
+return toP(F.at(newpos).NewArray(t, List.nil(), elems.toList()));
 }
 /** VariableInitializer = ArrayInitializer | Expression
 */
 public JCExpression variableInitializer() {
 Token prevToken = token;
 JCExpression t = term(EXPR | TYPE);
 if (token.kind == COLON && t.hasTag(IDENT)) {
 nextToken();
 JCStatement stat = parseStatementAsBlock();
-return List.<JCStatement>of(F.at(pos).Labelled(prevToken.name(), stat));
+return List.of(F.at(pos).Labelled(prevToken.name(), stat));
 } else if ((lastmode & TYPE) != 0 && LAX_IDENTIFIER.accepts(token.kind)) {
 pos = token.pos;
 JCModifiers mods = F.at(Position.NOPOS).Modifiers(0);
 F.at(pos);
 ListBuffer<JCStatement> stats =
 } else {
 // This Exec is an "ExpressionStatement"; it subsumes the terminating semicolon
 t = checkExprStat(t);
 accept(SEMI);
 JCExpressionStatement expr = toP(F.at(pos).Exec(t));
-return List.<JCStatement>of(expr);
+return List.of(expr);
 }
 }
 }
 /** Statement =
 return F.at(pos).If(cond, thenpart, elsepart);
 }
 case FOR: {
 nextToken();
 accept(LPAREN);
-List<JCStatement> inits = token.kind == SEMI ? List.<JCStatement>nil() : forInit();
+List<JCStatement> inits = token.kind == SEMI ? List.nil() : forInit();
 if (inits.length() == 1 &&
 inits.head.hasTag(VARDEF) &&
 ((JCVariableDecl) inits.head).init == null &&
 token.kind == COLON) {
 JCVariableDecl var = (JCVariableDecl)inits.head;
 return F.at(pos).ForeachLoop(var, expr, body);
 } else {
 accept(SEMI);
 JCExpression cond = token.kind == SEMI ? null : parseExpression();
 accept(SEMI);
-List<JCExpressionStatement> steps = token.kind == RPAREN ? List.<JCExpressionStatement>nil() : forUpdate();
+List<JCExpressionStatement> steps = token.kind == RPAREN ? List.nil() : forUpdate();
 accept(RPAREN);
 JCStatement body = parseStatementAsBlock();
 return F.at(pos).ForLoop(inits, cond, steps, body);
 }
 }
 JCDoWhileLoop t = toP(F.at(pos).DoLoop(body, cond));
 return t;
 }
 case TRY: {
 nextToken();
-List<JCTree> resources = List.<JCTree>nil();
+List<JCTree> resources = List.nil();
 if (token.kind == LPAREN) {
 checkTryWithResources();
 nextToken();
 resources = resources();
 accept(RPAREN);
 private JCStatement doRecover(int startPos, ErrorRecoveryAction action, String key) {
 int errPos = S.errPos();
 JCTree stm = action.doRecover(this);
 S.errPos(errPos);
-return toP(F.Exec(syntaxError(startPos, List.<JCTree>of(stm), key)));
+return toP(F.Exec(syntaxError(startPos, List.of(stm), key)));
 }
 /** CatchClause     = CATCH "(" FormalParameter ")" Block
 * TODO: the "FormalParameter" is not correct, it uses the special "catchTypes" rule below.
 */
 storeEnd(ann, S.prevToken().endPos);
 return ann;
 }
 List<JCExpression> annotationFieldValuesOpt() {
-return (token.kind == LPAREN) ? annotationFieldValues() : List.<JCExpression>nil();
+return (token.kind == LPAREN) ? annotationFieldValues() : List.nil();
 }
 /** AnnotationFieldValues   = "(" [ AnnotationFieldValue { "," AnnotationFieldValue } ] ")" */
 List<JCExpression> annotationFieldValues() {
 accept(LPAREN);
 if (token.kind == RBRACE) break;
 buf.append(annotationValue());
 }
 }
 accept(RBRACE);
-return toP(F.at(pos).NewArray(null, List.<JCExpression>nil(), buf.toList()));
+return toP(F.at(pos).NewArray(null, List.nil(), buf.toList()));
 default:
 mode = EXPR;
 return term1();
 }
 }
 return enumDeclaration(mods, dc);
 } else {
 int pos = token.pos;
 List<JCTree> errs;
 if (LAX_IDENTIFIER.accepts(token.kind)) {
-errs = List.<JCTree>of(mods, toP(F.at(pos).Ident(ident())));
+errs = List.of(mods, toP(F.at(pos).Ident(ident())));
 setErrorEndPos(token.pos);
 } else {
-errs = List.<JCTree>of(mods);
+errs = List.of(mods);
 }
 return toP(F.Exec(syntaxError(pos, errs, "expected3",
 CLASS, INTERFACE, ENUM)));
 }
 }
 }
 List<JCTree> defs = enumBody(name);
 mods.flags |= Flags.ENUM;
 JCClassDecl result = toP(F.at(pos).
-ClassDef(mods, name, List.<JCTypeParameter>nil(),
+ClassDef(mods, name, List.nil(),
 null, implementing, defs));
 attach(result, dc);
 return result;
 }
 List<JCExpression> typeArgs = typeArgumentsOpt();
 int identPos = token.pos;
 Name name = ident();
 int createPos = token.pos;
 List<JCExpression> args = (token.kind == LPAREN)
-? arguments() : List.<JCExpression>nil();
+? arguments() : List.nil();
 JCClassDecl body = null;
 if (token.kind == LBRACE) {
 JCModifiers mods1 = F.at(Position.NOPOS).Modifiers(Flags.ENUM);
 List<JCTree> defs = classOrInterfaceBody(names.empty, false);
 body = toP(F.at(identPos).AnonymousClassDef(mods1, defs));
 *
 */
 protected List<JCTree> classOrInterfaceBodyDeclaration(Name className, boolean isInterface) {
 if (token.kind == SEMI) {
 nextToken();
-return List.<JCTree>nil();
+return List.nil();
 } else {
 Comment dc = token.comment(CommentStyle.JAVADOC);
 int pos = token.pos;
 JCModifiers mods = modifiersOpt();
 if (token.kind == CLASS ||
 token.kind == INTERFACE ||
 token.kind == ENUM) {
-return List.<JCTree>of(classOrInterfaceOrEnumDeclaration(mods, dc));
+return List.of(classOrInterfaceOrEnumDeclaration(mods, dc));
 } else if (token.kind == LBRACE &&
 (mods.flags & Flags.StandardFlags & ~Flags.STATIC) == 0 &&
 mods.annotations.isEmpty()) {
 if (isInterface) {
 error(token.pos, "initializer.not.allowed");
 }
-return List.<JCTree>of(block(pos, mods.flags));
+return List.of(block(pos, mods.flags));
 } else {
 pos = token.pos;
 List<JCTypeParameter> typarams = typeParametersOpt();
 // if there are type parameters but no modifiers, save the start
 // position of the method in the modifiers.
 storeEnd(defs.last(), S.prevToken().endPos);
 return defs;
 } else {
 pos = token.pos;
 List<JCTree> err = isVoid
-? List.<JCTree>of(toP(F.at(pos).MethodDef(mods, name, type, typarams,
+? List.of(toP(F.at(pos).MethodDef(mods, name, type, typarams,
-List.<JCVariableDecl>nil(), List.<JCExpression>nil(), null, null)))
+List.nil(), List.nil(), null, null)))
 : null;
-return List.<JCTree>of(syntaxError(token.pos, err, "expected", LPAREN));
+return List.of(syntaxError(token.pos, err, "expected", LPAREN));
 }
 }
 }
 }
 }

changeset 42828	cce89649f958
parent 42827	36468b5fa7f4
child 43030	a3d5b201d899