Record Pattern Preview AST strucuture
Roman Ivanov edited this page Apr 1, 2023
·
9 revisions
New tokens: RECORD_PATTERN_DEF, RECORD_PATTERN_COMPONENTS sequence of sub tokens in new tokens are as it goes in file.
existing token reusage - PATTERN_VARIABLE_DEF:
Code: if (bo instanceof Box b) {
AST:
`--LITERAL_IF -> if [55:13]
|--LPAREN -> ( [55:16]
|--EXPR -> EXPR [55:20]
| `--LITERAL_INSTANCEOF -> instanceof [55:20]
| |--IDENT -> bo [55:17]
| `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [55:31]
| |--MODIFIERS -> MODIFIERS [55:31]
| |--TYPE -> TYPE [55:31]
| | `--IDENT -> Box [55:31]
| `--IDENT -> b [55:35]
|--RPAREN -> ) [55:36]
|--SLIST -> { [55:38]
NEW TOKENS:
Code:
if (b instanceof Box<String>(String s))
AST:
|--LITERAL_IF -> if [14:8]
| |--LPAREN -> ( [14:11]
| |--EXPR -> EXPR [14:14]
| | `--LITERAL_INSTANCEOF -> instanceof [14:14]
| | |--IDENT -> b [14:12]
| | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [14:25]
| | |--MODIFIERS -> MODIFIERS [14:25]
| | |--TYPE -> TYPE [14:25]
| | | |--IDENT -> Box [14:25]
| | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:28]
| | | |--GENERIC_START -> < [14:28]
| | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:29]
| | | | `--IDENT -> String [14:29]
| | | `--GENERIC_END -> > [14:35]
| | |--LPAREN -> ( [14:36]
| | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [14:37]
| | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:37]
| | | |--MODIFIERS -> MODIFIERS [14:37]
| | | |--TYPE -> TYPE [14:37]
| | | | `--IDENT -> String [14:37]
| | | `--IDENT -> s [14:44]
| | `--RPAREN -> ) [14:45]
| |--RPAREN -> ) [14:46]
Code: if (p instanceof @MyAnno2 final Pair<I>(D t1, D t2)) {
AST:
`--LITERAL_IF -> if [70:13]
|--LPAREN -> ( [70:16]
|--EXPR -> EXPR [70:19]
| `--LITERAL_INSTANCEOF -> instanceof [70:19]
| |--IDENT -> p [70:17]
| `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [70:30]
| |--MODIFIERS -> MODIFIERS [70:30]
| | |--ANNOTATION -> ANNOTATION [70:30]
| | | |--AT -> @ [70:30]
| | | `--IDENT -> MyAnno2 [70:31]
| | `--FINAL -> final [70:39]
| |--TYPE -> TYPE [70:45]
| | |--IDENT -> Pair [70:45]
| | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [70:49]
| | |--GENERIC_START -> < [70:49]
| | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [70:50]
| | | `--IDENT -> I [70:50]
| | `--GENERIC_END -> > [70:51]
| |--LPAREN -> ( [70:52]
| |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [70:53]
| | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [70:53]
| | | |--MODIFIERS -> MODIFIERS [70:53]
| | | |--TYPE -> TYPE [70:53]
| | | | `--IDENT -> D [70:53]
| | | `--IDENT -> t1 [70:55]
| | |--COMMA -> , [70:57]
| | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [70:59]
| | |--MODIFIERS -> MODIFIERS [70:59]
| | |--TYPE -> TYPE [70:59]
| | | `--IDENT -> D [70:59]
| | `--IDENT -> t2 [70:61]
| `--RPAREN -> ) [70:63]
|--RPAREN -> ) [70:64]
Code:
if (t instanceof final Tuple(
final Integer x,
@MyAnno1 Integer y,
final @MyAnno1 @MyAnno2 Integer z)) {
AST:
`--LITERAL_IF -> if [79:13]
|--LPAREN -> ( [79:16]
|--EXPR -> EXPR [79:19]
| `--LITERAL_INSTANCEOF -> instanceof [79:19]
| |--IDENT -> t [79:17]
| `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [79:30]
| |--MODIFIERS -> MODIFIERS [79:30]
| | `--FINAL -> final [79:30]
| |--TYPE -> TYPE [79:36]
| | `--IDENT -> Tuple [79:36]
| |--LPAREN -> ( [79:41]
| |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [80:16]
| | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [80:16]
| | | |--MODIFIERS -> MODIFIERS [80:16]
| | | | `--FINAL -> final [80:16]
| | | |--TYPE -> TYPE [80:22]
| | | | `--IDENT -> Integer [80:22]
| | | `--IDENT -> x [80:30]
| | |--COMMA -> , [80:31]
| | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [81:16]
| | | |--MODIFIERS -> MODIFIERS [81:16]
| | | | `--ANNOTATION -> ANNOTATION [81:16]
| | | | |--AT -> @ [81:16]
| | | | `--IDENT -> MyAnno1 [81:17]
| | | |--TYPE -> TYPE [81:25]
| | | | `--IDENT -> Integer [81:25]
| | | `--IDENT -> y [81:33]
| | |--COMMA -> , [81:34]
| | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [82:16]
| | |--MODIFIERS -> MODIFIERS [82:16]
| | | |--FINAL -> final [82:16]
| | | |--ANNOTATION -> ANNOTATION [82:22]
| | | | |--AT -> @ [82:22]
| | | | `--IDENT -> MyAnno1 [82:23]
| | | `--ANNOTATION -> ANNOTATION [82:31]
| | | |--AT -> @ [82:31]
| | | `--IDENT -> MyAnno2 [82:32]
| | |--TYPE -> TYPE [82:40]
| | | `--IDENT -> Integer [82:40]
| | `--IDENT -> z [82:48]
| `--RPAREN -> ) [82:49]
|--RPAREN -> ) [82:50]
Code:
if (r instanceof Rectangle(
ColoredPoint(Point(var x,var y),var c),
var lr)) {
AST:
|--LITERAL_IF -> if [74:8]
| |--LPAREN -> ( [74:11]
| |--EXPR -> EXPR [74:14]
| | `--LITERAL_INSTANCEOF -> instanceof [74:14]
| | |--IDENT -> r [74:12]
| | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [74:25]
| | |--MODIFIERS -> MODIFIERS [74:25]
| | |--TYPE -> TYPE [74:25]
| | | `--IDENT -> Rectangle [74:25]
| | |--LPAREN -> ( [74:34]
| | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [75:16]
| | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [75:16]
| | | | |--MODIFIERS -> MODIFIERS [75:16]
| | | | |--TYPE -> TYPE [75:16]
| | | | | `--IDENT -> ColoredPoint [75:16]
| | | | |--LPAREN -> ( [75:28]
| | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [75:29]
| | | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [75:29]
| | | | | | |--MODIFIERS -> MODIFIERS [75:29]
| | | | | | |--TYPE -> TYPE [75:29]
| | | | | | | `--IDENT -> Point [75:29]
| | | | | | |--LPAREN -> ( [75:34]
| | | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [75:35]
| | | | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [75:35]
| | | | | | | | |--MODIFIERS -> MODIFIERS [75:35]
| | | | | | | | |--TYPE -> TYPE [75:35]
| | | | | | | | | `--IDENT -> var [75:35]
| | | | | | | | `--IDENT -> x [75:39]
| | | | | | | |--COMMA -> , [75:40]
| | | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [75:41]
| | | | | | | |--MODIFIERS -> MODIFIERS [75:41]
| | | | | | | |--TYPE -> TYPE [75:41]
| | | | | | | | `--IDENT -> var [75:41]
| | | | | | | `--IDENT -> y [75:45]
| | | | | | `--RPAREN -> ) [75:46]
| | | | | |--COMMA -> , [75:47]
| | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [75:48]
| | | | | |--MODIFIERS -> MODIFIERS [75:48]
| | | | | |--TYPE -> TYPE [75:48]
| | | | | | `--IDENT -> var [75:48]
| | | | | `--IDENT -> c [75:52]
| | | | `--RPAREN -> ) [75:53]
| | | |--COMMA -> , [75:54]
| | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [76:16]
| | | |--MODIFIERS -> MODIFIERS [76:16]
| | | |--TYPE -> TYPE [76:16]
| | | | `--IDENT -> var [76:16]
| | | `--IDENT -> lr [76:20]
| | `--RPAREN -> ) [76:22]
| |--RPAREN -> ) [76:23]
Code: case Pair<I>(final C c,@MyAnno2 I i) -> "T!";
AST:
|--LITERAL_CASE -> case [89:12]
| `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [89:17]
| |--MODIFIERS -> MODIFIERS [89:17]
| |--TYPE -> TYPE [89:17]
| | |--IDENT -> Pair [89:17]
| | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [89:21]
| | |--GENERIC_START -> < [89:21]
| | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:22]
| | | `--IDENT -> I [89:22]
| | `--GENERIC_END -> > [89:23]
| |--LPAREN -> ( [89:24]
| |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [89:25]
| | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [89:25]
| | | |--MODIFIERS -> MODIFIERS [89:25]
| | | | `--FINAL -> final [89:25]
| | | |--TYPE -> TYPE [89:31]
| | | | `--IDENT -> C [89:31]
| | | `--IDENT -> c [89:33]
| | |--COMMA -> , [89:34]
| | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [89:35]
| | |--MODIFIERS -> MODIFIERS [89:35]
| | | `--ANNOTATION -> ANNOTATION [89:35]
| | | |--AT -> @ [89:35]
| | | `--IDENT -> MyAnno2 [89:36]
| | |--TYPE -> TYPE [89:44]
| | | `--IDENT -> I [89:44]
| | `--IDENT -> i [89:46]
| `--RPAREN -> ) [89:47]
|--LAMBDA -> -> [89:49]
|--EXPR -> EXPR [89:52]
| `--STRING_LITERAL -> "T!" [89:52]
`--SEMI -> ; [89:56]