Issue checkstyle#6615: Add support for Java 14 switch and yield

config/ant-phase-verify.xml

@@ -118,6 +118,8 @@
 
           <!-- Exclude because printed AST has line length > 100 characters -->
           <exclude name="**/InputJava14InstanceofWithPatternMatchingAST.txt"/>
+          <exclude name="**/InputJava14SwitchExpression.txt"/>
+
 
         </fileset>
       </path>

src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java

@@ -3595,6 +3595,13 @@ public final class TokenTypes {
     public static final int RECORD_DEF =
             GeneratedJavaTokenTypes.RECORD_DEF;
 
+    /**
+     * The {@code yield} keyword.  This element appears
+     * as part of a yield statement.
+     **/
+    public static final int LITERAL_YIELD =
+            GeneratedJavaTokenTypes.LITERAL_yield;
+
     /** Prevent instantiation. */
     private TokenTypes() {
     }

src/main/resources/com/puppycrawl/tools/checkstyle/grammar/java.g

@@ -117,7 +117,7 @@ tokens {
     FLOAT_LITERAL; DOUBLE_LITERAL; HEX_FLOAT_LITERAL; HEX_DOUBLE_LITERAL;
     SIGNED_INTEGER; BINARY_EXPONENT;
 
-    PATTERN_VARIABLE_DEF; RECORD_DEF; LITERAL_record="record";
+    PATTERN_VARIABLE_DEF; RECORD_DEF; LITERAL_record="record"; LITERAL_yield="yield";
 }
 
 {
@@ -1118,6 +1118,12 @@ traditionalStatement
         // record declaration, note that you cannot have modifiers in this case
         |   recordDefinition[#null]
 
+        // switch/case statement
+        |  switchExpression
+
+        // Yield statement, must be in a switchBlock
+        |  yieldStatement
+
         // An expression statement.  This could be a method call,
         // assignment statement, or any other expression evaluated for
         // side-effects.
@@ -1160,16 +1166,11 @@ traditionalStatement
         // Return an expression
         |    "return"^ (expression)? SEMI
 
-        // switch/case statement
-        |    "switch"^ LPAREN expression RPAREN LCURLY
-                ( casesGroup )*
-            RCURLY
-
         // exception try-catch block
         |    tryBlock
 
         // throw an exception
-        |    "throw"^ expression SEMI
+        |    throwStatement
 
         // synchronize a statement
         |    "synchronized"^ LPAREN expression RPAREN compoundStatement
@@ -1178,6 +1179,10 @@ traditionalStatement
         |    s:SEMI {#s.setType(EMPTY_STAT);}
     ;
 
+yieldStatement!
+    :  l:LITERAL_yield e:expression s:(SEMI)? {## = #(l,e,s);}
+    ;
+
 forStatement
     :   f:"for"^
         LPAREN
@@ -1210,6 +1215,10 @@ elseStatement
     : "else"^ statement
     ;
 
+switchBlock
+    : LCURLY ( casesGroup )* RCURLY
+    ;
+
 casesGroup
     :    (    // CONFLICT: to which case group do the statements bind?
             //           ANTLR generates proper code: it groups the
@@ -1226,7 +1235,12 @@ casesGroup
     ;
 
 aCase
-    :    ("case"^ expression | "default"^) COLON
+    :    ("case"^ exprConditionalExpression (COMMA exprConditionalExpression )* | "default"^)
+         ( COLON | (LAMBDA switchRule)=>(LAMBDA switchRule))
+    ;
+
+exprConditionalExpression
+    :   conditionalExpression {## = #(#[EXPR,"EXPR"],##);}
     ;
 
 caseSList
@@ -1244,6 +1258,10 @@ caseSList
         {#caseSList = #(#[SLIST,"SLIST"],#caseSList);}
     ;
 
+switchRule
+    :   ( expression SEMI | compoundStatement | throwStatement )
+    ;
+
 // The initializer for a for loop
 forInit
         // if it looks like a declaration, it is
@@ -1277,6 +1295,10 @@ tryBlock
         ( finallyHandler )?
     ;
 
+throwStatement
+    : "throw"^ expression SEMI
+    ;
+
 resourceSpecification
     : LPAREN resources (SEMI)? RPAREN
       {#resourceSpecification =
@@ -1497,31 +1519,35 @@ unaryExpression
 unaryExpressionNotPlusMinus
     :    BNOT^ unaryExpression
     |    LNOT^ unaryExpression
+    |   (switchExpression)=>switchExpression
+    |    (castExpression)=>castExpression
+    ;
 
-    |    (    // subrule allows option to shut off warnings
-            options {
-                // "(int" ambig with postfixExpr due to lack of sequence
-                // info in linear approximate LL(k).  It's ok.  Shut up.
-                generateAmbigWarnings=false;
-            }
-        :    // If typecast is built in type, must be numeric operand
-            // Also, no reason to backtrack if type keyword like int, float...
-            (LPAREN builtInTypeSpec[true] RPAREN unaryExpression) =>
-            lpb:LPAREN^ {#lpb.setType(TYPECAST);} builtInTypeSpec[true] RPAREN
-            unaryExpression
-
-            // Have to backtrack to see if operator follows.  If no operator
-            // follows, it's a typecast.  No semantic checking needed to parse.
-            // if it _looks_ like a cast, it _is_ a cast; else it's a "(expr)"
-        |    (LPAREN typeCastParameters RPAREN unaryExpressionNotPlusMinus)=>
-            lp:LPAREN^ {#lp.setType(TYPECAST);} typeCastParameters RPAREN
-            unaryExpressionNotPlusMinus
-
-        |   (LPAREN typeCastParameters RPAREN lambdaExpression) =>
-                lpl:LPAREN^ {#lpl.setType(TYPECAST);} typeCastParameters RPAREN
-                lambdaExpression
-
-        |    postfixExpression
+castExpression
+    :  (   // subrule allows option to shut off warnings
+                    options {
+                        // "(int" ambig with postfixExpr due to lack of sequence
+                        // info in linear approximate LL(k).  It's ok.  Shut up.
+                        generateAmbigWarnings=false;
+                    }
+                :   // If typecast is built in type, must be numeric operand
+                    // Also, no reason to backtrack if type keyword like int, float...
+                    (LPAREN builtInTypeSpec[true] RPAREN unaryExpression) =>
+                    lpb:LPAREN^ {#lpb.setType(TYPECAST);} builtInTypeSpec[true] RPAREN
+                    castExpression
+
+                    // Have to backtrack to see if operator follows.  If no operator
+                    // follows, it's a typecast.  No semantic checking needed to parse.
+                    // if it _looks_ like a cast, it _is_ a cast; else it's a "(expr)"
+                |    (LPAREN typeCastParameters RPAREN unaryExpressionNotPlusMinus)=>
+                    lp:LPAREN^ {#lp.setType(TYPECAST);} typeCastParameters RPAREN
+                    castExpression
+
+                |   (LPAREN typeCastParameters RPAREN lambdaExpression) =>
+                      lpl:LPAREN^ {#lpl.setType(TYPECAST);}
+                      typeCastParameters RPAREN lambdaExpression
+
+                |  postfixExpression
         )
     ;
 
@@ -1587,6 +1613,11 @@ postfixExpression
         )
     ;
 
+switchExpression
+    :
+    "switch"^ LPAREN expression RPAREN switchBlock
+    ;
+
 // the basic element of an expression
 primaryExpression
     :   (typeSpec[false] DOUBLE_COLON) => typeSpec[false]
@@ -1715,7 +1746,8 @@ lambdaExpression
 
 lambdaParameters
     :    id
-    |    LPAREN (parameterDeclarationList)? RPAREN
+    |    l:LPAREN (parameterDeclarationList)? RPAREN
+            (id {#l.setType(TYPECAST);})?
     ;
 
 lambdaBody
@@ -1725,9 +1757,11 @@ lambdaBody
 
 // This rule was created to remedy the "keyword as identifier" problem
 // See: https://github.com/checkstyle/checkstyle/issues/8308
-id: IDENT | recordKey ;
+id: IDENT | recordKey | yieldKey;
 
 recordKey: "record" {#recordKey.setType(IDENT);};
+yieldKey: "yield" {#yieldKey.setType(IDENT);};
+
 
 //----------------------------------------------------------------------------
 // The Java scanner

src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalTokenTextCheckTest.java

@@ -142,7 +142,7 @@ public void testOrderOfProperties() throws Exception {
 
     @Test
     public void testAcceptableTokensMakeSense() {
-        final int expectedTokenTypesTotalNumber = 172;
+        final int expectedTokenTypesTotalNumber = 173;
         assertEquals(expectedTokenTypesTotalNumber, TokenUtil.getTokenTypesTotalNumber(),
                 "Total number of TokenTypes has changed, acceptable tokens in"
                 + " IllegalTokenTextCheck need to be reconsidered.");

src/test/java/com/puppycrawl/tools/checkstyle/grammar/AstRegressionTest.java

@@ -209,6 +209,12 @@ public void testJava14Records() throws Exception {
                 getNonCompilablePath("java14/InputJava14Records.java"));
     }
 
+    @Test
+    public void testJava14SwitchExpression() throws Exception {
+        verifyAst(getPath("java14/InputJava14SwitchExpression.txt"),
+                getNonCompilablePath("java14/InputJava14SwitchExpression.java"));
+    }
+
     @Test
     public void testImpossibleExceptions() throws Exception {
         AssertGeneratedJavaLexer.verifyFail("mSTD_ESC", 'a');

src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java

@@ -256,8 +256,10 @@ public void testTokenNumbering() {
         assertEquals(198, GeneratedJavaTokenTypes.PATTERN_VARIABLE_DEF, message);
         assertEquals(199, GeneratedJavaTokenTypes.RECORD_DEF, message);
         assertEquals(200, GeneratedJavaTokenTypes.LITERAL_record, message);
+        assertEquals(201, GeneratedJavaTokenTypes.LITERAL_yield, message);
+
         // Read JavaDoc before changing
-        assertEquals(199, GeneratedJavaTokenTypes.class.getDeclaredFields().length,
+        assertEquals(200, GeneratedJavaTokenTypes.class.getDeclaredFields().length,
                 "all tokens must be added to list in"
                         + " 'GeneratedJavaTokenTypesTest' and verified"
                         + " that their old numbering didn't change");

src/test/java/com/puppycrawl/tools/checkstyle/internal/AllChecksTest.java

@@ -130,7 +130,8 @@ public class AllChecksTest extends AbstractModuleTestSupport {
                         "NUM_INT", "ANNOTATION_DEF", "METHOD_REF", "TYPE_ARGUMENTS",
                         "DOUBLE_COLON", "IDENT", "MOD_ASSIGN", "LITERAL_FOR", "SUPER_CTOR_CALL",
                         "STRING_LITERAL", "ARRAY_DECLARATOR", "LITERAL_CASE",
-                        "PATTERN_VARIABLE_DEF", "RECORD_DEF", "LITERAL_RECORD").collect(
+                        "PATTERN_VARIABLE_DEF", "RECORD_DEF", "LITERAL_RECORD",
+                        "LITERAL_YIELD").collect(
                         Collectors.toSet()));
         // we have no need to block specific token text
         CHECKSTYLE_TOKENS_IN_CONFIG_TO_IGNORE.put("IllegalTokenText",

src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java

@@ -200,16 +200,16 @@ public void testIsCommentType() {
     public void testGetTokenTypesTotalNumber() {
         final int tokenTypesTotalNumber = TokenUtil.getTokenTypesTotalNumber();
 
-        assertEquals(172, tokenTypesTotalNumber, "Invalid token total number");
+        assertEquals(173, tokenTypesTotalNumber, "Invalid token total number");
     }
 
     @Test
     public void testGetAllTokenIds() {
         final int[] allTokenIds = TokenUtil.getAllTokenIds();
         final int sum = Arrays.stream(allTokenIds).sum();
 
-        assertEquals(172, allTokenIds.length, "Invalid token length");
-        assertEquals(16259, sum, "invalid sum");
+        assertEquals(173, allTokenIds.length, "Invalid token length");
+        assertEquals(16460, sum, "invalid sum");
     }
 
     @Test

src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14SwitchExpression.java

@@ -428,7 +428,7 @@ I<String> lambdaCapture2(int i) {
             case 1 -> () -> "1" + j; //capture local variable
             default -> {
                 String k = "D";
-                yield () -> k; //capture local from the switch expr.
+                yield() ->k; //capture local from the switch expr.
             }
         };
     }