jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/parser/JavacParser.java

-:916143318f10
+:2d2b2be57c78
 public void nextToken() {
 S.nextToken();
 token = S.token();
 }
-protected boolean peekToken(TokenKind tk) {
+protected boolean peekToken(Filter<TokenKind> tk) {
 return peekToken(0, tk);
 }
-protected boolean peekToken(int lookahead, TokenKind tk) {
+protected boolean peekToken(int lookahead, Filter<TokenKind> tk) {
-return S.token(lookahead + 1).kind == tk;
+return tk.accepts(S.token(lookahead + 1).kind);
 }
-protected boolean peekToken(TokenKind tk1, TokenKind tk2) {
+protected boolean peekToken(Filter<TokenKind> tk1, Filter<TokenKind> tk2) {
 return peekToken(0, tk1, tk2);
 }
-protected boolean peekToken(int lookahead, TokenKind tk1, TokenKind tk2) {
+protected boolean peekToken(int lookahead, Filter<TokenKind> tk1, Filter<TokenKind> tk2) {
-return S.token(lookahead + 1).kind == tk1 &&
+return tk1.accepts(S.token(lookahead + 1).kind) &&
-S.token(lookahead + 2).kind == tk2;
+tk2.accepts(S.token(lookahead + 2).kind);
 }
-protected boolean peekToken(TokenKind tk1, TokenKind tk2, TokenKind tk3) {
+protected boolean peekToken(Filter<TokenKind> tk1, Filter<TokenKind> tk2, Filter<TokenKind> tk3) {
 return peekToken(0, tk1, tk2, tk3);
 }
-protected boolean peekToken(int lookahead, TokenKind tk1, TokenKind tk2, TokenKind tk3) {
+protected boolean peekToken(int lookahead, Filter<TokenKind> tk1, Filter<TokenKind> tk2, Filter<TokenKind> tk3) {
-return S.token(lookahead + 1).kind == tk1 &&
+return tk1.accepts(S.token(lookahead + 1).kind) &&
-S.token(lookahead + 2).kind == tk2 &&
+tk2.accepts(S.token(lookahead + 2).kind) &&
-S.token(lookahead + 3).kind == tk3;
+tk3.accepts(S.token(lookahead + 3).kind);
 }
-protected boolean peekToken(TokenKind... kinds) {
+@SuppressWarnings("unchecked")
+protected boolean peekToken(Filter<TokenKind>... kinds) {
 return peekToken(0, kinds);
 }
-protected boolean peekToken(int lookahead, TokenKind... kinds) {
+@SuppressWarnings("unchecked")
+protected boolean peekToken(int lookahead, Filter<TokenKind>... kinds) {
 for (; lookahead < kinds.length ; lookahead++) {
-if (S.token(lookahead + 1).kind != kinds[lookahead]) {
+if (!kinds[lookahead].accepts(S.token(lookahead + 1).kind)) {
 return false;
 }
 }
 return true;
 }
 case BOOLEAN:
 case VOID:
 if (stopAtMemberDecl)
 return;
 break;
+case UNDERSCORE:
 case IDENTIFIER:
 if (stopAtIdentifier)
 return;
 break;
 case CASE:
 warning(token.pos, "enum.as.identifier");
 Name name = token.name();
 nextToken();
 return name;
 }
+} else if (token.kind == UNDERSCORE) {
+warning(token.pos, "underscore.as.identifier");
+Name name = token.name();
+nextToken();
+return name;
 } else {
 accept(IDENTIFIER);
 return names.error;
 }
 }
 /**
 * Qualident = Ident { DOT Ident }
 */
 public JCExpression qualident() {
 if (token.kind == LT) typeArgs = typeArguments(false);
 t = creator(pos, typeArgs);
 typeArgs = null;
 } else return illegal();
 break;
-case IDENTIFIER: case ASSERT: case ENUM:
+case UNDERSCORE: case IDENTIFIER: case ASSERT: case ENUM:
 if (typeArgs != null) return illegal();
 if ((mode & EXPR) != 0 && peekToken(ARROW)) {
 t = lambdaExpressionOrStatement(false, false, pos);
 } else {
 t = toP(F.at(token.pos).Ident(ident()));
 @SuppressWarnings("fallthrough")
 boolean isUnboundMemberRef() {
 int pos = 0, depth = 0;
 for (Token t = S.token(pos) ; ; t = S.token(++pos)) {
 switch (t.kind) {
-case IDENTIFIER: case QUES: case EXTENDS: case SUPER:
+case IDENTIFIER: case UNDERSCORE: case QUES: case EXTENDS: case SUPER:
 case DOT: case RBRACKET: case LBRACKET: case COMMA:
 case BYTE: case SHORT: case INT: case LONG: case FLOAT:
 case DOUBLE: case BOOLEAN: case CHAR:
 break;
 case LT:
 case BYTE: case SHORT: case INT: case LONG: case FLOAT:
 case DOUBLE: case BOOLEAN: case CHAR:
 if (peekToken(lookahead, RPAREN)) {
 //Type, ')' -> cast
 return ParensResult.CAST;
-} else if (peekToken(lookahead, IDENTIFIER)) {
+} else if (peekToken(lookahead, LAX_IDENTIFIER)) {
-//Type, 'Identifier -> explicit lambda
+//Type, Identifier/'_'/'assert'/'enum' -> explicit lambda
 return ParensResult.EXPLICIT_LAMBDA;
 }
 break;
 case LPAREN:
 if (lookahead != 0) {
 case BANG: case TILDE:
 case LPAREN: case THIS: case SUPER:
 case INTLITERAL: case LONGLITERAL: case FLOATLITERAL:
 case DOUBLELITERAL: case CHARLITERAL: case STRINGLITERAL:
 case TRUE: case FALSE: case NULL:
-case NEW: case IDENTIFIER: case ASSERT: case ENUM:
+case NEW: case IDENTIFIER: case ASSERT: case ENUM: case UNDERSCORE:
 case BYTE: case SHORT: case CHAR: case INT:
 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, IDENTIFIER)) {
+if (peekToken(lookahead, LAX_IDENTIFIER)) {
-// Identifier, Identifier -> explicit lambda
+// Identifier, Identifier/'_'/'assert'/'enum' -> explicit lambda
 return ParensResult.EXPLICIT_LAMBDA;
 } else if (peekToken(lookahead, RPAREN, ARROW)) {
 // Identifier, ')' '->' -> implicit lambda
 return ParensResult.IMPLICIT_LAMBDA;
 }
 case ELLIPSIS:
 case MONKEYS_AT:
 //those can only appear in explicit lambdas
 return ParensResult.EXPLICIT_LAMBDA;
 case LBRACKET:
-if (peekToken(lookahead, RBRACKET, IDENTIFIER)) {
+if (peekToken(lookahead, RBRACKET, LAX_IDENTIFIER)) {
-// '[', ']', Identifier -> explicit lambda
+// '[', ']', Identifier/'_'/'assert'/'enum' -> explicit lambda
 return ParensResult.EXPLICIT_LAMBDA;
 } else if (peekToken(lookahead, RBRACKET, RPAREN) ||
 peekToken(lookahead, RBRACKET, AMP)) {
 // '[', ']', ')' -> cast
 // '[', ']', '&' -> cast (intersection type)
 if (peekToken(lookahead, RPAREN) ||
 peekToken(lookahead, AMP)) {
 // '>', ')' -> cast
 // '>', '&' -> cast
 return ParensResult.CAST;
-} else if (peekToken(lookahead, IDENTIFIER, COMMA) ||
+} else if (peekToken(lookahead, LAX_IDENTIFIER, COMMA) ||
-peekToken(lookahead, IDENTIFIER, RPAREN, ARROW) ||
+peekToken(lookahead, LAX_IDENTIFIER, RPAREN, ARROW) ||
 peekToken(lookahead, ELLIPSIS)) {
-// '>', Identifier, ',' -> explicit lambda
+// '>', Identifier/'_'/'assert'/'enum', ',' -> explicit lambda
-// '>', Identifier, ')', '->' -> explicit lambda
+// '>', Identifier/'_'/'assert'/'enum', ')', '->' -> explicit lambda
 // '>', '...' -> explicit lambda
 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
 return ParensResult.PARENS;
 }
 }
 }
+/** Accepts all identifier-like tokens */
+Filter<TokenKind> LAX_IDENTIFIER = new Filter<TokenKind>() {
+public boolean accepts(TokenKind t) {
+return t == IDENTIFIER || t == UNDERSCORE || t == ASSERT || t == ENUM;
+}
+};
 enum ParensResult {
 CAST,
 EXPLICIT_LAMBDA,
 IMPLICIT_LAMBDA,
 PARENS;
 }
-JCExpression lambdaExpressionOrStatement(JCVariableDecl firstParam, int pos) {
-ListBuffer<JCVariableDecl> params = new ListBuffer<JCVariableDecl>();
-params.append(firstParam);
-JCVariableDecl lastParam = firstParam;
-while ((lastParam.mods.flags & Flags.VARARGS) == 0 && token.kind == COMMA) {
-nextToken();
-params.append(lastParam = formalParameter());
-}
-accept(RPAREN);
-return lambdaExpressionOrStatementRest(params.toList(), pos);
-}
 JCExpression lambdaExpressionOrStatement(boolean hasParens, boolean explicitParams, int pos) {
 List<JCVariableDecl> params = explicitParams ?
-formalParameters() :
+formalParameters(true) :
 implicitParameters(hasParens);
 return lambdaExpressionOrStatementRest(params, pos);
 }
 } else if (token.kind == SUPER) {
 TypeBoundKind t = to(F.at(pos).TypeBoundKind(BoundKind.SUPER));
 nextToken();
 JCExpression bound = parseType();
 return F.at(pos).Wildcard(t, bound);
-} else if (token.kind == IDENTIFIER) {
+} else if (LAX_IDENTIFIER.accepts(token.kind)) {
 //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));
 nextToken();
 accept(CLASS);
 if (token.pos == endPosTable.errorEndPos) {
 // error recovery
 Name name = null;
-if (token.kind == IDENTIFIER) {
+if (LAX_IDENTIFIER.accepts(token.kind)) {
 name = token.name();
 nextToken();
 } else {
 name = names.error;
 }
 JCExpression t = term(EXPR | TYPE);
 if (token.kind == COLON && t.hasTag(IDENT)) {
 nextToken();
 JCStatement stat = parseStatement();
 return List.<JCStatement>of(F.at(pos).Labelled(prevToken.name(), stat));
-} else if ((lastmode & TYPE) != 0 &&
+} else if ((lastmode & TYPE) != 0 && LAX_IDENTIFIER.accepts(token.kind)) {
-(token.kind == IDENTIFIER ||
-token.kind == ASSERT ||
-token.kind == ENUM)) {
 pos = token.pos;
 JCModifiers mods = F.at(Position.NOPOS).Modifiers(0);
 F.at(pos);
 ListBuffer<JCStatement> stats =
 variableDeclarators(mods, t, new ListBuffer<JCStatement>());
 accept(SEMI);
 return t;
 }
 case BREAK: {
 nextToken();
-Name label = (token.kind == IDENTIFIER || token.kind == ASSERT || token.kind == ENUM) ? ident() : null;
+Name label = LAX_IDENTIFIER.accepts(token.kind) ? ident() : null;
 JCBreak t = to(F.at(pos).Break(label));
 accept(SEMI);
 return t;
 }
 case CONTINUE: {
 nextToken();
-Name label = (token.kind == IDENTIFIER || token.kind == ASSERT || token.kind == ENUM) ? ident() : null;
+Name label = LAX_IDENTIFIER.accepts(token.kind) ? ident() : null;
 JCContinue t =  to(F.at(pos).Continue(label));
 accept(SEMI);
 return t;
 }
 case SEMI:
 int pos = token.pos;
 if (token.kind == FINAL || token.kind == MONKEYS_AT) {
 return variableDeclarators(optFinal(0), parseType(), stats).toList();
 } else {
 JCExpression t = term(EXPR | TYPE);
-if ((lastmode & TYPE) != 0 &&
+if ((lastmode & TYPE) != 0 && LAX_IDENTIFIER.accepts(token.kind)) {
-(token.kind == IDENTIFIER || token.kind == ASSERT ||
-token.kind == ENUM)) {
 return variableDeclarators(modifiersOpt(), t, stats).toList();
 } else if ((lastmode & TYPE) != 0 && token.kind == COLON) {
 error(pos, "bad.initializer", "for-loop");
 return List.of((JCStatement)F.at(pos).VarDef(null, null, t, null));
 } else {
 }
 /** VariableDeclaratorId = Ident BracketsOpt
 */
 JCVariableDecl variableDeclaratorId(JCModifiers mods, JCExpression type) {
+return variableDeclaratorId(mods, type, false);
+}
+//where
+JCVariableDecl variableDeclaratorId(JCModifiers mods, JCExpression type, boolean lambdaParameter) {
 int pos = token.pos;
-Name name = ident();
+Name name;
+if (lambdaParameter && token.kind == UNDERSCORE) {
+syntaxError(pos, "expected", IDENTIFIER);
+name = token.name();
+} else {
+name = ident();
+}
 if ((mods.flags & Flags.VARARGS) != 0 &&
 token.kind == LBRACKET) {
 log.error(token.pos, "varargs.and.old.array.syntax");
 }
 type = bracketsOpt(type);
 if (token.kind == ENUM) {
 return enumDeclaration(mods, dc);
 } else {
 int pos = token.pos;
 List<JCTree> errs;
-if (token.kind == IDENTIFIER) {
+if (LAX_IDENTIFIER.accepts(token.kind)) {
 errs = List.<JCTree>of(mods, toP(F.at(pos).Ident(ident())));
 setErrorEndPos(token.pos);
 } else {
 errs = List.<JCTree>of(mods);
 }
 allowEnums = true;
 return enumDeclaration(mods, dc);
 }
 int pos = token.pos;
 List<JCTree> errs;
-if (token.kind == IDENTIFIER) {
+if (LAX_IDENTIFIER.accepts(token.kind)) {
 errs = List.<JCTree>of(mods, toP(F.at(pos).Ident(ident())));
 setErrorEndPos(token.pos);
 } else {
 errs = List.<JCTree>of(mods);
 }
 /** FormalParameters = "(" [ FormalParameterList ] ")"
 *  FormalParameterList = [ FormalParameterListNovarargs , ] LastFormalParameter
 *  FormalParameterListNovarargs = [ FormalParameterListNovarargs , ] FormalParameter
 */
 List<JCVariableDecl> formalParameters() {
+return formalParameters(false);
+}
+List<JCVariableDecl> formalParameters(boolean lambdaParameters) {
 ListBuffer<JCVariableDecl> params = new ListBuffer<JCVariableDecl>();
 JCVariableDecl lastParam = null;
 accept(LPAREN);
 if (token.kind != RPAREN) {
-params.append(lastParam = formalParameter());
+params.append(lastParam = formalParameter(lambdaParameters));
 while ((lastParam.mods.flags & Flags.VARARGS) == 0 && token.kind == COMMA) {
 nextToken();
-params.append(lastParam = formalParameter());
+params.append(lastParam = formalParameter(lambdaParameters));
 }
 }
 accept(RPAREN);
 return params.toList();
 }
 /** FormalParameter = { FINAL | '@' Annotation } Type VariableDeclaratorId
 *  LastFormalParameter = { FINAL | '@' Annotation } Type '...' Ident | FormalParameter
 */
 protected JCVariableDecl formalParameter() {
+return formalParameter(false);
+}
+protected JCVariableDecl formalParameter(boolean lambdaParameter) {
 JCModifiers mods = optFinal(Flags.PARAMETER);
 JCExpression type = parseType();
 if (token.kind == ELLIPSIS) {
 checkVarargs();
 mods.flags |= Flags.VARARGS;
 type = to(F.at(token.pos).TypeArray(type));
 nextToken();
 }
-return variableDeclaratorId(mods, type);
+return variableDeclaratorId(mods, type, lambdaParameter);
 }
 protected JCVariableDecl implicitParameter() {
 JCModifiers mods = F.at(token.pos).Modifiers(Flags.PARAMETER);
-return variableDeclaratorId(mods, null);
+return variableDeclaratorId(mods, null, true);
 }
 /* ---------- auxiliary methods -------------- */
 void error(int pos, String key, Object ... args) {

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/parser/JavacParser.java

src/share/classes/com/sun/tools/javac/parser/JavacParser.java