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

equal deleted inserted replaced

-:b2bba53b079d
+:02404e27d356
 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 com.sun.tools.javac.util.JCDiagnostic.Fragment;
 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;
 import static com.sun.tools.javac.parser.Tokens.TokenKind.CATCH;
 private JCErroneous errorTree;
 /** Skip forward until a suitable stop token is found.
 */
-protected void skip(boolean stopAtImport, boolean stopAtMemberDecl, boolean stopAtIdentifier, boolean stopAtStatement, boolean stopAtLambdaBody) {
+protected void skip(boolean stopAtImport, boolean stopAtMemberDecl, boolean stopAtIdentifier, boolean stopAtStatement) {
 while (true) {
 switch (token.kind) {
-case ARROW:
-if (stopAtLambdaBody) {
-//find end of lambda expression; this could be either a comma or an rparen (if in method context),
-//or a semi colon (if in assignment context).
-int depth = 0;
-while (true) {
-switch (token.kind) {
-case EOF:
-case LBRACE: depth++; break;
-case RBRACE: depth--; break;
-case COMMA:
-case RPAREN:
-case SEMI:
-if (depth == 0) {
-return;
-}
-break;
-}
-nextToken();
-}
-}
-break;
 case SEMI:
 nextToken();
 return;
 case PUBLIC:
 case FINAL:
 }
 } else return illegal();
 break;
 case LPAREN:
 if (typeArgs == null && (mode & EXPR) != 0) {
-LambdaClassfier lambdaClassifier = new LambdaClassfier();
+ParensResult pres = analyzeParens();
-ParensResult pres = analyzeParens(lambdaClassifier);
 switch (pres) {
 case CAST:
 accept(LPAREN);
 mode = TYPE;
 int pos1 = pos;
 }
 accept(RPAREN);
 mode = EXPR;
 JCExpression t1 = term3();
 return F.at(pos).TypeCast(t, t1);
-case BAD_LAMBDA:
-Assert.checkNonNull(lambdaClassifier.diagFragment);
-t = syntaxError(pos, List.nil(), Errors.InvalidLambdaParameterDeclaration(lambdaClassifier.diagFragment));
-skip(false, false, false, false, true);
-break;
 case IMPLICIT_LAMBDA:
 case EXPLICIT_LAMBDA:
-case IMPLICIT_LAMBDA_ALL_VAR:
+t = lambdaExpressionOrStatement(true, pres == ParensResult.EXPLICIT_LAMBDA, pos);
-t = lambdaExpressionOrStatement(true, pres != ParensResult.IMPLICIT_LAMBDA, pos);
 break;
 default: //PARENS
 accept(LPAREN);
 mode = EXPR;
 t = termRest(term1Rest(term2Rest(term3(), TreeInfo.orPrec)));
 * If we see an identifier followed by a '&lt;' it could be an unbound
 * method reference or a binary expression. To disambiguate, look for a
 * matching '&gt;' and see if the subsequent terminal is either '.' or '::'.
 */
 @SuppressWarnings("fallthrough")
-ParensResult analyzeParens(LambdaClassfier lambdaClassifier) {
+ParensResult analyzeParens() {
 int depth = 0;
 boolean type = false;
 outer: for (int lookahead = 0 ; ; lookahead++) {
-Token lookaheadToken = S.token(lookahead);
+TokenKind tk = S.token(lookahead).kind;
-TokenKind tk = lookaheadToken.kind;
 switch (tk) {
 case COMMA:
 type = true;
-break;
+case EXTENDS: case SUPER: case DOT: case AMP:
-case FINAL: case EXTENDS: case SUPER: case DOT: case AMP:
 //skip
 break;
 case QUES:
 if (peekToken(lookahead, EXTENDS) ||
 peekToken(lookahead, SUPER)) {
 if (peekToken(lookahead, RPAREN)) {
 //Type, ')' -> cast
 return ParensResult.CAST;
 } else if (peekToken(lookahead, LAX_IDENTIFIER)) {
 //Type, Identifier/'_'/'assert'/'enum' -> explicit lambda
-lambdaClassifier.addExplicitParameter();
+return ParensResult.EXPLICIT_LAMBDA;
-lookahead++; //skip Identifier
 }
 break;
 case LPAREN:
 if (lookahead != 0) {
 // '(' in a non-starting position -> parens
 // '(', ')' -> explicit lambda
 return ParensResult.EXPLICIT_LAMBDA;
 }
 break;
 case RPAREN:
-if (peekToken(lookahead, ARROW)) {
+// if we have seen something that looks like a type,
-//this is a lambda
+// then it's a cast expression
-return lambdaClassifier.result();
+if (type) return ParensResult.CAST;
-} else {
+// otherwise, disambiguate cast vs. parenthesized expression
-// if we have seen something that looks like a type,
+// based on subsequent token.
-// then it's a cast expression
+switch (S.token(lookahead + 1).kind) {
-if (type) return ParensResult.CAST;
+/*case PLUSPLUS: case SUBSUB: */
-// otherwise, disambiguate cast vs. parenthesized expression
+case BANG: case TILDE:
-// based on subsequent token.
+case LPAREN: case THIS: case SUPER:
-switch (S.token(lookahead + 1).kind) {
+case INTLITERAL: case LONGLITERAL: case FLOATLITERAL:
-/*case PLUSPLUS: case SUBSUB: */
+case DOUBLELITERAL: case CHARLITERAL: case STRINGLITERAL:
-case BANG: case TILDE:
+case TRUE: case FALSE: case NULL:
-case LPAREN: case THIS: case SUPER:
+case NEW: case IDENTIFIER: case ASSERT: case ENUM: case UNDERSCORE:
-case INTLITERAL: case LONGLITERAL: case FLOATLITERAL:
+case BYTE: case SHORT: case CHAR: case INT:
-case DOUBLELITERAL: case CHARLITERAL: case STRINGLITERAL:
+case LONG: case FLOAT: case DOUBLE: case BOOLEAN: case VOID:
-case TRUE: case FALSE: case NULL:
+return ParensResult.CAST;
-case NEW: case IDENTIFIER: case ASSERT: case ENUM: case UNDERSCORE:
+default:
-case BYTE: case SHORT: case CHAR: case INT:
+return ParensResult.PARENS;
-case LONG: case FLOAT: case DOUBLE: case BOOLEAN: case VOID:
-return ParensResult.CAST;
-default:
-return ParensResult.PARENS;
-}
 }
 case UNDERSCORE:
 case ASSERT:
 case ENUM:
 case IDENTIFIER:
 if (peekToken(lookahead, LAX_IDENTIFIER)) {
 // Identifier, Identifier/'_'/'assert'/'enum' -> explicit lambda
-if (Feature.LOCAL_VARIABLE_TYPE_INFERENCE.allowedInSource(source) &&
+return ParensResult.EXPLICIT_LAMBDA;
-lookaheadToken.name() == names.var) {
+} else if (peekToken(lookahead, RPAREN, ARROW)) {
-lambdaClassifier.addImplicitVarParameter();
+// Identifier, ')' '->' -> implicit lambda
-} else {
+return ParensResult.IMPLICIT_LAMBDA;
-lambdaClassifier.addExplicitParameter();
-}
-lookahead++; //skip Identifier
-} else if ((!type && peekToken(lookahead, COMMA)) || peekToken(lookahead, RPAREN)) {
-lambdaClassifier.addImplicitParameter();
 }
 type = false;
 break;
+case FINAL:
 case ELLIPSIS:
-//those can only appear in explicit, non-var, lambdas
+//those can only appear in explicit lambdas
-lambdaClassifier.addExplicitParameter();
+return ParensResult.EXPLICIT_LAMBDA;
-lookahead++; //skip Identifier
-break;
 case MONKEYS_AT:
 type = true;
 lookahead += 1; //skip '@'
 while (peekToken(lookahead, DOT)) {
 lookahead += 2;
 }
 break;
 case LBRACKET:
 if (peekToken(lookahead, RBRACKET, LAX_IDENTIFIER)) {
 // '[', ']', Identifier/'_'/'assert'/'enum' -> explicit lambda
-lambdaClassifier.addExplicitParameter();
+return ParensResult.EXPLICIT_LAMBDA;
-lookahead += 2; //skip ']' Identifier
-break;
 } else if (peekToken(lookahead, RBRACKET, RPAREN) ||
 peekToken(lookahead, RBRACKET, AMP)) {
 // '[', ']', ')' -> cast
 // '[', ']', '&' -> cast (intersection type)
 return ParensResult.CAST;
 peekToken(lookahead, AMP)) {
 // '>', ')' -> cast
 // '>', '&' -> cast
 return ParensResult.CAST;
 } else if (peekToken(lookahead, LAX_IDENTIFIER, COMMA) ||
-peekToken(lookahead, LAX_IDENTIFIER, RPAREN, ARROW)) {
+peekToken(lookahead, LAX_IDENTIFIER, RPAREN, ARROW) ||
+peekToken(lookahead, ELLIPSIS)) {
 // '>', Identifier/'_'/'assert'/'enum', ',' -> explicit lambda
 // '>', Identifier/'_'/'assert'/'enum', ')', '->' -> explicit lambda
-lambdaClassifier.addExplicitParameter();
-lookahead++; //skip Identifier
-break;
-} else if (peekToken(lookahead, ELLIPSIS)) {
 // '>', '...' -> explicit lambda
-break; //this is handled in the outer switch
+return ParensResult.EXPLICIT_LAMBDA;
 }
 //it looks a type, but could still be (i) a cast to generic type,
 //(ii) an unbound method reference or (iii) an explicit lambda
 type = true;
 break;
 return ParensResult.PARENS;
 }
 }
 }
-class LambdaClassfier {
-ParensResult kind;
-Fragment diagFragment;
-void addExplicitParameter() {
-reduce(ParensResult.EXPLICIT_LAMBDA);
-}
-void addImplicitVarParameter() {
-reduce(ParensResult.IMPLICIT_LAMBDA_ALL_VAR);
-}
-void addImplicitParameter() {
-reduce(ParensResult.IMPLICIT_LAMBDA);
-}
-private void reduce(ParensResult newKind) {
-if (kind == null) {
-kind = newKind;
-} else if (kind != newKind && kind != ParensResult.BAD_LAMBDA) {
-ParensResult currentKind = kind;
-kind = ParensResult.BAD_LAMBDA;
-switch (currentKind) {
-case EXPLICIT_LAMBDA:
-if (newKind == ParensResult.IMPLICIT_LAMBDA) {
-diagFragment = Fragments.ImplicitAndExplicitNotAllowed;
-} else if (newKind == ParensResult.IMPLICIT_LAMBDA_ALL_VAR) {
-diagFragment = Fragments.VarAndExplicitNotAllowed;
-}
-break;
-case IMPLICIT_LAMBDA:
-if (newKind == ParensResult.EXPLICIT_LAMBDA) {
-diagFragment = Fragments.ImplicitAndExplicitNotAllowed;
-} else if (newKind == ParensResult.IMPLICIT_LAMBDA_ALL_VAR) {
-diagFragment = Fragments.VarAndImplicitNotAllowed;
-}
-break;
-case IMPLICIT_LAMBDA_ALL_VAR:
-if (newKind == ParensResult.EXPLICIT_LAMBDA) {
-diagFragment = Fragments.VarAndExplicitNotAllowed;
-} else if (newKind == ParensResult.IMPLICIT_LAMBDA) {
-diagFragment = Fragments.VarAndImplicitNotAllowed;
-}
-break;
-default:
-throw new AssertionError("unexpected option for field kind");
-}
-}
-}
-ParensResult result() {
-return kind;
-}
-}
 /** Accepts all identifier-like tokens */
 protected Filter<TokenKind> LAX_IDENTIFIER = t -> t == IDENTIFIER || t == UNDERSCORE || t == ASSERT || t == ENUM;
 enum ParensResult {
 CAST,
 EXPLICIT_LAMBDA,
 IMPLICIT_LAMBDA,
-IMPLICIT_LAMBDA_ALL_VAR,
+PARENS
-BAD_LAMBDA,
-PARENS;
-}
-enum BAD_LAMBDA_KIND {
-EXPLICIT_AND_VAR,
-IMPLICIT_AND_VAR,
-EXPLICIT_AND_IMPLICIT,
 }
 JCExpression lambdaExpressionOrStatement(boolean hasParens, boolean explicitParams, int pos) {
 List<JCVariableDecl> params = explicitParams ?
 formalParameters(true) :
 private JCExpression bracketsOpt(JCExpression t,
 List<JCAnnotation> annotations) {
 List<JCAnnotation> nextLevelAnnotations = typeAnnotationsOpt();
 if (token.kind == LBRACKET) {
-if (t == null) {
-log.error(token.pos, Errors.VarNotAllowedArray);
-}
 int pos = token.pos;
 nextToken();
 t = bracketsOptCont(t, pos, nextLevelAnnotations);
 } else if (!nextLevelAnnotations.isEmpty()) {
 if (permitTypeAnnotationsPushBack) {
 } else {
 // error recovery
 if (token.pos == lastErrPos)
 return stats.toList();
 if (token.pos <= endPosTable.errorEndPos) {
-skip(false, true, true, true, false);
+skip(false, true, true, true);
 lastErrPos = token.pos;
 }
 stats.addAll(stat);
 }
 }
 boolean checkForImports = true;
 boolean firstTypeDecl = true;
 while (token.kind != EOF) {
 if (token.pos <= endPosTable.errorEndPos) {
 // error recovery
-skip(checkForImports, false, false, false, false);
+skip(checkForImports, false, false, false);
 if (token.kind == EOF)
 break;
 }
 if (checkForImports && mods == null && token.kind == IMPORT) {
 seenImport = true;
 List<JCExpression> implNames = qualidentList(false);
 accept(SEMI);
 defs.append(toP(F.at(pos).Provides(serviceName, implNames)));
 } else {
 log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.ExpectedStr("'" + names.with + "'"));
-skip(false, false, false, false, false);
+skip(false, false, false, false);
 }
 } else if (token.name() == names.uses) {
 nextToken();
 JCExpression service = qualident(false);
 accept(SEMI);
 while (token.kind != RBRACE && token.kind != EOF) {
 defs.appendList(classOrInterfaceBodyDeclaration(enumName,
 false));
 if (token.pos <= endPosTable.errorEndPos) {
 // error recovery
-skip(false, true, true, false, false);
+skip(false, true, true, false);
 }
 }
 }
 accept(RBRACE);
 return defs.toList();
 */
 List<JCTree> classOrInterfaceBody(Name className, boolean isInterface) {
 accept(LBRACE);
 if (token.pos <= endPosTable.errorEndPos) {
 // error recovery
-skip(false, true, false, false, false);
+skip(false, true, false, false);
 if (token.kind == LBRACE)
 nextToken();
 }
 ListBuffer<JCTree> defs = new ListBuffer<>();
 while (token.kind != RBRACE && token.kind != EOF) {
 defs.appendList(classOrInterfaceBodyDeclaration(className, isInterface));
 if (token.pos <= endPosTable.errorEndPos) {
 // error recovery
-skip(false, true, true, false, false);
+skip(false, true, true, false);
 }
 }
 accept(RBRACE);
 return defs.toList();
 }
 defaultValue = null;
 }
 accept(SEMI);
 if (token.pos <= endPosTable.errorEndPos) {
 // error recovery
-skip(false, true, false, false, false);
+skip(false, true, false, false);
 if (token.kind == LBRACE) {
 body = block();
 }
 }
 }
 protected JCVariableDecl formalParameter(boolean lambdaParameter) {
 JCModifiers mods = optFinal(Flags.PARAMETER);
 // need to distinguish between vararg annos and array annos
 // look at typeAnnotationsPushedBack comment
 this.permitTypeAnnotationsPushBack = true;
-JCExpression type = parseType(lambdaParameter);
+JCExpression type = parseType();
 this.permitTypeAnnotationsPushBack = false;
 if (token.kind == ELLIPSIS) {
 List<JCAnnotation> varargsAnnos = typeAnnotationsPushedBack;
 typeAnnotationsPushedBack = List.nil();
 // if not a var arg, then typeAnnotationsPushedBack should be null
 if (typeAnnotationsPushedBack.nonEmpty()) {
 reportSyntaxError(typeAnnotationsPushedBack.head.pos, Errors.IllegalStartOfType);
 }
 typeAnnotationsPushedBack = List.nil();
-}
-if (lambdaParameter && isRestrictedLocalVarTypeName(type)) {
-//implicit lambda parameter type (with 'var')
-type = null;
 }
 return variableDeclaratorId(mods, type, lambdaParameter);
 }
 protected JCVariableDecl implicitParameter() {

changeset 48926	02404e27d356
parent 48920	916690b5edc9
child 48935	03ae177c26b0