From 78c7001c46640f9ae51d87de9f44a213ba195e72 Mon Sep 17 00:00:00 2001 From: Nick Mancuso Date: Fri, 10 Jul 2020 08:24:41 -0400 Subject: [PATCH] Issue #6615: Add support for Java 14 switch and yield --- config/ant-phase-verify.xml | 2 + .../tools/checkstyle/api/TokenTypes.java | 7 + .../tools/checkstyle/grammar/java.g | 102 +- .../coding/IllegalTokenTextCheckTest.java | 2 +- .../checkstyle/grammar/AstRegressionTest.java | 6 + .../grammar/GeneratedJavaTokenTypesTest.java | 4 +- .../checkstyle/internal/AllChecksTest.java | 3 +- .../tools/checkstyle/utils/TokenUtilTest.java | 6 +- .../java14/InputJava14SwitchExpression.java | 2 +- .../java14/InputJava14SwitchExpression.txt | 2873 +++++++++++++++++ 10 files changed, 2966 insertions(+), 41 deletions(-) create mode 100644 src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14SwitchExpression.txt diff --git a/config/ant-phase-verify.xml b/config/ant-phase-verify.xml index 4e1ae344461..8fcc2322ee6 100644 --- a/config/ant-phase-verify.xml +++ b/config/ant-phase-verify.xml @@ -118,6 +118,8 @@ + + diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java b/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java index 2d87859fd50..3d2617b3771 100644 --- a/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java +++ b/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() { } diff --git a/src/main/resources/com/puppycrawl/tools/checkstyle/grammar/java.g b/src/main/resources/com/puppycrawl/tools/checkstyle/grammar/java.g index 3ea5482389c..7529fbe2f61 100644 --- a/src/main/resources/com/puppycrawl/tools/checkstyle/grammar/java.g +++ b/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 diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalTokenTextCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalTokenTextCheckTest.java index 106005a17aa..27291f7f3e7 100644 --- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalTokenTextCheckTest.java +++ b/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."); diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/AstRegressionTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/AstRegressionTest.java index b6067614fe5..f1bccbd901c 100644 --- a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/AstRegressionTest.java +++ b/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'); diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java index 56268ff0ad4..7bfde50762d 100644 --- a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java +++ b/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"); diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/internal/AllChecksTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/internal/AllChecksTest.java index 5dab8f6cc0f..e00dc8bf4a8 100644 --- a/src/test/java/com/puppycrawl/tools/checkstyle/internal/AllChecksTest.java +++ b/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", diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java index f6e08f6fad1..4283b32a6a7 100644 --- a/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java +++ b/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java @@ -200,7 +200,7 @@ 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 @@ -208,8 +208,8 @@ 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 diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14SwitchExpression.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14SwitchExpression.java index 6aaa5a6bcf4..538e4c390ae 100644 --- a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14SwitchExpression.java +++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14SwitchExpression.java @@ -428,7 +428,7 @@ I 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. } }; } diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14SwitchExpression.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14SwitchExpression.txt new file mode 100644 index 00000000000..b2958da0d8a --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java14/InputJava14SwitchExpression.txt @@ -0,0 +1,2873 @@ +PACKAGE_DEF -> package [2:0] +|--ANNOTATIONS -> ANNOTATIONS [2:39] +|--DOT -> . [2:39] +| |--DOT -> . [2:28] +| | |--DOT -> . [2:22] +| | | |--DOT -> . [2:11] +| | | | |--IDENT -> com [2:8] +| | | | `--IDENT -> puppycrawl [2:12] +| | | `--IDENT -> tools [2:23] +| | `--IDENT -> checkstyle [2:29] +| `--IDENT -> grammar [2:40] +`--SEMI -> ; [2:47] +IMPORT -> import [4:0] +|--DOT -> . [4:16] +| |--DOT -> . [4:11] +| | |--IDENT -> java [4:7] +| | `--IDENT -> util [4:12] +| `--IDENT -> EnumSet [4:17] +`--SEMI -> ; [4:24] +IMPORT -> import [5:0] +|--DOT -> . [5:16] +| |--DOT -> . [5:11] +| | |--IDENT -> java [5:7] +| | `--IDENT -> util [5:12] +| `--IDENT -> Set [5:17] +`--SEMI -> ; [5:20] +IMPORT -> import [6:0] +|--DOT -> . [6:25] +| |--DOT -> . [6:16] +| | |--DOT -> . [6:11] +| | | |--IDENT -> java [6:7] +| | | `--IDENT -> util [6:12] +| | `--IDENT -> function [6:17] +| `--IDENT -> Supplier [6:26] +`--SEMI -> ; [6:34] +CLASS_DEF -> CLASS_DEF [8:0] +|--MODIFIERS -> MODIFIERS [8:0] +| `--LITERAL_PUBLIC -> public [8:0] +|--LITERAL_CLASS -> class [8:7] +|--IDENT -> InputJava14SwitchExpression [8:13] +`--OBJBLOCK -> OBJBLOCK [8:41] + |--LCURLY -> { [8:41] + |--ENUM_DEF -> ENUM_DEF [10:4] + | |--MODIFIERS -> MODIFIERS [10:4] + | |--ENUM -> enum [10:4] + | |--IDENT -> Day [10:9] + | `--OBJBLOCK -> OBJBLOCK [10:13] + | |--LCURLY -> { [10:13] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [11:8] + | | |--ANNOTATIONS -> ANNOTATIONS [11:8] + | | `--IDENT -> MON [11:8] + | |--COMMA -> , [11:11] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [12:8] + | | |--ANNOTATIONS -> ANNOTATIONS [12:8] + | | `--IDENT -> TUE [12:8] + | |--COMMA -> , [12:11] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [13:8] + | | |--ANNOTATIONS -> ANNOTATIONS [13:8] + | | `--IDENT -> WED [13:8] + | |--COMMA -> , [13:11] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [14:8] + | | |--ANNOTATIONS -> ANNOTATIONS [14:8] + | | `--IDENT -> THU [14:8] + | |--COMMA -> , [14:11] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [15:8] + | | |--ANNOTATIONS -> ANNOTATIONS [15:8] + | | `--IDENT -> FRI [15:8] + | |--COMMA -> , [15:11] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [16:8] + | | |--ANNOTATIONS -> ANNOTATIONS [16:8] + | | `--IDENT -> SAT [16:8] + | |--COMMA -> , [16:11] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [17:8] + | | |--ANNOTATIONS -> ANNOTATIONS [17:8] + | | `--IDENT -> SUN [17:8] + | |--COMMA -> , [17:11] + | `--RCURLY -> } [18:4] + |--METHOD_DEF -> METHOD_DEF [20:4] + | |--MODIFIERS -> MODIFIERS [20:4] + | |--TYPE -> TYPE [20:4] + | | `--IDENT -> String [20:4] + | |--IDENT -> whatIsToday [20:11] + | |--LPAREN -> ( [20:22] + | |--PARAMETERS -> PARAMETERS [20:23] + | | `--PARAMETER_DEF -> PARAMETER_DEF [20:23] + | | |--MODIFIERS -> MODIFIERS [20:23] + | | |--TYPE -> TYPE [20:23] + | | | `--IDENT -> Day [20:23] + | | `--IDENT -> day [20:27] + | |--RPAREN -> ) [20:30] + | `--SLIST -> { [20:32] + | |--LITERAL_RETURN -> return [21:8] + | | |--EXPR -> EXPR [21:15] + | | | `--LITERAL_SWITCH -> switch [21:15] + | | | |--LPAREN -> ( [21:22] + | | | |--EXPR -> EXPR [21:23] + | | | | `--IDENT -> day [21:23] + | | | |--RPAREN -> ) [21:26] + | | | |--LCURLY -> { [21:28] + | | | |--CASE_GROUP -> CASE_GROUP [22:12] + | | | | |--LITERAL_CASE -> case [22:12] + | | | | | |--EXPR -> EXPR [22:17] + | | | | | | `--IDENT -> SAT [22:17] + | | | | | |--COMMA -> , [22:20] + | | | | | |--EXPR -> EXPR [22:22] + | | | | | | `--IDENT -> SUN [22:22] + | | | | | |--LAMBDA -> -> [22:26] + | | | | | |--EXPR -> EXPR [22:29] + | | | | | | `--STRING_LITERAL -> "Weekend" [22:29] + | | | | | `--SEMI -> ; [22:38] + | | | | |--LITERAL_CASE -> case [23:12] + | | | | | |--EXPR -> EXPR [23:17] + | | | | | | `--IDENT -> MON [23:17] + | | | | | |--COMMA -> , [23:20] + | | | | | |--EXPR -> EXPR [23:22] + | | | | | | `--IDENT -> TUE [23:22] + | | | | | |--COMMA -> , [23:25] + | | | | | |--EXPR -> EXPR [23:27] + | | | | | | `--IDENT -> WED [23:27] + | | | | | |--COMMA -> , [23:30] + | | | | | |--EXPR -> EXPR [23:32] + | | | | | | `--IDENT -> THU [23:32] + | | | | | |--COMMA -> , [23:35] + | | | | | |--EXPR -> EXPR [23:37] + | | | | | | `--IDENT -> FRI [23:37] + | | | | | |--LAMBDA -> -> [23:41] + | | | | | |--EXPR -> EXPR [23:44] + | | | | | | `--STRING_LITERAL -> "Working day" [23:44] + | | | | | `--SEMI -> ; [23:57] + | | | | `--LITERAL_DEFAULT -> default [24:12] + | | | | |--LAMBDA -> -> [24:20] + | | | | `--LITERAL_THROW -> throw [24:23] + | | | | |--EXPR -> EXPR [24:29] + | | | | | `--LITERAL_NEW -> new [24:29] + | | | | | |--IDENT -> IllegalArgumentException [24:33] + | | | | | |--LPAREN -> ( [24:57] + | | | | | |--ELIST -> ELIST [24:74] + | | | | | | `--EXPR -> EXPR [24:74] + | | | | | | `--PLUS -> + [24:74] + | | | | | | |--STRING_LITERAL -> "Invalid day: " [24:58] + | | | | | | `--METHOD_CALL -> ( [24:84] + | | | | | | |--DOT -> . [24:79] + | | | | | | | |--IDENT -> day [24:76] + | | | | | | | `--IDENT -> name [24:80] + | | | | | | |--ELIST -> ELIST [24:85] + | | | | | | `--RPAREN -> ) [24:85] + | | | | | `--RPAREN -> ) [24:86] + | | | | `--SEMI -> ; [24:87] + | | | `--RCURLY -> } [25:8] + | | `--SEMI -> ; [25:9] + | `--RCURLY -> } [26:4] + |--METHOD_DEF -> METHOD_DEF [28:4] + | |--MODIFIERS -> MODIFIERS [28:4] + | |--TYPE -> TYPE [28:4] + | | |--IDENT -> Set [28:4] + | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [28:7] + | | |--GENERIC_START -> < [28:7] + | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [28:8] + | | | `--IDENT -> Day [28:8] + | | `--GENERIC_END -> > [28:11] + | |--IDENT -> days [28:13] + | |--LPAREN -> ( [28:17] + | |--PARAMETERS -> PARAMETERS [28:18] + | | `--PARAMETER_DEF -> PARAMETER_DEF [28:18] + | | |--MODIFIERS -> MODIFIERS [28:18] + | | |--TYPE -> TYPE [28:18] + | | | `--IDENT -> String [28:18] + | | `--IDENT -> weekPart [28:25] + | |--RPAREN -> ) [28:33] + | `--SLIST -> { [28:35] + | |--LITERAL_RETURN -> return [29:8] + | | |--EXPR -> EXPR [29:15] + | | | `--LITERAL_SWITCH -> switch [29:15] + | | | |--LPAREN -> ( [29:22] + | | | |--EXPR -> EXPR [29:23] + | | | | `--IDENT -> weekPart [29:23] + | | | |--RPAREN -> ) [29:31] + | | | |--LCURLY -> { [29:33] + | | | |--CASE_GROUP -> CASE_GROUP [30:12] + | | | | |--LITERAL_CASE -> case [30:12] + | | | | | |--EXPR -> EXPR [30:17] + | | | | | | `--STRING_LITERAL -> "Weekend" [30:17] + | | | | | |--LAMBDA -> -> [30:27] + | | | | | |--EXPR -> EXPR [30:40] + | | | | | | `--METHOD_CALL -> ( [30:40] + | | | | | | |--DOT -> . [30:37] + | | | | | | | |--IDENT -> EnumSet [30:30] + | | | | | | | `--IDENT -> of [30:38] + | | | | | | |--ELIST -> ELIST [30:44] + | | | | | | | |--EXPR -> EXPR [30:44] + | | | | | | | | `--DOT -> . [30:44] + | | | | | | | | |--IDENT -> Day [30:41] + | | | | | | | | `--IDENT -> SAT [30:45] + | | | | | | | |--COMMA -> , [30:48] + | | | | | | | `--EXPR -> EXPR [30:53] + | | | | | | | `--DOT -> . [30:53] + | | | | | | | |--IDENT -> Day [30:50] + | | | | | | | `--IDENT -> SUN [30:54] + | | | | | | `--RPAREN -> ) [30:57] + | | | | | `--SEMI -> ; [30:58] + | | | | |--LITERAL_CASE -> case [31:12] + | | | | | |--EXPR -> EXPR [31:17] + | | | | | | `--STRING_LITERAL -> "Working day" [31:17] + | | | | | |--LAMBDA -> -> [31:31] + | | | | | |--EXPR -> EXPR [31:44] + | | | | | | `--METHOD_CALL -> ( [31:44] + | | | | | | |--DOT -> . [31:41] + | | | | | | | |--IDENT -> EnumSet [31:34] + | | | | | | | `--IDENT -> of [31:42] + | | | | | | |--ELIST -> ELIST [31:48] + | | | | | | | |--EXPR -> EXPR [31:48] + | | | | | | | | `--DOT -> . [31:48] + | | | | | | | | |--IDENT -> Day [31:45] + | | | | | | | | `--IDENT -> MON [31:49] + | | | | | | | |--COMMA -> , [31:52] + | | | | | | | |--EXPR -> EXPR [31:57] + | | | | | | | | `--DOT -> . [31:57] + | | | | | | | | |--IDENT -> Day [31:54] + | | | | | | | | `--IDENT -> TUE [31:58] + | | | | | | | |--COMMA -> , [31:61] + | | | | | | | |--EXPR -> EXPR [31:66] + | | | | | | | | `--DOT -> . [31:66] + | | | | | | | | |--IDENT -> Day [31:63] + | | | | | | | | `--IDENT -> WED [31:67] + | | | | | | | |--COMMA -> , [31:70] + | | | | | | | |--EXPR -> EXPR [31:75] + | | | | | | | | `--DOT -> . [31:75] + | | | | | | | | |--IDENT -> Day [31:72] + | | | | | | | | `--IDENT -> THU [31:76] + | | | | | | | |--COMMA -> , [31:79] + | | | | | | | `--EXPR -> EXPR [31:84] + | | | | | | | `--DOT -> . [31:84] + | | | | | | | |--IDENT -> Day [31:81] + | | | | | | | `--IDENT -> FRI [31:85] + | | | | | | `--RPAREN -> ) [31:88] + | | | | | `--SEMI -> ; [31:89] + | | | | `--LITERAL_DEFAULT -> default [32:12] + | | | | |--LAMBDA -> -> [32:20] + | | | | `--LITERAL_THROW -> throw [32:23] + | | | | |--EXPR -> EXPR [32:29] + | | | | | `--LITERAL_NEW -> new [32:29] + | | | | | |--IDENT -> IllegalArgumentException [32:33] + | | | | | |--LPAREN -> ( [32:57] + | | | | | |--ELIST -> ELIST [32:79] + | | | | | | `--EXPR -> EXPR [32:79] + | | | | | | `--PLUS -> + [32:79] + | | | | | | |--STRING_LITERAL -> "Invalid weekPart: " [32:58] + | | | | | | `--IDENT -> weekPart [32:81] + | | | | | `--RPAREN -> ) [32:89] + | | | | `--SEMI -> ; [32:90] + | | | `--RCURLY -> } [33:8] + | | `--SEMI -> ; [33:9] + | `--RCURLY -> } [34:4] + |--METHOD_DEF -> METHOD_DEF [36:4] + | |--MODIFIERS -> MODIFIERS [36:4] + | |--TYPE -> TYPE [36:4] + | | `--IDENT -> String [36:4] + | |--IDENT -> isDayNameLong [36:11] + | |--LPAREN -> ( [36:24] + | |--PARAMETERS -> PARAMETERS [36:25] + | | `--PARAMETER_DEF -> PARAMETER_DEF [36:25] + | | |--MODIFIERS -> MODIFIERS [36:25] + | | |--TYPE -> TYPE [36:25] + | | | `--IDENT -> Day [36:25] + | | `--IDENT -> day [36:29] + | |--RPAREN -> ) [36:32] + | `--SLIST -> { [36:34] + | |--LITERAL_RETURN -> return [37:8] + | | |--EXPR -> EXPR [42:14] + | | | `--QUESTION -> ? [42:14] + | | | |--GT -> > [42:10] + | | | | |--LITERAL_SWITCH -> switch [37:15] + | | | | | |--LPAREN -> ( [37:22] + | | | | | |--EXPR -> EXPR [37:23] + | | | | | | `--IDENT -> day [37:23] + | | | | | |--RPAREN -> ) [37:26] + | | | | | |--LCURLY -> { [37:28] + | | | | | |--CASE_GROUP -> CASE_GROUP [38:12] + | | | | | | |--LITERAL_CASE -> case [38:12] + | | | | | | | |--EXPR -> EXPR [38:17] + | | | | | | | | `--IDENT -> MON [38:17] + | | | | | | | |--COMMA -> , [38:20] + | | | | | | | |--EXPR -> EXPR [38:22] + | | | | | | | | `--IDENT -> FRI [38:22] + | | | | | | | |--COMMA -> , [38:25] + | | | | | | | |--EXPR -> EXPR [38:27] + | | | | | | | | `--IDENT -> SUN [38:27] + | | | | | | | |--LAMBDA -> -> [38:31] + | | | | | | | |--EXPR -> EXPR [38:34] + | | | | | | | | `--NUM_INT -> 6 [38:34] + | | | | | | | `--SEMI -> ; [38:35] + | | | | | | |--LITERAL_CASE -> case [39:12] + | | | | | | | |--EXPR -> EXPR [39:17] + | | | | | | | | `--IDENT -> TUE [39:17] + | | | | | | | |--LAMBDA -> -> [39:21] + | | | | | | | |--EXPR -> EXPR [39:24] + | | | | | | | | `--NUM_INT -> 7 [39:24] + | | | | | | | `--SEMI -> ; [39:25] + | | | | | | |--LITERAL_CASE -> case [40:12] + | | | | | | | |--EXPR -> EXPR [40:17] + | | | | | | | | `--IDENT -> THU [40:17] + | | | | | | | |--COMMA -> , [40:20] + | | | | | | | |--EXPR -> EXPR [40:22] + | | | | | | | | `--IDENT -> SAT [40:22] + | | | | | | | |--LAMBDA -> -> [40:26] + | | | | | | | |--EXPR -> EXPR [40:29] + | | | | | | | | `--NUM_INT -> 8 [40:29] + | | | | | | | `--SEMI -> ; [40:30] + | | | | | | `--LITERAL_CASE -> case [41:12] + | | | | | | |--EXPR -> EXPR [41:17] + | | | | | | | `--IDENT -> WED [41:17] + | | | | | | |--LAMBDA -> -> [41:21] + | | | | | | |--EXPR -> EXPR [41:24] + | | | | | | | `--NUM_INT -> 9 [41:24] + | | | | | | `--SEMI -> ; [41:25] + | | | | | `--RCURLY -> } [42:8] + | | | | `--NUM_INT -> 7 [42:12] + | | | |--STRING_LITERAL -> "long" [42:16] + | | | |--COLON -> : [42:23] + | | | `--STRING_LITERAL -> "short" [42:25] + | | `--SEMI -> ; [42:32] + | `--RCURLY -> } [43:4] + |--METHOD_DEF -> METHOD_DEF [45:4] + | |--MODIFIERS -> MODIFIERS [45:4] + | |--TYPE -> TYPE [45:4] + | | `--LITERAL_INT -> int [45:4] + | |--IDENT -> assignement [45:8] + | |--LPAREN -> ( [45:19] + | |--PARAMETERS -> PARAMETERS [45:20] + | | `--PARAMETER_DEF -> PARAMETER_DEF [45:20] + | | |--MODIFIERS -> MODIFIERS [45:20] + | | |--TYPE -> TYPE [45:20] + | | | `--IDENT -> Day [45:20] + | | `--IDENT -> day [45:24] + | |--RPAREN -> ) [45:27] + | `--SLIST -> { [45:29] + | |--VARIABLE_DEF -> VARIABLE_DEF [46:8] + | | |--MODIFIERS -> MODIFIERS [46:8] + | | |--TYPE -> TYPE [46:8] + | | | `--LITERAL_INT -> int [46:8] + | | |--IDENT -> numLetters [46:12] + | | `--ASSIGN -> = [46:23] + | | `--EXPR -> EXPR [46:25] + | | `--LITERAL_SWITCH -> switch [46:25] + | | |--LPAREN -> ( [46:32] + | | |--EXPR -> EXPR [46:33] + | | | `--IDENT -> day [46:33] + | | |--RPAREN -> ) [46:36] + | | |--LCURLY -> { [46:38] + | | |--CASE_GROUP -> CASE_GROUP [47:12] + | | | |--LITERAL_CASE -> case [47:12] + | | | | |--EXPR -> EXPR [47:17] + | | | | | `--IDENT -> MON [47:17] + | | | | |--COMMA -> , [47:20] + | | | | |--EXPR -> EXPR [47:22] + | | | | | `--IDENT -> FRI [47:22] + | | | | |--COMMA -> , [47:25] + | | | | |--EXPR -> EXPR [47:27] + | | | | | `--IDENT -> SUN [47:27] + | | | | |--LAMBDA -> -> [47:31] + | | | | |--EXPR -> EXPR [47:34] + | | | | | `--NUM_INT -> 6 [47:34] + | | | | `--SEMI -> ; [47:35] + | | | |--LITERAL_CASE -> case [48:12] + | | | | |--EXPR -> EXPR [48:17] + | | | | | `--IDENT -> TUE [48:17] + | | | | |--LAMBDA -> -> [48:21] + | | | | |--EXPR -> EXPR [48:24] + | | | | | `--NUM_INT -> 7 [48:24] + | | | | `--SEMI -> ; [48:25] + | | | |--LITERAL_CASE -> case [49:12] + | | | | |--EXPR -> EXPR [49:17] + | | | | | `--IDENT -> THU [49:17] + | | | | |--COMMA -> , [49:20] + | | | | |--EXPR -> EXPR [49:22] + | | | | | `--IDENT -> SAT [49:22] + | | | | |--LAMBDA -> -> [49:26] + | | | | |--EXPR -> EXPR [49:29] + | | | | | `--NUM_INT -> 8 [49:29] + | | | | `--SEMI -> ; [49:30] + | | | `--LITERAL_CASE -> case [50:12] + | | | |--EXPR -> EXPR [50:17] + | | | | `--IDENT -> WED [50:17] + | | | |--LAMBDA -> -> [50:21] + | | | |--EXPR -> EXPR [50:24] + | | | | `--NUM_INT -> 9 [50:24] + | | | `--SEMI -> ; [50:25] + | | `--RCURLY -> } [51:8] + | |--SEMI -> ; [51:9] + | |--LITERAL_RETURN -> return [52:8] + | | |--EXPR -> EXPR [52:15] + | | | `--IDENT -> numLetters [52:15] + | | `--SEMI -> ; [52:25] + | `--RCURLY -> } [53:4] + |--METHOD_DEF -> METHOD_DEF [55:4] + | |--MODIFIERS -> MODIFIERS [55:4] + | | `--LITERAL_STATIC -> static [55:4] + | |--TYPE -> TYPE [55:11] + | | `--LITERAL_VOID -> void [55:11] + | |--IDENT -> howMany [55:16] + | |--LPAREN -> ( [55:23] + | |--PARAMETERS -> PARAMETERS [55:24] + | | `--PARAMETER_DEF -> PARAMETER_DEF [55:24] + | | |--MODIFIERS -> MODIFIERS [55:24] + | | |--TYPE -> TYPE [55:24] + | | | `--LITERAL_INT -> int [55:24] + | | `--IDENT -> k [55:28] + | |--RPAREN -> ) [55:29] + | `--SLIST -> { [55:31] + | |--LITERAL_SWITCH -> switch [56:8] + | | |--LPAREN -> ( [56:15] + | | |--EXPR -> EXPR [56:16] + | | | `--IDENT -> k [56:16] + | | |--RPAREN -> ) [56:17] + | | |--LCURLY -> { [56:19] + | | |--CASE_GROUP -> CASE_GROUP [57:12] + | | | |--LITERAL_CASE -> case [57:12] + | | | | |--EXPR -> EXPR [57:17] + | | | | | `--NUM_INT -> 1 [57:17] + | | | | |--LAMBDA -> -> [57:19] + | | | | |--EXPR -> EXPR [57:40] + | | | | | `--METHOD_CALL -> ( [57:40] + | | | | | |--DOT -> . [57:32] + | | | | | | |--DOT -> . [57:28] + | | | | | | | |--IDENT -> System [57:22] + | | | | | | | `--IDENT -> out [57:29] + | | | | | | `--IDENT -> println [57:33] + | | | | | |--ELIST -> ELIST [57:41] + | | | | | | `--EXPR -> EXPR [57:41] + | | | | | | `--STRING_LITERAL -> "one" [57:41] + | | | | | `--RPAREN -> ) [57:46] + | | | | `--SEMI -> ; [57:47] + | | | |--LITERAL_CASE -> case [58:12] + | | | | |--EXPR -> EXPR [58:17] + | | | | | `--NUM_INT -> 2 [58:17] + | | | | |--LAMBDA -> -> [58:19] + | | | | |--EXPR -> EXPR [58:40] + | | | | | `--METHOD_CALL -> ( [58:40] + | | | | | |--DOT -> . [58:32] + | | | | | | |--DOT -> . [58:28] + | | | | | | | |--IDENT -> System [58:22] + | | | | | | | `--IDENT -> out [58:29] + | | | | | | `--IDENT -> println [58:33] + | | | | | |--ELIST -> ELIST [58:41] + | | | | | | `--EXPR -> EXPR [58:41] + | | | | | | `--STRING_LITERAL -> "two" [58:41] + | | | | | `--RPAREN -> ) [58:46] + | | | | `--SEMI -> ; [58:47] + | | | |--LITERAL_CASE -> case [59:12] + | | | | |--EXPR -> EXPR [59:17] + | | | | | `--NUM_INT -> 3 [59:17] + | | | | |--LAMBDA -> -> [59:19] + | | | | |--EXPR -> EXPR [59:40] + | | | | | `--METHOD_CALL -> ( [59:40] + | | | | | |--DOT -> . [59:32] + | | | | | | |--DOT -> . [59:28] + | | | | | | | |--IDENT -> System [59:22] + | | | | | | | `--IDENT -> out [59:29] + | | | | | | `--IDENT -> println [59:33] + | | | | | |--ELIST -> ELIST [59:41] + | | | | | | `--EXPR -> EXPR [59:41] + | | | | | | `--STRING_LITERAL -> "many" [59:41] + | | | | | `--RPAREN -> ) [59:47] + | | | | `--SEMI -> ; [59:48] + | | | `--LITERAL_DEFAULT -> default [60:12] + | | | |--LAMBDA -> -> [60:20] + | | | `--LITERAL_THROW -> throw [60:23] + | | | |--EXPR -> EXPR [60:29] + | | | | `--LITERAL_NEW -> new [60:29] + | | | | |--IDENT -> IllegalArgumentException [60:33] + | | | | |--LPAREN -> ( [60:57] + | | | | |--ELIST -> ELIST [60:58] + | | | | | `--EXPR -> EXPR [60:58] + | | | | | `--STRING_LITERAL -> "Unknown" [60:58] + | | | | `--RPAREN -> ) [60:67] + | | | `--SEMI -> ; [60:68] + | | `--RCURLY -> } [61:8] + | `--RCURLY -> } [62:4] + |--METHOD_DEF -> METHOD_DEF [64:4] + | |--MODIFIERS -> MODIFIERS [64:4] + | |--TYPE -> TYPE [64:4] + | | `--LITERAL_INT -> int [64:4] + | |--IDENT -> methodCalls [64:8] + | |--LPAREN -> ( [64:19] + | |--PARAMETERS -> PARAMETERS [64:20] + | | `--PARAMETER_DEF -> PARAMETER_DEF [64:20] + | | |--MODIFIERS -> MODIFIERS [64:20] + | | |--TYPE -> TYPE [64:20] + | | | `--IDENT -> Day [64:20] + | | `--IDENT -> day [64:24] + | |--RPAREN -> ) [64:27] + | `--SLIST -> { [64:29] + | |--LITERAL_RETURN -> return [65:8] + | | |--EXPR -> EXPR [65:15] + | | | `--LITERAL_SWITCH -> switch [65:15] + | | | |--LPAREN -> ( [65:22] + | | | |--EXPR -> EXPR [65:23] + | | | | `--IDENT -> day [65:23] + | | | |--RPAREN -> ) [65:26] + | | | |--LCURLY -> { [65:28] + | | | |--CASE_GROUP -> CASE_GROUP [66:12] + | | | | |--LITERAL_CASE -> case [66:12] + | | | | | |--EXPR -> EXPR [66:17] + | | | | | | `--IDENT -> MON [66:17] + | | | | | |--COMMA -> , [66:20] + | | | | | |--EXPR -> EXPR [66:22] + | | | | | | `--IDENT -> TUE [66:22] + | | | | | |--LAMBDA -> -> [66:26] + | | | | | |--EXPR -> EXPR [66:42] + | | | | | | `--METHOD_CALL -> ( [66:42] + | | | | | | |--DOT -> . [66:33] + | | | | | | | |--IDENT -> Math [66:29] + | | | | | | | `--IDENT -> addExact [66:34] + | | | | | | |--ELIST -> ELIST [66:43] + | | | | | | | |--EXPR -> EXPR [66:43] + | | | | | | | | `--NUM_INT -> 0 [66:43] + | | | | | | | |--COMMA -> , [66:44] + | | | | | | | `--EXPR -> EXPR [66:46] + | | | | | | | `--NUM_INT -> 1 [66:46] + | | | | | | `--RPAREN -> ) [66:47] + | | | | | `--SEMI -> ; [66:48] + | | | | |--LITERAL_CASE -> case [67:12] + | | | | | |--EXPR -> EXPR [67:17] + | | | | | | `--IDENT -> WED [67:17] + | | | | | |--LAMBDA -> -> [67:21] + | | | | | |--EXPR -> EXPR [67:37] + | | | | | | `--METHOD_CALL -> ( [67:37] + | | | | | | |--DOT -> . [67:28] + | | | | | | | |--IDENT -> Math [67:24] + | | | | | | | `--IDENT -> addExact [67:29] + | | | | | | |--ELIST -> ELIST [67:38] + | | | | | | | |--EXPR -> EXPR [67:38] + | | | | | | | | `--NUM_INT -> 1 [67:38] + | | | | | | | |--COMMA -> , [67:39] + | | | | | | | `--EXPR -> EXPR [67:41] + | | | | | | | `--NUM_INT -> 1 [67:41] + | | | | | | `--RPAREN -> ) [67:42] + | | | | | `--SEMI -> ; [67:43] + | | | | `--LITERAL_DEFAULT -> default [68:12] + | | | | |--LAMBDA -> -> [68:20] + | | | | `--SLIST -> { [68:23] + | | | | |--LITERAL_YIELD -> yield [69:16] + | | | | | `--EXPR -> EXPR [69:35] + | | | | | `--METHOD_CALL -> ( [69:35] + | | | | | |--DOT -> . [69:26] + | | | | | | |--IDENT -> Math [69:22] + | | | | | | `--IDENT -> addExact [69:27] + | | | | | |--ELIST -> ELIST [69:36] + | | | | | | |--EXPR -> EXPR [69:36] + | | | | | | | `--NUM_INT -> 2 [69:36] + | | | | | | |--COMMA -> , [69:37] + | | | | | | `--EXPR -> EXPR [69:39] + | | | | | | `--NUM_INT -> 1 [69:39] + | | | | | `--RPAREN -> ) [69:40] + | | | | `--RCURLY -> } [70:12] + | | | `--RCURLY -> } [71:8] + | | `--SEMI -> ; [71:9] + | `--RCURLY -> } [72:4] + |--METHOD_DEF -> METHOD_DEF [74:4] + | |--MODIFIERS -> MODIFIERS [74:4] + | |--TYPE -> TYPE [74:4] + | | `--LITERAL_INT -> int [74:4] + | |--IDENT -> yieldAcceptsExpressions [74:8] + | |--LPAREN -> ( [74:31] + | |--PARAMETERS -> PARAMETERS [74:32] + | | `--PARAMETER_DEF -> PARAMETER_DEF [74:32] + | | |--MODIFIERS -> MODIFIERS [74:32] + | | |--TYPE -> TYPE [74:32] + | | | `--IDENT -> Day [74:32] + | | `--IDENT -> day [74:36] + | |--RPAREN -> ) [74:39] + | `--SLIST -> { [74:41] + | |--LITERAL_RETURN -> return [75:8] + | | |--EXPR -> EXPR [75:15] + | | | `--LITERAL_SWITCH -> switch [75:15] + | | | |--LPAREN -> ( [75:22] + | | | |--EXPR -> EXPR [75:23] + | | | | `--IDENT -> day [75:23] + | | | |--RPAREN -> ) [75:26] + | | | |--LCURLY -> { [75:28] + | | | |--CASE_GROUP -> CASE_GROUP [76:12] + | | | | |--LITERAL_CASE -> case [76:12] + | | | | | |--EXPR -> EXPR [76:17] + | | | | | | `--IDENT -> MON [76:17] + | | | | | |--COMMA -> , [76:20] + | | | | | |--EXPR -> EXPR [76:22] + | | | | | | `--IDENT -> TUE [76:22] + | | | | | |--LAMBDA -> -> [76:26] + | | | | | |--EXPR -> EXPR [76:29] + | | | | | | `--NUM_INT -> 0 [76:29] + | | | | | `--SEMI -> ; [76:30] + | | | | |--LITERAL_CASE -> case [77:12] + | | | | | |--EXPR -> EXPR [77:17] + | | | | | | `--IDENT -> WED [77:17] + | | | | | |--LAMBDA -> -> [77:21] + | | | | | |--EXPR -> EXPR [77:24] + | | | | | | `--NUM_INT -> 1 [77:24] + | | | | | `--SEMI -> ; [77:25] + | | | | `--LITERAL_DEFAULT -> default [78:12] + | | | | |--LAMBDA -> -> [78:20] + | | | | |--EXPR -> EXPR [78:51] + | | | | | `--QUESTION -> ? [78:51] + | | | | | |--GT -> > [78:47] + | | | | | | |--METHOD_CALL -> ( [78:44] + | | | | | | | |--DOT -> . [78:37] + | | | | | | | | |--METHOD_CALL -> ( [78:35] + | | | | | | | | | |--DOT -> . [78:26] + | | | | | | | | | | |--IDENT -> day [78:23] + | | | | | | | | | | `--IDENT -> toString [78:27] + | | | | | | | | | |--ELIST -> ELIST [78:36] + | | | | | | | | | `--RPAREN -> ) [78:36] + | | | | | | | | `--IDENT -> length [78:38] + | | | | | | | |--ELIST -> ELIST [78:45] + | | | | | | | `--RPAREN -> ) [78:45] + | | | | | | `--NUM_INT -> 5 [78:49] + | | | | | |--NUM_INT -> 1 [78:53] + | | | | | |--COLON -> : [78:55] + | | | | | `--NUM_INT -> 0 [78:57] + | | | | `--SEMI -> ; [78:58] + | | | `--RCURLY -> } [79:8] + | | `--SEMI -> ; [79:9] + | `--RCURLY -> } [80:4] + |--METHOD_DEF -> METHOD_DEF [82:4] + | |--MODIFIERS -> MODIFIERS [82:4] + | |--TYPE -> TYPE [82:4] + | | `--LITERAL_INT -> int [82:4] + | |--IDENT -> complexCase [82:8] + | |--LPAREN -> ( [82:19] + | |--PARAMETERS -> PARAMETERS [82:20] + | | `--PARAMETER_DEF -> PARAMETER_DEF [82:20] + | | |--MODIFIERS -> MODIFIERS [82:20] + | | |--TYPE -> TYPE [82:20] + | | | `--IDENT -> Day [82:20] + | | `--IDENT -> day [82:24] + | |--RPAREN -> ) [82:27] + | `--SLIST -> { [82:29] + | |--LITERAL_RETURN -> return [83:8] + | | |--EXPR -> EXPR [83:15] + | | | `--LITERAL_SWITCH -> switch [83:15] + | | | |--LPAREN -> ( [83:22] + | | | |--EXPR -> EXPR [83:23] + | | | | `--IDENT -> day [83:23] + | | | |--RPAREN -> ) [83:26] + | | | |--LCURLY -> { [83:28] + | | | |--CASE_GROUP -> CASE_GROUP [84:12] + | | | | |--LITERAL_CASE -> case [84:12] + | | | | | |--EXPR -> EXPR [84:17] + | | | | | | `--IDENT -> MON [84:17] + | | | | | |--COMMA -> , [84:20] + | | | | | |--EXPR -> EXPR [84:22] + | | | | | | `--IDENT -> TUE [84:22] + | | | | | |--LAMBDA -> -> [84:26] + | | | | | `--SLIST -> { [84:29] + | | | | | |--VARIABLE_DEF -> VARIABLE_DEF [85:16] + | | | | | | |--MODIFIERS -> MODIFIERS [85:16] + | | | | | | |--TYPE -> TYPE [85:16] + | | | | | | | `--LITERAL_INT -> int [85:16] + | | | | | | |--IDENT -> l [85:20] + | | | | | | `--ASSIGN -> = [85:22] + | | | | | | `--EXPR -> EXPR [85:45] + | | | | | | `--METHOD_CALL -> ( [85:45] + | | | | | | |--DOT -> . [85:38] + | | | | | | | |--METHOD_CALL -> ( [85:36] + | | | | | | | | |--DOT -> . [85:27] + | | | | | | | | | |--IDENT -> day [85:24] + | | | | | | | | | `--IDENT -> toString [85:28] + | | | | | | | | |--ELIST -> ELIST [85:37] + | | | | | | | | `--RPAREN -> ) [85:37] + | | | | | | | `--IDENT -> length [85:39] + | | | | | | |--ELIST -> ELIST [85:46] + | | | | | | `--RPAREN -> ) [85:46] + | | | | | |--SEMI -> ; [85:47] + | | | | | |--LITERAL_YIELD -> yield [86:16] + | | | | | | `--EXPR -> EXPR [86:35] + | | | | | | `--METHOD_CALL -> ( [86:35] + | | | | | | |--DOT -> . [86:26] + | | | | | | | |--IDENT -> Math [86:22] + | | | | | | | `--IDENT -> addExact [86:27] + | | | | | | |--ELIST -> ELIST [86:36] + | | | | | | | |--EXPR -> EXPR [86:36] + | | | | | | | | `--IDENT -> l [86:36] + | | | | | | | |--COMMA -> , [86:37] + | | | | | | | `--EXPR -> EXPR [86:39] + | | | | | | | `--NUM_INT -> 0 [86:39] + | | | | | | `--RPAREN -> ) [86:40] + | | | | | `--RCURLY -> } [87:12] + | | | | |--LITERAL_CASE -> case [88:12] + | | | | | |--EXPR -> EXPR [88:17] + | | | | | | `--IDENT -> WED [88:17] + | | | | | |--LAMBDA -> -> [88:21] + | | | | | `--SLIST -> { [88:24] + | | | | | |--VARIABLE_DEF -> VARIABLE_DEF [89:16] + | | | | | | |--MODIFIERS -> MODIFIERS [89:16] + | | | | | | |--TYPE -> TYPE [89:16] + | | | | | | | `--LITERAL_INT -> int [89:16] + | | | | | | |--IDENT -> l [89:20] + | | | | | | `--ASSIGN -> = [89:22] + | | | | | | `--EXPR -> EXPR [89:45] + | | | | | | `--METHOD_CALL -> ( [89:45] + | | | | | | |--DOT -> . [89:38] + | | | | | | | |--METHOD_CALL -> ( [89:36] + | | | | | | | | |--DOT -> . [89:27] + | | | | | | | | | |--IDENT -> day [89:24] + | | | | | | | | | `--IDENT -> toString [89:28] + | | | | | | | | |--ELIST -> ELIST [89:37] + | | | | | | | | `--RPAREN -> ) [89:37] + | | | | | | | `--IDENT -> length [89:39] + | | | | | | |--ELIST -> ELIST [89:46] + | | | | | | `--RPAREN -> ) [89:46] + | | | | | |--SEMI -> ; [89:47] + | | | | | |--LITERAL_YIELD -> yield [90:16] + | | | | | | `--EXPR -> EXPR [90:35] + | | | | | | `--METHOD_CALL -> ( [90:35] + | | | | | | |--DOT -> . [90:26] + | | | | | | | |--IDENT -> Math [90:22] + | | | | | | | `--IDENT -> addExact [90:27] + | | | | | | |--ELIST -> ELIST [90:36] + | | | | | | | |--EXPR -> EXPR [90:36] + | | | | | | | | `--IDENT -> l [90:36] + | | | | | | | |--COMMA -> , [90:37] + | | | | | | | `--EXPR -> EXPR [90:39] + | | | | | | | `--NUM_INT -> 1 [90:39] + | | | | | | `--RPAREN -> ) [90:40] + | | | | | `--RCURLY -> } [91:12] + | | | | `--LITERAL_DEFAULT -> default [92:12] + | | | | |--LAMBDA -> -> [92:20] + | | | | `--SLIST -> { [92:23] + | | | | |--VARIABLE_DEF -> VARIABLE_DEF [93:16] + | | | | | |--MODIFIERS -> MODIFIERS [93:16] + | | | | | |--TYPE -> TYPE [93:16] + | | | | | | `--LITERAL_INT -> int [93:16] + | | | | | |--IDENT -> l [93:20] + | | | | | `--ASSIGN -> = [93:22] + | | | | | `--EXPR -> EXPR [93:45] + | | | | | `--METHOD_CALL -> ( [93:45] + | | | | | |--DOT -> . [93:38] + | | | | | | |--METHOD_CALL -> ( [93:36] + | | | | | | | |--DOT -> . [93:27] + | | | | | | | | |--IDENT -> day [93:24] + | | | | | | | | `--IDENT -> toString [93:28] + | | | | | | | |--ELIST -> ELIST [93:37] + | | | | | | | `--RPAREN -> ) [93:37] + | | | | | | `--IDENT -> length [93:39] + | | | | | |--ELIST -> ELIST [93:46] + | | | | | `--RPAREN -> ) [93:46] + | | | | |--SEMI -> ; [93:47] + | | | | |--LITERAL_YIELD -> yield [94:16] + | | | | | `--EXPR -> EXPR [94:35] + | | | | | `--METHOD_CALL -> ( [94:35] + | | | | | |--DOT -> . [94:26] + | | | | | | |--IDENT -> Math [94:22] + | | | | | | `--IDENT -> addExact [94:27] + | | | | | |--ELIST -> ELIST [94:36] + | | | | | | |--EXPR -> EXPR [94:36] + | | | | | | | `--IDENT -> l [94:36] + | | | | | | |--COMMA -> , [94:37] + | | | | | | `--EXPR -> EXPR [94:39] + | | | | | | `--NUM_INT -> 2 [94:39] + | | | | | `--RPAREN -> ) [94:40] + | | | | `--RCURLY -> } [95:12] + | | | `--RCURLY -> } [96:8] + | | `--SEMI -> ; [96:9] + | `--RCURLY -> } [97:4] + |--METHOD_DEF -> METHOD_DEF [99:4] + | |--MODIFIERS -> MODIFIERS [99:4] + | |--TYPE -> TYPE [99:4] + | | `--LITERAL_INT -> int [99:4] + | |--IDENT -> arithmetic [99:8] + | |--LPAREN -> ( [99:18] + | |--PARAMETERS -> PARAMETERS [99:19] + | | `--PARAMETER_DEF -> PARAMETER_DEF [99:19] + | | |--MODIFIERS -> MODIFIERS [99:19] + | | |--TYPE -> TYPE [99:19] + | | | `--IDENT -> Day [99:19] + | | `--IDENT -> day [99:23] + | |--RPAREN -> ) [99:26] + | `--SLIST -> { [99:28] + | |--LITERAL_RETURN -> return [100:8] + | | |--EXPR -> EXPR [105:10] + | | | `--MOD -> % [105:10] + | | | |--LITERAL_SWITCH -> switch [100:15] + | | | | |--LPAREN -> ( [100:22] + | | | | |--EXPR -> EXPR [100:23] + | | | | | `--IDENT -> day [100:23] + | | | | |--RPAREN -> ) [100:26] + | | | | |--LCURLY -> { [100:28] + | | | | |--CASE_GROUP -> CASE_GROUP [101:12] + | | | | | |--LITERAL_CASE -> case [101:12] + | | | | | | |--EXPR -> EXPR [101:17] + | | | | | | | `--IDENT -> MON [101:17] + | | | | | | |--COMMA -> , [101:20] + | | | | | | |--EXPR -> EXPR [101:22] + | | | | | | | `--IDENT -> FRI [101:22] + | | | | | | |--COMMA -> , [101:25] + | | | | | | |--EXPR -> EXPR [101:27] + | | | | | | | `--IDENT -> SUN [101:27] + | | | | | | |--LAMBDA -> -> [101:31] + | | | | | | |--EXPR -> EXPR [101:34] + | | | | | | | `--NUM_INT -> 6 [101:34] + | | | | | | `--SEMI -> ; [101:35] + | | | | | |--LITERAL_CASE -> case [102:12] + | | | | | | |--EXPR -> EXPR [102:17] + | | | | | | | `--IDENT -> TUE [102:17] + | | | | | | |--LAMBDA -> -> [102:21] + | | | | | | |--EXPR -> EXPR [102:24] + | | | | | | | `--NUM_INT -> 7 [102:24] + | | | | | | `--SEMI -> ; [102:25] + | | | | | |--LITERAL_CASE -> case [103:12] + | | | | | | |--EXPR -> EXPR [103:17] + | | | | | | | `--IDENT -> THU [103:17] + | | | | | | |--COMMA -> , [103:20] + | | | | | | |--EXPR -> EXPR [103:22] + | | | | | | | `--IDENT -> SAT [103:22] + | | | | | | |--LAMBDA -> -> [103:26] + | | | | | | |--EXPR -> EXPR [103:29] + | | | | | | | `--NUM_INT -> 8 [103:29] + | | | | | | `--SEMI -> ; [103:30] + | | | | | `--LITERAL_CASE -> case [104:12] + | | | | | |--EXPR -> EXPR [104:17] + | | | | | | `--IDENT -> WED [104:17] + | | | | | |--LAMBDA -> -> [104:21] + | | | | | |--EXPR -> EXPR [104:24] + | | | | | | `--NUM_INT -> 9 [104:24] + | | | | | `--SEMI -> ; [104:25] + | | | | `--RCURLY -> } [105:8] + | | | `--NUM_INT -> 2 [105:12] + | | `--SEMI -> ; [105:13] + | `--RCURLY -> } [106:4] + |--METHOD_DEF -> METHOD_DEF [108:4] + | |--MODIFIERS -> MODIFIERS [108:4] + | |--TYPE -> TYPE [108:4] + | | `--LITERAL_INT -> int [108:4] + | |--IDENT -> signArithmetic [108:8] + | |--LPAREN -> ( [108:22] + | |--PARAMETERS -> PARAMETERS [108:23] + | | `--PARAMETER_DEF -> PARAMETER_DEF [108:23] + | | |--MODIFIERS -> MODIFIERS [108:23] + | | |--TYPE -> TYPE [108:23] + | | | `--IDENT -> Day [108:23] + | | `--IDENT -> day [108:27] + | |--RPAREN -> ) [108:30] + | `--SLIST -> { [108:32] + | |--LITERAL_RETURN -> return [109:8] + | | |--EXPR -> EXPR [109:15] + | | | `--UNARY_MINUS -> - [109:15] + | | | `--LITERAL_SWITCH -> switch [109:16] + | | | |--LPAREN -> ( [109:23] + | | | |--EXPR -> EXPR [109:24] + | | | | `--IDENT -> day [109:24] + | | | |--RPAREN -> ) [109:27] + | | | |--LCURLY -> { [109:29] + | | | |--CASE_GROUP -> CASE_GROUP [110:12] + | | | | |--LITERAL_CASE -> case [110:12] + | | | | | |--EXPR -> EXPR [110:17] + | | | | | | `--IDENT -> MON [110:17] + | | | | | |--COMMA -> , [110:20] + | | | | | |--EXPR -> EXPR [110:22] + | | | | | | `--IDENT -> FRI [110:22] + | | | | | |--COMMA -> , [110:25] + | | | | | |--EXPR -> EXPR [110:27] + | | | | | | `--IDENT -> SUN [110:27] + | | | | | |--LAMBDA -> -> [110:31] + | | | | | |--EXPR -> EXPR [110:34] + | | | | | | `--NUM_INT -> 6 [110:34] + | | | | | `--SEMI -> ; [110:35] + | | | | |--LITERAL_CASE -> case [111:12] + | | | | | |--EXPR -> EXPR [111:17] + | | | | | | `--IDENT -> TUE [111:17] + | | | | | |--LAMBDA -> -> [111:21] + | | | | | |--EXPR -> EXPR [111:24] + | | | | | | `--NUM_INT -> 7 [111:24] + | | | | | `--SEMI -> ; [111:25] + | | | | |--LITERAL_CASE -> case [112:12] + | | | | | |--EXPR -> EXPR [112:17] + | | | | | | `--IDENT -> THU [112:17] + | | | | | |--COMMA -> , [112:20] + | | | | | |--EXPR -> EXPR [112:22] + | | | | | | `--IDENT -> SAT [112:22] + | | | | | |--LAMBDA -> -> [112:26] + | | | | | |--EXPR -> EXPR [112:29] + | | | | | | `--NUM_INT -> 8 [112:29] + | | | | | `--SEMI -> ; [112:30] + | | | | `--LITERAL_CASE -> case [113:12] + | | | | |--EXPR -> EXPR [113:17] + | | | | | `--IDENT -> WED [113:17] + | | | | |--LAMBDA -> -> [113:21] + | | | | |--EXPR -> EXPR [113:24] + | | | | | `--NUM_INT -> 9 [113:24] + | | | | `--SEMI -> ; [113:25] + | | | `--RCURLY -> } [114:8] + | | `--SEMI -> ; [114:9] + | `--RCURLY -> } [115:4] + |--METHOD_DEF -> METHOD_DEF [117:4] + | |--MODIFIERS -> MODIFIERS [117:4] + | |--TYPE -> TYPE [117:4] + | | `--LITERAL_INT -> int [117:4] + | |--IDENT -> usedOnBothSidesOfArithmeticExpression [117:8] + | |--LPAREN -> ( [117:45] + | |--PARAMETERS -> PARAMETERS [117:46] + | | `--PARAMETER_DEF -> PARAMETER_DEF [117:46] + | | |--MODIFIERS -> MODIFIERS [117:46] + | | |--TYPE -> TYPE [117:46] + | | | `--IDENT -> Day [117:46] + | | `--IDENT -> day [117:50] + | |--RPAREN -> ) [117:53] + | `--SLIST -> { [117:55] + | |--LITERAL_RETURN -> return [118:8] + | | |--EXPR -> EXPR [122:10] + | | | `--STAR -> * [122:10] + | | | |--LITERAL_SWITCH -> switch [118:15] + | | | | |--LPAREN -> ( [118:22] + | | | | |--EXPR -> EXPR [118:23] + | | | | | `--IDENT -> day [118:23] + | | | | |--RPAREN -> ) [118:26] + | | | | |--LCURLY -> { [118:28] + | | | | |--CASE_GROUP -> CASE_GROUP [119:12] + | | | | | |--LITERAL_CASE -> case [119:12] + | | | | | | |--EXPR -> EXPR [119:17] + | | | | | | | `--IDENT -> MON [119:17] + | | | | | | |--COMMA -> , [119:20] + | | | | | | |--EXPR -> EXPR [119:22] + | | | | | | | `--IDENT -> TUE [119:22] + | | | | | | |--LAMBDA -> -> [119:26] + | | | | | | |--EXPR -> EXPR [119:29] + | | | | | | | `--NUM_INT -> 0 [119:29] + | | | | | | `--SEMI -> ; [119:30] + | | | | | |--LITERAL_CASE -> case [120:12] + | | | | | | |--EXPR -> EXPR [120:17] + | | | | | | | `--IDENT -> WED [120:17] + | | | | | | |--LAMBDA -> -> [120:21] + | | | | | | |--EXPR -> EXPR [120:24] + | | | | | | | `--NUM_INT -> 1 [120:24] + | | | | | | `--SEMI -> ; [120:25] + | | | | | `--LITERAL_DEFAULT -> default [121:12] + | | | | | |--LAMBDA -> -> [121:20] + | | | | | |--EXPR -> EXPR [121:23] + | | | | | | `--NUM_INT -> 2 [121:23] + | | | | | `--SEMI -> ; [121:24] + | | | | `--RCURLY -> } [122:8] + | | | `--LITERAL_SWITCH -> switch [122:12] + | | | |--LPAREN -> ( [122:19] + | | | |--EXPR -> EXPR [122:20] + | | | | `--IDENT -> day [122:20] + | | | |--RPAREN -> ) [122:23] + | | | |--LCURLY -> { [122:25] + | | | |--CASE_GROUP -> CASE_GROUP [123:12] + | | | | |--LITERAL_CASE -> case [123:12] + | | | | | |--EXPR -> EXPR [123:17] + | | | | | | `--IDENT -> WED [123:17] + | | | | | |--COMMA -> , [123:20] + | | | | | |--EXPR -> EXPR [123:22] + | | | | | | `--IDENT -> THU [123:22] + | | | | | |--LAMBDA -> -> [123:26] + | | | | | |--EXPR -> EXPR [123:29] + | | | | | | `--NUM_INT -> 3 [123:29] + | | | | | `--SEMI -> ; [123:30] + | | | | |--LITERAL_CASE -> case [124:12] + | | | | | |--EXPR -> EXPR [124:17] + | | | | | | `--IDENT -> FRI [124:17] + | | | | | |--LAMBDA -> -> [124:21] + | | | | | |--EXPR -> EXPR [124:24] + | | | | | | `--NUM_INT -> 4 [124:24] + | | | | | `--SEMI -> ; [124:25] + | | | | `--LITERAL_DEFAULT -> default [125:12] + | | | | |--LAMBDA -> -> [125:20] + | | | | |--EXPR -> EXPR [125:23] + | | | | | `--NUM_INT -> 5 [125:23] + | | | | `--SEMI -> ; [125:24] + | | | `--RCURLY -> } [126:8] + | | `--SEMI -> ; [126:9] + | `--RCURLY -> } [127:4] + |--INSTANCE_INIT -> INSTANCE_INIT [129:4] + | `--SLIST -> { [129:4] + | |--VARIABLE_DEF -> VARIABLE_DEF [130:8] + | | |--MODIFIERS -> MODIFIERS [130:8] + | | |--TYPE -> TYPE [130:8] + | | | `--IDENT -> Integer [130:8] + | | |--IDENT -> i [130:16] + | | `--ASSIGN -> = [130:18] + | | `--EXPR -> EXPR [130:20] + | | `--NUM_INT -> 0 [130:20] + | |--SEMI -> ; [130:21] + | |--VARIABLE_DEF -> VARIABLE_DEF [131:8] + | | |--MODIFIERS -> MODIFIERS [131:8] + | | |--TYPE -> TYPE [131:8] + | | | `--IDENT -> Object [131:8] + | | |--IDENT -> o1 [131:15] + | | `--ASSIGN -> = [131:18] + | | `--EXPR -> EXPR [131:20] + | | `--STRING_LITERAL -> "o1" [131:20] + | |--SEMI -> ; [131:24] + | |--LITERAL_IF -> if [133:8] + | | |--LPAREN -> ( [133:11] + | | |--EXPR -> EXPR [133:12] + | | | `--LNOT -> ! [133:12] + | | | `--LITERAL_SWITCH -> switch [133:13] + | | | |--LPAREN -> ( [133:20] + | | | |--EXPR -> EXPR [133:21] + | | | | `--IDENT -> i [133:21] + | | | |--RPAREN -> ) [133:22] + | | | |--LCURLY -> { [133:24] + | | | |--CASE_GROUP -> CASE_GROUP [134:12] + | | | | |--LITERAL_DEFAULT -> default [134:12] + | | | | | `--COLON -> : [134:19] + | | | | `--SLIST -> SLIST [135:16] + | | | | |--LITERAL_IF -> if [135:16] + | | | | | |--LPAREN -> ( [135:19] + | | | | | |--EXPR -> EXPR [135:20] + | | | | | | `--LNOT -> ! [135:20] + | | | | | | |--LPAREN -> ( [135:21] + | | | | | | |--LITERAL_INSTANCEOF -> instanceof [135:25] + | | | | | | | |--IDENT -> o1 [135:22] + | | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [135:36] + | | | | | | | |--TYPE -> TYPE [135:36] + | | | | | | | | `--IDENT -> String [135:36] + | | | | | | | `--IDENT -> str [135:43] + | | | | | | `--RPAREN -> ) [135:46] + | | | | | |--RPAREN -> ) [135:47] + | | | | | `--SLIST -> { [135:49] + | | | | | |--LITERAL_YIELD -> yield [136:20] + | | | | | | `--EXPR -> EXPR [136:26] + | | | | | | `--LITERAL_FALSE -> false [136:26] + | | | | | `--RCURLY -> } [137:16] + | | | | |--LITERAL_IF -> if [138:16] + | | | | | |--LPAREN -> ( [138:19] + | | | | | |--EXPR -> EXPR [138:31] + | | | | | | `--METHOD_CALL -> ( [138:31] + | | | | | | |--DOT -> . [138:23] + | | | | | | | |--IDENT -> str [138:20] + | | | | | | | `--IDENT -> isEmpty [138:24] + | | | | | | |--ELIST -> ELIST [138:32] + | | | | | | `--RPAREN -> ) [138:32] + | | | | | |--RPAREN -> ) [138:33] + | | | | | `--SLIST -> { [138:35] + | | | | | |--LITERAL_YIELD -> yield [139:20] + | | | | | | `--EXPR -> EXPR [139:26] + | | | | | | `--LITERAL_TRUE -> true [139:26] + | | | | | `--RCURLY -> } [140:16] + | | | | `--LITERAL_YIELD -> yield [141:16] + | | | | `--EXPR -> EXPR [141:22] + | | | | `--LITERAL_TRUE -> true [141:22] + | | | `--RCURLY -> } [142:8] + | | |--RPAREN -> ) [142:9] + | | `--SLIST -> { [142:11] + | | |--LITERAL_THROW -> throw [143:12] + | | | |--EXPR -> EXPR [143:18] + | | | | `--LITERAL_NEW -> new [143:18] + | | | | |--IDENT -> AssertionError [143:22] + | | | | |--LPAREN -> ( [143:36] + | | | | |--ELIST -> ELIST [143:37] + | | | | `--RPAREN -> ) [143:37] + | | | `--SEMI -> ; [143:38] + | | `--RCURLY -> } [144:8] + | `--RCURLY -> } [145:4] + |--METHOD_DEF -> METHOD_DEF [147:4] + | |--MODIFIERS -> MODIFIERS [147:4] + | | |--LITERAL_PUBLIC -> public [147:4] + | | `--LITERAL_STATIC -> static [147:11] + | |--TYPE -> TYPE [147:18] + | | `--LITERAL_VOID -> void [147:18] + | |--IDENT -> main [147:23] + | |--LPAREN -> ( [147:27] + | |--PARAMETERS -> PARAMETERS [147:28] + | | `--PARAMETER_DEF -> PARAMETER_DEF [147:28] + | | |--MODIFIERS -> MODIFIERS [147:28] + | | |--TYPE -> TYPE [147:28] + | | | `--IDENT -> String [147:28] + | | |--ELLIPSIS -> ... [147:34] + | | `--IDENT -> args [147:38] + | |--RPAREN -> ) [147:42] + | `--SLIST -> { [147:44] + | |--VARIABLE_DEF -> VARIABLE_DEF [148:8] + | | |--MODIFIERS -> MODIFIERS [148:8] + | | |--TYPE -> TYPE [148:8] + | | | `--IDENT -> T [148:8] + | | |--IDENT -> t [148:10] + | | `--ASSIGN -> = [148:12] + | | `--EXPR -> EXPR [148:15] + | | `--DOT -> . [148:15] + | | |--IDENT -> T [148:14] + | | `--IDENT -> B [148:16] + | |--SEMI -> ; [148:17] + | |--VARIABLE_DEF -> VARIABLE_DEF [149:8] + | | |--MODIFIERS -> MODIFIERS [149:8] + | | |--TYPE -> TYPE [149:8] + | | | `--LITERAL_INT -> int [149:8] + | | |--IDENT -> a [149:12] + | | `--ASSIGN -> = [149:14] + | | `--EXPR -> EXPR [149:16] + | | `--NUM_INT -> 8 [149:16] + | |--SEMI -> ; [149:17] + | |--VARIABLE_DEF -> VARIABLE_DEF [150:8] + | | |--MODIFIERS -> MODIFIERS [150:8] + | | |--TYPE -> TYPE [150:8] + | | | `--LITERAL_INT -> int [150:8] + | | `--IDENT -> x [150:12] + | |--SEMI -> ; [150:13] + | |--EXPR -> EXPR [152:26] + | | `--METHOD_CALL -> ( [152:26] + | | |--DOT -> . [152:18] + | | | |--DOT -> . [152:14] + | | | | |--IDENT -> System [152:8] + | | | | `--IDENT -> out [152:15] + | | | `--IDENT -> println [152:19] + | | |--ELIST -> ELIST [152:27] + | | | `--EXPR -> EXPR [152:27] + | | | `--STRING_LITERAL -> "works!" [152:27] + | | `--RPAREN -> ) [152:35] + | |--SEMI -> ; [152:36] + | |--VARIABLE_DEF -> VARIABLE_DEF [153:8] + | | |--MODIFIERS -> MODIFIERS [153:8] + | | |--TYPE -> TYPE [153:8] + | | | `--LITERAL_BOOLEAN -> boolean [153:8] + | | |--IDENT -> t1b [153:16] + | | `--ASSIGN -> = [153:20] + | | `--EXPR -> EXPR [158:11] + | | `--LAND -> && [158:11] + | | |--LPAREN -> ( [153:22] + | | |--LITERAL_SWITCH -> switch [153:23] + | | | |--LPAREN -> ( [153:30] + | | | |--EXPR -> EXPR [153:31] + | | | | `--IDENT -> a [153:31] + | | | |--RPAREN -> ) [153:32] + | | | |--LCURLY -> { [153:34] + | | | |--CASE_GROUP -> CASE_GROUP [154:12] + | | | | |--LITERAL_CASE -> case [154:12] + | | | | | |--EXPR -> EXPR [154:17] + | | | | | | `--NUM_INT -> 0 [154:17] + | | | | | `--COLON -> : [154:18] + | | | | `--SLIST -> SLIST [155:16] + | | | | `--LITERAL_YIELD -> yield [155:16] + | | | | `--EXPR -> EXPR [155:30] + | | | | `--EQUAL -> == [155:30] + | | | | |--LPAREN -> ( [155:22] + | | | | |--ASSIGN -> = [155:25] + | | | | | |--IDENT -> x [155:23] + | | | | | `--NUM_INT -> 1 [155:27] + | | | | |--RPAREN -> ) [155:28] + | | | | `--NUM_INT -> 1 [155:33] + | | | |--CASE_GROUP -> CASE_GROUP [156:12] + | | | | |--LITERAL_DEFAULT -> default [156:12] + | | | | | `--COLON -> : [156:19] + | | | | `--SLIST -> SLIST [157:16] + | | | | `--LITERAL_YIELD -> yield [157:16] + | | | | `--EXPR -> EXPR [157:22] + | | | | `--LITERAL_FALSE -> false [157:22] + | | | `--RCURLY -> } [158:8] + | | |--RPAREN -> ) [158:9] + | | `--EQUAL -> == [158:16] + | | |--IDENT -> x [158:14] + | | `--NUM_INT -> 1 [158:19] + | |--SEMI -> ; [158:20] + | |--LITERAL_TRY -> try [160:8] + | | |--SLIST -> { [160:12] + | | | |--VARIABLE_DEF -> VARIABLE_DEF [161:12] + | | | | |--MODIFIERS -> MODIFIERS [161:12] + | | | | |--TYPE -> TYPE [161:12] + | | | | | `--LITERAL_INT -> int [161:12] + | | | | |--IDENT -> ii [161:16] + | | | | `--ASSIGN -> = [161:19] + | | | | `--EXPR -> EXPR [161:21] + | | | | `--LITERAL_SWITCH -> switch [161:21] + | | | | |--LPAREN -> ( [161:28] + | | | | |--EXPR -> EXPR [161:29] + | | | | | `--IDENT -> t [161:29] + | | | | |--RPAREN -> ) [161:30] + | | | | |--LCURLY -> { [161:32] + | | | | |--CASE_GROUP -> CASE_GROUP [162:16] + | | | | | |--LITERAL_CASE -> case [162:16] + | | | | | | |--EXPR -> EXPR [162:21] + | | | | | | | `--IDENT -> A [162:21] + | | | | | | |--LAMBDA -> -> [162:23] + | | | | | | |--EXPR -> EXPR [162:26] + | | | | | | | `--NUM_INT -> 0 [162:26] + | | | | | | `--SEMI -> ; [162:27] + | | | | | `--LITERAL_DEFAULT -> default [163:16] + | | | | | |--LAMBDA -> -> [163:24] + | | | | | `--LITERAL_THROW -> throw [163:27] + | | | | | |--EXPR -> EXPR [163:33] + | | | | | | `--LITERAL_NEW -> new [163:33] + | | | | | | |--IDENT -> IllegalStateException [163:37] + | | | | | | |--LPAREN -> ( [163:58] + | | | | | | |--ELIST -> ELIST [163:59] + | | | | | | `--RPAREN -> ) [163:59] + | | | | | `--SEMI -> ; [163:60] + | | | | `--RCURLY -> } [164:12] + | | | |--SEMI -> ; [164:13] + | | | |--LITERAL_THROW -> throw [165:12] + | | | | |--EXPR -> EXPR [165:18] + | | | | | `--LITERAL_NEW -> new [165:18] + | | | | | |--IDENT -> AssertionError [165:22] + | | | | | |--LPAREN -> ( [165:36] + | | | | | |--ELIST -> ELIST [165:37] + | | | | | | `--EXPR -> EXPR [165:37] + | | | | | | `--STRING_LITERAL -> "Expected exception not thrown." [165:37] + | | | | | `--RPAREN -> ) [165:69] + | | | | `--SEMI -> ; [165:70] + | | | `--RCURLY -> } [166:8] + | | `--LITERAL_CATCH -> catch [166:10] + | | |--LPAREN -> ( [166:16] + | | |--PARAMETER_DEF -> PARAMETER_DEF [166:17] + | | | |--MODIFIERS -> MODIFIERS [166:17] + | | | |--TYPE -> TYPE [166:17] + | | | | `--IDENT -> IllegalStateException [166:17] + | | | `--IDENT -> ex [166:39] + | | |--RPAREN -> ) [166:41] + | | `--SLIST -> { [166:43] + | | `--RCURLY -> } [168:8] + | `--RCURLY -> } [169:4] + |--ENUM_DEF -> ENUM_DEF [171:4] + | |--MODIFIERS -> MODIFIERS [171:4] + | |--ENUM -> enum [171:4] + | |--IDENT -> T [171:9] + | `--OBJBLOCK -> OBJBLOCK [171:11] + | |--LCURLY -> { [171:11] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [172:8] + | | |--ANNOTATIONS -> ANNOTATIONS [172:8] + | | `--IDENT -> A [172:8] + | |--COMMA -> , [172:9] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [172:11] + | | |--ANNOTATIONS -> ANNOTATIONS [172:11] + | | `--IDENT -> B [172:11] + | |--COMMA -> , [172:12] + | |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [172:14] + | | |--ANNOTATIONS -> ANNOTATIONS [172:14] + | | `--IDENT -> C [172:14] + | |--SEMI -> ; [172:15] + | `--RCURLY -> } [173:4] + |--METHOD_DEF -> METHOD_DEF [175:4] + | |--MODIFIERS -> MODIFIERS [175:4] + | | |--LITERAL_PRIVATE -> private [175:4] + | | `--LITERAL_STATIC -> static [175:12] + | |--TYPE -> TYPE [175:19] + | | `--LITERAL_BOOLEAN -> boolean [175:19] + | |--IDENT -> isTrue [175:27] + | |--LPAREN -> ( [175:33] + | |--PARAMETERS -> PARAMETERS [175:34] + | |--RPAREN -> ) [175:34] + | `--SLIST -> { [175:36] + | |--LITERAL_RETURN -> return [176:8] + | | |--EXPR -> EXPR [176:15] + | | | `--LITERAL_TRUE -> true [176:15] + | | `--SEMI -> ; [176:19] + | `--RCURLY -> } [177:4] + |--STATIC_INIT -> STATIC_INIT [179:4] + | `--SLIST -> { [179:11] + | |--VARIABLE_DEF -> VARIABLE_DEF [180:8] + | | |--MODIFIERS -> MODIFIERS [180:8] + | | |--TYPE -> TYPE [180:8] + | | | `--LITERAL_INT -> int [180:8] + | | `--IDENT -> x [180:12] + | |--SEMI -> ; [180:13] + | |--VARIABLE_DEF -> VARIABLE_DEF [182:8] + | | |--MODIFIERS -> MODIFIERS [182:8] + | | |--TYPE -> TYPE [182:8] + | | | `--LITERAL_INT -> int [182:8] + | | |--IDENT -> t7 [182:12] + | | `--ASSIGN -> = [182:15] + | | `--EXPR -> EXPR [182:45] + | | `--METHOD_CALL -> ( [182:45] + | | |--DOT -> . [182:42] + | | | |--LITERAL_NEW -> new [182:17] + | | | | |--IDENT -> DefiniteAssignment1 [182:21] + | | | | |--LPAREN -> ( [182:40] + | | | | |--ELIST -> ELIST [182:41] + | | | | `--RPAREN -> ) [182:41] + | | | `--IDENT -> id [182:43] + | | |--ELIST -> ELIST [184:36] + | | | `--EXPR -> EXPR [184:36] + | | | `--QUESTION -> ? [184:36] + | | | |--LAND -> && [184:26] + | | | | |--LAND -> && [184:10] + | | | | | |--LITERAL_SWITCH -> switch [182:46] + | | | | | | |--LPAREN -> ( [182:53] + | | | | | | |--EXPR -> EXPR [182:54] + | | | | | | | `--NUM_INT -> 0 [182:54] + | | | | | | |--RPAREN -> ) [182:55] + | | | | | | |--LCURLY -> { [182:57] + | | | | | | |--CASE_GROUP -> CASE_GROUP [183:12] + | | | | | | | `--LITERAL_DEFAULT -> default [183:12] + | | | | | | | |--LAMBDA -> -> [183:20] + | | | | | | | |--EXPR -> EXPR [183:29] + | | | | | | | | `--METHOD_CALL -> ( [183:29] + | | | | | | | | |--IDENT -> isTrue [183:23] + | | | | | | | | |--ELIST -> ELIST [183:30] + | | | | | | | | `--RPAREN -> ) [183:30] + | | | | | | | `--SEMI -> ; [183:31] + | | | | | | `--RCURLY -> } [184:8] + | | | | | `--EQUAL -> == [184:21] + | | | | | |--LPAREN -> ( [184:13] + | | | | | |--ASSIGN -> = [184:16] + | | | | | | |--IDENT -> x [184:14] + | | | | | | `--NUM_INT -> 1 [184:18] + | | | | | |--RPAREN -> ) [184:19] + | | | | | `--NUM_INT -> 1 [184:24] + | | | | `--EQUAL -> == [184:31] + | | | | |--IDENT -> x [184:29] + | | | | `--NUM_INT -> 1 [184:34] + | | | |--NUM_INT -> 2 [184:38] + | | | |--COLON -> : [184:40] + | | | `--UNARY_MINUS -> - [184:42] + | | | `--NUM_INT -> 1 [184:43] + | | `--RPAREN -> ) [184:44] + | |--SEMI -> ; [184:45] + | |--LITERAL_IF -> if [186:8] + | | |--LPAREN -> ( [186:11] + | | |--EXPR -> EXPR [186:15] + | | | `--NOT_EQUAL -> != [186:15] + | | | |--IDENT -> t7 [186:12] + | | | `--NUM_INT -> 2 [186:18] + | | |--RPAREN -> ) [186:19] + | | `--SLIST -> { [186:21] + | | |--LITERAL_THROW -> throw [187:12] + | | | |--EXPR -> EXPR [187:18] + | | | | `--LITERAL_NEW -> new [187:18] + | | | | |--IDENT -> IllegalStateException [187:22] + | | | | |--LPAREN -> ( [187:43] + | | | | |--ELIST -> ELIST [187:44] + | | | | | `--EXPR -> EXPR [187:44] + | | | | | `--STRING_LITERAL -> "Unexpected result." [187:44] + | | | | `--RPAREN -> ) [187:64] + | | | `--SEMI -> ; [187:65] + | | `--RCURLY -> } [188:8] + | `--RCURLY -> } [189:4] + |--STATIC_INIT -> STATIC_INIT [191:4] + | `--SLIST -> { [191:11] + | |--VARIABLE_DEF -> VARIABLE_DEF [192:8] + | | |--MODIFIERS -> MODIFIERS [192:8] + | | |--TYPE -> TYPE [192:8] + | | | `--LITERAL_INT -> int [192:8] + | | `--IDENT -> x [192:12] + | |--SEMI -> ; [192:13] + | |--VARIABLE_DEF -> VARIABLE_DEF [193:8] + | | |--MODIFIERS -> MODIFIERS [193:8] + | | |--TYPE -> TYPE [193:8] + | | | `--IDENT -> T [193:8] + | | |--IDENT -> e [193:10] + | | `--ASSIGN -> = [193:12] + | | `--EXPR -> EXPR [193:15] + | | `--DOT -> . [193:15] + | | |--IDENT -> T [193:14] + | | `--IDENT -> B [193:16] + | |--SEMI -> ; [193:17] + | |--VARIABLE_DEF -> VARIABLE_DEF [195:8] + | | |--MODIFIERS -> MODIFIERS [195:8] + | | |--TYPE -> TYPE [195:8] + | | | `--LITERAL_BOOLEAN -> boolean [195:8] + | | |--IDENT -> t8 [195:16] + | | `--ASSIGN -> = [195:19] + | | `--EXPR -> EXPR [203:11] + | | `--LAND -> && [203:11] + | | |--LPAREN -> ( [195:21] + | | |--LITERAL_SWITCH -> switch [195:22] + | | | |--LPAREN -> ( [195:29] + | | | |--EXPR -> EXPR [195:30] + | | | | `--IDENT -> e [195:30] + | | | |--RPAREN -> ) [195:31] + | | | |--LCURLY -> { [195:33] + | | | |--CASE_GROUP -> CASE_GROUP [196:12] + | | | | |--LITERAL_CASE -> case [196:12] + | | | | | |--EXPR -> EXPR [196:17] + | | | | | | `--IDENT -> A [196:17] + | | | | | `--COLON -> : [196:18] + | | | | `--SLIST -> SLIST [197:18] + | | | | |--EXPR -> EXPR [197:18] + | | | | | `--ASSIGN -> = [197:18] + | | | | | |--IDENT -> x [197:16] + | | | | | `--NUM_INT -> 1 [197:20] + | | | | |--SEMI -> ; [197:21] + | | | | `--LITERAL_YIELD -> yield [198:16] + | | | | `--EXPR -> EXPR [198:22] + | | | | `--LITERAL_TRUE -> true [198:22] + | | | |--CASE_GROUP -> CASE_GROUP [199:12] + | | | | |--LITERAL_CASE -> case [199:12] + | | | | | |--EXPR -> EXPR [199:17] + | | | | | | `--IDENT -> B [199:17] + | | | | | `--COLON -> : [199:18] + | | | | `--SLIST -> SLIST [200:16] + | | | | `--LITERAL_YIELD -> yield [200:16] + | | | | `--EXPR -> EXPR [200:35] + | | | | `--LOR -> || [200:35] + | | | | |--EQUAL -> == [200:30] + | | | | | |--LPAREN -> ( [200:22] + | | | | | |--ASSIGN -> = [200:25] + | | | | | | |--IDENT -> x [200:23] + | | | | | | `--NUM_INT -> 1 [200:27] + | | | | | |--RPAREN -> ) [200:28] + | | | | | `--NUM_INT -> 1 [200:33] + | | | | `--LITERAL_TRUE -> true [200:38] + | | | |--CASE_GROUP -> CASE_GROUP [201:12] + | | | | |--LITERAL_DEFAULT -> default [201:12] + | | | | | `--COLON -> : [201:19] + | | | | `--SLIST -> SLIST [202:16] + | | | | `--LITERAL_YIELD -> yield [202:16] + | | | | `--EXPR -> EXPR [202:22] + | | | | `--LITERAL_FALSE -> false [202:22] + | | | `--RCURLY -> } [203:8] + | | |--RPAREN -> ) [203:9] + | | `--EQUAL -> == [203:16] + | | |--IDENT -> x [203:14] + | | `--NUM_INT -> 1 [203:19] + | |--SEMI -> ; [203:20] + | |--LITERAL_IF -> if [205:8] + | | |--LPAREN -> ( [205:11] + | | |--EXPR -> EXPR [205:12] + | | | `--LNOT -> ! [205:12] + | | | `--IDENT -> t8 [205:13] + | | |--RPAREN -> ) [205:15] + | | `--SLIST -> { [205:17] + | | |--LITERAL_THROW -> throw [206:12] + | | | |--EXPR -> EXPR [206:18] + | | | | `--LITERAL_NEW -> new [206:18] + | | | | |--IDENT -> IllegalStateException [206:22] + | | | | |--LPAREN -> ( [206:43] + | | | | |--ELIST -> ELIST [206:44] + | | | | | `--EXPR -> EXPR [206:44] + | | | | | `--STRING_LITERAL -> "Unexpected result." [206:44] + | | | | `--RPAREN -> ) [206:64] + | | | `--SEMI -> ; [206:65] + | | `--RCURLY -> } [207:8] + | `--RCURLY -> } [208:4] + |--STATIC_INIT -> STATIC_INIT [210:4] + | `--SLIST -> { [210:11] + | |--VARIABLE_DEF -> VARIABLE_DEF [211:8] + | | |--MODIFIERS -> MODIFIERS [211:8] + | | |--TYPE -> TYPE [211:8] + | | | `--LITERAL_INT -> int [211:8] + | | `--IDENT -> x [211:12] + | |--SEMI -> ; [211:13] + | |--VARIABLE_DEF -> VARIABLE_DEF [212:8] + | | |--MODIFIERS -> MODIFIERS [212:8] + | | |--TYPE -> TYPE [212:8] + | | | `--IDENT -> T [212:8] + | | |--IDENT -> e [212:10] + | | `--ASSIGN -> = [212:12] + | | `--EXPR -> EXPR [212:15] + | | `--DOT -> . [212:15] + | | |--IDENT -> T [212:14] + | | `--IDENT -> B [212:16] + | |--SEMI -> ; [212:17] + | |--VARIABLE_DEF -> VARIABLE_DEF [214:8] + | | |--MODIFIERS -> MODIFIERS [214:8] + | | |--TYPE -> TYPE [214:8] + | | | `--LITERAL_BOOLEAN -> boolean [214:8] + | | |--IDENT -> t8 [214:16] + | | `--ASSIGN -> = [214:19] + | | `--EXPR -> EXPR [222:11] + | | `--LAND -> && [222:11] + | | |--LPAREN -> ( [214:21] + | | |--LITERAL_SWITCH -> switch [214:22] + | | | |--LPAREN -> ( [214:29] + | | | |--EXPR -> EXPR [214:30] + | | | | `--IDENT -> e [214:30] + | | | |--RPAREN -> ) [214:31] + | | | |--LCURLY -> { [214:33] + | | | |--CASE_GROUP -> CASE_GROUP [215:12] + | | | | |--LITERAL_CASE -> case [215:12] + | | | | | |--EXPR -> EXPR [215:17] + | | | | | | `--IDENT -> A [215:17] + | | | | | `--COLON -> : [215:18] + | | | | `--SLIST -> SLIST [216:18] + | | | | |--EXPR -> EXPR [216:18] + | | | | | `--ASSIGN -> = [216:18] + | | | | | |--IDENT -> x [216:16] + | | | | | `--NUM_INT -> 1 [216:20] + | | | | |--SEMI -> ; [216:21] + | | | | `--LITERAL_YIELD -> yield [217:16] + | | | | `--EXPR -> EXPR [217:28] + | | | | `--METHOD_CALL -> ( [217:28] + | | | | |--IDENT -> isTrue [217:22] + | | | | |--ELIST -> ELIST [217:29] + | | | | `--RPAREN -> ) [217:29] + | | | |--CASE_GROUP -> CASE_GROUP [218:12] + | | | | |--LITERAL_CASE -> case [218:12] + | | | | | |--EXPR -> EXPR [218:17] + | | | | | | `--IDENT -> B [218:17] + | | | | | `--COLON -> : [218:18] + | | | | `--SLIST -> SLIST [219:16] + | | | | `--LITERAL_YIELD -> yield [219:16] + | | | | `--EXPR -> EXPR [219:35] + | | | | `--LOR -> || [219:35] + | | | | |--EQUAL -> == [219:30] + | | | | | |--LPAREN -> ( [219:22] + | | | | | |--ASSIGN -> = [219:25] + | | | | | | |--IDENT -> x [219:23] + | | | | | | `--NUM_INT -> 1 [219:27] + | | | | | |--RPAREN -> ) [219:28] + | | | | | `--NUM_INT -> 1 [219:33] + | | | | `--METHOD_CALL -> ( [219:44] + | | | | |--IDENT -> isTrue [219:38] + | | | | |--ELIST -> ELIST [219:45] + | | | | `--RPAREN -> ) [219:45] + | | | |--CASE_GROUP -> CASE_GROUP [220:12] + | | | | |--LITERAL_DEFAULT -> default [220:12] + | | | | | `--COLON -> : [220:19] + | | | | `--SLIST -> SLIST [221:16] + | | | | `--LITERAL_YIELD -> yield [221:16] + | | | | `--EXPR -> EXPR [221:22] + | | | | `--LITERAL_FALSE -> false [221:22] + | | | `--RCURLY -> } [222:8] + | | |--RPAREN -> ) [222:9] + | | `--EQUAL -> == [222:16] + | | |--IDENT -> x [222:14] + | | `--NUM_INT -> 1 [222:19] + | |--SEMI -> ; [222:20] + | |--LITERAL_IF -> if [224:8] + | | |--LPAREN -> ( [224:11] + | | |--EXPR -> EXPR [224:12] + | | | `--LNOT -> ! [224:12] + | | | `--IDENT -> t8 [224:13] + | | |--RPAREN -> ) [224:15] + | | `--SLIST -> { [224:17] + | | |--LITERAL_THROW -> throw [225:12] + | | | |--EXPR -> EXPR [225:18] + | | | | `--LITERAL_NEW -> new [225:18] + | | | | |--IDENT -> IllegalStateException [225:22] + | | | | |--LPAREN -> ( [225:43] + | | | | |--ELIST -> ELIST [225:44] + | | | | | `--EXPR -> EXPR [225:44] + | | | | | `--STRING_LITERAL -> "Unexpected result." [225:44] + | | | | `--RPAREN -> ) [225:64] + | | | `--SEMI -> ; [225:65] + | | `--RCURLY -> } [226:8] + | |--SLIST -> { [228:8] + | | |--VARIABLE_DEF -> VARIABLE_DEF [229:12] + | | | |--MODIFIERS -> MODIFIERS [229:12] + | | | |--TYPE -> TYPE [229:12] + | | | | `--IDENT -> T [229:12] + | | | |--IDENT -> y [229:14] + | | | `--ASSIGN -> = [229:16] + | | | `--EXPR -> EXPR [229:19] + | | | `--DOT -> . [229:19] + | | | |--IDENT -> T [229:18] + | | | `--IDENT -> A [229:20] + | | |--SEMI -> ; [229:21] + | | |--VARIABLE_DEF -> VARIABLE_DEF [231:12] + | | | |--MODIFIERS -> MODIFIERS [231:12] + | | | |--TYPE -> TYPE [231:12] + | | | | `--LITERAL_BOOLEAN -> boolean [231:12] + | | | |--IDENT -> t9 [231:20] + | | | `--ASSIGN -> = [231:23] + | | | `--EXPR -> EXPR [239:15] + | | | `--LAND -> && [239:15] + | | | |--LPAREN -> ( [231:25] + | | | |--LITERAL_SWITCH -> switch [231:26] + | | | | |--LPAREN -> ( [231:33] + | | | | |--EXPR -> EXPR [231:34] + | | | | | `--IDENT -> y [231:34] + | | | | |--RPAREN -> ) [231:35] + | | | | |--LCURLY -> { [231:37] + | | | | |--CASE_GROUP -> CASE_GROUP [232:16] + | | | | | |--LITERAL_CASE -> case [232:16] + | | | | | | |--EXPR -> EXPR [232:21] + | | | | | | | `--IDENT -> A [232:21] + | | | | | | `--COLON -> : [232:22] + | | | | | `--SLIST -> SLIST [233:22] + | | | | | |--EXPR -> EXPR [233:22] + | | | | | | `--ASSIGN -> = [233:22] + | | | | | | |--IDENT -> x [233:20] + | | | | | | `--NUM_INT -> 1 [233:24] + | | | | | |--SEMI -> ; [233:25] + | | | | | `--LITERAL_YIELD -> yield [234:20] + | | | | | `--EXPR -> EXPR [234:26] + | | | | | `--LITERAL_TRUE -> true [234:26] + | | | | |--CASE_GROUP -> CASE_GROUP [235:16] + | | | | | |--LITERAL_CASE -> case [235:16] + | | | | | | |--EXPR -> EXPR [235:21] + | | | | | | | `--IDENT -> B [235:21] + | | | | | | `--COLON -> : [235:22] + | | | | | `--SLIST -> SLIST [236:20] + | | | | | `--LITERAL_YIELD -> yield [236:20] + | | | | | `--EXPR -> EXPR [236:39] + | | | | | `--LOR -> || [236:39] + | | | | | |--EQUAL -> == [236:34] + | | | | | | |--LPAREN -> ( [236:26] + | | | | | | |--ASSIGN -> = [236:29] + | | | | | | | |--IDENT -> x [236:27] + | | | | | | | `--NUM_INT -> 1 [236:31] + | | | | | | |--RPAREN -> ) [236:32] + | | | | | | `--NUM_INT -> 1 [236:37] + | | | | | `--LITERAL_TRUE -> true [236:42] + | | | | |--CASE_GROUP -> CASE_GROUP [237:16] + | | | | | |--LITERAL_DEFAULT -> default [237:16] + | | | | | | `--COLON -> : [237:23] + | | | | | `--SLIST -> SLIST [238:20] + | | | | | `--LITERAL_YIELD -> yield [238:20] + | | | | | `--EXPR -> EXPR [238:26] + | | | | | `--LITERAL_FALSE -> false [238:26] + | | | | `--RCURLY -> } [239:12] + | | | |--RPAREN -> ) [239:13] + | | | `--EQUAL -> == [239:20] + | | | |--IDENT -> x [239:18] + | | | `--NUM_INT -> 1 [239:23] + | | |--SEMI -> ; [239:24] + | | |--LITERAL_IF -> if [241:12] + | | | |--LPAREN -> ( [241:15] + | | | |--EXPR -> EXPR [241:16] + | | | | `--LNOT -> ! [241:16] + | | | | `--IDENT -> t9 [241:17] + | | | |--RPAREN -> ) [241:19] + | | | `--SLIST -> { [241:21] + | | | |--LITERAL_THROW -> throw [242:16] + | | | | |--EXPR -> EXPR [242:22] + | | | | | `--LITERAL_NEW -> new [242:22] + | | | | | |--IDENT -> IllegalStateException [242:26] + | | | | | |--LPAREN -> ( [242:47] + | | | | | |--ELIST -> ELIST [242:48] + | | | | | | `--EXPR -> EXPR [242:48] + | | | | | | `--STRING_LITERAL -> "Unexpected result." [242:48] + | | | | | `--RPAREN -> ) [242:68] + | | | | `--SEMI -> ; [242:69] + | | | `--RCURLY -> } [243:12] + | | `--RCURLY -> } [244:8] + | |--SLIST -> { [247:8] + | | |--VARIABLE_DEF -> VARIABLE_DEF [248:12] + | | | |--MODIFIERS -> MODIFIERS [248:12] + | | | |--TYPE -> TYPE [248:12] + | | | | `--IDENT -> T [248:12] + | | | |--IDENT -> y [248:14] + | | | `--ASSIGN -> = [248:16] + | | | `--EXPR -> EXPR [248:19] + | | | `--DOT -> . [248:19] + | | | |--IDENT -> T [248:18] + | | | `--IDENT -> A [248:20] + | | |--SEMI -> ; [248:21] + | | |--VARIABLE_DEF -> VARIABLE_DEF [250:12] + | | | |--MODIFIERS -> MODIFIERS [250:12] + | | | |--TYPE -> TYPE [250:12] + | | | | `--LITERAL_INT -> int [250:12] + | | | |--IDENT -> v [250:16] + | | | `--ASSIGN -> = [250:18] + | | | `--EXPR -> EXPR [250:20] + | | | `--LITERAL_SWITCH -> switch [250:20] + | | | |--LPAREN -> ( [250:27] + | | | |--EXPR -> EXPR [250:28] + | | | | `--IDENT -> y [250:28] + | | | |--RPAREN -> ) [250:29] + | | | |--LCURLY -> { [250:31] + | | | |--CASE_GROUP -> CASE_GROUP [251:16] + | | | | |--LITERAL_CASE -> case [251:16] + | | | | | |--EXPR -> EXPR [251:21] + | | | | | | `--IDENT -> A [251:21] + | | | | | |--LAMBDA -> -> [251:23] + | | | | | |--EXPR -> EXPR [251:28] + | | | | | | `--ASSIGN -> = [251:28] + | | | | | | |--IDENT -> x [251:26] + | | | | | | `--NUM_INT -> 0 [251:30] + | | | | | `--SEMI -> ; [251:31] + | | | | |--LITERAL_CASE -> case [252:16] + | | | | | |--EXPR -> EXPR [252:21] + | | | | | | `--IDENT -> B [252:21] + | | | | | |--LAMBDA -> -> [252:23] + | | | | | |--EXPR -> EXPR [252:28] + | | | | | | `--ASSIGN -> = [252:28] + | | | | | | |--IDENT -> x [252:26] + | | | | | | `--NUM_INT -> 0 [252:30] + | | | | | `--SEMI -> ; [252:31] + | | | | `--LITERAL_CASE -> case [253:16] + | | | | |--EXPR -> EXPR [253:21] + | | | | | `--IDENT -> C [253:21] + | | | | |--LAMBDA -> -> [253:23] + | | | | |--EXPR -> EXPR [253:28] + | | | | | `--ASSIGN -> = [253:28] + | | | | | |--IDENT -> x [253:26] + | | | | | `--NUM_INT -> 0 [253:30] + | | | | `--SEMI -> ; [253:31] + | | | `--RCURLY -> } [254:12] + | | |--SEMI -> ; [254:13] + | | |--LITERAL_IF -> if [256:12] + | | | |--LPAREN -> ( [256:15] + | | | |--EXPR -> EXPR [256:23] + | | | | `--LOR -> || [256:23] + | | | | |--NOT_EQUAL -> != [256:18] + | | | | | |--IDENT -> x [256:16] + | | | | | `--NUM_INT -> 0 [256:21] + | | | | `--NOT_EQUAL -> != [256:28] + | | | | |--IDENT -> v [256:26] + | | | | `--NUM_INT -> 0 [256:31] + | | | |--RPAREN -> ) [256:32] + | | | `--SLIST -> { [256:34] + | | | |--LITERAL_THROW -> throw [257:16] + | | | | |--EXPR -> EXPR [257:22] + | | | | | `--LITERAL_NEW -> new [257:22] + | | | | | |--IDENT -> IllegalStateException [257:26] + | | | | | |--LPAREN -> ( [257:47] + | | | | | |--ELIST -> ELIST [257:48] + | | | | | | `--EXPR -> EXPR [257:48] + | | | | | | `--STRING_LITERAL -> "Unexpected result." [257:48] + | | | | | `--RPAREN -> ) [257:68] + | | | | `--SEMI -> ; [257:69] + | | | `--RCURLY -> } [258:12] + | | `--RCURLY -> } [259:8] + | |--SLIST -> { [261:8] + | | |--VARIABLE_DEF -> VARIABLE_DEF [262:12] + | | | |--MODIFIERS -> MODIFIERS [262:12] + | | | |--TYPE -> TYPE [262:12] + | | | | `--IDENT -> T [262:12] + | | | |--IDENT -> y [262:14] + | | | `--ASSIGN -> = [262:16] + | | | `--EXPR -> EXPR [262:19] + | | | `--DOT -> . [262:19] + | | | |--IDENT -> T [262:18] + | | | `--IDENT -> A [262:20] + | | |--SEMI -> ; [262:21] + | | |--VARIABLE_DEF -> VARIABLE_DEF [264:12] + | | | |--MODIFIERS -> MODIFIERS [264:12] + | | | |--TYPE -> TYPE [264:12] + | | | | `--LITERAL_BOOLEAN -> boolean [264:12] + | | | |--IDENT -> tA [264:20] + | | | `--ASSIGN -> = [264:23] + | | | `--EXPR -> EXPR [277:15] + | | | `--LAND -> && [277:15] + | | | |--LPAREN -> ( [264:25] + | | | |--LITERAL_SWITCH -> switch [264:26] + | | | | |--LPAREN -> ( [264:33] + | | | | |--EXPR -> EXPR [264:34] + | | | | | `--IDENT -> y [264:34] + | | | | |--RPAREN -> ) [264:35] + | | | | |--LCURLY -> { [264:37] + | | | | |--CASE_GROUP -> CASE_GROUP [265:16] + | | | | | |--LITERAL_CASE -> case [265:16] + | | | | | | |--EXPR -> EXPR [265:21] + | | | | | | | `--IDENT -> A [265:21] + | | | | | | |--LAMBDA -> -> [265:23] + | | | | | | `--SLIST -> { [265:26] + | | | | | | |--EXPR -> EXPR [266:22] + | | | | | | | `--ASSIGN -> = [266:22] + | | | | | | | |--IDENT -> x [266:20] + | | | | | | | `--NUM_INT -> 1 [266:24] + | | | | | | |--SEMI -> ; [266:25] + | | | | | | |--LITERAL_YIELD -> yield [267:20] + | | | | | | | `--EXPR -> EXPR [267:26] + | | | | | | | `--LITERAL_TRUE -> true [267:26] + | | | | | | `--RCURLY -> } [268:16] + | | | | | |--LITERAL_CASE -> case [269:16] + | | | | | | |--EXPR -> EXPR [269:21] + | | | | | | | `--IDENT -> B [269:21] + | | | | | | |--LAMBDA -> -> [269:23] + | | | | | | `--SLIST -> { [269:26] + | | | | | | |--EXPR -> EXPR [270:22] + | | | | | | | `--ASSIGN -> = [270:22] + | | | | | | | |--IDENT -> x [270:20] + | | | | | | | `--NUM_INT -> 1 [270:24] + | | | | | | |--SEMI -> ; [270:25] + | | | | | | |--LITERAL_YIELD -> yield [271:20] + | | | | | | | `--EXPR -> EXPR [271:26] + | | | | | | | `--LITERAL_TRUE -> true [271:26] + | | | | | | `--RCURLY -> } [272:16] + | | | | | `--LITERAL_CASE -> case [273:16] + | | | | | |--EXPR -> EXPR [273:21] + | | | | | | `--IDENT -> C [273:21] + | | | | | |--LAMBDA -> -> [273:23] + | | | | | `--SLIST -> { [273:26] + | | | | | |--EXPR -> EXPR [274:22] + | | | | | | `--ASSIGN -> = [274:22] + | | | | | | |--IDENT -> x [274:20] + | | | | | | `--NUM_INT -> 1 [274:24] + | | | | | |--SEMI -> ; [274:25] + | | | | | |--LITERAL_YIELD -> yield [275:20] + | | | | | | `--EXPR -> EXPR [275:26] + | | | | | | `--LITERAL_TRUE -> true [275:26] + | | | | | `--RCURLY -> } [276:16] + | | | | `--RCURLY -> } [277:12] + | | | |--RPAREN -> ) [277:13] + | | | `--EQUAL -> == [277:20] + | | | |--IDENT -> x [277:18] + | | | `--NUM_INT -> 1 [277:23] + | | |--SEMI -> ; [277:24] + | | |--LITERAL_IF -> if [279:12] + | | | |--LPAREN -> ( [279:15] + | | | |--EXPR -> EXPR [279:16] + | | | | `--LNOT -> ! [279:16] + | | | | `--IDENT -> tA [279:17] + | | | |--RPAREN -> ) [279:19] + | | | `--SLIST -> { [279:21] + | | | |--LITERAL_THROW -> throw [280:16] + | | | | |--EXPR -> EXPR [280:22] + | | | | | `--LITERAL_NEW -> new [280:22] + | | | | | |--IDENT -> IllegalStateException [280:26] + | | | | | |--LPAREN -> ( [280:47] + | | | | | |--ELIST -> ELIST [280:48] + | | | | | | `--EXPR -> EXPR [280:48] + | | | | | | `--STRING_LITERAL -> "Unexpected result." [280:48] + | | | | | `--RPAREN -> ) [280:68] + | | | | `--SEMI -> ; [280:69] + | | | `--RCURLY -> } [281:12] + | | `--RCURLY -> } [282:8] + | `--RCURLY -> } [283:4] + |--STATIC_INIT -> STATIC_INIT [284:4] + | `--SLIST -> { [284:11] + | |--VARIABLE_DEF -> VARIABLE_DEF [285:8] + | | |--MODIFIERS -> MODIFIERS [285:8] + | | | `--FINAL -> final [285:8] + | | |--TYPE -> TYPE [285:14] + | | | `--LITERAL_INT -> int [285:14] + | | `--IDENT -> x [285:18] + | |--SEMI -> ; [285:19] + | |--VARIABLE_DEF -> VARIABLE_DEF [286:8] + | | |--MODIFIERS -> MODIFIERS [286:8] + | | |--TYPE -> TYPE [286:8] + | | | `--IDENT -> T [286:8] + | | |--IDENT -> e [286:10] + | | `--ASSIGN -> = [286:12] + | | `--EXPR -> EXPR [286:15] + | | `--DOT -> . [286:15] + | | |--IDENT -> T [286:14] + | | `--IDENT -> C [286:16] + | |--SEMI -> ; [286:17] + | |--VARIABLE_DEF -> VARIABLE_DEF [288:8] + | | |--MODIFIERS -> MODIFIERS [288:8] + | | |--TYPE -> TYPE [288:8] + | | | `--LITERAL_BOOLEAN -> boolean [288:8] + | | |--IDENT -> tA [288:16] + | | `--ASSIGN -> = [288:19] + | | `--EXPR -> EXPR [292:11] + | | `--LOR -> || [292:11] + | | |--LPAREN -> ( [288:21] + | | |--LITERAL_SWITCH -> switch [288:22] + | | | |--LPAREN -> ( [288:28] + | | | |--EXPR -> EXPR [288:29] + | | | | `--IDENT -> e [288:29] + | | | |--RPAREN -> ) [288:30] + | | | |--LCURLY -> { [288:32] + | | | |--CASE_GROUP -> CASE_GROUP [289:12] + | | | | |--LITERAL_CASE -> case [289:12] + | | | | | |--EXPR -> EXPR [289:17] + | | | | | | `--IDENT -> A [289:17] + | | | | | `--COLON -> : [289:18] + | | | | `--SLIST -> SLIST [289:22] + | | | | |--EXPR -> EXPR [289:22] + | | | | | `--ASSIGN -> = [289:22] + | | | | | |--IDENT -> x [289:20] + | | | | | `--NUM_INT -> 1 [289:24] + | | | | |--SEMI -> ; [289:25] + | | | | `--LITERAL_YIELD -> yield [289:27] + | | | | `--EXPR -> EXPR [289:33] + | | | | `--LITERAL_TRUE -> true [289:33] + | | | |--CASE_GROUP -> CASE_GROUP [290:12] + | | | | |--LITERAL_CASE -> case [290:12] + | | | | | |--EXPR -> EXPR [290:17] + | | | | | | `--IDENT -> B [290:17] + | | | | | `--COLON -> : [290:18] + | | | | `--SLIST -> SLIST [290:20] + | | | | `--LITERAL_YIELD -> yield [290:20] + | | | | `--EXPR -> EXPR [290:39] + | | | | `--LOR -> || [290:39] + | | | | |--EQUAL -> == [290:34] + | | | | | |--LPAREN -> ( [290:26] + | | | | | |--ASSIGN -> = [290:29] + | | | | | | |--IDENT -> x [290:27] + | | | | | | `--NUM_INT -> 2 [290:31] + | | | | | |--RPAREN -> ) [290:32] + | | | | | `--NUM_INT -> 2 [290:37] + | | | | `--LITERAL_TRUE -> true [290:42] + | | | |--CASE_GROUP -> CASE_GROUP [291:12] + | | | | |--LITERAL_DEFAULT -> default [291:12] + | | | | | `--COLON -> : [291:19] + | | | | `--SLIST -> SLIST [291:21] + | | | | `--LITERAL_YIELD -> yield [291:21] + | | | | `--EXPR -> EXPR [291:27] + | | | | `--LITERAL_FALSE -> false [291:27] + | | | `--RCURLY -> } [292:8] + | | |--RPAREN -> ) [292:9] + | | `--EQUAL -> == [292:22] + | | |--LPAREN -> ( [292:14] + | | |--ASSIGN -> = [292:17] + | | | |--IDENT -> x [292:15] + | | | `--NUM_INT -> 3 [292:19] + | | |--RPAREN -> ) [292:20] + | | `--NUM_INT -> 3 [292:25] + | |--SEMI -> ; [292:26] + | |--LITERAL_IF -> if [294:8] + | | |--LPAREN -> ( [294:11] + | | |--EXPR -> EXPR [294:14] + | | | `--NOT_EQUAL -> != [294:14] + | | | |--IDENT -> x [294:12] + | | | `--NUM_INT -> 3 [294:17] + | | |--RPAREN -> ) [294:18] + | | `--SLIST -> { [294:20] + | | |--LITERAL_THROW -> throw [295:12] + | | | |--EXPR -> EXPR [295:18] + | | | | `--LITERAL_NEW -> new [295:18] + | | | | |--IDENT -> IllegalStateException [295:22] + | | | | |--LPAREN -> ( [295:43] + | | | | |--ELIST -> ELIST [295:44] + | | | | | `--EXPR -> EXPR [295:44] + | | | | | `--STRING_LITERAL -> "Unexpected result." [295:44] + | | | | `--RPAREN -> ) [295:64] + | | | `--SEMI -> ; [295:65] + | | `--RCURLY -> } [296:8] + | `--RCURLY -> } [297:4] + |--STATIC_INIT -> STATIC_INIT [299:4] + | `--SLIST -> { [299:11] + | |--VARIABLE_DEF -> VARIABLE_DEF [300:8] + | | |--MODIFIERS -> MODIFIERS [300:8] + | | |--TYPE -> TYPE [300:8] + | | | `--LITERAL_INT -> int [300:8] + | | `--IDENT -> x [300:12] + | |--SEMI -> ; [300:13] + | |--VARIABLE_DEF -> VARIABLE_DEF [301:8] + | | |--MODIFIERS -> MODIFIERS [301:8] + | | |--TYPE -> TYPE [301:8] + | | | `--IDENT -> T [301:8] + | | |--IDENT -> e [301:10] + | | `--ASSIGN -> = [301:12] + | | `--EXPR -> EXPR [301:15] + | | `--DOT -> . [301:15] + | | |--IDENT -> T [301:14] + | | `--IDENT -> A [301:16] + | |--SEMI -> ; [301:17] + | |--VARIABLE_DEF -> VARIABLE_DEF [303:8] + | | |--MODIFIERS -> MODIFIERS [303:8] + | | |--TYPE -> TYPE [303:8] + | | | `--LITERAL_BOOLEAN -> boolean [303:8] + | | |--IDENT -> tA [303:16] + | | `--ASSIGN -> = [303:19] + | | `--EXPR -> EXPR [310:11] + | | `--LAND -> && [310:11] + | | |--LPAREN -> ( [303:21] + | | |--LITERAL_SWITCH -> switch [303:22] + | | | |--LPAREN -> ( [303:29] + | | | |--EXPR -> EXPR [303:30] + | | | | `--IDENT -> e [303:30] + | | | |--RPAREN -> ) [303:31] + | | | |--LCURLY -> { [303:33] + | | | |--CASE_GROUP -> CASE_GROUP [304:12] + | | | | |--LITERAL_CASE -> case [304:12] + | | | | | |--EXPR -> EXPR [304:17] + | | | | | | `--IDENT -> A [304:17] + | | | | | `--COLON -> : [304:18] + | | | | `--SLIST -> SLIST [305:16] + | | | | `--LITERAL_YIELD -> yield [305:16] + | | | | `--EXPR -> EXPR [305:43] + | | | | `--QUESTION -> ? [305:43] + | | | | |--LAND -> && [305:31] + | | | | | |--METHOD_CALL -> ( [305:28] + | | | | | | |--IDENT -> isTrue [305:22] + | | | | | | |--ELIST -> ELIST [305:29] + | | | | | | `--RPAREN -> ) [305:29] + | | | | | `--NOT_EQUAL -> != [305:36] + | | | | | |--IDENT -> e [305:34] + | | | | | `--DOT -> . [305:40] + | | | | | |--IDENT -> T [305:39] + | | | | | `--IDENT -> C [305:41] + | | | | |--LAND -> && [305:58] + | | | | | |--EQUAL -> == [305:53] + | | | | | | |--LPAREN -> ( [305:45] + | | | | | | |--ASSIGN -> = [305:48] + | | | | | | | |--IDENT -> x [305:46] + | | | | | | | `--NUM_INT -> 1 [305:50] + | | | | | | |--RPAREN -> ) [305:51] + | | | | | | `--NUM_INT -> 1 [305:56] + | | | | | `--NOT_EQUAL -> != [305:63] + | | | | | |--IDENT -> e [305:61] + | | | | | `--DOT -> . [305:67] + | | | | | |--IDENT -> T [305:66] + | | | | | `--IDENT -> B [305:68] + | | | | |--COLON -> : [305:70] + | | | | `--LITERAL_FALSE -> false [305:72] + | | | |--CASE_GROUP -> CASE_GROUP [306:12] + | | | | |--LITERAL_CASE -> case [306:12] + | | | | | |--EXPR -> EXPR [306:17] + | | | | | | `--IDENT -> B [306:17] + | | | | | `--COLON -> : [306:18] + | | | | `--SLIST -> SLIST [307:16] + | | | | `--LITERAL_YIELD -> yield [307:16] + | | | | `--EXPR -> EXPR [307:35] + | | | | `--LOR -> || [307:35] + | | | | |--EQUAL -> == [307:30] + | | | | | |--LPAREN -> ( [307:22] + | | | | | |--ASSIGN -> = [307:25] + | | | | | | |--IDENT -> x [307:23] + | | | | | | `--NUM_INT -> 1 [307:27] + | | | | | |--RPAREN -> ) [307:28] + | | | | | `--NUM_INT -> 1 [307:33] + | | | | `--METHOD_CALL -> ( [307:44] + | | | | |--IDENT -> isTrue [307:38] + | | | | |--ELIST -> ELIST [307:45] + | | | | `--RPAREN -> ) [307:45] + | | | |--CASE_GROUP -> CASE_GROUP [308:12] + | | | | |--LITERAL_DEFAULT -> default [308:12] + | | | | | `--COLON -> : [308:19] + | | | | `--SLIST -> SLIST [309:16] + | | | | `--LITERAL_YIELD -> yield [309:16] + | | | | `--EXPR -> EXPR [309:22] + | | | | `--LITERAL_FALSE -> false [309:22] + | | | `--RCURLY -> } [310:8] + | | |--RPAREN -> ) [310:9] + | | `--EQUAL -> == [310:16] + | | |--IDENT -> x [310:14] + | | `--NUM_INT -> 1 [310:19] + | |--SEMI -> ; [310:20] + | |--LITERAL_IF -> if [312:8] + | | |--LPAREN -> ( [312:11] + | | |--EXPR -> EXPR [312:12] + | | | `--LNOT -> ! [312:12] + | | | `--IDENT -> tA [312:13] + | | |--RPAREN -> ) [312:15] + | | `--SLIST -> { [312:17] + | | |--LITERAL_THROW -> throw [313:12] + | | | |--EXPR -> EXPR [313:18] + | | | | `--LITERAL_NEW -> new [313:18] + | | | | |--IDENT -> IllegalStateException [313:22] + | | | | |--LPAREN -> ( [313:43] + | | | | |--ELIST -> ELIST [313:44] + | | | | | `--EXPR -> EXPR [313:44] + | | | | | `--STRING_LITERAL -> "Unexpected result." [313:44] + | | | | `--RPAREN -> ) [313:64] + | | | `--SEMI -> ; [313:65] + | | `--RCURLY -> } [314:8] + | `--RCURLY -> } [315:4] + |--STATIC_INIT -> STATIC_INIT [317:4] + | `--SLIST -> { [317:11] + | |--VARIABLE_DEF -> VARIABLE_DEF [318:8] + | | |--MODIFIERS -> MODIFIERS [318:8] + | | |--TYPE -> TYPE [318:8] + | | | `--LITERAL_INT -> int [318:8] + | | `--IDENT -> x [318:12] + | |--SEMI -> ; [318:13] + | |--VARIABLE_DEF -> VARIABLE_DEF [319:8] + | | |--MODIFIERS -> MODIFIERS [319:8] + | | |--TYPE -> TYPE [319:8] + | | | `--IDENT -> T [319:8] + | | |--IDENT -> e [319:10] + | | `--ASSIGN -> = [319:12] + | | `--EXPR -> EXPR [319:15] + | | `--DOT -> . [319:15] + | | |--IDENT -> T [319:14] + | | `--IDENT -> A [319:16] + | |--SEMI -> ; [319:17] + | |--VARIABLE_DEF -> VARIABLE_DEF [321:8] + | | |--MODIFIERS -> MODIFIERS [321:8] + | | |--TYPE -> TYPE [321:8] + | | | `--LITERAL_INT -> int [321:8] + | | |--IDENT -> v [321:12] + | | `--ASSIGN -> = [321:14] + | | `--EXPR -> EXPR [321:16] + | | |--LPAREN -> ( [321:16] + | | |--LITERAL_SWITCH -> switch [321:17] + | | | |--LPAREN -> ( [321:23] + | | | |--EXPR -> EXPR [321:24] + | | | | `--IDENT -> e [321:24] + | | | |--RPAREN -> ) [321:25] + | | | |--LCURLY -> { [321:27] + | | | |--CASE_GROUP -> CASE_GROUP [322:12] + | | | | |--LITERAL_CASE -> case [322:12] + | | | | | |--EXPR -> EXPR [322:17] + | | | | | | `--IDENT -> A [322:17] + | | | | | |--LAMBDA -> -> [322:19] + | | | | | |--EXPR -> EXPR [322:24] + | | | | | | `--ASSIGN -> = [322:24] + | | | | | | |--IDENT -> x [322:22] + | | | | | | `--NUM_INT -> 0 [322:26] + | | | | | `--SEMI -> ; [322:27] + | | | | |--LITERAL_CASE -> case [323:12] + | | | | | |--EXPR -> EXPR [323:17] + | | | | | | `--IDENT -> B [323:17] + | | | | | |--LAMBDA -> -> [323:19] + | | | | | |--EXPR -> EXPR [323:24] + | | | | | | `--ASSIGN -> = [323:24] + | | | | | | |--IDENT -> x [323:22] + | | | | | | `--NUM_INT -> 0 [323:26] + | | | | | `--SEMI -> ; [323:27] + | | | | `--LITERAL_CASE -> case [324:12] + | | | | |--EXPR -> EXPR [324:17] + | | | | | `--IDENT -> C [324:17] + | | | | |--LAMBDA -> -> [324:19] + | | | | |--EXPR -> EXPR [324:24] + | | | | | `--ASSIGN -> = [324:24] + | | | | | |--IDENT -> x [324:22] + | | | | | `--NUM_INT -> 0 [324:26] + | | | | `--SEMI -> ; [324:27] + | | | `--RCURLY -> } [325:8] + | | `--RPAREN -> ) [325:9] + | |--SEMI -> ; [325:10] + | |--LITERAL_IF -> if [327:8] + | | |--LPAREN -> ( [327:11] + | | |--EXPR -> EXPR [327:19] + | | | `--LOR -> || [327:19] + | | | |--NOT_EQUAL -> != [327:14] + | | | | |--IDENT -> x [327:12] + | | | | `--NUM_INT -> 0 [327:17] + | | | `--NOT_EQUAL -> != [327:24] + | | | |--IDENT -> v [327:22] + | | | `--NUM_INT -> 0 [327:27] + | | |--RPAREN -> ) [327:28] + | | `--SLIST -> { [327:30] + | | |--LITERAL_THROW -> throw [328:12] + | | | |--EXPR -> EXPR [328:18] + | | | | `--LITERAL_NEW -> new [328:18] + | | | | |--IDENT -> IllegalStateException [328:22] + | | | | |--LPAREN -> ( [328:43] + | | | | |--ELIST -> ELIST [328:44] + | | | | | `--EXPR -> EXPR [328:44] + | | | | | `--STRING_LITERAL -> "Unexpected result." [328:44] + | | | | `--RPAREN -> ) [328:64] + | | | `--SEMI -> ; [328:65] + | | `--RCURLY -> } [329:8] + | `--RCURLY -> } [330:4] + |--INSTANCE_INIT -> INSTANCE_INIT [332:4] + | `--SLIST -> { [332:4] + | |--VARIABLE_DEF -> VARIABLE_DEF [333:8] + | | |--MODIFIERS -> MODIFIERS [333:8] + | | |--TYPE -> TYPE [333:8] + | | | `--LITERAL_INT -> int [333:8] + | | `--IDENT -> x [333:12] + | |--SEMI -> ; [333:13] + | |--VARIABLE_DEF -> VARIABLE_DEF [334:8] + | | |--MODIFIERS -> MODIFIERS [334:8] + | | |--TYPE -> TYPE [334:8] + | | | `--IDENT -> T [334:8] + | | |--IDENT -> e [334:10] + | | `--ASSIGN -> = [334:12] + | | `--EXPR -> EXPR [334:15] + | | `--DOT -> . [334:15] + | | |--IDENT -> T [334:14] + | | `--IDENT -> A [334:16] + | |--SEMI -> ; [334:17] + | |--VARIABLE_DEF -> VARIABLE_DEF [336:8] + | | |--MODIFIERS -> MODIFIERS [336:8] + | | |--TYPE -> TYPE [336:8] + | | | `--LITERAL_BOOLEAN -> boolean [336:8] + | | |--IDENT -> tA [336:16] + | | `--ASSIGN -> = [336:19] + | | `--EXPR -> EXPR [340:11] + | | `--LAND -> && [340:11] + | | |--LPAREN -> ( [336:21] + | | |--LITERAL_SWITCH -> switch [336:22] + | | | |--LPAREN -> ( [336:28] + | | | |--EXPR -> EXPR [336:29] + | | | | `--IDENT -> e [336:29] + | | | |--RPAREN -> ) [336:30] + | | | |--LCURLY -> { [336:32] + | | | |--CASE_GROUP -> CASE_GROUP [337:12] + | | | | |--LITERAL_CASE -> case [337:12] + | | | | | |--EXPR -> EXPR [337:17] + | | | | | | `--IDENT -> A [337:17] + | | | | | |--LAMBDA -> -> [337:19] + | | | | | `--SLIST -> { [337:22] + | | | | | |--EXPR -> EXPR [337:26] + | | | | | | `--ASSIGN -> = [337:26] + | | | | | | |--IDENT -> x [337:24] + | | | | | | `--NUM_INT -> 1 [337:28] + | | | | | |--SEMI -> ; [337:29] + | | | | | |--LITERAL_YIELD -> yield [337:31] + | | | | | | `--EXPR -> EXPR [337:37] + | | | | | | `--LITERAL_TRUE -> true [337:37] + | | | | | `--RCURLY -> } [337:43] + | | | | |--LITERAL_CASE -> case [338:12] + | | | | | |--EXPR -> EXPR [338:17] + | | | | | | `--IDENT -> B [338:17] + | | | | | |--LAMBDA -> -> [338:19] + | | | | | `--SLIST -> { [338:22] + | | | | | |--EXPR -> EXPR [338:26] + | | | | | | `--ASSIGN -> = [338:26] + | | | | | | |--IDENT -> x [338:24] + | | | | | | `--NUM_INT -> 1 [338:28] + | | | | | |--SEMI -> ; [338:29] + | | | | | |--LITERAL_YIELD -> yield [338:31] + | | | | | | `--EXPR -> EXPR [338:37] + | | | | | | `--LITERAL_TRUE -> true [338:37] + | | | | | `--RCURLY -> } [338:43] + | | | | `--LITERAL_CASE -> case [339:12] + | | | | |--EXPR -> EXPR [339:17] + | | | | | `--IDENT -> C [339:17] + | | | | |--LAMBDA -> -> [339:19] + | | | | `--SLIST -> { [339:22] + | | | | |--EXPR -> EXPR [339:26] + | | | | | `--ASSIGN -> = [339:26] + | | | | | |--IDENT -> x [339:24] + | | | | | `--NUM_INT -> 1 [339:28] + | | | | |--SEMI -> ; [339:29] + | | | | |--LITERAL_YIELD -> yield [339:31] + | | | | | `--EXPR -> EXPR [339:37] + | | | | | `--LITERAL_TRUE -> true [339:37] + | | | | `--RCURLY -> } [339:43] + | | | `--RCURLY -> } [340:8] + | | |--RPAREN -> ) [340:9] + | | `--EQUAL -> == [340:16] + | | |--IDENT -> x [340:14] + | | `--NUM_INT -> 1 [340:19] + | |--SEMI -> ; [340:20] + | |--LITERAL_IF -> if [342:8] + | | |--LPAREN -> ( [342:11] + | | |--EXPR -> EXPR [342:12] + | | | `--LNOT -> ! [342:12] + | | | `--IDENT -> tA [342:13] + | | |--RPAREN -> ) [342:15] + | | `--SLIST -> { [342:17] + | | |--LITERAL_THROW -> throw [343:12] + | | | |--EXPR -> EXPR [343:18] + | | | | `--LITERAL_NEW -> new [343:18] + | | | | |--IDENT -> IllegalStateException [343:22] + | | | | |--LPAREN -> ( [343:43] + | | | | |--ELIST -> ELIST [343:44] + | | | | | `--EXPR -> EXPR [343:44] + | | | | | `--STRING_LITERAL -> "Unexpected result." [343:44] + | | | | `--RPAREN -> ) [343:64] + | | | `--SEMI -> ; [343:65] + | | `--RCURLY -> } [344:8] + | `--RCURLY -> } [345:4] + |--RECORD_DEF -> RECORD_DEF [347:4] + | |--MODIFIERS -> MODIFIERS [347:4] + | | `--LITERAL_PRIVATE -> private [347:4] + | |--LITERAL_RECORD -> record [347:12] + | `--IDENT -> DefiniteAssignment1 [347:19] + |--METHOD_DEF -> METHOD_DEF [351:4] + | |--MODIFIERS -> MODIFIERS [351:4] + | | `--LITERAL_PRIVATE -> private [351:4] + | |--TYPE -> TYPE [351:12] + | | `--IDENT -> String [351:12] + | |--IDENT -> print2 [351:19] + | |--LPAREN -> ( [351:25] + | |--PARAMETERS -> PARAMETERS [351:26] + | | |--PARAMETER_DEF -> PARAMETER_DEF [351:26] + | | | |--MODIFIERS -> MODIFIERS [351:26] + | | | |--TYPE -> TYPE [351:26] + | | | | `--LITERAL_INT -> int [351:26] + | | | `--IDENT -> i [351:30] + | | |--COMMA -> , [351:31] + | | |--PARAMETER_DEF -> PARAMETER_DEF [351:33] + | | | |--MODIFIERS -> MODIFIERS [351:33] + | | | |--TYPE -> TYPE [351:33] + | | | | `--LITERAL_INT -> int [351:33] + | | | `--IDENT -> j [351:37] + | | |--COMMA -> , [351:38] + | | `--PARAMETER_DEF -> PARAMETER_DEF [351:40] + | | |--MODIFIERS -> MODIFIERS [351:40] + | | |--TYPE -> TYPE [351:40] + | | | `--LITERAL_INT -> int [351:40] + | | `--IDENT -> k [351:44] + | |--RPAREN -> ) [351:45] + | `--SLIST -> { [351:47] + | |--LITERAL_RETURN -> return [352:8] + | | |--EXPR -> EXPR [352:15] + | | | `--LITERAL_SWITCH -> switch [352:15] + | | | |--LPAREN -> ( [352:22] + | | | |--EXPR -> EXPR [352:23] + | | | | `--IDENT -> i [352:23] + | | | |--RPAREN -> ) [352:24] + | | | |--LCURLY -> { [352:26] + | | | |--CASE_GROUP -> CASE_GROUP [353:12] + | | | | |--LITERAL_CASE -> case [353:12] + | | | | | |--EXPR -> EXPR [353:17] + | | | | | | `--NUM_INT -> 0 [353:17] + | | | | | `--COLON -> : [353:18] + | | | | `--SLIST -> SLIST [354:16] + | | | | |--VARIABLE_DEF -> VARIABLE_DEF [354:16] + | | | | | |--MODIFIERS -> MODIFIERS [354:16] + | | | | | |--TYPE -> TYPE [354:16] + | | | | | | `--IDENT -> String [354:16] + | | | | | `--IDENT -> r [354:23] + | | | | |--SEMI -> ; [354:24] + | | | | |--LABELED_STAT -> : [355:21] + | | | | | |--IDENT -> OUTER [355:16] + | | | | | `--LITERAL_SWITCH -> switch [355:23] + | | | | | |--LPAREN -> ( [355:30] + | | | | | |--EXPR -> EXPR [355:31] + | | | | | | `--IDENT -> j [355:31] + | | | | | |--RPAREN -> ) [355:32] + | | | | | |--LCURLY -> { [355:34] + | | | | | |--CASE_GROUP -> CASE_GROUP [356:20] + | | | | | | |--LITERAL_CASE -> case [356:20] + | | | | | | | |--EXPR -> EXPR [356:25] + | | | | | | | | `--NUM_INT -> 0 [356:25] + | | | | | | | `--COLON -> : [356:26] + | | | | | | `--SLIST -> SLIST [357:24] + | | | | | | |--VARIABLE_DEF -> VARIABLE_DEF [357:24] + | | | | | | | |--MODIFIERS -> MODIFIERS [357:24] + | | | | | | | |--TYPE -> TYPE [357:24] + | | | | | | | | `--IDENT -> String [357:24] + | | | | | | | `--IDENT -> res [357:31] + | | | | | | |--SEMI -> ; [357:34] + | | | | | | |--LABELED_STAT -> : [358:29] + | | | | | | | |--IDENT -> INNER [358:24] + | | | | | | | `--LITERAL_SWITCH -> switch [358:31] + | | | | | | | |--LPAREN -> ( [358:38] + | | | | | | | |--EXPR -> EXPR [358:39] + | | | | | | | | `--IDENT -> k [358:39] + | | | | | | | |--RPAREN -> ) [358:40] + | | | | | | | |--LCURLY -> { [358:42] + | | | | | | | |--CASE_GROUP -> CASE_GROUP [359:28] + | | | | | | | | |--LITERAL_CASE -> case [359:28] + | | | | | | | | | |--EXPR -> EXPR [359:33] + | | | | | | | | | | `--NUM_INT -> 0 [359:33] + | | | | | | | | | `--COLON -> : [359:34] + | | | | | | | | `--SLIST -> SLIST [359:40] + | | | | | | | | |--EXPR -> EXPR [359:40] + | | | | | | | | | `--ASSIGN -> = [359:40] + | | | | | | | | | |--IDENT -> res [359:36] + | | | | | | | | | `--STRING_LITERAL -> "0-0-0" [359:42] + | | | | | | | | |--SEMI -> ; [359:49] + | | | | | | | | `--LITERAL_BREAK -> break [359:51] + | | | | | | | | `--SEMI -> ; [359:56] + | | | | | | | |--CASE_GROUP -> CASE_GROUP [360:28] + | | | | | | | | |--LITERAL_CASE -> case [360:28] + | | | | | | | | | |--EXPR -> EXPR [360:33] + | | | | | | | | | | `--NUM_INT -> 1 [360:33] + | | | | | | | | | `--COLON -> : [360:34] + | | | | | | | | `--SLIST -> SLIST [360:40] + | | | | | | | | |--EXPR -> EXPR [360:40] + | | | | | | | | | `--ASSIGN -> = [360:40] + | | | | | | | | | |--IDENT -> res [360:36] + | | | | | | | | | `--STRING_LITERAL -> "0-0-1" [360:42] + | | | | | | | | |--SEMI -> ; [360:49] + | | | | | | | | `--LITERAL_BREAK -> break [360:51] + | | | | | | | | `--SEMI -> ; [360:56] + | | | | | | | |--CASE_GROUP -> CASE_GROUP [361:28] + | | | | | | | | |--LITERAL_CASE -> case [361:28] + | | | | | | | | | |--EXPR -> EXPR [361:33] + | | | | | | | | | | `--NUM_INT -> 2 [361:33] + | | | | | | | | | `--COLON -> : [361:34] + | | | | | | | | `--SLIST -> SLIST [361:40] + | | | | | | | | |--EXPR -> EXPR [361:40] + | | | | | | | | | `--ASSIGN -> = [361:40] + | | | | | | | | | |--IDENT -> res [361:36] + | | | | | | | | | `--STRING_LITERAL -> "0-0-2" [361:42] + | | | | | | | | |--SEMI -> ; [361:49] + | | | | | | | | `--LITERAL_BREAK -> break [361:51] + | | | | | | | | |--IDENT -> INNER [361:57] + | | | | | | | | `--SEMI -> ; [361:62] + | | | | | | | |--CASE_GROUP -> CASE_GROUP [362:28] + | | | | | | | | |--LITERAL_DEFAULT -> default [362:28] + | | | | | | | | | `--COLON -> : [362:35] + | | | | | | | | `--SLIST -> SLIST [362:39] + | | | | | | | | |--EXPR -> EXPR [362:39] + | | | | | | | | | `--ASSIGN -> = [362:39] + | | | | | | | | | |--IDENT -> r [362:37] + | | | | | | | | | `--STRING_LITERAL -> "0-0-X" [362:41] + | | | | | | | | |--SEMI -> ; [362:48] + | | | | | | | | `--LITERAL_BREAK -> break [362:50] + | | | | | | | | |--IDENT -> OUTER [362:56] + | | | | | | | | `--SEMI -> ; [362:61] + | | | | | | | `--RCURLY -> } [363:24] + | | | | | | |--EXPR -> EXPR [364:26] + | | | | | | | `--ASSIGN -> = [364:26] + | | | | | | | |--IDENT -> r [364:24] + | | | | | | | `--IDENT -> res [364:28] + | | | | | | |--SEMI -> ; [364:31] + | | | | | | `--LITERAL_BREAK -> break [365:24] + | | | | | | `--SEMI -> ; [365:29] + | | | | | |--CASE_GROUP -> CASE_GROUP [366:20] + | | | | | | |--LITERAL_CASE -> case [366:20] + | | | | | | | |--EXPR -> EXPR [366:25] + | | | | | | | | `--NUM_INT -> 1 [366:25] + | | | | | | | `--COLON -> : [366:26] + | | | | | | `--SLIST -> SLIST [367:26] + | | | | | | |--EXPR -> EXPR [367:26] + | | | | | | | `--ASSIGN -> = [367:26] + | | | | | | | |--IDENT -> r [367:24] + | | | | | | | `--STRING_LITERAL -> "0-1" [367:28] + | | | | | | |--SEMI -> ; [367:33] + | | | | | | `--LITERAL_BREAK -> break [368:24] + | | | | | | `--SEMI -> ; [368:29] + | | | | | |--CASE_GROUP -> CASE_GROUP [369:20] + | | | | | | |--LITERAL_DEFAULT -> default [369:20] + | | | | | | | `--COLON -> : [369:27] + | | | | | | `--SLIST -> SLIST [370:26] + | | | | | | |--EXPR -> EXPR [370:26] + | | | | | | | `--ASSIGN -> = [370:26] + | | | | | | | |--IDENT -> r [370:24] + | | | | | | | `--STRING_LITERAL -> "0-X" [370:28] + | | | | | | |--SEMI -> ; [370:33] + | | | | | | `--LITERAL_BREAK -> break [371:24] + | | | | | | `--SEMI -> ; [371:29] + | | | | | `--RCURLY -> } [372:16] + | | | | |--VARIABLE_DEF -> VARIABLE_DEF [373:16] + | | | | | |--MODIFIERS -> MODIFIERS [373:16] + | | | | | |--TYPE -> TYPE [373:16] + | | | | | | `--IDENT -> yield [373:16] + | | | | | `--IDENT -> r [373:22] + | | | | `--SEMI -> ; [373:23] + | | | |--CASE_GROUP -> CASE_GROUP [374:12] + | | | | |--LITERAL_CASE -> case [374:12] + | | | | | |--EXPR -> EXPR [374:17] + | | | | | | `--NUM_INT -> 1 [374:17] + | | | | | `--COLON -> : [374:18] + | | | | `--SLIST -> SLIST [375:16] + | | | | `--LITERAL_YIELD -> yield [375:16] + | | | | `--EXPR -> EXPR [375:22] + | | | | `--STRING_LITERAL -> "1" [375:22] + | | | |--CASE_GROUP -> CASE_GROUP [376:12] + | | | | |--LITERAL_CASE -> case [376:12] + | | | | | |--EXPR -> EXPR [376:17] + | | | | | | `--NUM_INT -> 2 [376:17] + | | | | | `--COLON -> : [376:18] + | | | | `--SLIST -> SLIST [377:19] + | | | | |--LABELED_STAT -> : [377:19] + | | | | | |--IDENT -> LOP [377:16] + | | | | | `--LITERAL_WHILE -> while [377:21] + | | | | | |--LPAREN -> ( [377:27] + | | | | | |--EXPR -> EXPR [377:32] + | | | | | | `--GT -> > [377:32] + | | | | | | |--POST_DEC -> -- [377:29] + | | | | | | | `--IDENT -> j [377:28] + | | | | | | `--NUM_INT -> 0 [377:34] + | | | | | |--RPAREN -> ) [377:35] + | | | | | `--SLIST -> { [377:37] + | | | | | |--LITERAL_IF -> if [378:20] + | | | | | | |--LPAREN -> ( [378:23] + | | | | | | |--EXPR -> EXPR [378:26] + | | | | | | | `--EQUAL -> == [378:26] + | | | | | | | |--IDENT -> k [378:24] + | | | | | | | `--NUM_INT -> 5 [378:29] + | | | | | | |--RPAREN -> ) [378:30] + | | | | | | `--SLIST -> { [378:32] + | | | | | | |--EXPR -> EXPR [379:25] + | | | | | | | `--POST_DEC -> -- [379:25] + | | | | | | | `--IDENT -> k [379:24] + | | | | | | |--SEMI -> ; [379:27] + | | | | | | |--LITERAL_CONTINUE -> continue [380:24] + | | | | | | | `--SEMI -> ; [380:32] + | | | | | | `--RCURLY -> } [381:20] + | | | | | |--LITERAL_BREAK -> break [382:20] + | | | | | | |--IDENT -> LOP [382:26] + | | | | | | `--SEMI -> ; [382:29] + | | | | | `--RCURLY -> } [383:16] + | | | | |--VARIABLE_DEF -> VARIABLE_DEF [384:16] + | | | | | |--MODIFIERS -> MODIFIERS [384:16] + | | | | | |--TYPE -> TYPE [384:16] + | | | | | | |--IDENT -> Supplier [384:16] + | | | | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [384:24] + | | | | | | |--GENERIC_START -> < [384:24] + | | | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [384:25] + | | | | | | | `--IDENT -> String [384:25] + | | | | | | `--GENERIC_END -> > [384:31] + | | | | | |--IDENT -> getter [384:33] + | | | | | `--ASSIGN -> = [384:40] + | | | | | `--LAMBDA -> -> [384:45] + | | | | | |--LPAREN -> ( [384:42] + | | | | | |--PARAMETERS -> PARAMETERS [384:43] + | | | | | |--RPAREN -> ) [384:43] + | | | | | `--SLIST -> { [384:48] + | | | | | |--LITERAL_RETURN -> return [384:50] + | | | | | | |--EXPR -> EXPR [384:57] + | | | | | | | `--STRING_LITERAL -> "2-X-5" [384:57] + | | | | | | `--SEMI -> ; [384:64] + | | | | | `--RCURLY -> } [384:66] + | | | | |--SEMI -> ; [384:67] + | | | | `--LITERAL_YIELD -> yield [385:16] + | | | | `--EXPR -> EXPR [385:32] + | | | | `--METHOD_CALL -> ( [385:32] + | | | | |--DOT -> . [385:28] + | | | | | |--IDENT -> getter [385:22] + | | | | | `--IDENT -> get [385:29] + | | | | |--ELIST -> ELIST [385:33] + | | | | `--RPAREN -> ) [385:33] + | | | |--CASE_GROUP -> CASE_GROUP [386:12] + | | | | |--LITERAL_DEFAULT -> default [386:12] + | | | | | `--COLON -> : [386:19] + | | | | `--SLIST -> SLIST [387:16] + | | | | `--LITERAL_YIELD -> yield [387:16] + | | | | `--EXPR -> EXPR [387:22] + | | | | `--STRING_LITERAL -> "X" [387:22] + | | | `--RCURLY -> } [388:8] + | | `--SEMI -> ; [388:9] + | `--RCURLY -> } [389:4] + |--METHOD_DEF -> METHOD_DEF [391:4] + | |--MODIFIERS -> MODIFIERS [391:4] + | | `--LITERAL_PRIVATE -> private [391:4] + | |--TYPE -> TYPE [391:12] + | | `--IDENT -> String [391:12] + | |--IDENT -> expression1 [391:19] + | |--LPAREN -> ( [391:30] + | |--PARAMETERS -> PARAMETERS [391:31] + | | `--PARAMETER_DEF -> PARAMETER_DEF [391:31] + | | |--MODIFIERS -> MODIFIERS [391:31] + | | |--TYPE -> TYPE [391:31] + | | | `--IDENT -> T [391:31] + | | `--IDENT -> t [391:33] + | |--RPAREN -> ) [391:34] + | `--SLIST -> { [391:36] + | |--VARIABLE_DEF -> VARIABLE_DEF [392:8] + | | |--MODIFIERS -> MODIFIERS [392:8] + | | |--TYPE -> TYPE [392:8] + | | | `--IDENT -> String [392:8] + | | |--IDENT -> help [392:15] + | | `--ASSIGN -> = [392:20] + | | `--EXPR -> EXPR [392:22] + | | `--STRING_LITERAL -> "" [392:22] + | |--SEMI -> ; [392:24] + | |--LITERAL_RETURN -> return [393:8] + | | |--EXPR -> EXPR [393:15] + | | | `--LITERAL_SWITCH -> switch [393:15] + | | | |--LPAREN -> ( [393:22] + | | | |--EXPR -> EXPR [393:23] + | | | | `--IDENT -> t [393:23] + | | | |--RPAREN -> ) [393:24] + | | | |--LCURLY -> { [393:26] + | | | |--CASE_GROUP -> CASE_GROUP [394:12] + | | | | |--LITERAL_CASE -> case [394:12] + | | | | | |--EXPR -> EXPR [394:17] + | | | | | | `--IDENT -> A [394:17] + | | | | | `--COLON -> : [394:18] + | | | | `--SLIST -> SLIST [394:25] + | | | | |--EXPR -> EXPR [394:25] + | | | | | `--ASSIGN -> = [394:25] + | | | | | |--IDENT -> help [394:20] + | | | | | `--STRING_LITERAL -> "a" [394:27] + | | | | `--SEMI -> ; [394:30] + | | | |--CASE_GROUP -> CASE_GROUP [395:12] + | | | | |--LITERAL_CASE -> case [395:12] + | | | | | |--EXPR -> EXPR [395:17] + | | | | | | `--IDENT -> B [395:17] + | | | | | `--COLON -> : [395:18] + | | | | `--SLIST -> SLIST [395:25] + | | | | |--EXPR -> EXPR [395:25] + | | | | | `--PLUS_ASSIGN -> += [395:25] + | | | | | |--IDENT -> help [395:20] + | | | | | `--STRING_LITERAL -> "b" [395:28] + | | | | `--SEMI -> ; [395:31] + | | | |--CASE_GROUP -> CASE_GROUP [396:12] + | | | | |--LITERAL_DEFAULT -> default [396:12] + | | | | | `--COLON -> : [396:19] + | | | | `--SLIST -> SLIST [396:21] + | | | | |--VARIABLE_DEF -> VARIABLE_DEF [396:21] + | | | | | |--MODIFIERS -> MODIFIERS [396:21] + | | | | | |--TYPE -> TYPE [396:21] + | | | | | | `--IDENT -> yield [396:21] + | | | | | `--IDENT -> help [396:27] + | | | | `--SEMI -> ; [396:31] + | | | `--RCURLY -> } [397:8] + | | `--SEMI -> ; [397:9] + | `--RCURLY -> } [398:4] + |--METHOD_DEF -> METHOD_DEF [400:4] + | |--MODIFIERS -> MODIFIERS [400:4] + | | `--LITERAL_PRIVATE -> private [400:4] + | |--TYPE -> TYPE [400:12] + | | `--IDENT -> String [400:12] + | |--IDENT -> expression2 [400:19] + | |--LPAREN -> ( [400:30] + | |--PARAMETERS -> PARAMETERS [400:31] + | | `--PARAMETER_DEF -> PARAMETER_DEF [400:31] + | | |--MODIFIERS -> MODIFIERS [400:31] + | | |--TYPE -> TYPE [400:31] + | | | `--IDENT -> T [400:31] + | | `--IDENT -> t [400:33] + | |--RPAREN -> ) [400:34] + | `--SLIST -> { [400:36] + | |--VARIABLE_DEF -> VARIABLE_DEF [401:8] + | | |--MODIFIERS -> MODIFIERS [401:8] + | | |--TYPE -> TYPE [401:8] + | | | `--IDENT -> String [401:8] + | | |--IDENT -> help [401:15] + | | `--ASSIGN -> = [401:20] + | | `--EXPR -> EXPR [401:22] + | | `--STRING_LITERAL -> "" [401:22] + | |--SEMI -> ; [401:24] + | |--LITERAL_RETURN -> return [402:8] + | | |--EXPR -> EXPR [402:15] + | | | `--LITERAL_SWITCH -> switch [402:15] + | | | |--LPAREN -> ( [402:22] + | | | |--EXPR -> EXPR [402:23] + | | | | `--IDENT -> t [402:23] + | | | |--RPAREN -> ) [402:24] + | | | |--LCURLY -> { [402:26] + | | | |--CASE_GROUP -> CASE_GROUP [403:12] + | | | | |--LITERAL_CASE -> case [403:12] + | | | | | |--EXPR -> EXPR [403:17] + | | | | | | `--IDENT -> A [403:17] + | | | | | `--COLON -> : [403:18] + | | | | `--SLIST -> SLIST [403:25] + | | | | |--EXPR -> EXPR [403:25] + | | | | | `--ASSIGN -> = [403:25] + | | | | | |--IDENT -> help [403:20] + | | | | | `--STRING_LITERAL -> "a" [403:27] + | | | | `--SEMI -> ; [403:30] + | | | |--CASE_GROUP -> CASE_GROUP [404:12] + | | | | |--LITERAL_CASE -> case [404:12] + | | | | | |--EXPR -> EXPR [404:17] + | | | | | | `--IDENT -> B [404:17] + | | | | | `--COLON -> : [404:18] + | | | | `--SLIST -> SLIST [404:25] + | | | | |--EXPR -> EXPR [404:25] + | | | | | `--PLUS_ASSIGN -> += [404:25] + | | | | | |--IDENT -> help [404:20] + | | | | | `--STRING_LITERAL -> "b" [404:28] + | | | | `--SEMI -> ; [404:31] + | | | |--CASE_GROUP -> CASE_GROUP [405:12] + | | | | |--LITERAL_DEFAULT -> default [405:12] + | | | | | `--COLON -> : [405:19] + | | | | `--SLIST -> SLIST [405:21] + | | | | |--VARIABLE_DEF -> VARIABLE_DEF [405:21] + | | | | | |--MODIFIERS -> MODIFIERS [405:21] + | | | | | |--TYPE -> TYPE [405:21] + | | | | | | `--IDENT -> yield [405:21] + | | | | | `--IDENT -> help [405:27] + | | | | `--SEMI -> ; [405:31] + | | | `--RCURLY -> } [406:8] + | | `--SEMI -> ; [406:9] + | `--RCURLY -> } [407:4] + |--METHOD_DEF -> METHOD_DEF [409:4] + | |--MODIFIERS -> MODIFIERS [409:4] + | |--TYPE -> TYPE [409:4] + | | |--IDENT -> I [409:4] + | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [409:5] + | | |--GENERIC_START -> < [409:5] + | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [409:6] + | | | `--IDENT -> String [409:6] + | | `--GENERIC_END -> > [409:12] + | |--IDENT -> lambdaCapture1 [409:14] + | |--LPAREN -> ( [409:28] + | |--PARAMETERS -> PARAMETERS [409:29] + | | `--PARAMETER_DEF -> PARAMETER_DEF [409:29] + | | |--MODIFIERS -> MODIFIERS [409:29] + | | |--TYPE -> TYPE [409:29] + | | | `--LITERAL_INT -> int [409:29] + | | `--IDENT -> i [409:33] + | |--RPAREN -> ) [409:34] + | `--SLIST -> { [409:36] + | |--VARIABLE_DEF -> VARIABLE_DEF [410:8] + | | |--MODIFIERS -> MODIFIERS [410:8] + | | |--TYPE -> TYPE [410:8] + | | | `--LITERAL_INT -> int [410:8] + | | |--IDENT -> j [410:12] + | | `--ASSIGN -> = [410:14] + | | `--EXPR -> EXPR [410:18] + | | `--PLUS -> + [410:18] + | | |--IDENT -> i [410:16] + | | `--NUM_INT -> 1 [410:20] + | |--SEMI -> ; [410:21] + | |--VARIABLE_DEF -> VARIABLE_DEF [411:8] + | | |--MODIFIERS -> MODIFIERS [411:8] + | | |--TYPE -> TYPE [411:8] + | | | |--IDENT -> I [411:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [411:9] + | | | |--GENERIC_START -> < [411:9] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [411:10] + | | | | `--IDENT -> String [411:10] + | | | `--GENERIC_END -> > [411:16] + | | |--IDENT -> r [411:18] + | | `--ASSIGN -> = [411:20] + | | `--EXPR -> EXPR [411:22] + | | `--LITERAL_SWITCH -> switch [411:22] + | | |--LPAREN -> ( [411:29] + | | |--EXPR -> EXPR [411:30] + | | | `--IDENT -> i [411:30] + | | |--RPAREN -> ) [411:31] + | | |--LCURLY -> { [411:33] + | | |--CASE_GROUP -> CASE_GROUP [412:12] + | | | |--LITERAL_CASE -> case [412:12] + | | | | |--EXPR -> EXPR [412:17] + | | | | | `--NUM_INT -> 0 [412:17] + | | | | |--LAMBDA -> -> [412:19] + | | | | |--LAMBDA -> -> [412:25] + | | | | | |--LPAREN -> ( [412:22] + | | | | | |--PARAMETERS -> PARAMETERS [412:23] + | | | | | |--RPAREN -> ) [412:23] + | | | | | `--EXPR -> EXPR [412:32] + | | | | | `--PLUS -> + [412:32] + | | | | | |--STRING_LITERAL -> "0" [412:28] + | | | | | `--IDENT -> i [412:34] + | | | | `--SEMI -> ; [412:35] + | | | |--LITERAL_CASE -> case [413:12] + | | | | |--EXPR -> EXPR [413:17] + | | | | | `--NUM_INT -> 1 [413:17] + | | | | |--LAMBDA -> -> [413:19] + | | | | |--LAMBDA -> -> [413:25] + | | | | | |--LPAREN -> ( [413:22] + | | | | | |--PARAMETERS -> PARAMETERS [413:23] + | | | | | |--RPAREN -> ) [413:23] + | | | | | `--EXPR -> EXPR [413:32] + | | | | | `--PLUS -> + [413:32] + | | | | | |--STRING_LITERAL -> "1" [413:28] + | | | | | `--IDENT -> j [413:34] + | | | | `--SEMI -> ; [413:35] + | | | `--LITERAL_DEFAULT -> default [414:12] + | | | |--LAMBDA -> -> [414:20] + | | | `--SLIST -> { [414:23] + | | | |--VARIABLE_DEF -> VARIABLE_DEF [415:16] + | | | | |--MODIFIERS -> MODIFIERS [415:16] + | | | | |--TYPE -> TYPE [415:16] + | | | | | `--IDENT -> String [415:16] + | | | | |--IDENT -> k [415:23] + | | | | `--ASSIGN -> = [415:25] + | | | | `--EXPR -> EXPR [415:27] + | | | | `--STRING_LITERAL -> "D" [415:27] + | | | |--SEMI -> ; [415:30] + | | | |--LITERAL_YIELD -> yield [416:16] + | | | | `--LAMBDA -> -> [416:25] + | | | | |--LPAREN -> ( [416:22] + | | | | |--PARAMETERS -> PARAMETERS [416:23] + | | | | |--RPAREN -> ) [416:23] + | | | | `--EXPR -> EXPR [416:28] + | | | | `--IDENT -> k [416:28] + | | | `--RCURLY -> } [417:12] + | | `--RCURLY -> } [418:8] + | |--SEMI -> ; [418:9] + | |--LITERAL_RETURN -> return [420:8] + | | |--EXPR -> EXPR [420:15] + | | | `--IDENT -> r [420:15] + | | `--SEMI -> ; [420:16] + | `--RCURLY -> } [421:4] + |--METHOD_DEF -> METHOD_DEF [423:4] + | |--MODIFIERS -> MODIFIERS [423:4] + | |--TYPE -> TYPE [423:4] + | | |--IDENT -> I [423:4] + | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [423:5] + | | |--GENERIC_START -> < [423:5] + | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [423:6] + | | | `--IDENT -> String [423:6] + | | `--GENERIC_END -> > [423:12] + | |--IDENT -> lambdaCapture2 [423:14] + | |--LPAREN -> ( [423:28] + | |--PARAMETERS -> PARAMETERS [423:29] + | | `--PARAMETER_DEF -> PARAMETER_DEF [423:29] + | | |--MODIFIERS -> MODIFIERS [423:29] + | | |--TYPE -> TYPE [423:29] + | | | `--LITERAL_INT -> int [423:29] + | | `--IDENT -> i [423:33] + | |--RPAREN -> ) [423:34] + | `--SLIST -> { [423:36] + | |--VARIABLE_DEF -> VARIABLE_DEF [424:8] + | | |--MODIFIERS -> MODIFIERS [424:8] + | | |--TYPE -> TYPE [424:8] + | | | `--LITERAL_INT -> int [424:8] + | | |--IDENT -> j [424:12] + | | `--ASSIGN -> = [424:14] + | | `--EXPR -> EXPR [424:18] + | | `--PLUS -> + [424:18] + | | |--IDENT -> i [424:16] + | | `--NUM_INT -> 1 [424:20] + | |--SEMI -> ; [424:21] + | |--LITERAL_RETURN -> return [426:8] + | | |--EXPR -> EXPR [426:15] + | | | `--LITERAL_SWITCH -> switch [426:15] + | | | |--LPAREN -> ( [426:22] + | | | |--EXPR -> EXPR [426:23] + | | | | `--IDENT -> i [426:23] + | | | |--RPAREN -> ) [426:24] + | | | |--LCURLY -> { [426:26] + | | | |--CASE_GROUP -> CASE_GROUP [427:12] + | | | | |--LITERAL_CASE -> case [427:12] + | | | | | |--EXPR -> EXPR [427:17] + | | | | | | `--NUM_INT -> 0 [427:17] + | | | | | |--LAMBDA -> -> [427:19] + | | | | | |--LAMBDA -> -> [427:25] + | | | | | | |--LPAREN -> ( [427:22] + | | | | | | |--PARAMETERS -> PARAMETERS [427:23] + | | | | | | |--RPAREN -> ) [427:23] + | | | | | | `--EXPR -> EXPR [427:32] + | | | | | | `--PLUS -> + [427:32] + | | | | | | |--STRING_LITERAL -> "0" [427:28] + | | | | | | `--IDENT -> i [427:34] + | | | | | `--SEMI -> ; [427:35] + | | | | |--LITERAL_CASE -> case [428:12] + | | | | | |--EXPR -> EXPR [428:17] + | | | | | | `--NUM_INT -> 1 [428:17] + | | | | | |--LAMBDA -> -> [428:19] + | | | | | |--LAMBDA -> -> [428:25] + | | | | | | |--LPAREN -> ( [428:22] + | | | | | | |--PARAMETERS -> PARAMETERS [428:23] + | | | | | | |--RPAREN -> ) [428:23] + | | | | | | `--EXPR -> EXPR [428:32] + | | | | | | `--PLUS -> + [428:32] + | | | | | | |--STRING_LITERAL -> "1" [428:28] + | | | | | | `--IDENT -> j [428:34] + | | | | | `--SEMI -> ; [428:35] + | | | | `--LITERAL_DEFAULT -> default [429:12] + | | | | |--LAMBDA -> -> [429:20] + | | | | `--SLIST -> { [429:23] + | | | | |--VARIABLE_DEF -> VARIABLE_DEF [430:16] + | | | | | |--MODIFIERS -> MODIFIERS [430:16] + | | | | | |--TYPE -> TYPE [430:16] + | | | | | | `--IDENT -> String [430:16] + | | | | | |--IDENT -> k [430:23] + | | | | | `--ASSIGN -> = [430:25] + | | | | | `--EXPR -> EXPR [430:27] + | | | | | `--STRING_LITERAL -> "D" [430:27] + | | | | |--SEMI -> ; [430:30] + | | | | |--LITERAL_YIELD -> yield [431:16] + | | | | | `--LAMBDA -> -> [431:24] + | | | | | |--LPAREN -> ( [431:21] + | | | | | |--PARAMETERS -> PARAMETERS [431:22] + | | | | | |--RPAREN -> ) [431:22] + | | | | | `--EXPR -> EXPR [431:26] + | | | | | `--IDENT -> k [431:26] + | | | | `--RCURLY -> } [432:12] + | | | `--RCURLY -> } [433:8] + | | `--SEMI -> ; [433:9] + | `--RCURLY -> } [434:4] + |--INTERFACE_DEF -> INTERFACE_DEF [436:4] + | |--MODIFIERS -> MODIFIERS [436:4] + | |--LITERAL_INTERFACE -> interface [436:4] + | |--IDENT -> I [436:14] + | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [436:15] + | | |--GENERIC_START -> < [436:15] + | | |--TYPE_PARAMETER -> TYPE_PARAMETER [436:16] + | | | `--IDENT -> T [436:16] + | | `--GENERIC_END -> > [436:17] + | `--OBJBLOCK -> OBJBLOCK [436:19] + | |--LCURLY -> { [436:19] + | |--METHOD_DEF -> METHOD_DEF [437:8] + | | |--MODIFIERS -> MODIFIERS [437:8] + | | | `--LITERAL_PUBLIC -> public [437:8] + | | |--TYPE -> TYPE [437:15] + | | | `--IDENT -> T [437:15] + | | |--IDENT -> t [437:17] + | | |--LPAREN -> ( [437:18] + | | |--PARAMETERS -> PARAMETERS [437:19] + | | |--RPAREN -> ) [437:19] + | | `--SEMI -> ; [437:20] + | `--RCURLY -> } [438:4] + |--STATIC_INIT -> STATIC_INIT [440:4] + | `--SLIST -> { [440:11] + | |--VARIABLE_DEF -> VARIABLE_DEF [441:8] + | | |--MODIFIERS -> MODIFIERS [441:8] + | | |--TYPE -> TYPE [441:8] + | | | `--LITERAL_INT -> int [441:8] + | | |--IDENT -> i [441:12] + | | `--ASSIGN -> = [441:14] + | | `--EXPR -> EXPR [441:16] + | | `--NUM_INT -> 0 [441:16] + | |--SEMI -> ; [441:17] + | |--VARIABLE_DEF -> VARIABLE_DEF [442:8] + | | |--MODIFIERS -> MODIFIERS [442:8] + | | |--TYPE -> TYPE [442:8] + | | | `--LITERAL_INT -> int [442:8] + | | |--IDENT -> dummy [442:12] + | | `--ASSIGN -> = [442:18] + | | `--EXPR -> EXPR [442:22] + | | `--PLUS -> + [442:22] + | | |--NUM_INT -> 1 [442:20] + | | `--LITERAL_SWITCH -> switch [442:24] + | | |--LPAREN -> ( [442:31] + | | |--EXPR -> EXPR [442:32] + | | | `--IDENT -> i [442:32] + | | |--RPAREN -> ) [442:33] + | | |--LCURLY -> { [442:35] + | | |--CASE_GROUP -> CASE_GROUP [443:12] + | | | |--LITERAL_CASE -> case [443:12] + | | | | |--EXPR -> EXPR [443:17] + | | | | | `--UNARY_MINUS -> - [443:17] + | | | | | `--NUM_INT -> 1 [443:18] + | | | | `--COLON -> : [443:19] + | | | `--SLIST -> SLIST [443:21] + | | | `--LITERAL_YIELD -> yield [443:21] + | | | `--EXPR -> EXPR [443:27] + | | | `--NUM_INT -> 1 [443:27] + | | |--CASE_GROUP -> CASE_GROUP [444:12] + | | | |--LITERAL_DEFAULT -> default [444:12] + | | | | `--COLON -> : [444:19] + | | | `--SLIST -> SLIST [445:17] + | | | |--EXPR -> EXPR [445:17] + | | | | `--POST_INC -> ++ [445:17] + | | | | `--IDENT -> i [445:16] + | | | |--SEMI -> ; [445:19] + | | | `--LITERAL_YIELD -> yield [446:16] + | | | `--EXPR -> EXPR [446:22] + | | | `--NUM_INT -> 1 [446:22] + | | `--RCURLY -> } [447:8] + | |--SEMI -> ; [447:9] + | |--LITERAL_IF -> if [448:8] + | | |--LPAREN -> ( [448:11] + | | |--EXPR -> EXPR [448:14] + | | | `--NOT_EQUAL -> != [448:14] + | | | |--IDENT -> i [448:12] + | | | `--NUM_INT -> 1 [448:17] + | | |--RPAREN -> ) [448:18] + | | `--SLIST -> { [448:20] + | | |--LITERAL_THROW -> throw [449:12] + | | | |--EXPR -> EXPR [449:18] + | | | | `--LITERAL_NEW -> new [449:18] + | | | | |--IDENT -> IllegalStateException [449:22] + | | | | |--LPAREN -> ( [449:43] + | | | | |--ELIST -> ELIST [449:44] + | | | | | `--EXPR -> EXPR [449:44] + | | | | | `--STRING_LITERAL -> "Side effects missing." [449:44] + | | | | `--RPAREN -> ) [449:67] + | | | `--SEMI -> ; [449:68] + | | `--RCURLY -> } [450:8] + | `--RCURLY -> } [451:4] + `--RCURLY -> } [452:0]