COMPILATION_UNIT -> COMPILATION_UNIT [2:1]
|--PACKAGE_DEF -> package [2:1]
| |--ANNOTATIONS -> ANNOTATIONS [2:48]
| |--DOT -> . [2:48]
| | |--DOT -> . [2:40]
| | | |--DOT -> . [2:29]
| | | | |--DOT -> . [2:23]
| | | | | |--DOT -> . [2:12]
| | | | | | |--IDENT -> com [2:9]
| | | | | | `--IDENT -> puppycrawl [2:13]
| | | | | `--IDENT -> tools [2:24]
| | | | `--IDENT -> checkstyle [2:30]
| | | `--IDENT -> grammar [2:41]
| | `--IDENT -> java21 [2:49]
| `--SEMI -> ; [2:55]
`--CLASS_DEF -> CLASS_DEF [4:1]
|--MODIFIERS -> MODIFIERS [4:1]
| `--LITERAL_PUBLIC -> public [4:1]
|--LITERAL_CLASS -> class [4:8]
|--IDENT -> InputUnnamedVariableSwitch [4:14]
`--OBJBLOCK -> OBJBLOCK [4:41]
|--LCURLY -> { [4:41]
|--METHOD_DEF -> METHOD_DEF [5:9]
| |--MODIFIERS -> MODIFIERS [5:9]
| |--TYPE -> TYPE [5:9]
| | `--LITERAL_INT -> int [5:9]
| |--IDENT -> testMultiValuesTopLevel [5:13]
| |--LPAREN -> ( [5:36]
| |--PARAMETERS -> PARAMETERS [5:37]
| | `--PARAMETER_DEF -> PARAMETER_DEF [5:37]
| | |--MODIFIERS -> MODIFIERS [5:37]
| | |--TYPE -> TYPE [5:37]
| | | `--IDENT -> Object [5:37]
| | `--IDENT -> o [5:44]
| |--RPAREN -> ) [5:45]
| `--SLIST -> { [5:47]
| |--LITERAL_RETURN -> return [6:9]
| | |--EXPR -> EXPR [6:16]
| | | `--LITERAL_SWITCH -> switch [6:16]
| | | |--LPAREN -> ( [6:23]
| | | |--EXPR -> EXPR [6:24]
| | | | `--IDENT -> o [6:24]
| | | |--RPAREN -> ) [6:25]
| | | |--LCURLY -> { [6:27]
| | | |--SWITCH_RULE -> SWITCH_RULE [7:13]
| | | | |--LITERAL_CASE -> case [7:13]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [7:18]
| | | | | | |--MODIFIERS -> MODIFIERS [7:18]
| | | | | | |--TYPE -> TYPE [7:18]
| | | | | | | `--IDENT -> R1 [7:18]
| | | | | | `--IDENT -> _ [7:21]
| | | | | |--COMMA -> , [7:22]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [7:24]
| | | | | |--MODIFIERS -> MODIFIERS [7:24]
| | | | | |--TYPE -> TYPE [7:24]
| | | | | | `--IDENT -> R2 [7:24]
| | | | | `--IDENT -> _ [7:27]
| | | | |--LAMBDA -> -> [7:29]
| | | | |--EXPR -> EXPR [7:32]
| | | | | `--NUM_INT -> 1 [7:32]
| | | | `--SEMI -> ; [7:33]
| | | |--SWITCH_RULE -> SWITCH_RULE [8:13]
| | | | |--LITERAL_DEFAULT -> default [8:13]
| | | | |--LAMBDA -> -> [8:21]
| | | | |--EXPR -> EXPR [8:24]
| | | | | `--NUM_INT -> 2 [8:24]
| | | | `--SEMI -> ; [8:25]
| | | `--RCURLY -> } [9:9]
| | `--SEMI -> ; [9:10]
| `--RCURLY -> } [10:5]
|--METHOD_DEF -> METHOD_DEF [12:5]
| |--MODIFIERS -> MODIFIERS [12:5]
| |--TYPE -> TYPE [12:5]
| | `--LITERAL_INT -> int [12:5]
| |--IDENT -> testMultiValuesTopLevel2 [12:9]
| |--LPAREN -> ( [12:33]
| |--PARAMETERS -> PARAMETERS [12:34]
| | `--PARAMETER_DEF -> PARAMETER_DEF [12:34]
| | |--MODIFIERS -> MODIFIERS [12:34]
| | |--TYPE -> TYPE [12:34]
| | | `--IDENT -> Base [12:34]
| | `--IDENT -> o [12:39]
| |--RPAREN -> ) [12:40]
| `--SLIST -> { [12:42]
| |--LITERAL_RETURN -> return [13:9]
| | |--EXPR -> EXPR [13:16]
| | | `--LITERAL_SWITCH -> switch [13:16]
| | | |--LPAREN -> ( [13:23]
| | | |--EXPR -> EXPR [13:24]
| | | | `--IDENT -> o [13:24]
| | | |--RPAREN -> ) [13:25]
| | | |--LCURLY -> { [13:27]
| | | |--SWITCH_RULE -> SWITCH_RULE [14:13]
| | | | |--LITERAL_CASE -> case [14:13]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:18]
| | | | | |--MODIFIERS -> MODIFIERS [14:18]
| | | | | |--TYPE -> TYPE [14:18]
| | | | | | `--IDENT -> R1 [14:18]
| | | | | `--IDENT -> r [14:21]
| | | | |--LAMBDA -> -> [14:23]
| | | | |--EXPR -> EXPR [14:26]
| | | | | `--NUM_INT -> 1 [14:26]
| | | | `--SEMI -> ; [14:27]
| | | |--SWITCH_RULE -> SWITCH_RULE [15:13]
| | | | |--LITERAL_CASE -> case [15:13]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [15:18]
| | | | | | |--MODIFIERS -> MODIFIERS [15:18]
| | | | | | |--TYPE -> TYPE [15:18]
| | | | | | | `--IDENT -> R2 [15:18]
| | | | | | `--IDENT -> _ [15:21]
| | | | | |--COMMA -> , [15:22]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [15:24]
| | | | | | |--MODIFIERS -> MODIFIERS [15:24]
| | | | | | |--TYPE -> TYPE [15:24]
| | | | | | | `--IDENT -> R3 [15:24]
| | | | | | `--IDENT -> _ [15:27]
| | | | | |--COMMA -> , [15:28]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [15:30]
| | | | | |--MODIFIERS -> MODIFIERS [15:30]
| | | | | |--TYPE -> TYPE [15:30]
| | | | | | `--IDENT -> R4 [15:30]
| | | | | `--IDENT -> _ [15:33]
| | | | |--LAMBDA -> -> [15:35]
| | | | |--EXPR -> EXPR [15:38]
| | | | | `--NUM_INT -> 2 [15:38]
| | | | `--SEMI -> ; [15:39]
| | | `--RCURLY -> } [16:9]
| | `--SEMI -> ; [16:10]
| `--RCURLY -> } [17:5]
|--METHOD_DEF -> METHOD_DEF [19:5]
| |--MODIFIERS -> MODIFIERS [19:5]
| |--TYPE -> TYPE [19:5]
| | `--LITERAL_INT -> int [19:5]
| |--IDENT -> testMultiValuesNested [19:9]
| |--LPAREN -> ( [19:30]
| |--PARAMETERS -> PARAMETERS [19:31]
| | `--PARAMETER_DEF -> PARAMETER_DEF [19:31]
| | |--MODIFIERS -> MODIFIERS [19:31]
| | |--TYPE -> TYPE [19:31]
| | | |--IDENT -> Box [19:31]
| | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [19:34]
| | | |--GENERIC_START -> < [19:34]
| | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [19:35]
| | | | `--WILDCARD_TYPE -> ? [19:35]
| | | `--GENERIC_END -> > [19:36]
| | `--IDENT -> b [19:38]
| |--RPAREN -> ) [19:39]
| `--SLIST -> { [19:41]
| |--LITERAL_RETURN -> return [20:9]
| | |--EXPR -> EXPR [20:16]
| | | `--LITERAL_SWITCH -> switch [20:16]
| | | |--LPAREN -> ( [20:23]
| | | |--EXPR -> EXPR [20:24]
| | | | `--IDENT -> b [20:24]
| | | |--RPAREN -> ) [20:25]
| | | |--LCURLY -> { [20:27]
| | | |--SWITCH_RULE -> SWITCH_RULE [21:13]
| | | | |--LITERAL_CASE -> case [21:13]
| | | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:18]
| | | | | | |--MODIFIERS -> MODIFIERS [21:18]
| | | | | | |--TYPE -> TYPE [21:18]
| | | | | | | `--IDENT -> Box [21:18]
| | | | | | |--LPAREN -> ( [21:21]
| | | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:22]
| | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [21:22]
| | | | | | | |--MODIFIERS -> MODIFIERS [21:22]
| | | | | | | |--TYPE -> TYPE [21:22]
| | | | | | | | `--IDENT -> R1 [21:22]
| | | | | | | `--IDENT -> _ [21:25]
| | | | | | `--RPAREN -> ) [21:26]
| | | | | |--COMMA -> , [21:27]
| | | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:29]
| | | | | |--MODIFIERS -> MODIFIERS [21:29]
| | | | | |--TYPE -> TYPE [21:29]
| | | | | | `--IDENT -> Box [21:29]
| | | | | |--LPAREN -> ( [21:32]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:33]
| | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [21:33]
| | | | | | |--MODIFIERS -> MODIFIERS [21:33]
| | | | | | |--TYPE -> TYPE [21:33]
| | | | | | | `--IDENT -> R2 [21:33]
| | | | | | `--IDENT -> _ [21:36]
| | | | | `--RPAREN -> ) [21:37]
| | | | |--LAMBDA -> -> [21:39]
| | | | |--EXPR -> EXPR [21:42]
| | | | | `--NUM_INT -> 1 [21:42]
| | | | `--SEMI -> ; [21:43]
| | | |--SWITCH_RULE -> SWITCH_RULE [22:13]
| | | | |--LITERAL_CASE -> case [22:13]
| | | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [22:18]
| | | | | |--MODIFIERS -> MODIFIERS [22:18]
| | | | | |--TYPE -> TYPE [22:18]
| | | | | | `--IDENT -> Box [22:18]
| | | | | |--LPAREN -> ( [22:21]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [22:22]
| | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [22:22]
| | | | | | |--MODIFIERS -> MODIFIERS [22:22]
| | | | | | |--TYPE -> TYPE [22:22]
| | | | | | | `--IDENT -> R3 [22:22]
| | | | | | `--IDENT -> _ [22:25]
| | | | | `--RPAREN -> ) [22:26]
| | | | |--LAMBDA -> -> [22:28]
| | | | |--EXPR -> EXPR [22:31]
| | | | | `--NUM_INT -> 2 [22:31]
| | | | `--SEMI -> ; [22:32]
| | | |--SWITCH_RULE -> SWITCH_RULE [23:13]
| | | | |--LITERAL_CASE -> case [23:13]
| | | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [23:18]
| | | | | |--MODIFIERS -> MODIFIERS [23:18]
| | | | | |--TYPE -> TYPE [23:18]
| | | | | | `--IDENT -> Box [23:18]
| | | | | |--LPAREN -> ( [23:21]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [23:22]
| | | | | | `--UNNAMED_PATTERN_DEF -> _ [23:22]
| | | | | `--RPAREN -> ) [23:23]
| | | | |--LAMBDA -> -> [23:26]
| | | | |--EXPR -> EXPR [23:29]
| | | | | `--NUM_INT -> 3 [23:29]
| | | | `--SEMI -> ; [23:30]
| | | `--RCURLY -> } [24:9]
| | `--SEMI -> ; [24:10]
| `--RCURLY -> } [25:5]
|--METHOD_DEF -> METHOD_DEF [27:5]
| |--MODIFIERS -> MODIFIERS [27:5]
| |--TYPE -> TYPE [27:5]
| | `--LITERAL_INT -> int [27:5]
| |--IDENT -> testMultiValuesNestedUnnamedVarAndPattern [27:9]
| |--LPAREN -> ( [27:50]
| |--PARAMETERS -> PARAMETERS [27:51]
| | `--PARAMETER_DEF -> PARAMETER_DEF [27:51]
| | |--MODIFIERS -> MODIFIERS [27:51]
| | |--TYPE -> TYPE [27:51]
| | | |--IDENT -> Box [27:51]
| | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [27:54]
| | | |--GENERIC_START -> < [27:54]
| | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [27:55]
| | | | `--WILDCARD_TYPE -> ? [27:55]
| | | `--GENERIC_END -> > [27:56]
| | `--IDENT -> b [27:58]
| |--RPAREN -> ) [27:59]
| `--SLIST -> { [27:61]
| |--LITERAL_RETURN -> return [28:9]
| | |--EXPR -> EXPR [28:16]
| | | `--LITERAL_SWITCH -> switch [28:16]
| | | |--LPAREN -> ( [28:23]
| | | |--EXPR -> EXPR [28:24]
| | | | `--IDENT -> b [28:24]
| | | |--RPAREN -> ) [28:25]
| | | |--LCURLY -> { [28:27]
| | | |--SWITCH_RULE -> SWITCH_RULE [29:13]
| | | | |--LITERAL_CASE -> case [29:13]
| | | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [29:18]
| | | | | | |--MODIFIERS -> MODIFIERS [29:18]
| | | | | | |--TYPE -> TYPE [29:18]
| | | | | | | `--IDENT -> Box [29:18]
| | | | | | |--LPAREN -> ( [29:21]
| | | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [29:22]
| | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [29:22]
| | | | | | | |--MODIFIERS -> MODIFIERS [29:22]
| | | | | | | |--TYPE -> TYPE [29:22]
| | | | | | | | `--IDENT -> R1 [29:22]
| | | | | | | `--IDENT -> _ [29:25]
| | | | | | `--RPAREN -> ) [29:26]
| | | | | |--COMMA -> , [29:27]
| | | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [29:29]
| | | | | |--MODIFIERS -> MODIFIERS [29:29]
| | | | | |--TYPE -> TYPE [29:29]
| | | | | | `--IDENT -> Box [29:29]
| | | | | |--LPAREN -> ( [29:32]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [29:33]
| | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [29:33]
| | | | | | |--MODIFIERS -> MODIFIERS [29:33]
| | | | | | |--TYPE -> TYPE [29:33]
| | | | | | | `--IDENT -> R2 [29:33]
| | | | | | `--IDENT -> _ [29:36]
| | | | | `--RPAREN -> ) [29:37]
| | | | |--LAMBDA -> -> [29:39]
| | | | |--EXPR -> EXPR [29:42]
| | | | | `--NUM_INT -> 1 [29:42]
| | | | `--SEMI -> ; [29:43]
| | | |--SWITCH_RULE -> SWITCH_RULE [30:13]
| | | | |--LITERAL_CASE -> case [30:13]
| | | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:18]
| | | | | | |--MODIFIERS -> MODIFIERS [30:18]
| | | | | | |--TYPE -> TYPE [30:18]
| | | | | | | `--IDENT -> Box [30:18]
| | | | | | |--LPAREN -> ( [30:21]
| | | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:22]
| | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [30:22]
| | | | | | | |--MODIFIERS -> MODIFIERS [30:22]
| | | | | | | |--TYPE -> TYPE [30:22]
| | | | | | | | `--IDENT -> R3 [30:22]
| | | | | | | `--IDENT -> _ [30:25]
| | | | | | `--RPAREN -> ) [30:26]
| | | | | |--COMMA -> , [30:27]
| | | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:29]
| | | | | |--MODIFIERS -> MODIFIERS [30:29]
| | | | | |--TYPE -> TYPE [30:29]
| | | | | | `--IDENT -> Box [30:29]
| | | | | |--LPAREN -> ( [30:32]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:33]
| | | | | | `--UNNAMED_PATTERN_DEF -> _ [30:33]
| | | | | `--RPAREN -> ) [30:34]
| | | | |--LAMBDA -> -> [30:36]
| | | | |--EXPR -> EXPR [30:39]
| | | | | `--NUM_INT -> 2 [30:39]
| | | | `--SEMI -> ; [30:40]
| | | `--RCURLY -> } [31:9]
| | `--SEMI -> ; [31:10]
| `--RCURLY -> } [32:5]
|--METHOD_DEF -> METHOD_DEF [34:5]
| |--MODIFIERS -> MODIFIERS [34:5]
| |--TYPE -> TYPE [34:5]
| | `--LITERAL_INT -> int [34:5]
| |--IDENT -> testMultiValuesNestedMix [34:9]
| |--LPAREN -> ( [34:33]
| |--PARAMETERS -> PARAMETERS [34:34]
| | `--PARAMETER_DEF -> PARAMETER_DEF [34:34]
| | |--MODIFIERS -> MODIFIERS [34:34]
| | |--TYPE -> TYPE [34:34]
| | | `--IDENT -> Object [34:34]
| | `--IDENT -> b [34:41]
| |--RPAREN -> ) [34:42]
| `--SLIST -> { [34:44]
| |--LITERAL_RETURN -> return [35:9]
| | |--EXPR -> EXPR [35:16]
| | | `--LITERAL_SWITCH -> switch [35:16]
| | | |--LPAREN -> ( [35:23]
| | | |--EXPR -> EXPR [35:24]
| | | | `--IDENT -> b [35:24]
| | | |--RPAREN -> ) [35:25]
| | | |--LCURLY -> { [35:27]
| | | |--SWITCH_RULE -> SWITCH_RULE [36:13]
| | | | |--LITERAL_CASE -> case [36:13]
| | | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [36:18]
| | | | | | |--MODIFIERS -> MODIFIERS [36:18]
| | | | | | |--TYPE -> TYPE [36:18]
| | | | | | | `--IDENT -> Box [36:18]
| | | | | | |--LPAREN -> ( [36:21]
| | | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [36:22]
| | | | | | | `--UNNAMED_PATTERN_DEF -> _ [36:22]
| | | | | | `--RPAREN -> ) [36:23]
| | | | | |--COMMA -> , [36:24]
| | | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [36:26]
| | | | | |--MODIFIERS -> MODIFIERS [36:26]
| | | | | |--TYPE -> TYPE [36:26]
| | | | | | `--IDENT -> Box2 [36:26]
| | | | | |--LPAREN -> ( [36:30]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [36:31]
| | | | | | `--UNNAMED_PATTERN_DEF -> _ [36:31]
| | | | | `--RPAREN -> ) [36:32]
| | | | |--LAMBDA -> -> [36:34]
| | | | |--EXPR -> EXPR [36:37]
| | | | | `--NUM_INT -> 1 [36:37]
| | | | `--SEMI -> ; [36:38]
| | | |--SWITCH_RULE -> SWITCH_RULE [37:13]
| | | | |--LITERAL_DEFAULT -> default [37:13]
| | | | |--LAMBDA -> -> [37:21]
| | | | |--EXPR -> EXPR [37:24]
| | | | | `--NUM_INT -> 2 [37:24]
| | | | `--SEMI -> ; [37:25]
| | | `--RCURLY -> } [38:9]
| | `--SEMI -> ; [38:10]
| `--RCURLY -> } [39:5]
|--METHOD_DEF -> METHOD_DEF [41:5]
| |--MODIFIERS -> MODIFIERS [41:5]
| |--TYPE -> TYPE [41:5]
| | `--LITERAL_INT -> int [41:5]
| |--IDENT -> testMultiValuesNestedMix2 [41:9]
| |--LPAREN -> ( [41:34]
| |--PARAMETERS -> PARAMETERS [41:35]
| | `--PARAMETER_DEF -> PARAMETER_DEF [41:35]
| | |--MODIFIERS -> MODIFIERS [41:35]
| | |--TYPE -> TYPE [41:35]
| | | `--IDENT -> Object [41:35]
| | `--IDENT -> b [41:42]
| |--RPAREN -> ) [41:43]
| `--SLIST -> { [41:45]
| |--LITERAL_RETURN -> return [42:9]
| | |--EXPR -> EXPR [42:16]
| | | `--LITERAL_SWITCH -> switch [42:16]
| | | |--LPAREN -> ( [42:23]
| | | |--EXPR -> EXPR [42:24]
| | | | `--IDENT -> b [42:24]
| | | |--RPAREN -> ) [42:25]
| | | |--LCURLY -> { [42:27]
| | | |--SWITCH_RULE -> SWITCH_RULE [43:13]
| | | | |--LITERAL_CASE -> case [43:13]
| | | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [43:18]
| | | | | | |--MODIFIERS -> MODIFIERS [43:18]
| | | | | | |--TYPE -> TYPE [43:18]
| | | | | | | `--IDENT -> Box [43:18]
| | | | | | |--LPAREN -> ( [43:21]
| | | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [43:22]
| | | | | | | `--UNNAMED_PATTERN_DEF -> _ [43:22]
| | | | | | `--RPAREN -> ) [43:23]
| | | | | |--COMMA -> , [43:24]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [43:26]
| | | | | |--MODIFIERS -> MODIFIERS [43:26]
| | | | | |--TYPE -> TYPE [43:26]
| | | | | | `--IDENT -> String [43:26]
| | | | | `--IDENT -> _ [43:33]
| | | | |--LAMBDA -> -> [43:35]
| | | | |--EXPR -> EXPR [43:38]
| | | | | `--NUM_INT -> 1 [43:38]
| | | | `--SEMI -> ; [43:39]
| | | |--SWITCH_RULE -> SWITCH_RULE [44:13]
| | | | |--LITERAL_DEFAULT -> default [44:13]
| | | | |--LAMBDA -> -> [44:21]
| | | | |--EXPR -> EXPR [44:24]
| | | | | `--NUM_INT -> 2 [44:24]
| | | | `--SEMI -> ; [44:25]
| | | `--RCURLY -> } [45:9]
| | `--SEMI -> ; [45:10]
| `--RCURLY -> } [46:5]
|--METHOD_DEF -> METHOD_DEF [48:5]
| |--MODIFIERS -> MODIFIERS [48:5]
| |--TYPE -> TYPE [48:5]
| | `--LITERAL_INT -> int [48:5]
| |--IDENT -> testMultiValuesStatementBlock2 [48:9]
| |--LPAREN -> ( [48:39]
| |--PARAMETERS -> PARAMETERS [48:40]
| | `--PARAMETER_DEF -> PARAMETER_DEF [48:40]
| | |--MODIFIERS -> MODIFIERS [48:40]
| | |--TYPE -> TYPE [48:40]
| | | `--IDENT -> Object [48:40]
| | `--IDENT -> o [48:47]
| |--RPAREN -> ) [48:48]
| `--SLIST -> { [48:50]
| |--LITERAL_SWITCH -> switch [49:9]
| | |--LPAREN -> ( [49:16]
| | |--EXPR -> EXPR [49:17]
| | | `--IDENT -> o [49:17]
| | |--RPAREN -> ) [49:18]
| | |--LCURLY -> { [49:20]
| | |--CASE_GROUP -> CASE_GROUP [50:13]
| | | |--LITERAL_CASE -> case [50:13]
| | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [50:18]
| | | | | |--MODIFIERS -> MODIFIERS [50:18]
| | | | | |--TYPE -> TYPE [50:18]
| | | | | | `--IDENT -> Box [50:18]
| | | | | |--LPAREN -> ( [50:21]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [50:22]
| | | | | | `--UNNAMED_PATTERN_DEF -> _ [50:22]
| | | | | `--RPAREN -> ) [50:23]
| | | | `--COLON -> : [50:24]
| | | |--LITERAL_CASE -> case [51:13]
| | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [51:18]
| | | | | |--MODIFIERS -> MODIFIERS [51:18]
| | | | | |--TYPE -> TYPE [51:18]
| | | | | | `--IDENT -> String [51:18]
| | | | | `--IDENT -> _ [51:25]
| | | | `--COLON -> : [51:26]
| | | `--SLIST -> SLIST [52:17]
| | | `--LITERAL_RETURN -> return [52:17]
| | | |--EXPR -> EXPR [52:24]
| | | | `--NUM_INT -> 1 [52:24]
| | | `--SEMI -> ; [52:25]
| | |--CASE_GROUP -> CASE_GROUP [53:13]
| | | |--LITERAL_DEFAULT -> default [53:13]
| | | | `--COLON -> : [53:20]
| | | `--SLIST -> SLIST [54:17]
| | | `--LITERAL_RETURN -> return [54:17]
| | | |--EXPR -> EXPR [54:24]
| | | | `--NUM_INT -> 2 [54:24]
| | | `--SEMI -> ; [54:25]
| | `--RCURLY -> } [55:9]
| `--RCURLY -> } [56:5]
|--METHOD_DEF -> METHOD_DEF [58:5]
| |--MODIFIERS -> MODIFIERS [58:5]
| |--TYPE -> TYPE [58:5]
| | `--LITERAL_INT -> int [58:5]
| |--IDENT -> testMultiValuesGuards [58:9]
| |--LPAREN -> ( [58:30]
| |--PARAMETERS -> PARAMETERS [58:31]
| | |--PARAMETER_DEF -> PARAMETER_DEF [58:31]
| | | |--MODIFIERS -> MODIFIERS [58:31]
| | | |--TYPE -> TYPE [58:31]
| | | | `--IDENT -> Base [58:31]
| | | `--IDENT -> b [58:36]
| | |--COMMA -> , [58:37]
| | `--PARAMETER_DEF -> PARAMETER_DEF [58:39]
| | |--MODIFIERS -> MODIFIERS [58:39]
| | |--TYPE -> TYPE [58:39]
| | | `--LITERAL_INT -> int [58:39]
| | `--IDENT -> x [58:43]
| |--RPAREN -> ) [58:44]
| `--SLIST -> { [58:46]
| |--LITERAL_RETURN -> return [59:9]
| | |--EXPR -> EXPR [59:16]
| | | `--LITERAL_SWITCH -> switch [59:16]
| | | |--LPAREN -> ( [59:23]
| | | |--EXPR -> EXPR [59:24]
| | | | `--IDENT -> b [59:24]
| | | |--RPAREN -> ) [59:25]
| | | |--LCURLY -> { [59:27]
| | | |--SWITCH_RULE -> SWITCH_RULE [60:13]
| | | | |--LITERAL_CASE -> case [60:13]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [60:18]
| | | | | |--MODIFIERS -> MODIFIERS [60:18]
| | | | | |--TYPE -> TYPE [60:18]
| | | | | | `--IDENT -> R1 [60:18]
| | | | | `--IDENT -> r [60:21]
| | | | |--LAMBDA -> -> [60:23]
| | | | |--EXPR -> EXPR [60:26]
| | | | | `--NUM_INT -> 1 [60:26]
| | | | `--SEMI -> ; [60:27]
| | | |--SWITCH_RULE -> SWITCH_RULE [61:13]
| | | | |--LITERAL_CASE -> case [61:13]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [61:18]
| | | | | | |--MODIFIERS -> MODIFIERS [61:18]
| | | | | | |--TYPE -> TYPE [61:18]
| | | | | | | `--IDENT -> R2 [61:18]
| | | | | | `--IDENT -> _ [61:21]
| | | | | |--COMMA -> , [61:22]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [61:24]
| | | | | | |--MODIFIERS -> MODIFIERS [61:24]
| | | | | | |--TYPE -> TYPE [61:24]
| | | | | | | `--IDENT -> R3 [61:24]
| | | | | | `--IDENT -> _ [61:27]
| | | | | |--COMMA -> , [61:28]
| | | | | `--PATTERN_DEF -> PATTERN_DEF [61:35]
| | | | | `--LITERAL_WHEN -> when [61:35]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [61:30]
| | | | | | |--MODIFIERS -> MODIFIERS [61:30]
| | | | | | |--TYPE -> TYPE [61:30]
| | | | | | | `--IDENT -> R4 [61:30]
| | | | | | `--IDENT -> _ [61:33]
| | | | | `--EXPR -> EXPR [61:42]
| | | | | `--EQUAL -> == [61:42]
| | | | | |--IDENT -> x [61:40]
| | | | | `--NUM_INT -> 1 [61:45]
| | | | |--LAMBDA -> -> [61:47]
| | | | |--EXPR -> EXPR [61:50]
| | | | | `--NUM_INT -> 2 [61:50]
| | | | `--SEMI -> ; [61:51]
| | | |--SWITCH_RULE -> SWITCH_RULE [62:13]
| | | | |--LITERAL_CASE -> case [62:13]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:18]
| | | | | | |--MODIFIERS -> MODIFIERS [62:18]
| | | | | | |--TYPE -> TYPE [62:18]
| | | | | | | `--IDENT -> R2 [62:18]
| | | | | | `--IDENT -> _ [62:21]
| | | | | |--COMMA -> , [62:22]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:24]
| | | | | | |--MODIFIERS -> MODIFIERS [62:24]
| | | | | | |--TYPE -> TYPE [62:24]
| | | | | | | `--IDENT -> R3 [62:24]
| | | | | | `--IDENT -> _ [62:27]
| | | | | |--COMMA -> , [62:28]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:30]
| | | | | |--MODIFIERS -> MODIFIERS [62:30]
| | | | | |--TYPE -> TYPE [62:30]
| | | | | | `--IDENT -> R4 [62:30]
| | | | | `--IDENT -> _ [62:33]
| | | | |--LAMBDA -> -> [62:35]
| | | | |--EXPR -> EXPR [62:38]
| | | | | `--NUM_INT -> 3 [62:38]
| | | | `--SEMI -> ; [62:39]
| | | `--RCURLY -> } [63:9]
| | `--SEMI -> ; [63:10]
| `--RCURLY -> } [64:5]
|--METHOD_DEF -> METHOD_DEF [66:5]
| |--MODIFIERS -> MODIFIERS [66:5]
| |--TYPE -> TYPE [66:5]
| | `--LITERAL_INT -> int [66:5]
| |--IDENT -> testMixVarWithExplicit [66:9]
| |--LPAREN -> ( [66:31]
| |--PARAMETERS -> PARAMETERS [66:32]
| | `--PARAMETER_DEF -> PARAMETER_DEF [66:32]
| | |--MODIFIERS -> MODIFIERS [66:32]
| | |--TYPE -> TYPE [66:32]
| | | |--IDENT -> Box [66:32]
| | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [66:35]
| | | |--GENERIC_START -> < [66:35]
| | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [66:36]
| | | | `--WILDCARD_TYPE -> ? [66:36]
| | | `--GENERIC_END -> > [66:37]
| | `--IDENT -> t [66:39]
| |--RPAREN -> ) [66:40]
| `--SLIST -> { [66:42]
| |--VARIABLE_DEF -> VARIABLE_DEF [67:9]
| | |--MODIFIERS -> MODIFIERS [67:9]
| | |--TYPE -> TYPE [67:9]
| | | `--LITERAL_INT -> int [67:9]
| | |--IDENT -> success [67:13]
| | `--ASSIGN -> = [67:21]
| | `--EXPR -> EXPR [67:23]
| | `--UNARY_MINUS -> - [67:23]
| | `--NUM_INT -> 1 [67:24]
| |--SEMI -> ; [67:25]
| |--EXPR -> EXPR [68:17]
| | `--ASSIGN -> = [68:17]
| | |--IDENT -> success [68:9]
| | `--LITERAL_SWITCH -> switch [68:19]
| | |--LPAREN -> ( [68:25]
| | |--EXPR -> EXPR [68:26]
| | | `--IDENT -> t [68:26]
| | |--RPAREN -> ) [68:27]
| | |--LCURLY -> { [68:29]
| | |--CASE_GROUP -> CASE_GROUP [69:13]
| | | |--LITERAL_CASE -> case [69:13]
| | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [69:18]
| | | | | |--MODIFIERS -> MODIFIERS [69:18]
| | | | | |--TYPE -> TYPE [69:18]
| | | | | | `--IDENT -> Box [69:18]
| | | | | |--LPAREN -> ( [69:21]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [69:22]
| | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [69:22]
| | | | | | |--MODIFIERS -> MODIFIERS [69:22]
| | | | | | |--TYPE -> TYPE [69:22]
| | | | | | | `--IDENT -> R1 [69:22]
| | | | | | `--IDENT -> _ [69:25]
| | | | | `--RPAREN -> ) [69:26]
| | | | `--COLON -> : [69:28]
| | | `--SLIST -> SLIST [69:30]
| | | `--SLIST -> { [69:30]
| | | |--LITERAL_YIELD -> yield [70:17]
| | | | |--EXPR -> EXPR [70:23]
| | | | | `--NUM_INT -> 1 [70:23]
| | | | `--SEMI -> ; [70:24]
| | | `--RCURLY -> } [71:13]
| | |--CASE_GROUP -> CASE_GROUP [72:13]
| | | |--LITERAL_CASE -> case [72:13]
| | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [72:18]
| | | | | |--MODIFIERS -> MODIFIERS [72:18]
| | | | | |--TYPE -> TYPE [72:18]
| | | | | | `--IDENT -> Box [72:18]
| | | | | |--LPAREN -> ( [72:21]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [72:22]
| | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [72:22]
| | | | | | |--MODIFIERS -> MODIFIERS [72:22]
| | | | | | |--TYPE -> TYPE [72:22]
| | | | | | | `--IDENT -> R2 [72:22]
| | | | | | `--IDENT -> _ [72:25]
| | | | | `--RPAREN -> ) [72:26]
| | | | |--COMMA -> , [72:27]
| | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [72:29]
| | | | | |--MODIFIERS -> MODIFIERS [72:29]
| | | | | |--TYPE -> TYPE [72:29]
| | | | | | `--IDENT -> Box [72:29]
| | | | | |--LPAREN -> ( [72:32]
| | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [72:33]
| | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [72:33]
| | | | | | |--MODIFIERS -> MODIFIERS [72:33]
| | | | | | |--TYPE -> TYPE [72:33]
| | | | | | | `--IDENT -> var [72:33]
| | | | | | `--IDENT -> _ [72:37]
| | | | | `--RPAREN -> ) [72:38]
| | | | `--COLON -> : [72:40]
| | | `--SLIST -> SLIST [72:42]
| | | `--SLIST -> { [72:42]
| | | |--LITERAL_YIELD -> yield [73:17]
| | | | |--EXPR -> EXPR [73:23]
| | | | | `--NUM_INT -> 2 [73:23]
| | | | `--SEMI -> ; [73:24]
| | | `--RCURLY -> } [74:13]
| | |--CASE_GROUP -> CASE_GROUP [75:13]
| | | |--LITERAL_DEFAULT -> default [75:13]
| | | | `--COLON -> : [75:21]
| | | `--SLIST -> SLIST [75:23]
| | | `--SLIST -> { [75:23]
| | | |--LITERAL_YIELD -> yield [76:17]
| | | | |--EXPR -> EXPR [76:23]
| | | | | `--UNARY_MINUS -> - [76:23]
| | | | | `--NUM_INT -> 2 [76:24]
| | | | `--SEMI -> ; [76:25]
| | | `--RCURLY -> } [77:13]
| | `--RCURLY -> } [78:9]
| |--SEMI -> ; [78:10]
| |--LITERAL_RETURN -> return [79:9]
| | |--EXPR -> EXPR [79:16]
| | | `--IDENT -> success [79:16]
| | `--SEMI -> ; [79:23]
| `--RCURLY -> } [80:5]
|--METHOD_DEF -> METHOD_DEF [82:5]
| |--MODIFIERS -> MODIFIERS [82:5]
| |--TYPE -> TYPE [82:5]
| | `--IDENT -> String [82:5]
| |--IDENT -> unnamedGuardAddsBindings [82:12]
| |--LPAREN -> ( [82:36]
| |--PARAMETERS -> PARAMETERS [82:37]
| | |--PARAMETER_DEF -> PARAMETER_DEF [82:37]
| | | |--MODIFIERS -> MODIFIERS [82:37]
| | | |--TYPE -> TYPE [82:37]
| | | | `--IDENT -> Object [82:37]
| | | `--IDENT -> o1 [82:44]
| | |--COMMA -> , [82:46]
| | `--PARAMETER_DEF -> PARAMETER_DEF [82:48]
| | |--MODIFIERS -> MODIFIERS [82:48]
| | |--TYPE -> TYPE [82:48]
| | | `--IDENT -> Object [82:48]
| | `--IDENT -> o2 [82:55]
| |--RPAREN -> ) [82:57]
| `--SLIST -> { [82:59]
| |--LITERAL_RETURN -> return [83:9]
| | |--EXPR -> EXPR [83:16]
| | | `--LITERAL_SWITCH -> switch [83:16]
| | | |--LPAREN -> ( [83:23]
| | | |--EXPR -> EXPR [83:24]
| | | | `--IDENT -> o1 [83:24]
| | | |--RPAREN -> ) [83:26]
| | | |--LCURLY -> { [83:28]
| | | |--CASE_GROUP -> CASE_GROUP [84:13]
| | | | |--LITERAL_CASE -> case [84:13]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:18]
| | | | | | |--MODIFIERS -> MODIFIERS [84:18]
| | | | | | |--TYPE -> TYPE [84:18]
| | | | | | | `--IDENT -> String [84:18]
| | | | | | `--IDENT -> _ [84:25]
| | | | | |--COMMA -> , [84:26]
| | | | | |--PATTERN_DEF -> PATTERN_DEF [84:37]
| | | | | | `--LITERAL_WHEN -> when [84:37]
| | | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:28]
| | | | | | | |--MODIFIERS -> MODIFIERS [84:28]
| | | | | | | |--TYPE -> TYPE [84:28]
| | | | | | | | `--IDENT -> Object [84:28]
| | | | | | | `--IDENT -> _ [84:35]
| | | | | | `--EXPR -> EXPR [84:45]
| | | | | | `--LITERAL_INSTANCEOF -> instanceof [84:45]
| | | | | | |--IDENT -> o2 [84:42]
| | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:56]
| | | | | | |--MODIFIERS -> MODIFIERS [84:56]
| | | | | | |--TYPE -> TYPE [84:56]
| | | | | | | `--IDENT -> String [84:56]
| | | | | | `--IDENT -> s [84:63]
| | | | | `--COLON -> : [84:64]
| | | | `--SLIST -> SLIST [84:66]
| | | | `--LITERAL_YIELD -> yield [84:66]
| | | | |--EXPR -> EXPR [84:72]
| | | | | `--IDENT -> s [84:72]
| | | | `--SEMI -> ; [84:73]
| | | |--CASE_GROUP -> CASE_GROUP [85:13]
| | | | |--LITERAL_CASE -> case [85:13]
| | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [85:18]
| | | | | | |--MODIFIERS -> MODIFIERS [85:18]
| | | | | | |--TYPE -> TYPE [85:18]
| | | | | | | `--IDENT -> Object [85:18]
| | | | | | `--IDENT -> _ [85:25]
| | | | | `--COLON -> : [85:26]
| | | | `--SLIST -> SLIST [85:28]
| | | | `--LITERAL_YIELD -> yield [85:28]
| | | | |--EXPR -> EXPR [85:34]
| | | | | `--STRING_LITERAL -> "any" [85:34]
| | | | `--SEMI -> ; [85:39]
| | | `--RCURLY -> } [86:9]
| | `--SEMI -> ; [86:10]
| `--RCURLY -> } [87:5]
|--METHOD_DEF -> METHOD_DEF [89:5]
| |--MODIFIERS -> MODIFIERS [89:5]
| |--TYPE -> TYPE [89:5]
| | `--LITERAL_BOOLEAN -> boolean [89:5]
| |--IDENT -> testUnnamedPrimitiveAndExhaustiveness [89:13]
| |--LPAREN -> ( [89:50]
| |--PARAMETERS -> PARAMETERS [89:51]
| | `--PARAMETER_DEF -> PARAMETER_DEF [89:51]
| | |--MODIFIERS -> MODIFIERS [89:51]
| | |--TYPE -> TYPE [89:51]
| | | `--IDENT -> RecordWithPrimitive [89:51]
| | `--IDENT -> a [89:71]
| |--RPAREN -> ) [89:72]
| `--SLIST -> { [89:74]
| |--VARIABLE_DEF -> VARIABLE_DEF [90:9]
| | |--MODIFIERS -> MODIFIERS [90:9]
| | |--TYPE -> TYPE [90:9]
| | | `--LITERAL_BOOLEAN -> boolean [90:9]
| | |--IDENT -> r1 [90:17]
| | `--ASSIGN -> = [90:20]
| | `--EXPR -> EXPR [90:22]
| | `--LITERAL_SWITCH -> switch [90:22]
| | |--LPAREN -> ( [90:29]
| | |--EXPR -> EXPR [90:30]
| | | `--IDENT -> a [90:30]
| | |--RPAREN -> ) [90:31]
| | |--LCURLY -> { [90:33]
| | |--SWITCH_RULE -> SWITCH_RULE [91:13]
| | | |--LITERAL_CASE -> case [91:13]
| | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [91:18]
| | | | |--MODIFIERS -> MODIFIERS [91:18]
| | | | |--TYPE -> TYPE [91:18]
| | | | | `--IDENT -> Prim1 [91:18]
| | | | |--LPAREN -> ( [91:23]
| | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [91:24]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [91:24]
| | | | | |--MODIFIERS -> MODIFIERS [91:24]
| | | | | |--TYPE -> TYPE [91:24]
| | | | | | `--IDENT -> var [91:24]
| | | | | `--IDENT -> _ [91:28]
| | | | `--RPAREN -> ) [91:29]
| | | |--LAMBDA -> -> [91:31]
| | | |--EXPR -> EXPR [91:34]
| | | | `--LITERAL_TRUE -> true [91:34]
| | | `--SEMI -> ; [91:38]
| | |--SWITCH_RULE -> SWITCH_RULE [92:13]
| | | |--LITERAL_CASE -> case [92:13]
| | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [92:18]
| | | | |--MODIFIERS -> MODIFIERS [92:18]
| | | | |--TYPE -> TYPE [92:18]
| | | | | `--IDENT -> Prim2 [92:18]
| | | | |--LPAREN -> ( [92:23]
| | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [92:24]
| | | | | `--UNNAMED_PATTERN_DEF -> _ [92:24]
| | | | `--RPAREN -> ) [92:25]
| | | |--LAMBDA -> -> [92:27]
| | | |--EXPR -> EXPR [92:30]
| | | | `--LITERAL_FALSE -> false [92:30]
| | | `--SEMI -> ; [92:35]
| | `--RCURLY -> } [93:9]
| |--SEMI -> ; [93:10]
| |--VARIABLE_DEF -> VARIABLE_DEF [95:9]
| | |--MODIFIERS -> MODIFIERS [95:9]
| | |--TYPE -> TYPE [95:9]
| | | `--LITERAL_BOOLEAN -> boolean [95:9]
| | |--IDENT -> r2 [95:17]
| | `--ASSIGN -> = [95:20]
| | `--EXPR -> EXPR [95:22]
| | `--LITERAL_SWITCH -> switch [95:22]
| | |--LPAREN -> ( [95:29]
| | |--EXPR -> EXPR [95:30]
| | | `--IDENT -> a [95:30]
| | |--RPAREN -> ) [95:31]
| | |--LCURLY -> { [95:33]
| | |--SWITCH_RULE -> SWITCH_RULE [96:13]
| | | |--LITERAL_CASE -> case [96:13]
| | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [96:18]
| | | | |--MODIFIERS -> MODIFIERS [96:18]
| | | | |--TYPE -> TYPE [96:18]
| | | | | `--IDENT -> Prim1 [96:18]
| | | | |--LPAREN -> ( [96:23]
| | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [96:24]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [96:24]
| | | | | |--MODIFIERS -> MODIFIERS [96:24]
| | | | | |--TYPE -> TYPE [96:24]
| | | | | | `--IDENT -> var [96:24]
| | | | | `--IDENT -> _ [96:28]
| | | | `--RPAREN -> ) [96:29]
| | | |--LAMBDA -> -> [96:31]
| | | |--EXPR -> EXPR [96:34]
| | | | `--LITERAL_TRUE -> true [96:34]
| | | `--SEMI -> ; [96:38]
| | |--SWITCH_RULE -> SWITCH_RULE [97:13]
| | | |--LITERAL_CASE -> case [97:13]
| | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [97:18]
| | | | |--MODIFIERS -> MODIFIERS [97:18]
| | | | |--TYPE -> TYPE [97:18]
| | | | | `--IDENT -> Prim2 [97:18]
| | | | |--LPAREN -> ( [97:23]
| | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [97:24]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [97:24]
| | | | | |--MODIFIERS -> MODIFIERS [97:24]
| | | | | |--TYPE -> TYPE [97:24]
| | | | | | `--IDENT -> var [97:24]
| | | | | `--IDENT -> _ [97:28]
| | | | `--RPAREN -> ) [97:29]
| | | |--LAMBDA -> -> [97:31]
| | | |--EXPR -> EXPR [97:34]
| | | | `--LITERAL_FALSE -> false [97:34]
| | | `--SEMI -> ; [97:39]
| | `--RCURLY -> } [98:9]
| |--SEMI -> ; [98:10]
| |--VARIABLE_DEF -> VARIABLE_DEF [100:9]
| | |--MODIFIERS -> MODIFIERS [100:9]
| | |--TYPE -> TYPE [100:9]
| | | `--LITERAL_BOOLEAN -> boolean [100:9]
| | |--IDENT -> r3 [100:17]
| | `--ASSIGN -> = [100:20]
| | `--EXPR -> EXPR [100:22]
| | `--LITERAL_SWITCH -> switch [100:22]
| | |--LPAREN -> ( [100:29]
| | |--EXPR -> EXPR [100:30]
| | | `--IDENT -> a [100:30]
| | |--RPAREN -> ) [100:31]
| | |--LCURLY -> { [100:33]
| | |--SWITCH_RULE -> SWITCH_RULE [101:13]
| | | |--LITERAL_CASE -> case [101:13]
| | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [101:18]
| | | | |--MODIFIERS -> MODIFIERS [101:18]
| | | | |--TYPE -> TYPE [101:18]
| | | | | `--IDENT -> Prim1 [101:18]
| | | | |--LPAREN -> ( [101:23]
| | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [101:24]
| | | | | `--UNNAMED_PATTERN_DEF -> _ [101:24]
| | | | `--RPAREN -> ) [101:25]
| | | |--LAMBDA -> -> [101:27]
| | | |--EXPR -> EXPR [101:30]
| | | | `--LITERAL_TRUE -> true [101:30]
| | | `--SEMI -> ; [101:34]
| | |--SWITCH_RULE -> SWITCH_RULE [102:13]
| | | |--LITERAL_CASE -> case [102:13]
| | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [102:18]
| | | | |--MODIFIERS -> MODIFIERS [102:18]
| | | | |--TYPE -> TYPE [102:18]
| | | | | `--IDENT -> Prim2 [102:18]
| | | | |--LPAREN -> ( [102:23]
| | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [102:24]
| | | | | `--UNNAMED_PATTERN_DEF -> _ [102:24]
| | | | `--RPAREN -> ) [102:25]
| | | |--LAMBDA -> -> [102:27]
| | | |--EXPR -> EXPR [102:30]
| | | | `--LITERAL_FALSE -> false [102:30]
| | | `--SEMI -> ; [102:35]
| | `--RCURLY -> } [103:9]
| |--SEMI -> ; [103:10]
| |--LITERAL_RETURN -> return [105:9]
| | |--EXPR -> EXPR [105:25]
| | | `--LAND -> && [105:25]
| | | |--LAND -> && [105:19]
| | | | |--IDENT -> r1 [105:16]
| | | | `--IDENT -> r2 [105:22]
| | | `--IDENT -> r3 [105:28]
| | `--SEMI -> ; [105:30]
| `--RCURLY -> } [106:5]
|--CLASS_DEF -> CLASS_DEF [108:5]
| |--MODIFIERS -> MODIFIERS [108:5]
| | |--ABSTRACT -> abstract [108:5]
| | `--LITERAL_SEALED -> sealed [108:14]
| |--LITERAL_CLASS -> class [108:21]
| |--IDENT -> Base [108:27]
| |--PERMITS_CLAUSE -> permits [108:32]
| | |--IDENT -> R1 [108:40]
| | |--COMMA -> , [108:42]
| | |--IDENT -> R2 [108:44]
| | |--COMMA -> , [108:46]
| | |--IDENT -> R3 [108:48]
| | |--COMMA -> , [108:50]
| | `--IDENT -> R4 [108:52]
| `--OBJBLOCK -> OBJBLOCK [108:55]
| |--LCURLY -> { [108:55]
| `--RCURLY -> } [108:57]
|--CLASS_DEF -> CLASS_DEF [109:5]
| |--MODIFIERS -> MODIFIERS [109:5]
| | `--FINAL -> final [109:5]
| |--LITERAL_CLASS -> class [109:12]
| |--IDENT -> R1 [109:18]
| |--EXTENDS_CLAUSE -> extends [109:22]
| | `--IDENT -> Base [109:30]
| `--OBJBLOCK -> OBJBLOCK [109:35]
| |--LCURLY -> { [109:35]
| `--RCURLY -> } [109:37]
|--CLASS_DEF -> CLASS_DEF [110:5]
| |--MODIFIERS -> MODIFIERS [110:5]
| | `--FINAL -> final [110:5]
| |--LITERAL_CLASS -> class [110:12]
| |--IDENT -> R2 [110:18]
| |--EXTENDS_CLAUSE -> extends [110:22]
| | `--IDENT -> Base [110:30]
| `--OBJBLOCK -> OBJBLOCK [110:35]
| |--LCURLY -> { [110:35]
| `--RCURLY -> } [110:37]
|--CLASS_DEF -> CLASS_DEF [111:5]
| |--MODIFIERS -> MODIFIERS [111:5]
| | `--FINAL -> final [111:5]
| |--LITERAL_CLASS -> class [111:12]
| |--IDENT -> R3 [111:18]
| |--EXTENDS_CLAUSE -> extends [111:22]
| | `--IDENT -> Base [111:30]
| `--OBJBLOCK -> OBJBLOCK [111:35]
| |--LCURLY -> { [111:35]
| `--RCURLY -> } [111:37]
|--CLASS_DEF -> CLASS_DEF [112:5]
| |--MODIFIERS -> MODIFIERS [112:5]
| | `--FINAL -> final [112:5]
| |--LITERAL_CLASS -> class [112:12]
| |--IDENT -> R4 [112:18]
| |--EXTENDS_CLAUSE -> extends [112:22]
| | `--IDENT -> Base [112:30]
| `--OBJBLOCK -> OBJBLOCK [112:35]
| |--LCURLY -> { [112:35]
| `--RCURLY -> } [112:37]
|--INTERFACE_DEF -> INTERFACE_DEF [113:5]
| |--MODIFIERS -> MODIFIERS [113:5]
| | `--LITERAL_SEALED -> sealed [113:5]
| |--LITERAL_INTERFACE -> interface [113:12]
| |--IDENT -> RecordWithPrimitive [113:22]
| |--PERMITS_CLAUSE -> permits [113:42]
| | |--IDENT -> Prim1 [113:50]
| | |--COMMA -> , [113:55]
| | `--IDENT -> Prim2 [113:57]
| `--OBJBLOCK -> OBJBLOCK [113:63]
| |--LCURLY -> { [113:63]
| `--RCURLY -> } [113:64]
|--SEMI -> ; [113:65]
|--RECORD_DEF -> RECORD_DEF [114:5]
| |--MODIFIERS -> MODIFIERS [114:5]
| |--LITERAL_RECORD -> record [114:5]
| |--IDENT -> Prim1 [114:12]
| |--LPAREN -> ( [114:17]
| |--RECORD_COMPONENTS -> RECORD_COMPONENTS [114:18]
| | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [114:18]
| | |--ANNOTATIONS -> ANNOTATIONS [114:18]
| | |--TYPE -> TYPE [114:18]
| | | `--LITERAL_INT -> int [114:18]
| | `--IDENT -> n1 [114:22]
| |--RPAREN -> ) [114:24]
| |--IMPLEMENTS_CLAUSE -> implements [114:26]
| | `--IDENT -> RecordWithPrimitive [114:37]
| `--OBJBLOCK -> OBJBLOCK [114:57]
| |--LCURLY -> { [114:57]
| `--RCURLY -> } [114:58]
|--SEMI -> ; [114:59]
|--RECORD_DEF -> RECORD_DEF [115:5]
| |--MODIFIERS -> MODIFIERS [115:5]
| |--LITERAL_RECORD -> record [115:5]
| |--IDENT -> Prim2 [115:12]
| |--LPAREN -> ( [115:17]
| |--RECORD_COMPONENTS -> RECORD_COMPONENTS [115:18]
| | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [115:18]
| | |--ANNOTATIONS -> ANNOTATIONS [115:18]
| | |--TYPE -> TYPE [115:18]
| | | `--LITERAL_INT -> int [115:18]
| | `--IDENT -> n2 [115:22]
| |--RPAREN -> ) [115:24]
| |--IMPLEMENTS_CLAUSE -> implements [115:26]
| | `--IDENT -> RecordWithPrimitive [115:37]
| `--OBJBLOCK -> OBJBLOCK [115:57]
| |--LCURLY -> { [115:57]
| `--RCURLY -> } [115:58]
|--SEMI -> ; [115:59]
|--RECORD_DEF -> RECORD_DEF [116:5]
| |--MODIFIERS -> MODIFIERS [116:5]
| |--LITERAL_RECORD -> record [116:5]
| |--IDENT -> Box [116:12]
| |--TYPE_PARAMETERS -> TYPE_PARAMETERS [116:15]
| | |--GENERIC_START -> < [116:15]
| | |--TYPE_PARAMETER -> TYPE_PARAMETER [116:16]
| | | |--IDENT -> T [116:16]
| | | `--TYPE_UPPER_BOUNDS -> extends [116:18]
| | | `--IDENT -> Base [116:26]
| | `--GENERIC_END -> > [116:30]
| |--LPAREN -> ( [116:31]
| |--RECORD_COMPONENTS -> RECORD_COMPONENTS [116:32]
| | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [116:32]
| | |--ANNOTATIONS -> ANNOTATIONS [116:32]
| | |--TYPE -> TYPE [116:32]
| | | `--IDENT -> T [116:32]
| | `--IDENT -> content [116:34]
| |--RPAREN -> ) [116:41]
| `--OBJBLOCK -> OBJBLOCK [116:43]
| |--LCURLY -> { [116:43]
| `--RCURLY -> } [116:45]
|--RECORD_DEF -> RECORD_DEF [117:5]
| |--MODIFIERS -> MODIFIERS [117:5]
| |--LITERAL_RECORD -> record [117:5]
| |--IDENT -> Box2 [117:12]
| |--TYPE_PARAMETERS -> TYPE_PARAMETERS [117:16]
| | |--GENERIC_START -> < [117:16]
| | |--TYPE_PARAMETER -> TYPE_PARAMETER [117:17]
| | | |--IDENT -> T [117:17]
| | | `--TYPE_UPPER_BOUNDS -> extends [117:19]
| | | `--IDENT -> Base [117:27]
| | `--GENERIC_END -> > [117:31]
| |--LPAREN -> ( [117:32]
| |--RECORD_COMPONENTS -> RECORD_COMPONENTS [117:33]
| | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [117:33]
| | |--ANNOTATIONS -> ANNOTATIONS [117:33]
| | |--TYPE -> TYPE [117:33]
| | | `--IDENT -> T [117:33]
| | `--IDENT -> content [117:35]
| |--RPAREN -> ) [117:42]
| `--OBJBLOCK -> OBJBLOCK [117:44]
| |--LCURLY -> { [117:44]
| `--RCURLY -> } [117:46]
`--RCURLY -> } [118:1]