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

equal deleted inserted replaced

-:290b480df13e
+:ef3557eb4306
 */
 package com.sun.tools.javac.parser;
 import java.util.*;
-import java.util.function.Function;
-import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
 import com.sun.source.tree.ModuleTree.ModuleKind;
 import com.sun.tools.javac.code.Source.Feature;
 import com.sun.tools.javac.parser.Tokens.*;
 import com.sun.tools.javac.parser.Tokens.Comment.CommentStyle;
 import com.sun.tools.javac.resources.CompilerProperties;
 import com.sun.tools.javac.resources.CompilerProperties.Errors;
+import com.sun.tools.javac.resources.CompilerProperties.Fragments;
+import com.sun.tools.javac.resources.CompilerProperties.Warnings;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.util.JCDiagnostic.Error;
+import com.sun.tools.javac.util.JCDiagnostic.Warning;
+import com.sun.tools.javac.util.JCDiagnostic.Fragment;
 import com.sun.tools.javac.util.List;
 import static com.sun.tools.javac.parser.Tokens.TokenKind.*;
 import static com.sun.tools.javac.parser.Tokens.TokenKind.ASSERT;
 import static com.sun.tools.javac.parser.Tokens.TokenKind.CASE;
 }
 nextToken();
 }
 }
-protected JCErroneous syntaxError(int pos, String key, TokenKind... args) {
+protected JCErroneous syntaxError(int pos, Error errorKey) {
-return syntaxError(pos, List.nil(), key, args);
+return syntaxError(pos, List.nil(), errorKey);
 }
-protected JCErroneous syntaxError(int pos, List<JCTree> errs, String key, TokenKind... args) {
+protected JCErroneous syntaxError(int pos, List<JCTree> errs, Error errorKey) {
 setErrorEndPos(pos);
 JCErroneous err = F.at(pos).Erroneous(errs);
-reportSyntaxError(err, key, (Object[])args);
+reportSyntaxError(err, errorKey);
 if (errs != null) {
 JCTree last = errs.last();
 if (last != null)
 storeEnd(last, pos);
 }
 /**
 * Report a syntax using the given the position parameter and arguments,
 * unless one was already reported at the same position.
 */
-protected void reportSyntaxError(int pos, String key, Object... args) {
+protected void reportSyntaxError(int pos, Error errorKey) {
 JCDiagnostic.DiagnosticPosition diag = new JCDiagnostic.SimpleDiagnosticPosition(pos);
-reportSyntaxError(diag, key, args);
+reportSyntaxError(diag, errorKey);
 }
 /**
 * Report a syntax error using the given DiagnosticPosition object and
 * arguments, unless one was already reported at the same position.
 */
-protected void reportSyntaxError(JCDiagnostic.DiagnosticPosition diagPos, String key, Object... args) {
+protected void reportSyntaxError(JCDiagnostic.DiagnosticPosition diagPos, Error errorKey) {
 int pos = diagPos.getPreferredPosition();
 if (pos > S.errPos() || pos == Position.NOPOS) {
 if (token.kind == EOF) {
-error(diagPos, "premature.eof");
+log.error(DiagnosticFlag.SYNTAX, diagPos, Errors.PrematureEof);
 } else {
-error(diagPos, key, args);
+log.error(DiagnosticFlag.SYNTAX, diagPos, errorKey);
 }
 }
 S.errPos(pos);
 if (token.pos == errorPos) {
 //check for a possible infinite loop in parsing:
 count = 0;
 errorPos = token.pos;
 }
 }
-/** Generate a syntax error at current position unless one was already
-*  reported at the same position.
-*/
-protected JCErroneous syntaxError(String key) {
-return syntaxError(token.pos, key);
-}
-/** Generate a syntax error at current position unless one was
-*  already reported at the same position.
-*/
-protected JCErroneous syntaxError(String key, TokenKind arg) {
-return syntaxError(token.pos, key, arg);
-}
 /** If next input token matches given token, skip it, otherwise report
 *  an error.
 */
 public void accept(TokenKind tk) {
 if (token.kind == tk) {
 nextToken();
 } else {
 setErrorEndPos(token.pos);
-reportSyntaxError(S.prevToken().endPos, "expected", tk);
+reportSyntaxError(S.prevToken().endPos, Errors.Expected(tk));
 }
 }
 /** Report an illegal start of expression/type error at given position.
 */
 JCExpression illegal(int pos) {
 setErrorEndPos(pos);
 if ((mode & EXPR) != 0)
-return syntaxError(pos, "illegal.start.of.expr");
+return syntaxError(pos, Errors.IllegalStartOfExpr);
 else
-return syntaxError(pos, "illegal.start.of.type");
+return syntaxError(pos, Errors.IllegalStartOfType);
 }
 /** Report an illegal start of expression/type error at current position.
 */
 /** Diagnose a modifier flag from the set, if any. */
 protected void checkNoMods(long mods) {
 if (mods != 0) {
 long lowestMod = mods & -mods;
-error(token.pos, "mod.not.allowed.here",
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.ModNotAllowedHere(Flags.asFlagSet(lowestMod)));
-Flags.asFlagSet(lowestMod));
 }
 }
 /* ---------- doc comments --------- */
 if (token.kind == IDENTIFIER) {
 Name name = token.name();
 nextToken();
 return name;
 } else if (token.kind == ASSERT) {
-error(token.pos, "assert.as.identifier");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.AssertAsIdentifier);
 nextToken();
 return names.error;
 } else if (token.kind == ENUM) {
-error(token.pos, "enum.as.identifier");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.EnumAsIdentifier);
 nextToken();
 return names.error;
 } else if (token.kind == THIS) {
 if (allowThisIdent) {
 // Make sure we're using a supported source version.
 checkSourceLevel(Feature.TYPE_ANNOTATIONS);
 Name name = token.name();
 nextToken();
 return name;
 } else {
-error(token.pos, "this.as.identifier");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.ThisAsIdentifier);
 nextToken();
 return names.error;
 }
 } else if (token.kind == UNDERSCORE) {
 if (Feature.UNDERSCORE_IDENTIFIER.allowedInSource(source)) {
-warning(token.pos, "underscore.as.identifier");
+log.warning(token.pos, Warnings.UnderscoreAsIdentifier);
 } else {
-error(token.pos, "underscore.as.identifier");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.UnderscoreAsIdentifier);
 }
 Name name = token.name();
 nextToken();
 return name;
 } else {
 try {
 t = F.at(pos).Literal(
 TypeTag.INT,
 Convert.string2int(strval(prefix), token.radix()));
 } catch (NumberFormatException ex) {
-error(token.pos, "int.number.too.large", strval(prefix));
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.IntNumberTooLarge(strval(prefix)));
 }
 break;
 case LONGLITERAL:
 try {
 t = F.at(pos).Literal(
 TypeTag.LONG,
 Long.valueOf(Convert.string2long(strval(prefix), token.radix())));
 } catch (NumberFormatException ex) {
-error(token.pos, "int.number.too.large", strval(prefix));
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.IntNumberTooLarge(strval(prefix)));
 }
 break;
 case FLOATLITERAL: {
 String proper = token.radix() == 16 ?
 ("0x"+ token.stringVal()) :
 } catch (NumberFormatException ex) {
 // error already reported in scanner
 n = Float.NaN;
 }
 if (n.floatValue() == 0.0f && !isZero(proper))
-error(token.pos, "fp.number.too.small");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.FpNumberTooSmall);
 else if (n.floatValue() == Float.POSITIVE_INFINITY)
-error(token.pos, "fp.number.too.large");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.FpNumberTooLarge);
 else
 t = F.at(pos).Literal(TypeTag.FLOAT, n);
 break;
 }
 case DOUBLELITERAL: {
 } catch (NumberFormatException ex) {
 // error already reported in scanner
 n = Double.NaN;
 }
 if (n.doubleValue() == 0.0d && !isZero(proper))
-error(token.pos, "fp.number.too.small");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.FpNumberTooSmall);
 else if (n.doubleValue() == Double.POSITIVE_INFINITY)
-error(token.pos, "fp.number.too.large");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.FpNumberTooLarge);
 else
 t = F.at(pos).Literal(TypeTag.DOUBLE, n);
 break;
 }
 case CHARLITERAL:
 public JCExpression unannotatedType(boolean allowVar) {
 JCExpression result = term(TYPE);
 if (!allowVar && isRestrictedLocalVarTypeName(result)) {
-syntaxError(result.pos, "var.not.allowed.here");
+syntaxError(result.pos, Errors.VarNotAllowedHere);
 }
 return result;
 }
 args.append(parseExpression());
 }
 }
 accept(RPAREN);
 } else {
-syntaxError(token.pos, "expected", LPAREN);
+syntaxError(token.pos, Errors.Expected(LPAREN));
 }
 return args.toList();
 }
 JCMethodInvocation arguments(List<JCExpression> typeArgs, JCExpression t) {
 break;
 case GT:
 nextToken();
 break;
 default:
-args.append(syntaxError(token.pos, "expected", GT));
+args.append(syntaxError(token.pos, Errors.Expected(GT)));
 break;
 }
 return args.toList();
 }
 } else {
-return List.of(syntaxError(token.pos, "expected", LT));
+return List.of(syntaxError(token.pos, Errors.Expected(LT)));
 }
 }
 /**
 *  {@literal
 //error recovery
 TypeBoundKind t = F.at(Position.NOPOS).TypeBoundKind(BoundKind.UNBOUND);
 JCExpression wc = toP(F.at(pos).Wildcard(t, null));
 JCIdent id = toP(F.at(token.pos).Ident(ident()));
 JCErroneous err = F.at(pos).Erroneous(List.<JCTree>of(wc, id));
-reportSyntaxError(err, "expected3", GT, EXTENDS, SUPER);
+reportSyntaxError(err, Errors.Expected3(GT, EXTENDS, SUPER));
 result = err;
 } else {
 TypeBoundKind t = toP(F.at(pos).TypeBoundKind(BoundKind.UNBOUND));
 result = toP(F.at(pos).Wildcard(t, null));
 }
 Tag tag = t.getTag();
 // Type annotations are illegal on class literals. Annotated non array class literals
 // are complained about directly in term3(), Here check for type annotations on dimensions
 // taking care to handle some interior dimension(s) being annotated.
 if ((tag == TYPEARRAY && TreeInfo.containsTypeAnnotation(t)) || tag == ANNOTATED_TYPE)
-syntaxError("no.annotations.on.dot.class");
+syntaxError(token.pos, Errors.NoAnnotationsOnDotClass);
 t = toP(F.at(pos).Select(t, names._class));
 }
 } else if ((mode & TYPE) != 0) {
 if (token.kind != COLCOL) {
 mode = TYPE;
 }
 } else if (token.kind != COLCOL) {
-syntaxError(token.pos, "dot.class.expected");
+syntaxError(token.pos, Errors.DotClassExpected);
 }
 return t;
 }
 /**
 t = insertAnnotationsToMostInner(t, newAnnotations, false);
 }
 JCExpression e = arrayCreatorRest(newpos, t);
 if (diamondFound) {
-reportSyntaxError(lastTypeargsPos, "cannot.create.array.with.diamond");
+reportSyntaxError(lastTypeargsPos, Errors.CannotCreateArrayWithDiamond);
 return toP(F.at(newpos).Erroneous(List.of(e)));
 }
 else if (typeArgs != null) {
 int pos = newpos;
 if (!typeArgs.isEmpty() && typeArgs.head.pos != Position.NOPOS) {
 // modified to improve error recovery.
 pos = typeArgs.head.pos;
 }
 setErrorEndPos(S.prevToken().endPos);
 JCErroneous err = F.at(pos).Erroneous(typeArgs.prepend(e));
-reportSyntaxError(err, "cannot.create.array.with.type.arguments");
+reportSyntaxError(err, Errors.CannotCreateArrayWithTypeArguments);
 return toP(err);
 }
 return e;
 } else if (token.kind == LPAREN) {
 JCNewClass newClass = classCreatorRest(newpos, null, typeArgs, t);
 }
 }
 return newClass;
 } else {
 setErrorEndPos(token.pos);
-reportSyntaxError(token.pos, "expected2", LPAREN, LBRACKET);
+reportSyntaxError(token.pos, Errors.Expected2(LPAREN, LBRACKET));
 t = toP(F.at(newpos).NewClass(null, typeArgs, t, List.nil(), null));
 return toP(F.at(newpos).Erroneous(List.<JCTree>of(t)));
 }
 }
 na.elemtype = annotated.underlyingType;
 }
 return na;
 } else {
 JCExpression t = toP(F.at(newpos).NewArray(elemtype, List.nil(), null));
-return syntaxError(token.pos, List.of(t), "array.dimension.missing");
+return syntaxError(token.pos, List.of(t), Errors.ArrayDimensionMissing);
 }
 } else {
 ListBuffer<JCExpression> dims = new ListBuffer<>();
 // maintain array dimension type annotations
 JCNewArray na = toP(F.at(newpos).NewArray(elemtype, dims.toList(), elems));
 na.dimAnnotations = dimAnnotations.toList();
 if (elems != null) {
-return syntaxError(errpos, List.of(na), "illegal.array.creation.both.dimension.and.initialization");
+return syntaxError(errpos, List.of(na), Errors.IllegalArrayCreationBothDimensionAndInitialization);
 }
 return na;
 }
 }
 JCBlock block(int pos, long flags) {
 accept(LBRACE);
 List<JCStatement> stats = blockStatements();
 JCBlock t = F.at(pos).Block(flags, stats);
 while (token.kind == CASE || token.kind == DEFAULT) {
-syntaxError("orphaned", token.kind);
+syntaxError(token.pos, Errors.Orphaned(token.kind));
 switchBlockStatementGroups();
 }
 // the Block node has a field "endpos" for first char of last token, which is
 // usually but not necessarily the last char of the last token.
 t.endpos = token.pos;
 */
 JCStatement parseStatementAsBlock() {
 int pos = token.pos;
 List<JCStatement> stats = blockStatement();
 if (stats.isEmpty()) {
-JCErroneous e = syntaxError(pos, "illegal.start.of.stmt");
+JCErroneous e = syntaxError(pos, Errors.IllegalStartOfStmt);
 return toP(F.at(pos).Exec(e));
 } else {
 JCStatement first = stats.head;
-String error = null;
+Error error = null;
 switch (first.getTag()) {
 case CLASSDEF:
-error = "class.not.allowed";
+error = Errors.ClassNotAllowed;
 break;
 case VARDEF:
-error = "variable.not.allowed";
+error = Errors.VariableNotAllowed;
 break;
 }
 if (error != null) {
-error(first, error);
+log.error(DiagnosticFlag.SYNTAX, first, error);
 List<JCBlock> blist = List.of(F.at(first.pos).Block(0, stats));
 return toP(F.at(pos).Exec(F.at(first.pos).Erroneous(blist)));
 }
 return first;
 }
 case INTERFACE:
 case CLASS:
 Comment dc = token.comment(CommentStyle.JAVADOC);
 return List.of(classOrInterfaceOrEnumDeclaration(modifiersOpt(), dc));
 case ENUM:
-error(token.pos, "local.enum");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.LocalEnum);
 dc = token.comment(CommentStyle.JAVADOC);
 return List.of(classOrInterfaceOrEnumDeclaration(modifiersOpt(), dc));
 default:
 Token prevToken = token;
 JCExpression t = term(EXPR | TYPE);
 finalizer = block();
 }
 } else {
 if (resources.isEmpty()) {
 if (Feature.TRY_WITH_RESOURCES.allowedInSource(source)) {
-error(pos, "try.without.catch.finally.or.resource.decls");
+log.error(DiagnosticFlag.SYNTAX, pos, Errors.TryWithoutCatchFinallyOrResourceDecls);
 } else {
-error(pos, "try.without.catch.or.finally");
+log.error(DiagnosticFlag.SYNTAX, pos, Errors.TryWithoutCatchOrFinally);
 }
 }
 }
 return F.at(pos).Try(resources, body, catchers.toList(), finalizer);
 }
 nextToken();
 return toP(F.at(pos).Skip());
 case ELSE:
 int elsePos = token.pos;
 nextToken();
-return doRecover(elsePos, BasicErrorRecoveryAction.BLOCK_STMT, "else.without.if");
+return doRecover(elsePos, BasicErrorRecoveryAction.BLOCK_STMT, Errors.ElseWithoutIf);
 case FINALLY:
 int finallyPos = token.pos;
 nextToken();
-return doRecover(finallyPos, BasicErrorRecoveryAction.BLOCK_STMT, "finally.without.try");
+return doRecover(finallyPos, BasicErrorRecoveryAction.BLOCK_STMT, Errors.FinallyWithoutTry);
 case CATCH:
-return doRecover(token.pos, BasicErrorRecoveryAction.CATCH_CLAUSE, "catch.without.try");
+return doRecover(token.pos, BasicErrorRecoveryAction.CATCH_CLAUSE, Errors.CatchWithoutTry);
 case ASSERT: {
 nextToken();
 JCExpression assertion = parseExpression();
 JCExpression message = null;
 if (token.kind == COLON) {
 @Override
 public JCStatement parseStatement() {
 return parseStatementAsBlock();
 }
-private JCStatement doRecover(int startPos, ErrorRecoveryAction action, String key) {
+private JCStatement doRecover(int startPos, ErrorRecoveryAction action, Error errorKey) {
 int errPos = S.errPos();
 JCTree stm = action.doRecover(this);
 S.errPos(errPos);
-return toP(F.Exec(syntaxError(startPos, List.of(stm), key)));
+return toP(F.Exec(syntaxError(startPos, List.of(stm), errorKey)));
 }
 /** CatchClause     = CATCH "(" FormalParameter ")" Block
 * TODO: the "FormalParameter" is not correct, it uses the special "catchTypes" rule below.
 */
 break;
 case RBRACE: case EOF:
 return cases.toList();
 default:
 nextToken(); // to ensure progress
-syntaxError(pos, "expected3",
+syntaxError(pos, Errors.Expected3(CASE, DEFAULT, RBRACE));
-CASE, DEFAULT, RBRACE);
 }
 }
 }
 protected JCCase switchBlockStatementGroup() {
 } else {
 JCExpression t = term(EXPR | TYPE);
 if ((lastmode & TYPE) != 0 && LAX_IDENTIFIER.accepts(token.kind)) {
 return variableDeclarators(modifiersOpt(), t, stats, true).toList();
 } else if ((lastmode & TYPE) != 0 && token.kind == COLON) {
-error(pos, "bad.initializer", "for-loop");
+log.error(DiagnosticFlag.SYNTAX, pos, Errors.BadInitializer("for-loop"));
 return List.of((JCStatement)F.at(pos).VarDef(null, null, t, null));
 } else {
 return moreStatementExpressions(pos, t, stats).toList();
 }
 }
 case MONKEYS_AT  : flag = Flags.ANNOTATION; break;
 case DEFAULT     : checkSourceLevel(Feature.DEFAULT_METHODS); flag = Flags.DEFAULT; break;
 case ERROR       : flag = 0; nextToken(); break;
 default: break loop;
 }
-if ((flags & flag) != 0) error(token.pos, "repeated.modifier");
+if ((flags & flag) != 0) log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.RepeatedModifier);
 lastPos = token.pos;
 nextToken();
 if (flag == Flags.ANNOTATION) {
 if (token.kind != INTERFACE) {
 JCAnnotation ann = annotation(lastPos, Tag.ANNOTATION);
 JCVariableDecl head = variableDeclaratorRest(pos, mods, type, name, reqInit, dc, localDecl);
 boolean implicit = Feature.LOCAL_VARIABLE_TYPE_INFERENCE.allowedInSource(source) && head.vartype == null;
 vdefs.append(head);
 while (token.kind == COMMA) {
 if (implicit) {
-reportSyntaxError(pos, "var.not.allowed.compound");
+reportSyntaxError(pos, Errors.VarNotAllowedCompound);
 }
 // All but last of multiple declarators subsume a comma
 storeEnd((JCTree)vdefs.last(), token.endPos);
 nextToken();
 vdefs.append(variableDeclarator(mods, type, reqInit, dc, localDecl));
 JCExpression init = null;
 if (token.kind == EQ) {
 nextToken();
 init = variableInitializer();
 }
-else if (reqInit) syntaxError(token.pos, "expected", EQ);
+else if (reqInit) syntaxError(token.pos, Errors.Expected(EQ));
 JCTree elemType = TreeInfo.innermostType(type, true);
 int startPos = Position.NOPOS;
 if (Feature.LOCAL_VARIABLE_TYPE_INFERENCE.allowedInSource(source) && elemType.hasTag(IDENT)) {
 Name typeName = ((JCIdent)elemType).name;
 if (isRestrictedLocalVarTypeName(typeName)) {
 if (type.hasTag(TYPEARRAY)) {
 //error - 'var' and arrays
-reportSyntaxError(pos, "var.not.allowed.array");
+reportSyntaxError(pos, Errors.VarNotAllowedArray);
 } else {
 startPos = TreeInfo.getStartPos(mods);
 if (startPos == Position.NOPOS)
 startPos = TreeInfo.getStartPos(type);
 //implicit type
 }
 defs.append(moduleDecl(mods, kind, docComment));
 consumedToplevelDoc = true;
 break;
 } else if (kind != ModuleKind.STRONG) {
-reportSyntaxError(token.pos, "expected.module");
+reportSyntaxError(token.pos, Errors.ExpectedModule);
 }
 }
 JCTree def = typeDeclaration(mods, docComment);
 if (def instanceof JCExpressionStatement)
 def = ((JCExpressionStatement)def).expr;
 } else {
 break loop;
 }
 case STATIC:
 if (isStaticPhase) {
-error(token.pos, "repeated.modifier");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.RepeatedModifier);
 }
 isStaticPhase = true;
 break;
 default:
 break loop;
 nextToken();
 List<JCExpression> implNames = qualidentList(false);
 accept(SEMI);
 defs.append(toP(F.at(pos).Provides(serviceName, implNames)));
 } else {
-error(token.pos, "expected", "'" + names.with + "'");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.ExpectedStr("'" + names.with + "'"));
 skip(false, false, false, false);
 }
 } else if (token.name() == names.uses) {
 nextToken();
 JCExpression service = qualident(false);
 accept(SEMI);
 defs.append(toP(F.at(pos).Uses(service)));
 } else {
 setErrorEndPos(pos);
-reportSyntaxError(pos, "invalid.module.directive");
+reportSyntaxError(pos, Errors.InvalidModuleDirective);
 break;
 }
 }
 return defs.toList();
 }
 } else {
 errs = List.of(mods);
 }
 final JCErroneous erroneousTree;
 if (parseModuleInfo) {
-erroneousTree = syntaxError(pos, errs, "expected.module.or.open");
+erroneousTree = syntaxError(pos, errs, Errors.ExpectedModuleOrOpen);
 } else {
-erroneousTree = syntaxError(pos, errs, "expected3", CLASS, INTERFACE, ENUM);
+erroneousTree = syntaxError(pos, errs, Errors.Expected3(CLASS, INTERFACE, ENUM));
 }
 return toP(F.Exec(erroneousTree));
 }
 }
 Name typeName() {
 int pos = token.pos;
 Name name = ident();
 if (name == names.var) {
 if (Feature.LOCAL_VARIABLE_TYPE_INFERENCE.allowedInSource(source)) {
-reportSyntaxError(pos, "var.not.allowed", name);
+reportSyntaxError(pos, Errors.VarNotAllowed(name));
 } else {
-warning(pos, "var.not.allowed");
+log.warning(pos, Warnings.VarNotAllowed);
 }
 }
 return name;
 }
 nextToken();
 if (token.kind == RBRACE || token.kind == SEMI) break;
 defs.append(enumeratorDeclaration(enumName));
 }
 if (token.kind != SEMI && token.kind != RBRACE) {
-defs.append(syntaxError(token.pos, "expected3",
+defs.append(syntaxError(token.pos, Errors.Expected3(COMMA, RBRACE, SEMI)));
-COMMA, RBRACE, SEMI));
 nextToken();
 }
 }
 if (token.kind == SEMI) {
 nextToken();
 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");
+log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.InitializerNotAllowed);
 }
 return List.of(block(pos, mods.flags));
 } else {
 pos = token.pos;
 List<JCTypeParameter> typarams = typeParametersOpt();
 // method returns types are un-annotated types
 type = unannotatedType(false);
 }
 if (token.kind == LPAREN && !isInterface && type.hasTag(IDENT)) {
 if (isInterface || tk.name() != className)
-error(pos, "invalid.meth.decl.ret.type.req");
+log.error(DiagnosticFlag.SYNTAX, pos, Errors.InvalidMethDeclRetTypeReq);
 else if (annosAfterParams.nonEmpty())
 illegal(annosAfterParams.head.pos);
 return List.of(methodDeclaratorRest(
 pos, mods, null, names.init, typarams,
 isInterface, true, dc));
 pos = token.pos;
 List<JCTree> err = isVoid
 ? List.of(toP(F.at(pos).MethodDef(mods, name, type, typarams,
 List.nil(), List.nil(), null, null)))
 : null;
-return List.of(syntaxError(token.pos, err, "expected", LPAREN));
+return List.of(syntaxError(token.pos, err, Errors.Expected(LPAREN)));
 }
 }
 }
 }
 }
 params.append(lastParam);
 }
 this.allowThisIdent = false;
 while (token.kind == COMMA) {
 if ((lastParam.mods.flags & Flags.VARARGS) != 0) {
-error(lastParam, "varargs.must.be.last");
+log.error(DiagnosticFlag.SYNTAX, lastParam, Errors.VarargsMustBeLast);
 }
 nextToken();
 params.append(lastParam = formalParameter(lambdaParameters));
 }
 }
 if (token.kind == RPAREN) {
 nextToken();
 } else {
 setErrorEndPos(token.pos);
-reportSyntaxError(S.prevToken().endPos, "expected3", COMMA, RPAREN, LBRACKET);
+reportSyntaxError(S.prevToken().endPos, Errors.Expected3(COMMA, RPAREN, LBRACKET));
 }
 return params.toList();
 }
 List<JCVariableDecl> implicitParameters(boolean hasParens) {
 type = insertAnnotationsToMostInner(type, varargsAnnos, true);
 nextToken();
 } else {
 // if not a var arg, then typeAnnotationsPushedBack should be null
 if (typeAnnotationsPushedBack.nonEmpty()) {
-reportSyntaxError(typeAnnotationsPushedBack.head.pos,
+reportSyntaxError(typeAnnotationsPushedBack.head.pos, Errors.IllegalStartOfType);
-"illegal.start.of.type");
 }
 typeAnnotationsPushedBack = List.nil();
 }
 return variableDeclaratorId(mods, type, lambdaParameter);
 }
 JCModifiers mods = F.at(token.pos).Modifiers(Flags.PARAMETER);
 return variableDeclaratorId(mods, null, true);
 }
 /* ---------- auxiliary methods -------------- */
-void error(int pos, String key, Object ... args) {
-log.error(DiagnosticFlag.SYNTAX, pos, key, args);
-}
-void error(DiagnosticPosition pos, String key, Object ... args) {
-log.error(DiagnosticFlag.SYNTAX, pos, key, args);
-}
-void warning(int pos, String key, Object ... args) {
-log.warning(pos, key, args);
-}
 /** Check that given tree is a legal expression statement.
 */
 protected JCExpression checkExprStat(JCExpression t) {
 if (!TreeInfo.isExpressionStatement(t)) {
 JCExpression ret = F.at(t.pos).Erroneous(List.<JCTree>of(t));
-error(ret, "not.stmt");
+log.error(DiagnosticFlag.SYNTAX, ret, Errors.NotStmt);
 return ret;
 } else {
 return t;
 }
 }

changeset 48721	ef3557eb4306
parent 48551	9cf44c40aa35
child 48920	916690b5edc9