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

equal deleted inserted replaced

-:6dcbdc9f99fc
+:702043a4cdeb
 */
 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.*;
+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.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.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(); // prime the pump
 this.F = fac.F;
 this.log = fac.log;
 this.names = fac.names;
 this.source = fac.source;
-this.allowTWR = source.allowTryWithResources();
-this.allowEffectivelyFinalVariablesInTWR =
-source.allowEffectivelyFinalVariablesInTryWithResources();
-this.allowDiamond = source.allowDiamond();
-this.allowMulticatch = source.allowMulticatch();
 this.allowStringFolding = fac.options.getBoolean("allowStringFolding", true);
-this.allowLambda = source.allowLambda();
-this.allowMethodReferences = source.allowMethodReferences();
-this.allowDefaultMethods = source.allowDefaultMethods();
-this.allowStaticInterfaceMethods = source.allowStaticInterfaceMethods();
-this.allowIntersectionTypesInCast = source.allowIntersectionTypesInCast();
-this.allowTypeAnnotations = source.allowTypeAnnotations();
-this.allowModules = source.allowModules();
-this.allowAnnotationsAfterTypeParams = source.allowAnnotationsAfterTypeParams();
-this.allowUnderscoreIdentifier = source.allowUnderscoreIdentifier();
-this.allowPrivateInterfaceMethods = source.allowPrivateInterfaceMethods();
-this.allowLocalVariableTypeInference = source.allowLocalVariableTypeInference();
 this.keepDocComments = keepDocComments;
 this.parseModuleInfo = parseModuleInfo;
 docComments = newDocCommentTable(keepDocComments, fac);
 this.keepLineMap = keepLineMap;
 this.errorTree = F.Erroneous();
 protected DocCommentTable newDocCommentTable(boolean keepDocComments, ParserFactory fac) {
 return keepDocComments ? new LazyDocCommentTable(fac) : null;
 }
-/** Switch: Should diamond operator be recognized?
-*/
-boolean allowDiamond;
-/** Switch: Should multicatch clause be accepted?
-*/
-boolean allowMulticatch;
-/** Switch: should we recognize try-with-resources?
-*/
-boolean allowTWR;
-/** Switch: should we allow (effectively) final variables as resources in try-with-resources?
-*/
-boolean allowEffectivelyFinalVariablesInTWR;
 /** Switch: should we fold strings?
 */
 boolean allowStringFolding;
-/** Switch: should we recognize lambda expressions?
-*/
-boolean allowLambda;
-/** Switch: should we allow method/constructor references?
-*/
-boolean allowMethodReferences;
-/** Switch: should we recognize modules?
-*/
-boolean allowModules;
-/** Switch: should we allow default methods in interfaces?
-*/
-boolean allowDefaultMethods;
-/** Switch: should we allow static methods in interfaces?
-*/
-boolean allowStaticInterfaceMethods;
-/** Switch: should we allow private (instance) methods in interfaces?
-*/
-boolean allowPrivateInterfaceMethods;
-/** Switch: should we allow intersection types in cast?
-*/
-boolean allowIntersectionTypesInCast;
 /** Switch: should we keep docComments?
 */
 boolean keepDocComments;
 /** Switch: should we keep line table?
 */
 boolean keepLineMap;
-/** Switch: should we recognize type annotations?
-*/
-boolean allowTypeAnnotations;
-/** Switch: should we allow annotations after the method type parameters?
-*/
-boolean allowAnnotationsAfterTypeParams;
-/** Switch: should we allow '_' as an identifier?
-*/
-boolean allowUnderscoreIdentifier;
 /** Switch: is "this" allowed as an identifier?
 * This is needed to parse receiver types.
 */
 boolean allowThisIdent;
-/** Switch: is local variable inference allowed?
-*/
-boolean allowLocalVariableTypeInference;
 /** The type of the method receiver, as specified by a first "this" parameter.
 */
 JCVariableDecl receiverParam;
 nextToken();
 return names.error;
 } else if (token.kind == THIS) {
 if (allowThisIdent) {
 // Make sure we're using a supported source version.
-checkTypeAnnotations();
+checkSourceLevel(Feature.TYPE_ANNOTATIONS);
 Name name = token.name();
 nextToken();
 return name;
 } else {
 error(token.pos, "this.as.identifier");
 nextToken();
 return names.error;
 }
 } else if (token.kind == UNDERSCORE) {
-if (allowUnderscoreIdentifier) {
+if (Feature.UNDERSCORE_IDENTIFIER.allowedInSource(source)) {
 warning(token.pos, "underscore.as.identifier");
 } else {
 error(token.pos, "underscore.as.identifier");
 }
 Name name = token.name();
 accept(LPAREN);
 mode = TYPE;
 int pos1 = pos;
 List<JCExpression> targets = List.of(t = parseType());
 while (token.kind == AMP) {
-checkIntersectionTypesInCast();
+checkSourceLevel(Feature.INTERSECTION_TYPES_IN_CAST);
 accept(AMP);
 targets = targets.prepend(parseType());
 }
 if (targets.length() > 1) {
 t = toP(F.at(pos1).TypeIntersection(targets.reverse()));
 return lambdaExpressionOrStatementRest(params, pos);
 }
 JCExpression lambdaExpressionOrStatementRest(List<JCVariableDecl> args, int pos) {
-checkLambda();
+checkSourceLevel(Feature.LAMBDA);
 accept(ARROW);
 return token.kind == LBRACE ?
 lambdaStatement(args, pos, token.pos) :
 lambdaExpression(args, pos);
 */
 List<JCExpression> typeArguments(boolean diamondAllowed) {
 if (token.kind == LT) {
 nextToken();
 if (token.kind == GT && diamondAllowed) {
-checkDiamond();
+checkSourceLevel(Feature.DIAMOND);
 mode |= DIAMOND;
 nextToken();
 return List.nil();
 } else {
 ListBuffer<JCExpression> args = new ListBuffer<>();
 accept(COLCOL);
 return memberReferenceSuffix(pos1, t);
 }
 JCExpression memberReferenceSuffix(int pos1, JCExpression t) {
-checkMethodReferences();
+checkSourceLevel(Feature.METHOD_REFERENCES);
 mode = EXPR;
 List<JCExpression> typeArgs = null;
 if (token.kind == LT) {
 typeArgs = typeArguments(false);
 }
 }
 case TRY: {
 nextToken();
 List<JCTree> resources = List.nil();
 if (token.kind == LPAREN) {
-checkTryWithResources();
+checkSourceLevel(Feature.TRY_WITH_RESOURCES);
 nextToken();
 resources = resources();
 accept(RPAREN);
 }
 JCBlock body = block();
 nextToken();
 finalizer = block();
 }
 } else {
 if (resources.isEmpty()) {
-if (allowTWR) {
+if (Feature.TRY_WITH_RESOURCES.allowedInSource(source)) {
 error(pos, "try.without.catch.finally.or.resource.decls");
 } else {
 error(pos, "try.without.catch.or.finally");
 }
 }
 List<JCExpression> catchTypes() {
 ListBuffer<JCExpression> catchTypes = new ListBuffer<>();
 catchTypes.add(parseType());
 while (token.kind == BAR) {
-checkMulticatch();
+checkSourceLevel(Feature.MULTICATCH);
 nextToken();
 // Instead of qualident this is now parseType.
 // But would that allow too much, e.g. arrays or generics?
 catchTypes.add(parseType());
 }
 case NATIVE      : flag = Flags.NATIVE; break;
 case VOLATILE    : flag = Flags.VOLATILE; break;
 case SYNCHRONIZED: flag = Flags.SYNCHRONIZED; break;
 case STRICTFP    : flag = Flags.STRICTFP; break;
 case MONKEYS_AT  : flag = Flags.ANNOTATION; break;
-case DEFAULT     : checkDefaultMethods(); flag = Flags.DEFAULT; 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");
 lastPos = token.pos;
 * @param kind Whether to parse an ANNOTATION or TYPE_ANNOTATION
 */
 JCAnnotation annotation(int pos, Tag kind) {
 // accept(AT); // AT consumed by caller
 if (kind == Tag.TYPE_ANNOTATION) {
-checkTypeAnnotations();
+checkSourceLevel(Feature.TYPE_ANNOTATIONS);
 }
 JCTree ident = qualident(false);
 List<JCExpression> fieldValues = annotationFieldValuesOpt();
 JCAnnotation ann;
 if (kind == Tag.ANNOTATION) {
 Comment dc,
 T vdefs,
 boolean localDecl)
 {
 JCVariableDecl head = variableDeclaratorRest(pos, mods, type, name, reqInit, dc, localDecl);
-boolean implicit = allowLocalVariableTypeInference && head.vartype == null;
+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");
 }
 init = variableInitializer();
 }
 else if (reqInit) syntaxError(token.pos, "expected", EQ);
 JCTree elemType = TreeInfo.innermostType(type, true);
 int startPos = Position.NOPOS;
-if (allowLocalVariableTypeInference && elemType.hasTag(IDENT)) {
+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");
 return false;
 }
 }
 boolean isRestrictedLocalVarTypeName(Name name) {
-return allowLocalVariableTypeInference && name == names.var;
+return Feature.LOCAL_VARIABLE_TYPE_INFERENCE.allowedInSource(source) && name == names.var;
 }
 /** VariableDeclaratorId = Ident BracketsOpt
 */
 JCVariableDecl variableDeclaratorId(JCModifiers mods, JCExpression type) {
 JCExpression t = term(EXPR | TYPE);
 if ((lastmode & TYPE) != 0 && LAX_IDENTIFIER.accepts(token.kind)) {
 JCModifiers mods = toP(F.at(startPos).Modifiers(Flags.FINAL));
 return variableDeclaratorRest(token.pos, mods, t, ident(), true, null, true);
 } else {
-checkVariableInTryWithResources(startPos);
+checkSourceLevel(Feature.EFFECTIVELY_FINAL_VARIABLES_IN_TRY_WITH_RESOURCES);
 if (!t.hasTag(IDENT) && !t.hasTag(SELECT)) {
 log.error(t.pos(), Errors.TryWithResourcesExprNeedsVar);
 }
 return t;
 return toplevel;
 }
 JCModuleDecl moduleDecl(JCModifiers mods, ModuleKind kind, Comment dc) {
 int pos = token.pos;
-if (!allowModules) {
+checkSourceLevel(Feature.MODULES);
-log.error(pos, Errors.ModulesNotSupportedInSource(source.name));
-allowModules = true;
-}
 nextToken();
 JCExpression name = qualident(false);
 List<JCDirective> directives = null;
 storeEnd(mods, pos);
 }
 List<JCAnnotation> annosAfterParams = annotationsOpt(Tag.ANNOTATION);
 if (annosAfterParams.nonEmpty()) {
-checkAnnotationsAfterTypeParams(annosAfterParams.head.pos);
+checkSourceLevel(annosAfterParams.head.pos, Feature.ANNOTATIONS_AFTER_TYPE_PARAMS);
 mods.annotations = mods.annotations.appendList(annosAfterParams);
 if (mods.pos == Position.NOPOS)
 mods.pos = mods.annotations.head.pos;
 }
 List<JCTypeParameter> typarams,
 boolean isInterface, boolean isVoid,
 Comment dc) {
 if (isInterface) {
 if ((mods.flags & Flags.STATIC) != 0) {
-checkStaticInterfaceMethods();
+checkSourceLevel(Feature.STATIC_INTERFACE_METHODS);
 }
 if ((mods.flags & Flags.PRIVATE) != 0) {
-checkPrivateInterfaceMethods();
+checkSourceLevel(Feature.PRIVATE_INTERFACE_METHODS);
 }
 }
 JCVariableDecl prevReceiverParam = this.receiverParam;
 try {
 this.receiverParam = null;
 default:
 return TypeTag.NONE;
 }
 }
-void checkDiamond() {
+void checkSourceLevel(Feature feature) {
-if (!allowDiamond) {
+checkSourceLevel(token.pos, feature);
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, Errors.DiamondNotSupportedInSource(source.name));
+}
-}
-}
+protected void checkSourceLevel(int pos, Feature feature) {
-void checkMulticatch() {
+if (!feature.allowedInSource(source)) {
-if (!allowMulticatch) {
+log.error(DiagnosticFlag.SOURCE_LEVEL, pos, feature.error(source.name));
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, Errors.MulticatchNotSupportedInSource(source.name));
-}
-}
-void checkTryWithResources() {
-if (!allowTWR) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, Errors.TryWithResourcesNotSupportedInSource(source.name));
-}
-}
-void checkVariableInTryWithResources(int startPos) {
-if (!allowEffectivelyFinalVariablesInTWR) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, startPos, Errors.VarInTryWithResourcesNotSupportedInSource(source.name));
-}
-}
-void checkLambda() {
-if (!allowLambda) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, Errors.LambdaNotSupportedInSource(source.name));
-}
-}
-void checkMethodReferences() {
-if (!allowMethodReferences) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, Errors.MethodReferencesNotSupportedInSource(source.name));
-}
-}
-void checkDefaultMethods() {
-if (!allowDefaultMethods) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, Errors.DefaultMethodsNotSupportedInSource(source.name));
-}
-}
-void checkIntersectionTypesInCast() {
-if (!allowIntersectionTypesInCast) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, Errors.IntersectionTypesInCastNotSupportedInSource(source.name));
-}
-}
-void checkStaticInterfaceMethods() {
-if (!allowStaticInterfaceMethods) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, Errors.StaticIntfMethodsNotSupportedInSource(source.name));
-}
-}
-void checkTypeAnnotations() {
-if (!allowTypeAnnotations) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, Errors.TypeAnnotationsNotSupportedInSource(source.name));
-}
-}
-void checkPrivateInterfaceMethods() {
-if (!allowPrivateInterfaceMethods) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, token.pos, CompilerProperties.Errors.PrivateIntfMethodsNotSupportedInSource(source.name));
-}
-}
-protected void checkAnnotationsAfterTypeParams(int pos) {
-if (!allowAnnotationsAfterTypeParams) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, pos, Errors.AnnotationsAfterTypeParamsNotSupportedInSource(source.name));
 }
 }
 /*
 * a functional source tree and end position mappings

changeset 48054	702043a4cdeb
parent 47936	3b1ef48862cf
child 48551	9cf44c40aa35