COMPILATION_UNIT -> COMPILATION_UNIT [1:1]
|--PACKAGE_DEF -> package [1:1]
| |--ANNOTATIONS -> ANNOTATIONS [1:40]
| |--DOT -> . [1:40]
| | |--DOT -> . [1:29]
| | | |--DOT -> . [1:23]
| | | | |--DOT -> . [1:12]
| | | | | |--IDENT -> com [1:9]
| | | | | `--IDENT -> puppycrawl [1:13]
| | | | `--IDENT -> tools [1:24]
| | | `--IDENT -> checkstyle [1:30]
| | `--IDENT -> grammar [1:41]
| `--SEMI -> ; [1:48]
|--IMPORT -> import [3:1]
| |--DOT -> . [3:17]
| | |--DOT -> . [3:12]
| | | |--IDENT -> java [3:8]
| | | `--IDENT -> util [3:13]
| | `--IDENT -> ArrayList [3:18]
| `--SEMI -> ; [3:27]
|--IMPORT -> import [4:1]
| |--DOT -> . [4:17]
| | |--DOT -> . [4:12]
| | | |--IDENT -> java [4:8]
| | | `--IDENT -> util [4:13]
| | `--IDENT -> LinkedList [4:18]
| `--SEMI -> ; [4:28]
|--IMPORT -> import [5:1]
| |--DOT -> . [5:17]
| | |--DOT -> . [5:12]
| | | |--IDENT -> java [5:8]
| | | `--IDENT -> util [5:13]
| | `--IDENT -> List [5:18]
| `--SEMI -> ; [5:22]
|--IMPORT -> import [6:1]
| |--DOT -> . [6:17]
| | |--DOT -> . [6:12]
| | | |--IDENT -> java [6:8]
| | | `--IDENT -> util [6:13]
| | `--IDENT -> Set [6:18]
| `--SEMI -> ; [6:21]
|--CLASS_DEF -> CLASS_DEF [8:1]
| |--MODIFIERS -> MODIFIERS [8:1]
| | `--LITERAL_PUBLIC -> public [8:1]
| |--LITERAL_CLASS -> class [8:8]
| |--IDENT -> InputPatternsInSwitchLabels [8:14]
| `--OBJBLOCK -> OBJBLOCK [8:42]
| |--LCURLY -> { [8:42]
| |--METHOD_DEF -> METHOD_DEF [9:5]
| | |--MODIFIERS -> MODIFIERS [9:5]
| | | `--LITERAL_STATIC -> static [9:5]
| | |--TYPE -> TYPE [9:12]
| | | `--LITERAL_VOID -> void [9:12]
| | |--IDENT -> m1 [9:17]
| | |--LPAREN -> ( [9:19]
| | |--PARAMETERS -> PARAMETERS [9:20]
| | | `--PARAMETER_DEF -> PARAMETER_DEF [9:20]
| | | |--MODIFIERS -> MODIFIERS [9:20]
| | | |--TYPE -> TYPE [9:20]
| | | | `--IDENT -> Object [9:20]
| | | `--IDENT -> o [9:27]
| | |--RPAREN -> ) [9:28]
| | `--SLIST -> { [9:30]
| | |--LITERAL_SWITCH -> switch [11:9]
| | | |--LPAREN -> ( [11:16]
| | | |--EXPR -> EXPR [11:17]
| | | | `--IDENT -> o [11:17]
| | | |--RPAREN -> ) [11:18]
| | | |--LCURLY -> { [11:20]
| | | |--SWITCH_RULE -> SWITCH_RULE [12:13]
| | | | |--LITERAL_CASE -> case [12:13]
| | | | | `--PATTERN_DEF -> PATTERN_DEF [12:28]
| | | | | `--LITERAL_WHEN -> when [12:28]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [12:18]
| | | | | | |--MODIFIERS -> MODIFIERS [12:18]
| | | | | | |--TYPE -> TYPE [12:18]
| | | | | | | `--IDENT -> Integer [12:18]
| | | | | | `--IDENT -> i [12:26]
| | | | | `--EXPR -> EXPR [12:35]
| | | | | `--GE -> >= [12:35]
| | | | | |--IDENT -> i [12:33]
| | | | | `--NUM_INT -> 0 [12:38]
| | | | |--LAMBDA -> -> [12:40]
| | | | |--EXPR -> EXPR [12:61]
| | | | | `--METHOD_CALL -> ( [12:61]
| | | | | |--DOT -> . [12:53]
| | | | | | |--DOT -> . [12:49]
| | | | | | | |--IDENT -> System [12:43]
| | | | | | | `--IDENT -> out [12:50]
| | | | | | `--IDENT -> println [12:54]
| | | | | |--ELIST -> ELIST [12:62]
| | | | | | `--EXPR -> EXPR [12:62]
| | | | | | `--IDENT -> i [12:62]
| | | | | `--RPAREN -> ) [12:63]
| | | | `--SEMI -> ; [12:64]
| | | |--SWITCH_RULE -> SWITCH_RULE [13:13]
| | | | |--LITERAL_CASE -> case [13:13]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [13:18]
| | | | | |--MODIFIERS -> MODIFIERS [13:18]
| | | | | |--TYPE -> TYPE [13:18]
| | | | | | `--IDENT -> Integer [13:18]
| | | | | `--IDENT -> i [13:26]
| | | | |--LAMBDA -> -> [13:28]
| | | | |--EXPR -> EXPR [13:49]
| | | | | `--METHOD_CALL -> ( [13:49]
| | | | | |--DOT -> . [13:41]
| | | | | | |--DOT -> . [13:37]
| | | | | | | |--IDENT -> System [13:31]
| | | | | | | `--IDENT -> out [13:38]
| | | | | | `--IDENT -> println [13:42]
| | | | | |--ELIST -> ELIST [13:52]
| | | | | | `--EXPR -> EXPR [13:52]
| | | | | | `--SL -> << [13:52]
| | | | | | |--IDENT -> i [13:50]
| | | | | | `--NUM_INT -> 1 [13:55]
| | | | | `--RPAREN -> ) [13:56]
| | | | `--SEMI -> ; [13:57]
| | | |--SWITCH_RULE -> SWITCH_RULE [14:13]
| | | | |--LITERAL_DEFAULT -> default [14:13]
| | | | |--LAMBDA -> -> [14:21]
| | | | `--LITERAL_THROW -> throw [14:24]
| | | | |--EXPR -> EXPR [14:30]
| | | | | `--LITERAL_NEW -> new [14:30]
| | | | | |--IDENT -> IllegalStateException [14:34]
| | | | | |--LPAREN -> ( [14:55]
| | | | | |--ELIST -> ELIST [15:42]
| | | | | | `--EXPR -> EXPR [15:42]
| | | | | | `--PLUS -> + [15:42]
| | | | | | |--STRING_LITERAL -> "Unexpected value: " [15:21]
| | | | | | `--IDENT -> o [15:44]
| | | | | `--RPAREN -> ) [15:45]
| | | | `--SEMI -> ; [15:46]
| | | `--RCURLY -> } [16:9]
| | `--RCURLY -> } [17:5]
| |--METHOD_DEF -> METHOD_DEF [19:5]
| | |--MODIFIERS -> MODIFIERS [19:5]
| | | `--LITERAL_STATIC -> static [19:5]
| | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [19:12]
| | | |--GENERIC_START -> < [19:12]
| | | |--TYPE_PARAMETER -> TYPE_PARAMETER [19:13]
| | | | `--IDENT -> T [19:13]
| | | `--GENERIC_END -> > [19:14]
| | |--TYPE -> TYPE [19:16]
| | | `--LITERAL_VOID -> void [19:16]
| | |--IDENT -> m2 [19:21]
| | |--LPAREN -> ( [19:23]
| | |--PARAMETERS -> PARAMETERS [19:24]
| | | `--PARAMETER_DEF -> PARAMETER_DEF [19:24]
| | | |--MODIFIERS -> MODIFIERS [19:24]
| | | |--TYPE -> TYPE [19:24]
| | | | `--IDENT -> Object [19:24]
| | | `--IDENT -> o [19:31]
| | |--RPAREN -> ) [19:32]
| | `--SLIST -> { [19:34]
| | |--LITERAL_SWITCH -> switch [21:9]
| | | |--LPAREN -> ( [21:16]
| | | |--EXPR -> EXPR [21:17]
| | | | `--IDENT -> o [21:17]
| | | |--RPAREN -> ) [21:18]
| | | |--LCURLY -> { [21:20]
| | | |--SWITCH_RULE -> SWITCH_RULE [22:13]
| | | | |--LITERAL_CASE -> case [22:13]
| | | | | `--PATTERN_DEF -> PATTERN_DEF [22:29]
| | | | | `--LITERAL_WHEN -> when [22:29]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [22:18]
| | | | | | |--MODIFIERS -> MODIFIERS [22:18]
| | | | | | |--TYPE -> TYPE [22:18]
| | | | | | | `--IDENT -> List [22:18]
| | | | | | `--IDENT -> list1 [22:23]
| | | | | `--EXPR -> EXPR [23:43]
| | | | | `--LOR -> || [23:43]
| | | | | |--LPAREN -> ( [22:34]
| | | | | |--LAND -> && [23:21]
| | | | | | |--GE -> >= [22:48]
| | | | | | | |--METHOD_CALL -> ( [22:45]
| | | | | | | | |--DOT -> . [22:40]
| | | | | | | | | |--IDENT -> list1 [22:35]
| | | | | | | | | `--IDENT -> size [22:41]
| | | | | | | | |--ELIST -> ELIST [22:46]
| | | | | | | | `--RPAREN -> ) [22:46]
| | | | | | | `--NUM_INT -> 0 [22:51]
| | | | | | `--LT -> < [23:37]
| | | | | | |--METHOD_CALL -> ( [23:34]
| | | | | | | |--DOT -> . [23:29]
| | | | | | | | |--IDENT -> list1 [23:24]
| | | | | | | | `--IDENT -> size [23:30]
| | | | | | | |--ELIST -> ELIST [23:35]
| | | | | | | `--RPAREN -> ) [23:35]
| | | | | | `--NUM_INT -> 10 [23:39]
| | | | | |--RPAREN -> ) [23:41]
| | | | | `--METHOD_CALL -> ( [23:58]
| | | | | |--DOT -> . [23:51]
| | | | | | |--IDENT -> list1 [23:46]
| | | | | | `--IDENT -> equals [23:52]
| | | | | |--ELIST -> ELIST [23:59]
| | | | | | `--EXPR -> EXPR [23:59]
| | | | | | `--LITERAL_NEW -> new [23:59]
| | | | | | |--IDENT -> ArrayList [23:63]
| | | | | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [23:72]
| | | | | | | |--GENERIC_START -> < [23:72]
| | | | | | | `--GENERIC_END -> > [23:73]
| | | | | | |--LPAREN -> ( [23:74]
| | | | | | |--ELIST -> ELIST [23:75]
| | | | | | `--RPAREN -> ) [23:75]
| | | | | `--RPAREN -> ) [23:76]
| | | | |--LAMBDA -> -> [23:78]
| | | | |--EXPR -> EXPR [24:39]
| | | | | `--METHOD_CALL -> ( [24:39]
| | | | | |--DOT -> . [24:31]
| | | | | | |--DOT -> . [24:27]
| | | | | | | |--IDENT -> System [24:21]
| | | | | | | `--IDENT -> out [24:28]
| | | | | | `--IDENT -> println [24:32]
| | | | | |--ELIST -> ELIST [24:40]
| | | | | | `--EXPR -> EXPR [24:40]
| | | | | | `--IDENT -> list1 [24:40]
| | | | | `--RPAREN -> ) [24:45]
| | | | `--SEMI -> ; [24:46]
| | | |--SWITCH_RULE -> SWITCH_RULE [25:13]
| | | | |--LITERAL_CASE -> case [25:13]
| | | | | `--PATTERN_DEF -> PATTERN_DEF [25:29]
| | | | | `--LITERAL_WHEN -> when [25:29]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [25:18]
| | | | | | |--MODIFIERS -> MODIFIERS [25:18]
| | | | | | |--TYPE -> TYPE [25:18]
| | | | | | | `--IDENT -> List [25:18]
| | | | | | `--IDENT -> list2 [25:23]
| | | | | `--EXPR -> EXPR [26:43]
| | | | | `--LOR -> || [26:43]
| | | | | |--LPAREN -> ( [25:34]
| | | | | |--LAND -> && [26:21]
| | | | | | |--GE -> >= [25:48]
| | | | | | | |--METHOD_CALL -> ( [25:45]
| | | | | | | | |--DOT -> . [25:40]
| | | | | | | | | |--IDENT -> list2 [25:35]
| | | | | | | | | `--IDENT -> size [25:41]
| | | | | | | | |--ELIST -> ELIST [25:46]
| | | | | | | | `--RPAREN -> ) [25:46]
| | | | | | | `--NUM_INT -> 0 [25:51]
| | | | | | `--LT -> < [26:37]
| | | | | | |--METHOD_CALL -> ( [26:34]
| | | | | | | |--DOT -> . [26:29]
| | | | | | | | |--IDENT -> list2 [26:24]
| | | | | | | | `--IDENT -> size [26:30]
| | | | | | | |--ELIST -> ELIST [26:35]
| | | | | | | `--RPAREN -> ) [26:35]
| | | | | | `--NUM_INT -> 20 [26:39]
| | | | | |--RPAREN -> ) [26:41]
| | | | | `--METHOD_CALL -> ( [26:58]
| | | | | |--DOT -> . [26:51]
| | | | | | |--IDENT -> list2 [26:46]
| | | | | | `--IDENT -> equals [26:52]
| | | | | |--ELIST -> ELIST [26:59]
| | | | | | `--EXPR -> EXPR [26:59]
| | | | | | `--LITERAL_NEW -> new [26:59]
| | | | | | |--IDENT -> LinkedList [26:63]
| | | | | | |--LPAREN -> ( [26:73]
| | | | | | |--ELIST -> ELIST [26:74]
| | | | | | `--RPAREN -> ) [26:74]
| | | | | `--RPAREN -> ) [26:75]
| | | | |--LAMBDA -> -> [26:77]
| | | | |--EXPR -> EXPR [27:39]
| | | | | `--METHOD_CALL -> ( [27:39]
| | | | | |--DOT -> . [27:31]
| | | | | | |--DOT -> . [27:27]
| | | | | | | |--IDENT -> System [27:21]
| | | | | | | `--IDENT -> out [27:28]
| | | | | | `--IDENT -> println [27:32]
| | | | | |--ELIST -> ELIST [27:40]
| | | | | | `--EXPR -> EXPR [27:40]
| | | | | | `--STRING_LITERAL -> "list2" [27:40]
| | | | | `--RPAREN -> ) [27:47]
| | | | `--SEMI -> ; [27:48]
| | | |--SWITCH_RULE -> SWITCH_RULE [28:13]
| | | | |--LITERAL_CASE -> case [28:13]
| | | | | `--PATTERN_DEF -> PATTERN_DEF [28:29]
| | | | | `--LITERAL_WHEN -> when [28:29]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [28:18]
| | | | | | |--MODIFIERS -> MODIFIERS [28:18]
| | | | | | |--TYPE -> TYPE [28:18]
| | | | | | | `--IDENT -> List [28:18]
| | | | | | `--IDENT -> list3 [28:23]
| | | | | `--EXPR -> EXPR [29:42]
| | | | | `--LOR -> || [29:42]
| | | | | |--LAND -> && [29:21]
| | | | | | |--GE -> >= [28:47]
| | | | | | | |--METHOD_CALL -> ( [28:44]
| | | | | | | | |--DOT -> . [28:39]
| | | | | | | | | |--IDENT -> list3 [28:34]
| | | | | | | | | `--IDENT -> size [28:40]
| | | | | | | | |--ELIST -> ELIST [28:45]
| | | | | | | | `--RPAREN -> ) [28:45]
| | | | | | | `--NUM_INT -> 0 [28:50]
| | | | | | `--LT -> < [29:37]
| | | | | | |--METHOD_CALL -> ( [29:34]
| | | | | | | |--DOT -> . [29:29]
| | | | | | | | |--IDENT -> list3 [29:24]
| | | | | | | | `--IDENT -> size [29:30]
| | | | | | | |--ELIST -> ELIST [29:35]
| | | | | | | `--RPAREN -> ) [29:35]
| | | | | | `--NUM_INT -> 45 [29:39]
| | | | | `--METHOD_CALL -> ( [29:57]
| | | | | |--DOT -> . [29:50]
| | | | | | |--IDENT -> list3 [29:45]
| | | | | | `--IDENT -> equals [29:51]
| | | | | |--ELIST -> ELIST [29:58]
| | | | | | `--EXPR -> EXPR [29:58]
| | | | | | `--LITERAL_NEW -> new [29:58]
| | | | | | |--IDENT -> LinkedList [29:62]
| | | | | | |--LPAREN -> ( [29:72]
| | | | | | |--ELIST -> ELIST [29:73]
| | | | | | `--RPAREN -> ) [29:73]
| | | | | `--RPAREN -> ) [29:74]
| | | | |--LAMBDA -> -> [29:76]
| | | | |--EXPR -> EXPR [30:39]
| | | | | `--METHOD_CALL -> ( [30:39]
| | | | | |--DOT -> . [30:31]
| | | | | | |--DOT -> . [30:27]
| | | | | | | |--IDENT -> System [30:21]
| | | | | | | `--IDENT -> out [30:28]
| | | | | | `--IDENT -> println [30:32]
| | | | | |--ELIST -> ELIST [30:40]
| | | | | | `--EXPR -> EXPR [30:40]
| | | | | | `--STRING_LITERAL -> "list3" [30:40]
| | | | | `--RPAREN -> ) [30:47]
| | | | `--SEMI -> ; [30:48]
| | | |--SWITCH_RULE -> SWITCH_RULE [31:13]
| | | | |--LITERAL_CASE -> case [31:13]
| | | | | `--PATTERN_DEF -> PATTERN_DEF [31:26]
| | | | | `--LITERAL_WHEN -> when [31:26]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [31:18]
| | | | | | |--MODIFIERS -> MODIFIERS [31:18]
| | | | | | |--TYPE -> TYPE [31:18]
| | | | | | | `--IDENT -> Set [31:18]
| | | | | | `--IDENT -> set [31:22]
| | | | | `--EXPR -> EXPR [31:44]
| | | | | `--METHOD_CALL -> ( [31:44]
| | | | | |--DOT -> . [31:37]
| | | | | | |--STRING_LITERAL -> "test" [31:31]
| | | | | | `--IDENT -> equals [31:38]
| | | | | |--ELIST -> ELIST [31:57]
| | | | | | `--EXPR -> EXPR [31:57]
| | | | | | `--METHOD_CALL -> ( [31:57]
| | | | | | |--DOT -> . [31:48]
| | | | | | | |--IDENT -> set [31:45]
| | | | | | | `--IDENT -> toString [31:49]
| | | | | | |--ELIST -> ELIST [31:58]
| | | | | | `--RPAREN -> ) [31:58]
| | | | | `--RPAREN -> ) [31:59]
| | | | |--LAMBDA -> -> [31:61]
| | | | |--EXPR -> EXPR [32:39]
| | | | | `--METHOD_CALL -> ( [32:39]
| | | | | |--DOT -> . [32:31]
| | | | | | |--DOT -> . [32:27]
| | | | | | | |--IDENT -> System [32:21]
| | | | | | | `--IDENT -> out [32:28]
| | | | | | `--IDENT -> println [32:32]
| | | | | |--ELIST -> ELIST [32:40]
| | | | | | `--EXPR -> EXPR [32:40]
| | | | | | `--IDENT -> set [32:40]
| | | | | `--RPAREN -> ) [32:43]
| | | | `--SEMI -> ; [32:44]
| | | |--SWITCH_RULE -> SWITCH_RULE [33:13]
| | | | |--LITERAL_DEFAULT -> default [33:13]
| | | | |--LAMBDA -> -> [33:21]
| | | | `--LITERAL_THROW -> throw [33:24]
| | | | |--EXPR -> EXPR [33:30]
| | | | | `--LITERAL_NEW -> new [33:30]
| | | | | |--IDENT -> IllegalStateException [33:34]
| | | | | |--LPAREN -> ( [33:55]
| | | | | |--ELIST -> ELIST [34:42]
| | | | | | `--EXPR -> EXPR [34:42]
| | | | | | `--PLUS -> + [34:42]
| | | | | | |--STRING_LITERAL -> "Unexpected value: " [34:21]
| | | | | | `--IDENT -> o [34:44]
| | | | | `--RPAREN -> ) [34:45]
| | | | `--SEMI -> ; [34:46]
| | | `--RCURLY -> } [35:9]
| | `--RCURLY -> } [36:5]
| |--METHOD_DEF -> METHOD_DEF [38:5]
| | |--MODIFIERS -> MODIFIERS [38:5]
| | | `--LITERAL_STATIC -> static [38:5]
| | |--TYPE -> TYPE [38:12]
| | | `--IDENT -> String [38:12]
| | |--IDENT -> m3 [38:19]
| | |--LPAREN -> ( [38:21]
| | |--PARAMETERS -> PARAMETERS [38:22]
| | | `--PARAMETER_DEF -> PARAMETER_DEF [38:22]
| | | |--MODIFIERS -> MODIFIERS [38:22]
| | | |--TYPE -> TYPE [38:22]
| | | | `--IDENT -> Object [38:22]
| | | `--IDENT -> o [38:29]
| | |--RPAREN -> ) [38:30]
| | `--SLIST -> { [38:32]
| | |--LITERAL_RETURN -> return [40:9]
| | | |--EXPR -> EXPR [40:16]
| | | | `--LITERAL_SWITCH -> switch [40:16]
| | | | |--LPAREN -> ( [40:23]
| | | | |--EXPR -> EXPR [40:24]
| | | | | `--IDENT -> o [40:24]
| | | | |--RPAREN -> ) [40:25]
| | | | |--LCURLY -> { [40:27]
| | | | |--SWITCH_RULE -> SWITCH_RULE [41:13]
| | | | | |--LITERAL_CASE -> case [41:13]
| | | | | | `--PATTERN_DEF -> PATTERN_DEF [41:29]
| | | | | | `--LITERAL_WHEN -> when [41:29]
| | | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [41:18]
| | | | | | | |--MODIFIERS -> MODIFIERS [41:18]
| | | | | | | |--TYPE -> TYPE [41:18]
| | | | | | | | `--IDENT -> List [41:18]
| | | | | | | `--IDENT -> list1 [41:23]
| | | | | | `--EXPR -> EXPR [42:21]
| | | | | | `--LOR -> || [42:21]
| | | | | | |--GE -> >= [41:47]
| | | | | | | |--METHOD_CALL -> ( [41:44]
| | | | | | | | |--DOT -> . [41:39]
| | | | | | | | | |--IDENT -> list1 [41:34]
| | | | | | | | | `--IDENT -> size [41:40]
| | | | | | | | |--ELIST -> ELIST [41:45]
| | | | | | | | `--RPAREN -> ) [41:45]
| | | | | | | `--NUM_INT -> 0 [41:50]
| | | | | | `--LT -> < [42:37]
| | | | | | |--METHOD_CALL -> ( [42:34]
| | | | | | | |--DOT -> . [42:29]
| | | | | | | | |--IDENT -> list1 [42:24]
| | | | | | | | `--IDENT -> size [42:30]
| | | | | | | |--ELIST -> ELIST [42:35]
| | | | | | | `--RPAREN -> ) [42:35]
| | | | | | `--NUM_INT -> 20 [42:39]
| | | | | |--LAMBDA -> -> [42:42]
| | | | | `--SLIST -> { [42:45]
| | | | | |--LITERAL_YIELD -> yield [43:17]
| | | | | | |--EXPR -> EXPR [43:23]
| | | | | | | `--STRING_LITERAL -> "list1!" [43:23]
| | | | | | `--SEMI -> ; [43:31]
| | | | | `--RCURLY -> } [44:13]
| | | | |--SWITCH_RULE -> SWITCH_RULE [45:13]
| | | | | |--LITERAL_CASE -> case [45:13]
| | | | | | `--PATTERN_DEF -> PATTERN_DEF [45:29]
| | | | | | `--LITERAL_WHEN -> when [45:29]
| | | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [45:18]
| | | | | | | |--MODIFIERS -> MODIFIERS [45:18]
| | | | | | | |--TYPE -> TYPE [45:18]
| | | | | | | | `--IDENT -> List [45:18]
| | | | | | | `--IDENT -> list1 [45:23]
| | | | | | `--EXPR -> EXPR [46:21]
| | | | | | `--LOR -> || [46:21]
| | | | | | |--GE -> >= [45:47]
| | | | | | | |--METHOD_CALL -> ( [45:44]
| | | | | | | | |--DOT -> . [45:39]
| | | | | | | | | |--IDENT -> list1 [45:34]
| | | | | | | | | `--IDENT -> size [45:40]
| | | | | | | | |--ELIST -> ELIST [45:45]
| | | | | | | | `--RPAREN -> ) [45:45]
| | | | | | | `--NUM_INT -> 0 [45:50]
| | | | | | `--LT -> < [46:37]
| | | | | | |--METHOD_CALL -> ( [46:34]
| | | | | | | |--DOT -> . [46:29]
| | | | | | | | |--IDENT -> list1 [46:24]
| | | | | | | | `--IDENT -> size [46:30]
| | | | | | | |--ELIST -> ELIST [46:35]
| | | | | | | `--RPAREN -> ) [46:35]
| | | | | | `--NUM_INT -> 50 [46:39]
| | | | | |--LAMBDA -> -> [46:42]
| | | | | |--EXPR -> EXPR [46:45]
| | | | | | `--STRING_LITERAL -> "list1!" [46:45]
| | | | | `--SEMI -> ; [46:53]
| | | | |--SWITCH_RULE -> SWITCH_RULE [48:13]
| | | | | |--LITERAL_CASE -> case [48:13]
| | | | | | `--PATTERN_DEF -> PATTERN_DEF [48:29]
| | | | | | `--LITERAL_WHEN -> when [48:29]
| | | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [48:18]
| | | | | | | |--MODIFIERS -> MODIFIERS [48:18]
| | | | | | | |--TYPE -> TYPE [48:18]
| | | | | | | | `--IDENT -> Integer [48:18]
| | | | | | | `--IDENT -> i1 [48:26]
| | | | | | `--EXPR -> EXPR [48:41]
| | | | | | `--LAND -> && [48:41]
| | | | | | |--LT -> < [48:37]
| | | | | | | |--IDENT -> i1 [48:34]
| | | | | | | `--NUM_INT -> 3 [48:39]
| | | | | | `--GT -> > [48:47]
| | | | | | |--IDENT -> i1 [48:44]
| | | | | | `--NUM_INT -> 0 [48:49]
| | | | | |--LAMBDA -> -> [48:51]
| | | | | |--EXPR -> EXPR [48:54]
| | | | | | `--STRING_LITERAL -> "small integer!" [48:54]
| | | | | `--SEMI -> ; [48:70]
| | | | |--SWITCH_RULE -> SWITCH_RULE [49:13]
| | | | | |--LITERAL_CASE -> case [49:13]
| | | | | | `--PATTERN_DEF -> PATTERN_DEF [49:29]
| | | | | | `--LITERAL_WHEN -> when [49:29]
| | | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [49:18]
| | | | | | | |--MODIFIERS -> MODIFIERS [49:18]
| | | | | | | |--TYPE -> TYPE [49:18]
| | | | | | | | `--IDENT -> Integer [49:18]
| | | | | | | `--IDENT -> i2 [49:26]
| | | | | | `--EXPR -> EXPR [49:41]
| | | | | | `--LOR -> || [49:41]
| | | | | | |--LT -> < [49:37]
| | | | | | | |--IDENT -> i2 [49:34]
| | | | | | | `--NUM_INT -> 0 [49:39]
| | | | | | `--LT -> < [49:47]
| | | | | | |--IDENT -> i2 [49:44]
| | | | | | `--UNARY_MINUS -> - [49:49]
| | | | | | `--NUM_INT -> 5 [49:50]
| | | | | |--LAMBDA -> -> [49:52]
| | | | | |--EXPR -> EXPR [49:55]
| | | | | | `--STRING_LITERAL -> "small negative integer!" [49:55]
| | | | | `--SEMI -> ; [49:80]
| | | | |--SWITCH_RULE -> SWITCH_RULE [50:13]
| | | | | |--LITERAL_CASE -> case [50:13]
| | | | | | `--PATTERN_DEF -> PATTERN_DEF [50:23]
| | | | | | `--LITERAL_WHEN -> when [50:23]
| | | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:18]
| | | | | | | |--MODIFIERS -> MODIFIERS [50:18]
| | | | | | | |--TYPE -> TYPE [50:18]
| | | | | | | | `--IDENT -> AA [50:18]
| | | | | | | `--IDENT -> a [50:21]
| | | | | | `--EXPR -> EXPR [50:46]
| | | | | | `--LAND -> && [50:46]
| | | | | | |--LITERAL_INSTANCEOF -> instanceof [50:30]
| | | | | | | |--IDENT -> a [50:28]
| | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:41]
| | | | | | | |--MODIFIERS -> MODIFIERS [50:41]
| | | | | | | |--TYPE -> TYPE [50:41]
| | | | | | | | `--IDENT -> BB [50:41]
| | | | | | | `--IDENT -> b [50:44]
| | | | | | `--EQUAL -> == [50:53]
| | | | | | |--DOT -> . [50:50]
| | | | | | | |--IDENT -> b [50:49]
| | | | | | | `--IDENT -> f [50:51]
| | | | | | `--NUM_INT -> 2 [50:56]
| | | | | |--LAMBDA -> -> [50:58]
| | | | | |--EXPR -> EXPR [51:21]
| | | | | | `--STRING_LITERAL -> "it's a 'b'!" [51:21]
| | | | | `--SEMI -> ; [51:34]
| | | | |--SWITCH_RULE -> SWITCH_RULE [52:13]
| | | | | |--LITERAL_CASE -> case [52:13]
| | | | | | `--PATTERN_DEF -> PATTERN_DEF [52:23]
| | | | | | `--LITERAL_WHEN -> when [52:23]
| | | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:18]
| | | | | | | |--MODIFIERS -> MODIFIERS [52:18]
| | | | | | | |--TYPE -> TYPE [52:18]
| | | | | | | | `--IDENT -> AA [52:18]
| | | | | | | `--IDENT -> a [52:21]
| | | | | | `--EXPR -> EXPR [52:49]
| | | | | | `--LOR -> || [52:49]
| | | | | | |--LNOT -> ! [52:28]
| | | | | | | |--LPAREN -> ( [52:29]
| | | | | | | |--LITERAL_INSTANCEOF -> instanceof [52:32]
| | | | | | | | |--IDENT -> a [52:30]
| | | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:43]
| | | | | | | | |--MODIFIERS -> MODIFIERS [52:43]
| | | | | | | | |--TYPE -> TYPE [52:43]
| | | | | | | | | `--IDENT -> BB [52:43]
| | | | | | | | `--IDENT -> b [52:46]
| | | | | | | `--RPAREN -> ) [52:47]
| | | | | | `--LAND -> && [52:72]
| | | | | | |--LITERAL_INSTANCEOF -> instanceof [52:54]
| | | | | | | |--IDENT -> a [52:52]
| | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:65]
| | | | | | | |--MODIFIERS -> MODIFIERS [52:65]
| | | | | | | |--TYPE -> TYPE [52:65]
| | | | | | | | `--IDENT -> BB [52:65]
| | | | | | | `--IDENT -> b1 [52:69]
| | | | | | `--LT -> < [52:79]
| | | | | | |--DOT -> . [52:76]
| | | | | | | |--IDENT -> b [52:75]
| | | | | | | `--IDENT -> f [52:77]
| | | | | | `--NUM_INT -> 0 [52:81]
| | | | | |--LAMBDA -> -> [52:83]
| | | | | |--EXPR -> EXPR [53:21]
| | | | | | `--STRING_LITERAL -> "it's not a 'b' or it's a negative 'b'" [53:21]
| | | | | `--SEMI -> ; [53:60]
| | | | |--SWITCH_RULE -> SWITCH_RULE [54:13]
| | | | | |--LITERAL_CASE -> case [54:13]
| | | | | | `--PATTERN_DEF -> PATTERN_DEF [54:23]
| | | | | | `--LITERAL_WHEN -> when [54:23]
| | | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [54:18]
| | | | | | | |--MODIFIERS -> MODIFIERS [54:18]
| | | | | | | |--TYPE -> TYPE [54:18]
| | | | | | | | `--IDENT -> AA [54:18]
| | | | | | | `--IDENT -> a [54:21]
| | | | | | `--EXPR -> EXPR [54:49]
| | | | | | `--LOR -> || [54:49]
| | | | | | |--LNOT -> ! [54:28]
| | | | | | | |--LPAREN -> ( [54:29]
| | | | | | | |--LITERAL_INSTANCEOF -> instanceof [54:32]
| | | | | | | | |--IDENT -> a [54:30]
| | | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [54:43]
| | | | | | | | |--MODIFIERS -> MODIFIERS [54:43]
| | | | | | | | |--TYPE -> TYPE [54:43]
| | | | | | | | | `--IDENT -> BB [54:43]
| | | | | | | | `--IDENT -> b [54:46]
| | | | | | | `--RPAREN -> ) [54:47]
| | | | | | `--LAND -> && [54:71]
| | | | | | |--LITERAL_INSTANCEOF -> instanceof [54:54]
| | | | | | | |--IDENT -> a [54:52]
| | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [54:65]
| | | | | | | |--MODIFIERS -> MODIFIERS [54:65]
| | | | | | | |--TYPE -> TYPE [54:65]
| | | | | | | | `--IDENT -> BB [54:65]
| | | | | | | `--IDENT -> b2 [54:68]
| | | | | | `--LT -> < [54:78]
| | | | | | |--DOT -> . [54:75]
| | | | | | | |--IDENT -> b [54:74]
| | | | | | | `--IDENT -> f [54:76]
| | | | | | `--UNARY_MINUS -> - [54:80]
| | | | | | `--NUM_INT -> 5 [54:81]
| | | | | |--LAMBDA -> -> [54:83]
| | | | | |--EXPR -> EXPR [55:21]
| | | | | | `--STRING_LITERAL -> "it's not a 'b' or it's a negative 'b'..." [55:21]
| | | | | `--SEMI -> ; [55:63]
| | | | |--SWITCH_RULE -> SWITCH_RULE [56:13]
| | | | | |--LITERAL_CASE -> case [56:13]
| | | | | | `--EXPR -> EXPR [56:18]
| | | | | | `--LITERAL_NULL -> null [56:18]
| | | | | |--LAMBDA -> -> [56:23]
| | | | | |--EXPR -> EXPR [56:26]
| | | | | | `--STRING_LITERAL -> "it's null!" [56:26]
| | | | | `--SEMI -> ; [56:38]
| | | | |--SWITCH_RULE -> SWITCH_RULE [57:13]
| | | | | |--LITERAL_DEFAULT -> default [57:13]
| | | | | |--LAMBDA -> -> [57:21]
| | | | | `--LITERAL_THROW -> throw [57:24]
| | | | | |--EXPR -> EXPR [57:30]
| | | | | | `--LITERAL_NEW -> new [57:30]
| | | | | | |--IDENT -> IllegalStateException [57:34]
| | | | | | |--LPAREN -> ( [57:55]
| | | | | | |--ELIST -> ELIST [58:42]
| | | | | | | `--EXPR -> EXPR [58:42]
| | | | | | | `--PLUS -> + [58:42]
| | | | | | | |--STRING_LITERAL -> "Unexpected value: " [58:21]
| | | | | | | `--IDENT -> o [58:44]
| | | | | | `--RPAREN -> ) [58:45]
| | | | | `--SEMI -> ; [58:46]
| | | | `--RCURLY -> } [59:9]
| | | `--SEMI -> ; [59:10]
| | `--RCURLY -> } [60:5]
| `--RCURLY -> } [62:1]
|--CLASS_DEF -> CLASS_DEF [64:1]
| |--MODIFIERS -> MODIFIERS [64:1]
| | `--LITERAL_SEALED -> sealed [64:1]
| |--LITERAL_CLASS -> class [64:8]
| |--IDENT -> AA [64:14]
| |--PERMITS_CLAUSE -> permits [64:17]
| | `--IDENT -> BB [64:25]
| `--OBJBLOCK -> OBJBLOCK [64:28]
| |--LCURLY -> { [64:28]
| `--RCURLY -> } [66:1]
`--CLASS_DEF -> CLASS_DEF [68:1]
|--MODIFIERS -> MODIFIERS [68:1]
| `--LITERAL_NON_SEALED -> non-sealed [68:1]
|--LITERAL_CLASS -> class [68:12]
|--IDENT -> BB [68:18]
|--EXTENDS_CLAUSE -> extends [68:21]
| `--IDENT -> AA [68:29]
`--OBJBLOCK -> OBJBLOCK [68:32]
|--LCURLY -> { [68:32]
|--VARIABLE_DEF -> VARIABLE_DEF [69:5]
| |--MODIFIERS -> MODIFIERS [69:5]
| | `--LITERAL_PUBLIC -> public [69:5]
| |--TYPE -> TYPE [69:12]
| | `--LITERAL_INT -> int [69:12]
| |--IDENT -> f [69:16]
| |--ASSIGN -> = [69:18]
| | `--EXPR -> EXPR [69:20]
| | `--NUM_INT -> 2 [69:20]
| `--SEMI -> ; [69:21]
`--RCURLY -> } [70:1]