1415 }
1416
1417 private List<JCCase> switchExpressionStatementGroup() {
1418 ListBuffer<JCCase> caseExprs = new ListBuffer<>();
1419 int casePos = token.pos;
1420 ListBuffer<JCExpression> pats = new ListBuffer<>();
1421
1422 if (token.kind == DEFAULT) {
1423 nextToken();
1424 } else {
1425 accept(CASE);
1426 while (true) {
1427 pats.append(term(EXPR | NOLAMBDA));
1428 if (token.kind != COMMA) break;
1429 checkSourceLevel(Feature.SWITCH_MULTIPLE_CASE_LABELS);
1430 nextToken();
1431 };
1432 }
1433 List<JCStatement> stats = null;
1434 JCTree body = null;
1435 @SuppressWarnings("preview")
1436 CaseTree.CaseKind kind;
1437 switch (token.kind) {
1438 case ARROW:
1439 checkSourceLevel(Feature.SWITCH_RULE);
1440 nextToken();
1441 if (token.kind == TokenKind.THROW || token.kind == TokenKind.LBRACE) {
1442 stats = List.of(parseStatement());
1443 body = stats.head;
1444 kind = JCCase.RULE;
1445 } else {
1446 JCExpression value = parseExpression();
1447 stats = List.of(to(F.at(value).Yield(value)));
1448 body = value;
1449 kind = JCCase.RULE;
1450 accept(SEMI);
1451 }
1452 break;
1453 default:
1454 accept(COLON, tk -> Errors.Expected2(COLON, ARROW));
1455 stats = blockStatements();
2880 syntaxError(pos, Errors.Expected3(CASE, DEFAULT, RBRACE));
2881 }
2882 }
2883 }
2884
2885 protected List<JCCase> switchBlockStatementGroup() {
2886 int pos = token.pos;
2887 List<JCStatement> stats;
2888 JCCase c;
2889 ListBuffer<JCCase> cases = new ListBuffer<JCCase>();
2890 switch (token.kind) {
2891 case CASE: {
2892 nextToken();
2893 ListBuffer<JCExpression> pats = new ListBuffer<>();
2894 while (true) {
2895 pats.append(term(EXPR | NOLAMBDA));
2896 if (token.kind != COMMA) break;
2897 nextToken();
2898 checkSourceLevel(Feature.SWITCH_MULTIPLE_CASE_LABELS);
2899 };
2900 @SuppressWarnings("preview")
2901 CaseTree.CaseKind caseKind;
2902 JCTree body = null;
2903 if (token.kind == ARROW) {
2904 checkSourceLevel(Feature.SWITCH_RULE);
2905 accept(ARROW);
2906 caseKind = JCCase.RULE;
2907 JCStatement statement = parseStatementAsBlock();
2908 if (!statement.hasTag(EXEC) && !statement.hasTag(BLOCK) && !statement.hasTag(Tag.THROW)) {
2909 log.error(statement.pos(), Errors.SwitchCaseUnexpectedStatement);
2910 }
2911 stats = List.of(statement);
2912 body = stats.head;
2913 } else {
2914 accept(COLON, tk -> Errors.Expected2(COLON, ARROW));
2915 caseKind = JCCase.STATEMENT;
2916 stats = blockStatements();
2917 }
2918 c = F.at(pos).Case(caseKind, pats.toList(), stats, body);
2919 if (stats.isEmpty())
2920 storeEnd(c, S.prevToken().endPos);
2921 return cases.append(c).toList();
2922 }
2923 case DEFAULT: {
2924 nextToken();
2925 @SuppressWarnings("preview")
2926 CaseTree.CaseKind caseKind;
2927 JCTree body = null;
2928 if (token.kind == ARROW) {
2929 checkSourceLevel(Feature.SWITCH_RULE);
2930 accept(ARROW);
2931 caseKind = JCCase.RULE;
2932 JCStatement statement = parseStatementAsBlock();
2933 if (!statement.hasTag(EXEC) && !statement.hasTag(BLOCK) && !statement.hasTag(Tag.THROW)) {
2934 log.error(statement.pos(), Errors.SwitchCaseUnexpectedStatement);
2935 }
2936 stats = List.of(statement);
2937 body = stats.head;
2938 } else {
2939 accept(COLON, tk -> Errors.Expected2(COLON, ARROW));
2940 caseKind = JCCase.STATEMENT;
2941 stats = blockStatements();
2942 }
2943 c = F.at(pos).Case(caseKind, List.nil(), stats, body);
2944 if (stats.isEmpty())
2945 storeEnd(c, S.prevToken().endPos);
3283 return isRestrictedTypeName(((JCIdent)e).name, e.pos, shouldWarn) ? ((JCIdent)e).name : null;
3284 case TYPEARRAY:
3285 return restrictedTypeName(((JCArrayTypeTree)e).elemtype, shouldWarn);
3286 default:
3287 return null;
3288 }
3289 }
3290
3291 boolean isRestrictedTypeName(Name name, int pos, boolean shouldWarn) {
3292 if (name == names.var) {
3293 if (Feature.LOCAL_VARIABLE_TYPE_INFERENCE.allowedInSource(source)) {
3294 return true;
3295 } else if (shouldWarn) {
3296 log.warning(pos, Warnings.RestrictedTypeNotAllowed(name, Source.JDK10));
3297 }
3298 }
3299 if (name == names.yield) {
3300 if (allowYieldStatement) {
3301 return true;
3302 } else if (shouldWarn) {
3303 log.warning(pos, Warnings.RestrictedTypeNotAllowedPreview(name, Source.JDK13));
3304 }
3305 }
3306 return false;
3307 }
3308
3309 /** VariableDeclaratorId = Ident BracketsOpt
3310 */
3311 JCVariableDecl variableDeclaratorId(JCModifiers mods, JCExpression type) {
3312 return variableDeclaratorId(mods, type, false);
3313 }
3314 //where
3315 JCVariableDecl variableDeclaratorId(JCModifiers mods, JCExpression type, boolean lambdaParameter) {
3316 int pos = token.pos;
3317 Name name;
3318 if (lambdaParameter && token.kind == UNDERSCORE) {
3319 log.error(pos, Errors.UnderscoreAsIdentifierInLambda);
3320 name = token.name();
3321 nextToken();
3322 } else {
3323 if (allowThisIdent ||
|
1415 }
1416
1417 private List<JCCase> switchExpressionStatementGroup() {
1418 ListBuffer<JCCase> caseExprs = new ListBuffer<>();
1419 int casePos = token.pos;
1420 ListBuffer<JCExpression> pats = new ListBuffer<>();
1421
1422 if (token.kind == DEFAULT) {
1423 nextToken();
1424 } else {
1425 accept(CASE);
1426 while (true) {
1427 pats.append(term(EXPR | NOLAMBDA));
1428 if (token.kind != COMMA) break;
1429 checkSourceLevel(Feature.SWITCH_MULTIPLE_CASE_LABELS);
1430 nextToken();
1431 };
1432 }
1433 List<JCStatement> stats = null;
1434 JCTree body = null;
1435 CaseTree.CaseKind kind;
1436 switch (token.kind) {
1437 case ARROW:
1438 checkSourceLevel(Feature.SWITCH_RULE);
1439 nextToken();
1440 if (token.kind == TokenKind.THROW || token.kind == TokenKind.LBRACE) {
1441 stats = List.of(parseStatement());
1442 body = stats.head;
1443 kind = JCCase.RULE;
1444 } else {
1445 JCExpression value = parseExpression();
1446 stats = List.of(to(F.at(value).Yield(value)));
1447 body = value;
1448 kind = JCCase.RULE;
1449 accept(SEMI);
1450 }
1451 break;
1452 default:
1453 accept(COLON, tk -> Errors.Expected2(COLON, ARROW));
1454 stats = blockStatements();
2879 syntaxError(pos, Errors.Expected3(CASE, DEFAULT, RBRACE));
2880 }
2881 }
2882 }
2883
2884 protected List<JCCase> switchBlockStatementGroup() {
2885 int pos = token.pos;
2886 List<JCStatement> stats;
2887 JCCase c;
2888 ListBuffer<JCCase> cases = new ListBuffer<JCCase>();
2889 switch (token.kind) {
2890 case CASE: {
2891 nextToken();
2892 ListBuffer<JCExpression> pats = new ListBuffer<>();
2893 while (true) {
2894 pats.append(term(EXPR | NOLAMBDA));
2895 if (token.kind != COMMA) break;
2896 nextToken();
2897 checkSourceLevel(Feature.SWITCH_MULTIPLE_CASE_LABELS);
2898 };
2899 CaseTree.CaseKind caseKind;
2900 JCTree body = null;
2901 if (token.kind == ARROW) {
2902 checkSourceLevel(Feature.SWITCH_RULE);
2903 accept(ARROW);
2904 caseKind = JCCase.RULE;
2905 JCStatement statement = parseStatementAsBlock();
2906 if (!statement.hasTag(EXEC) && !statement.hasTag(BLOCK) && !statement.hasTag(Tag.THROW)) {
2907 log.error(statement.pos(), Errors.SwitchCaseUnexpectedStatement);
2908 }
2909 stats = List.of(statement);
2910 body = stats.head;
2911 } else {
2912 accept(COLON, tk -> Errors.Expected2(COLON, ARROW));
2913 caseKind = JCCase.STATEMENT;
2914 stats = blockStatements();
2915 }
2916 c = F.at(pos).Case(caseKind, pats.toList(), stats, body);
2917 if (stats.isEmpty())
2918 storeEnd(c, S.prevToken().endPos);
2919 return cases.append(c).toList();
2920 }
2921 case DEFAULT: {
2922 nextToken();
2923 CaseTree.CaseKind caseKind;
2924 JCTree body = null;
2925 if (token.kind == ARROW) {
2926 checkSourceLevel(Feature.SWITCH_RULE);
2927 accept(ARROW);
2928 caseKind = JCCase.RULE;
2929 JCStatement statement = parseStatementAsBlock();
2930 if (!statement.hasTag(EXEC) && !statement.hasTag(BLOCK) && !statement.hasTag(Tag.THROW)) {
2931 log.error(statement.pos(), Errors.SwitchCaseUnexpectedStatement);
2932 }
2933 stats = List.of(statement);
2934 body = stats.head;
2935 } else {
2936 accept(COLON, tk -> Errors.Expected2(COLON, ARROW));
2937 caseKind = JCCase.STATEMENT;
2938 stats = blockStatements();
2939 }
2940 c = F.at(pos).Case(caseKind, List.nil(), stats, body);
2941 if (stats.isEmpty())
2942 storeEnd(c, S.prevToken().endPos);
3280 return isRestrictedTypeName(((JCIdent)e).name, e.pos, shouldWarn) ? ((JCIdent)e).name : null;
3281 case TYPEARRAY:
3282 return restrictedTypeName(((JCArrayTypeTree)e).elemtype, shouldWarn);
3283 default:
3284 return null;
3285 }
3286 }
3287
3288 boolean isRestrictedTypeName(Name name, int pos, boolean shouldWarn) {
3289 if (name == names.var) {
3290 if (Feature.LOCAL_VARIABLE_TYPE_INFERENCE.allowedInSource(source)) {
3291 return true;
3292 } else if (shouldWarn) {
3293 log.warning(pos, Warnings.RestrictedTypeNotAllowed(name, Source.JDK10));
3294 }
3295 }
3296 if (name == names.yield) {
3297 if (allowYieldStatement) {
3298 return true;
3299 } else if (shouldWarn) {
3300 log.warning(pos, Warnings.RestrictedTypeNotAllowed(name, Source.JDK14));
3301 }
3302 }
3303 return false;
3304 }
3305
3306 /** VariableDeclaratorId = Ident BracketsOpt
3307 */
3308 JCVariableDecl variableDeclaratorId(JCModifiers mods, JCExpression type) {
3309 return variableDeclaratorId(mods, type, false);
3310 }
3311 //where
3312 JCVariableDecl variableDeclaratorId(JCModifiers mods, JCExpression type, boolean lambdaParameter) {
3313 int pos = token.pos;
3314 Name name;
3315 if (lambdaParameter && token.kind == UNDERSCORE) {
3316 log.error(pos, Errors.UnderscoreAsIdentifierInLambda);
3317 name = token.name();
3318 nextToken();
3319 } else {
3320 if (allowThisIdent ||
|