Repository: checkstyle/checkstyle

Problem statement:
Support record patterns (preview-feature in Java 19) as described by JEP 405
**How it works Now:**

**Compilation works**
```bash
javac --release 19 --enable-preview Example.java

Note: Example.java uses preview features of Java SE 19.
Note: Recompile with -Xlint:preview for details.
```

**The source file**
```bash
cat Example.java

class Example {

    record A(Object o) {}
    record B(Object o) {}

    void method(Object param) {
        switch (param) {
            case A(Object o) -> {}
            case B(var o) -> {}
            default -> {}
        }
        if (param instanceof A(var o)) {

        }
    }
}
```

**Run checkstyle 10.5.0**
```bash
RUN_LOCALE="-Duser.language=en -Duser.country=US"
java $RUN_LOCALE -jar checkstyle-10.5.0-all.jar -c /sun_checks.xml  Example.java

Starting audit...
com.puppycrawl.tools.checkstyle.api.CheckstyleException: Exception was thrown while processing Example.java
	at com.puppycrawl.tools.checkstyle.Checker.processFiles(Checker.java:307)
	at com.puppycrawl.tools.checkstyle.Checker.process(Checker.java:224)
	at com.puppycrawl.tools.checkstyle.Main.runCheckstyle(Main.java:415)
	at com.puppycrawl.tools.checkstyle.Main.runCli(Main.java:338)
	at com.puppycrawl.tools.checkstyle.Main.execute(Main.java:195)
	at com.puppycrawl.tools.checkstyle.Main.main(Main.java:130)
Caused by: com.puppycrawl.tools.checkstyle.api.CheckstyleException: IllegalStateException occurred while parsing file /Users/apflieger/src/sample-checkstyle-record-pattern/Example.java.
	at com.puppycrawl.tools.checkstyle.JavaParser.parse(JavaParser.java:105)
	at com.puppycrawl.tools.checkstyle.TreeWalker.processFiltered(TreeWalker.java:153)
	at com.puppycrawl.tools.checkstyle.api.AbstractFileSetCheck.process(AbstractFileSetCheck.java:98)
	at com.puppycrawl.tools.checkstyle.Checker.processFile(Checker.java:335)
	at com.puppycrawl.tools.checkstyle.Checker.processFiles(Checker.java:294)
	... 5 more
Caused by: java.lang.IllegalStateException: 9:12: no viable alternative at input 'switch(param){caseA(Objecto)->{}case'
	at com.puppycrawl.tools.checkstyle.JavaParser$CheckstyleErrorListener.syntaxError(JavaParser.java:255)
	at org.antlr.v4.runtime.ProxyErrorListener.syntaxError(ProxyErrorListener.java:41)
	at org.antlr.v4.runtime.Parser.notifyErrorListeners(Parser.java:544)
	at org.antlr.v4.runtime.DefaultErrorStrategy.reportNoViableAlternative(DefaultErrorStrategy.java:310)
	at org.antlr.v4.runtime.DefaultErrorStrategy.reportError(DefaultErrorStrategy.java:136)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.statement(JavaLanguageParser.java:7050)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.blockStatement(JavaLanguageParser.java:6192)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.block(JavaLanguageParser.java:6095)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.methodBody(JavaLanguageParser.java:2938)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.methodDeclaration(JavaLanguageParser.java:2896)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.memberDeclaration(JavaLanguageParser.java:2743)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.classBodyDeclaration(JavaLanguageParser.java:2669)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.classBody(JavaLanguageParser.java:2475)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.classDeclaration(JavaLanguageParser.java:1094)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.types(JavaLanguageParser.java:751)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.typeDeclaration(JavaLanguageParser.java:665)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.compilationUnit(JavaLanguageParser.java:412)
	at com.puppycrawl.tools.checkstyle.JavaParser.parse(JavaParser.java:99)
	... 9 more
Caused by: org.antlr.v4.runtime.NoViableAltException
	at org.antlr.v4.runtime.atn.ParserATNSimulator.noViableAlt(ParserATNSimulator.java:2031)
	at org.antlr.v4.runtime.atn.ParserATNSimulator.execATN(ParserATNSimulator.java:470)
	at org.antlr.v4.runtime.atn.ParserATNSimulator.adaptivePredict(ParserATNSimulator.java:396)
	at com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageParser.statement(JavaLanguageParser.java:6723)
	... 21 more
Checkstyle ends with 1 errors.
```

**Is your feature request related to a problem? Please describe.**
This feature has been released in september 2022 as a preview feature. To me, given the trend of the recent java evolutions, it is very unlikely to be withdrawn.
Here's the jep https://openjdk.org/jeps/405

😇

Thank you for your awesome work 🙏


Hints:
I am on it.
@apflieger , can we ask you to try workaround while fix is in progress ?

please try to apply this update to your config - https://github.com/checkstyle/checkstyle/issues/12542#issuecomment-1365367872
it should allow you to use new features without being blocked by checkstyle. Please share feedback.
It works but other rules on the same file seem not to be executed then.
> It works but other rules on the same file seem not to be executed then.

Yes, TreeWalker checks (java code) will not work if file cannot be parsed. Checks that have Checker as a parent (FileSet) checks will still work with the file:
```
➜  src cat config.xml 
<?xml version="1.0"?>
<!DOCTYPE module PUBLIC
        "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
        "https://checkstyle.org/dtds/configuration_1_3.dtd">
<module name="Checker">
  <module name="RegexpSingleline">
    <property name="format" value="Object param"/>
    <property name="minimum" value="0"/>
    <property name="maximum" value="0"/>
  </module>
  <property name="haltOnException" value="false"/>
  <module name="SuppressionSingleFilter">
    <property name="message" value=".*IllegalStateException occurred while parsing file.*"/>
  </module>
  <module name="TreeWalker">
    <module name="IllegalIdentifierName"/>
  </module>
</module>

➜  src cat Test.java 
public class Test {
    record A(Object o) {}
    record B(Object o) {}

    void method(Object param) {
        switch (param) {
            case A(Object o) -> {}
            case B(var o) -> {}
            default -> {}
        }
        if (param instanceof A(var o)) {

        }
    }
}                                                                                                          

 ➜  src javac --enable-preview --release 19 Test.java            
Note: Test.java uses preview features of Java SE 19.
Note: Recompile with -Xlint:preview for details.

➜  src java -jar checkstyle-10.4-all.jar -c config.xml Test.java
Starting audit...
[ERROR] /home/nick/IdeaProjects/tester/src/Test.java:5: Line matches the illegal pattern 'Object param'. [RegexpSingleline]
Audit done.
Checkstyle ends with 1 errors.


```

Workaround at https://github.com/checkstyle/checkstyle/issues/12542#issuecomment-1365367872 allows users to still use checkstyle, but not use TreeWalker checks on new syntax until support is added.

Edit: there is a nuance, modules are executed sequentially:
```
➜  src cat config.xml 
<?xml version="1.0"?>
<!DOCTYPE module PUBLIC
        "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
        "https://checkstyle.org/dtds/configuration_1_3.dtd">
<module name="Checker">

  <property name="haltOnException" value="false"/>
  <module name="SuppressionSingleFilter">
    <property name="message" value=".*IllegalStateException occurred while parsing file.*"/>
  </module>
  <module name="TreeWalker">
    <module name="IllegalIdentifierName"/>
  </module>
    <module name="RegexpSingleline">
    <property name="format" value="Object param"/>
    <property name="minimum" value="0"/>
    <property name="maximum" value="0"/>
  </module>
</module>
➜  src java -jar checkstyle-10.4-all.jar -c config.xml Test.java
Starting audit...
Audit done.


```

So, for this workaround to still allow other checks (non TreeWalker) to execute, they must appear in config BEFORE TreeWalker module.
On my main project we have Checker rules like `RegexpMultiline`, they are declared before the TreeWalker module. These rules are sometimes executed, sometimes not. Weird, but it's not really a problem for me.
@apflieger , if you move Treewalker in xml to be last child, execution will be more predictable.

Patch:
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/JavaAstVisitor.java b/src/main/java/com/puppycrawl/tools/checkstyle/JavaAstVisitor.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/JavaAstVisitor.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/JavaAstVisitor.java
@@ -1952,14 +1952,20 @@ public DetailAstImpl visitArguments(JavaLanguageParser.ArgumentsContext ctx) {
 
     @Override
     public DetailAstImpl visitPattern(JavaLanguageParser.PatternContext ctx) {
-        final ParserRuleContext primaryPattern = ctx.primaryPattern();
+        final JavaLanguageParser.InnerPatternContext innerPattern = ctx.innerPattern();
+        final ParserRuleContext primaryPattern = innerPattern.primaryPattern();
+        final ParserRuleContext recordPattern = innerPattern.recordPattern();
         final boolean isSimpleTypePattern = primaryPattern != null
                 && primaryPattern.getChild(0) instanceof JavaLanguageParser.TypePatternContext;
 
         final DetailAstImpl pattern;
-        if (isSimpleTypePattern) {
+
+        if (recordPattern != null) {
+            pattern = visit(recordPattern);
+        }
+        else if (isSimpleTypePattern) {
             // For simple type pattern like 'Integer i`, we do not add `PATTERN_DEF` parent
-            pattern = visit(ctx.primaryPattern());
+            pattern = visit(primaryPattern);
         }
         else {
             pattern = createImaginary(TokenTypes.PATTERN_DEF);
@@ -1968,6 +1974,11 @@ public DetailAstImpl visitPattern(JavaLanguageParser.PatternContext ctx) {
         return pattern;
     }
 
+    @Override
+    public DetailAstImpl visitInnerPattern(JavaLanguageParser.InnerPatternContext ctx) {
+        return flattenedTree(ctx);
+    }
+
     @Override
     public DetailAstImpl visitGuardedPattern(JavaLanguageParser.GuardedPatternContext ctx) {
         final DetailAstImpl guardAstNode = flattenedTree(ctx.guard());
@@ -1985,6 +1996,11 @@ public DetailAstImpl visitParenPattern(JavaLanguageParser.ParenPatternContext ct
         return lparen;
     }
 
+    @Override
+    public DetailAstImpl visitRecordPatternDef(JavaLanguageParser.RecordPatternDefContext ctx) {
+        return flattenedTree(ctx);
+    }
+
     @Override
     public DetailAstImpl visitTypePattern(
             JavaLanguageParser.TypePatternContext ctx) {
@@ -1996,6 +2012,24 @@ public DetailAstImpl visitTypePattern(
         return patternVariableDef;
     }
 
+    @Override
+    public DetailAstImpl visitRecordPattern(JavaLanguageParser.RecordPatternContext ctx) {
+        final DetailAstImpl recordPattern = createImaginary(TokenTypes.RECORD_PATTERN_DEF);
+        recordPattern.addChild(createModifiers(ctx.mods));
+        processChildren(recordPattern,
+                ctx.children.subList(ctx.mods.size(), ctx.children.size()));
+        return recordPattern;
+    }
+
+    @Override
+    public DetailAstImpl visitRecordComponentPatternList(
+            JavaLanguageParser.RecordComponentPatternListContext ctx) {
+        final DetailAstImpl recordComponents =
+                createImaginary(TokenTypes.RECORD_PATTERN_COMPONENTS);
+        processChildren(recordComponents, ctx.children);
+        return recordComponents;
+    }
+
     @Override
     public DetailAstImpl visitPermittedSubclassesAndInterfaces(
             JavaLanguageParser.PermittedSubclassesAndInterfacesContext ctx) {
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java b/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java
@@ -6272,6 +6272,194 @@ public final class TokenTypes {
     public static final int LITERAL_WHEN =
         JavaLanguageLexer.LITERAL_WHEN;
 
+    /**
+     * A {@code record} pattern definition. A record pattern consists of a type,
+     * a (possibly empty) record component pattern list which is used to match against
+     * the corresponding record components, and an optional identifier. Appears as part of
+     * an {@code instanceof} expression or a {@code case} label in a switch.
+     *
+     * <p>For example:</p>
+     * <pre>
+     * record R(Object o){}
+     * if (o instanceof R(String s) myRecord) {}
+     * switch (o) {
+     *     case R(String s) myRecord -&gt; {}
+     * }
+     * </pre>
+     * <p>parses as:</p>
+     * <pre>
+     * |--RECORD_DEF -&gt; RECORD_DEF
+     * |   |--MODIFIERS -&gt; MODIFIERS
+     * |   |--LITERAL_RECORD -&gt; record
+     * |   |--IDENT -&gt; R
+     * |   |--LPAREN -&gt; (
+     * |   |--RECORD_COMPONENTS -&gt; RECORD_COMPONENTS
+     * |   |   `--RECORD_COMPONENT_DEF -&gt; RECORD_COMPONENT_DEF
+     * |   |       |--ANNOTATIONS -&gt; ANNOTATIONS
+     * |   |       |--TYPE -&gt; TYPE
+     * |   |       |   `--IDENT -&gt; Object
+     * |   |       `--IDENT -&gt; o
+     * |   |--RPAREN -&gt; )
+     * |   `--OBJBLOCK -&gt; OBJBLOCK
+     * |       |--LCURLY -&gt; {
+     * |       `--RCURLY -&gt; }
+     * |--LITERAL_IF -&gt; if
+     * |   |--LPAREN -&gt; (
+     * |   |--EXPR -&gt; EXPR
+     * |   |   `--LITERAL_INSTANCEOF -&gt; instanceof
+     * |   |       |--IDENT -&gt; o
+     * |   |       `--RECORD_PATTERN_DEF -&gt; RECORD_PATTERN_DEF
+     * |   |           |--MODIFIERS -&gt; MODIFIERS
+     * |   |           |--TYPE -&gt; TYPE
+     * |   |           |   `--IDENT -&gt; R
+     * |   |           |--LPAREN -&gt; (
+     * |   |           |--RECORD_PATTERN_COMPONENTS -&gt; RECORD_PATTERN_COMPONENTS
+     * |   |           |   `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
+     * |   |           |       |--MODIFIERS -&gt; MODIFIERS
+     * |   |           |       |--TYPE -&gt; TYPE
+     * |   |           |       |   `--IDENT -&gt; String
+     * |   |           |       `--IDENT -&gt; s
+     * |   |           |--RPAREN -&gt; )
+     * |   |           `--IDENT -&gt; myRecord
+     * |   |--RPAREN -&gt; )
+     * |   `--SLIST -&gt; {
+     * |       `--RCURLY -&gt; }
+     * |--LITERAL_SWITCH -&gt; switch
+     * |   |--LPAREN -&gt; (
+     * |   |--EXPR -&gt; EXPR
+     * |   |   `--IDENT -&gt; o
+     * |   |--RPAREN -&gt; )
+     * |   |--LCURLY -&gt; {
+     * |   |--SWITCH_RULE -&gt; SWITCH_RULE
+     * |   |   |--LITERAL_CASE -&gt; case
+     * |   |   |   `--RECORD_PATTERN_DEF -&gt; RECORD_PATTERN_DEF
+     * |   |   |       |--MODIFIERS -&gt; MODIFIERS
+     * |   |   |       |--TYPE -&gt; TYPE
+     * |   |   |       |   `--IDENT -&gt; R
+     * |   |   |       |--LPAREN -&gt; (
+     * |   |   |       |--RECORD_PATTERN_COMPONENTS -&gt; RECORD_PATTERN_COMPONENTS
+     * |   |   |       |   `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
+     * |   |   |       |       |--MODIFIERS -&gt; MODIFIERS
+     * |   |   |       |       |--TYPE -&gt; TYPE
+     * |   |   |       |       |   `--IDENT -&gt; String
+     * |   |   |       |       `--IDENT -&gt; s
+     * |   |   |       |--RPAREN -&gt; )
+     * |   |   |       `--IDENT -&gt; myRecord
+     * |   |   |--LAMBDA -&gt; -&gt;
+     * |   |   `--SLIST -&gt; {
+     * |   |       `--RCURLY -&gt; }
+     * |   `--RCURLY -&gt; }
+     * `--RCURLY -&gt; }
+     * </pre>
+     *
+     * @see <a href="https://openjdk.org/jeps/405">JEP 405: Record Patterns</a>
+     * @see #LITERAL_WHEN
+     * @see #PATTERN_VARIABLE_DEF
+     * @see #LITERAL_INSTANCEOF
+     * @see #SWITCH_RULE
+     *
+     * @since 10.12.0
+     */
+    public static final int RECORD_PATTERN_DEF =
+        JavaLanguageLexer.RECORD_PATTERN_DEF;
+
+    /**
+     * A (possibly empty) record component pattern list which is used to match against
+     * the corresponding record components. Appears as part of a record pattern definition.
+     *
+     * <p>For example:</p>
+     * <pre>
+     * record R(Object o){}
+     * if (o instanceof R(String myComponent)) {}
+     * switch (o) {
+     *     case R(String myComponent) when "component".equalsIgnoreCase(myComponent) -&gt; {}
+     * }
+     * </pre>
+     * <p>parses as:</p>
+     * <pre>
+     * |--RECORD_DEF -&gt; RECORD_DEF
+     * |   |--MODIFIERS -&gt; MODIFIERS
+     * |   |--LITERAL_RECORD -&gt; record
+     * |   |--IDENT -&gt; R
+     * |   |--LPAREN -&gt; (
+     * |   |--RECORD_COMPONENTS -&gt; RECORD_COMPONENTS
+     * |   |   `--RECORD_COMPONENT_DEF -&gt; RECORD_COMPONENT_DEF
+     * |   |       |--ANNOTATIONS -&gt; ANNOTATIONS
+     * |   |       |--TYPE -&gt; TYPE
+     * |   |       |   `--IDENT -&gt; Object
+     * |   |       `--IDENT -&gt; o
+     * |   |--RPAREN -&gt; )
+     * |   `--OBJBLOCK -&gt; OBJBLOCK
+     * |       |--LCURLY -&gt; {
+     * |       `--RCURLY -&gt; }
+     * |--LITERAL_IF -&gt; if
+     * |   |--LPAREN -&gt; (
+     * |   |--EXPR -&gt; EXPR
+     * |   |   `--LITERAL_INSTANCEOF -&gt; instanceof
+     * |   |       |--IDENT -&gt; o
+     * |   |       `--RECORD_PATTERN_DEF -&gt; RECORD_PATTERN_DEF
+     * |   |           |--MODIFIERS -&gt; MODIFIERS
+     * |   |           |--TYPE -&gt; TYPE
+     * |   |           |   `--IDENT -&gt; R
+     * |   |           |--LPAREN -&gt; (
+     * |   |           |--RECORD_PATTERN_COMPONENTS -&gt; RECORD_PATTERN_COMPONENTS
+     * |   |           |   `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
+     * |   |           |       |--MODIFIERS -&gt; MODIFIERS
+     * |   |           |       |--TYPE -&gt; TYPE
+     * |   |           |       |   `--IDENT -&gt; String
+     * |   |           |       `--IDENT -&gt; myComponent
+     * |   |           `--RPAREN -&gt; )
+     * |   |--RPAREN -&gt; )
+     * |   `--SLIST -&gt; {
+     * |       `--RCURLY -&gt; }
+     * |--LITERAL_SWITCH -&gt; switch
+     * |   |--LPAREN -&gt; (
+     * |   |--EXPR -&gt; EXPR
+     * |   |   `--IDENT -&gt; o
+     * |   |--RPAREN -&gt; )
+     * |   |--LCURLY -&gt; {
+     * |   |--SWITCH_RULE -&gt; SWITCH_RULE
+     * |   |   |--LITERAL_CASE -&gt; case
+     * |   |   |   `--PATTERN_DEF -&gt; PATTERN_DEF
+     * |   |   |       `--LITERAL_WHEN -&gt; when
+     * |   |   |           |--RECORD_PATTERN_DEF -&gt; RECORD_PATTERN_DEF
+     * |   |   |           |   |--MODIFIERS -&gt; MODIFIERS
+     * |   |   |           |   |--TYPE -&gt; TYPE
+     * |   |   |           |   |   `--IDENT -&gt; R
+     * |   |   |           |   |--LPAREN -&gt; (
+     * |   |   |           |   |--RECORD_PATTERN_COMPONENTS -&gt; RECORD_PATTERN_COMPONENTS
+     * |   |   |           |   |   `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
+     * |   |   |           |   |       |--MODIFIERS -&gt; MODIFIERS
+     * |   |   |           |   |       |--TYPE -&gt; TYPE
+     * |   |   |           |   |       |   `--IDENT -&gt; String
+     * |   |   |           |   |       `--IDENT -&gt; myComponent
+     * |   |   |           |   `--RPAREN -&gt; )
+     * |   |   |           `--METHOD_CALL -&gt; (
+     * |   |   |               |--DOT -&gt; .
+     * |   |   |               |   |--STRING_LITERAL -&gt; "component"
+     * |   |   |               |   `--IDENT -&gt; equalsIgnoreCase
+     * |   |   |               |--ELIST -&gt; ELIST
+     * |   |   |               |   `--EXPR -&gt; EXPR
+     * |   |   |               |       `--IDENT -&gt; myComponent
+     * |   |   |               `--RPAREN -&gt; )
+     * |   |   |--LAMBDA -&gt; -&gt;
+     * |   |   `--SLIST -&gt; {
+     * |   |       `--RCURLY -&gt; }
+     * |   `--RCURLY -&gt; }
+     * `--RCURLY -&gt; }
+     * </pre>
+     *
+     * @see <a href="https://openjdk.org/jeps/405">JEP 405: Record Patterns</a>
+     * @see #LITERAL_WHEN
+     * @see #PATTERN_VARIABLE_DEF
+     * @see #LITERAL_INSTANCEOF
+     * @see #SWITCH_RULE
+     *
+     * @since 10.12.0
+     */
+    public static final int RECORD_PATTERN_COMPONENTS =
+            JavaLanguageLexer.RECORD_PATTERN_COMPONENTS;
+
     /** Prevent instantiation. */
     private TokenTypes() {
     }


Test patch:
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
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalTokenTextCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/IllegalTokenTextCheckTest.java
@@ -161,7 +161,7 @@ public void testOrderOfProperties() {
 
     @Test
     public void testAcceptableTokensMakeSense() {
-        final int expectedTokenTypesTotalNumber = 186;
+        final int expectedTokenTypesTotalNumber = 188;
         assertWithMessage("Total number of TokenTypes has changed, acceptable tokens in"
                 + " IllegalTokenTextCheck need to be reconsidered.")
             .that(TokenUtil.getTokenTypesTotalNumber())
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java
@@ -709,6 +709,12 @@ public void testTokenNumbering() {
         assertWithMessage(message)
              .that(JavaLanguageLexer.LITERAL_WHEN)
              .isEqualTo(214);
+        assertWithMessage(message)
+             .that(JavaLanguageLexer.RECORD_PATTERN_DEF)
+             .isEqualTo(215);
+        assertWithMessage(message)
+             .that(JavaLanguageLexer.RECORD_PATTERN_COMPONENTS)
+             .isEqualTo(216);
 
         final int tokenCount = (int) Arrays.stream(JavaLanguageLexer.class.getDeclaredFields())
                 .filter(GeneratedJavaTokenTypesTest::isPublicStaticFinalInt)
@@ -719,7 +725,7 @@ public void testTokenNumbering() {
                         + " 'GeneratedJavaTokenTypesTest' and verified"
                         + " that their old numbering didn't change")
             .that(tokenCount)
-            .isEqualTo(226);
+            .isEqualTo(228);
     }
 
     /**
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/java19/Java19AstRegressionTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/java19/Java19AstRegressionTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/java19/Java19AstRegressionTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/java19/Java19AstRegressionTest.java
@@ -65,4 +65,43 @@ public void testLotsOfOperators() throws Exception {
         verifyAst(getNonCompilablePath("ExpectedJava19BindingsWithLotsOfOperators.txt"),
                 getNonCompilablePath("InputJava19BindingsWithLotsOfOperators.java"));
     }
+
+    @Test
+    public void testRecordPatternsWithNestedDecomposition() throws Exception {
+        verifyAst(getPath("ExpectedRecordPatternsPreviewNestedDecomposition.txt"),
+                getNonCompilablePath("InputRecordPatternsPreviewNestedDecomposition.java"));
+    }
+
+    @Test
+    public void testRecordPatternsPreview() throws Exception {
+        verifyAst(getPath("ExpectedRecordPatternsPreview.txt"),
+                getNonCompilablePath("InputRecordPatternsPreview.java"));
+    }
+
+    @Test
+    public void testGenericRecordDecomposition() throws Exception {
+        verifyAst(getNonCompilablePath("ExpectedGenericRecordDeconstructionPattern.txt"),
+                getNonCompilablePath("InputGenericRecordDeconstructionPattern.java"));
+    }
+
+    @Test
+    public void testGuardsWithExtraParenthesis() throws Exception {
+        verifyAst(getNonCompilablePath("ExpectedJava19GuardsWithExtraParenthesis.txt"),
+                getNonCompilablePath("InputJava19GuardsWithExtraParenthesis.java"));
+    }
+
+    @Test
+    public void testBindingWithModifiers() throws Exception {
+        verifyAst(getNonCompilablePath("ExpectedJava19BindingWithModifiers.txt"),
+                getNonCompilablePath("InputJava19BindingWithModifiers.java"));
+    }
+
+    @Test
+    public void test() throws Exception {
+        verifyAst(getNonCompilablePath(
+                "ExpectedJava19RecordDecompositionWithConditionInLoops.txt"),
+                getNonCompilablePath(
+                        "InputJava19RecordDecompositionWithConditionInLoops.java"
+                ));
+    }
 }
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java
@@ -228,7 +228,7 @@ public void testGetTokenTypesTotalNumber() {
 
         assertWithMessage("Invalid token total number")
             .that(tokenTypesTotalNumber)
-            .isEqualTo(186);
+            .isEqualTo(188);
     }
 
     @Test
@@ -238,10 +238,10 @@ public void testGetAllTokenIds() {
 
         assertWithMessage("Invalid token length")
             .that(allTokenIds.length)
-            .isEqualTo(186);
+            .isEqualTo(188);
         assertWithMessage("invalid sum")
             .that(sum)
-            .isEqualTo(19164);
+            .isEqualTo(19595);
     }
 
     @Test
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedGenericRecordDeconstructionPattern.txt b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedGenericRecordDeconstructionPattern.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedGenericRecordDeconstructionPattern.txt
@@ -0,0 +1,790 @@
+COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
+|--PACKAGE_DEF -> package [2:0]
+|   |--ANNOTATIONS -> ANNOTATIONS [2:47]
+|   |--DOT -> . [2:47]
+|   |   |--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]
+|   |   `--IDENT -> java19 [2:48]
+|   `--SEMI -> ; [2:54]
+|--IMPORT -> import [4:0]
+|   |--DOT -> . [4:16]
+|   |   |--DOT -> . [4:11]
+|   |   |   |--IDENT -> java [4:7]
+|   |   |   `--IDENT -> util [4:12]
+|   |   `--IDENT -> Objects [4:17]
+|   `--SEMI -> ; [4:24]
+|--IMPORT -> import [5:0]
+|   |--DOT -> . [5:25]
+|   |   |--DOT -> . [5:16]
+|   |   |   |--DOT -> . [5:11]
+|   |   |   |   |--IDENT -> java [5:7]
+|   |   |   |   `--IDENT -> util [5:12]
+|   |   |   `--IDENT -> function [5:17]
+|   |   `--IDENT -> Function [5:26]
+|   `--SEMI -> ; [5:34]
+`--CLASS_DEF -> CLASS_DEF [7:0]
+    |--MODIFIERS -> MODIFIERS [7:0]
+    |   `--LITERAL_PUBLIC -> public [7:0]
+    |--LITERAL_CLASS -> class [7:7]
+    |--IDENT -> InputGenericRecordDeconstructionPattern [7:13]
+    `--OBJBLOCK -> OBJBLOCK [7:53]
+        |--LCURLY -> { [7:53]
+        |--METHOD_DEF -> METHOD_DEF [9:4]
+        |   |--MODIFIERS -> MODIFIERS [9:4]
+        |   |--TYPE -> TYPE [9:4]
+        |   |   `--LITERAL_VOID -> void [9:4]
+        |   |--IDENT -> m1 [9:9]
+        |   |--LPAREN -> ( [9:11]
+        |   |--PARAMETERS -> PARAMETERS [9:12]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [9:12]
+        |   |       |--MODIFIERS -> MODIFIERS [9:12]
+        |   |       |--TYPE -> TYPE [9:12]
+        |   |       |   |--IDENT -> Function [9:12]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [9:20]
+        |   |       |       |--GENERIC_START -> < [9:20]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [9:21]
+        |   |       |       |   |--IDENT -> Box [9:21]
+        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [9:24]
+        |   |       |       |       |--GENERIC_START -> < [9:24]
+        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [9:25]
+        |   |       |       |       |   `--IDENT -> String [9:25]
+        |   |       |       |       `--GENERIC_END -> > [9:31]
+        |   |       |       |--COMMA -> , [9:32]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [9:34]
+        |   |       |       |   `--IDENT -> Integer [9:34]
+        |   |       |       `--GENERIC_END -> > [9:41]
+        |   |       `--IDENT -> test [9:43]
+        |   |--RPAREN -> ) [9:47]
+        |   `--SLIST -> { [9:49]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [10:8]
+        |       |   |--MODIFIERS -> MODIFIERS [10:8]
+        |       |   |--TYPE -> TYPE [10:8]
+        |       |   |   |--IDENT -> Box [10:8]
+        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [10:11]
+        |       |   |       |--GENERIC_START -> < [10:11]
+        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [10:12]
+        |       |   |       |   `--IDENT -> String [10:12]
+        |       |   |       `--GENERIC_END -> > [10:18]
+        |       |   |--IDENT -> b [10:20]
+        |       |   `--ASSIGN -> = [10:22]
+        |       |       `--EXPR -> EXPR [10:24]
+        |       |           `--LITERAL_NEW -> new [10:24]
+        |       |               |--IDENT -> Box [10:28]
+        |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [10:31]
+        |       |               |   |--GENERIC_START -> < [10:31]
+        |       |               |   `--GENERIC_END -> > [10:32]
+        |       |               |--LPAREN -> ( [10:33]
+        |       |               |--ELIST -> ELIST [10:34]
+        |       |               |   `--EXPR -> EXPR [10:34]
+        |       |               |       `--LITERAL_NULL -> null [10:34]
+        |       |               `--RPAREN -> ) [10:38]
+        |       |--SEMI -> ; [10:39]
+        |       `--RCURLY -> } [11:4]
+        |--METHOD_DEF -> METHOD_DEF [13:4]
+        |   |--MODIFIERS -> MODIFIERS [13:4]
+        |   |--TYPE -> TYPE [13:4]
+        |   |   `--LITERAL_INT -> int [13:4]
+        |   |--IDENT -> m2 [13:8]
+        |   |--LPAREN -> ( [13:10]
+        |   |--PARAMETERS -> PARAMETERS [13:11]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [13:11]
+        |   |       |--MODIFIERS -> MODIFIERS [13:11]
+        |   |       |--TYPE -> TYPE [13:11]
+        |   |       |   |--IDENT -> Box [13:11]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:14]
+        |   |       |       |--GENERIC_START -> < [13:14]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:15]
+        |   |       |       |   `--IDENT -> String [13:15]
+        |   |       |       `--GENERIC_END -> > [13:21]
+        |   |       `--IDENT -> b [13:23]
+        |   |--RPAREN -> ) [13:24]
+        |   `--SLIST -> { [13:26]
+        |       |--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]
+        |       |   `--LITERAL_RETURN -> return [14:48]
+        |       |       |--EXPR -> EXPR [14:55]
+        |       |       |   `--NUM_INT -> 1 [14:55]
+        |       |       `--SEMI -> ; [14:56]
+        |       |--LITERAL_IF -> if [15:8]
+        |       |   |--LPAREN -> ( [15:11]
+        |       |   |--EXPR -> EXPR [18:12]
+        |       |   |   `--LAND -> && [18:12]
+        |       |   |       |--LAND -> && [17:12]
+        |       |   |       |   |--LAND -> && [16:12]
+        |       |   |       |   |   |--LITERAL_INSTANCEOF -> instanceof [15:14]
+        |       |   |       |   |   |   |--IDENT -> b [15:12]
+        |       |   |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [15:25]
+        |       |   |       |   |   |       |--MODIFIERS -> MODIFIERS [15:25]
+        |       |   |       |   |   |       |--TYPE -> TYPE [15:25]
+        |       |   |       |   |   |       |   |--IDENT -> Box [15:25]
+        |       |   |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:28]
+        |       |   |       |   |   |       |       |--GENERIC_START -> < [15:28]
+        |       |   |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:29]
+        |       |   |       |   |   |       |       |   `--IDENT -> String [15:29]
+        |       |   |       |   |   |       |       `--GENERIC_END -> > [15:35]
+        |       |   |       |   |   |       |--LPAREN -> ( [15:36]
+        |       |   |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [15:37]
+        |       |   |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [15:37]
+        |       |   |       |   |   |       |       |--MODIFIERS -> MODIFIERS [15:37]
+        |       |   |       |   |   |       |       |--TYPE -> TYPE [15:37]
+        |       |   |       |   |   |       |       |   `--IDENT -> String [15:37]
+        |       |   |       |   |   |       |       `--IDENT -> s [15:44]
+        |       |   |       |   |   |       `--RPAREN -> ) [15:45]
+        |       |   |       |   |   `--NOT_EQUAL -> != [16:19]
+        |       |   |       |   |       |--DOT -> . [16:16]
+        |       |   |       |   |       |   |--IDENT -> b [16:15]
+        |       |   |       |   |       |   `--IDENT -> v [16:17]
+        |       |   |       |   |       `--LITERAL_NULL -> null [16:22]
+        |       |   |       |   `--NOT_EQUAL -> != [17:21]
+        |       |   |       |       |--METHOD_CALL -> ( [17:18]
+        |       |   |       |       |   |--DOT -> . [17:16]
+        |       |   |       |       |   |   |--IDENT -> b [17:15]
+        |       |   |       |       |   |   `--IDENT -> v [17:17]
+        |       |   |       |       |   |--ELIST -> ELIST [17:19]
+        |       |   |       |       |   `--RPAREN -> ) [17:19]
+        |       |   |       |       `--LITERAL_NULL -> null [17:24]
+        |       |   |       `--METHOD_CALL -> ( [18:32]
+        |       |   |           |--DOT -> . [18:25]
+        |       |   |           |   |--STRING_LITERAL -> "whatever" [18:15]
+        |       |   |           |   `--IDENT -> equals [18:26]
+        |       |   |           |--ELIST -> ELIST [18:34]
+        |       |   |           |   `--EXPR -> EXPR [18:34]
+        |       |   |           |       `--DOT -> . [18:34]
+        |       |   |           |           |--IDENT -> b [18:33]
+        |       |   |           |           `--IDENT -> v [18:35]
+        |       |   |           `--RPAREN -> ) [18:36]
+        |       |   |--RPAREN -> ) [18:37]
+        |       |   `--LITERAL_RETURN -> return [18:39]
+        |       |       |--EXPR -> EXPR [18:46]
+        |       |       |   `--NUM_INT -> 1 [18:46]
+        |       |       `--SEMI -> ; [18:47]
+        |       |--LITERAL_RETURN -> return [19:8]
+        |       |   |--EXPR -> EXPR [19:15]
+        |       |   |   `--UNARY_MINUS -> - [19:15]
+        |       |   |       `--NUM_INT -> 1 [19:16]
+        |       |   `--SEMI -> ; [19:17]
+        |       `--RCURLY -> } [20:4]
+        |--METHOD_DEF -> METHOD_DEF [22:4]
+        |   |--MODIFIERS -> MODIFIERS [22:4]
+        |   |--TYPE -> TYPE [22:4]
+        |   |   `--LITERAL_INT -> int [22:4]
+        |   |--IDENT -> m3 [22:8]
+        |   |--LPAREN -> ( [22:10]
+        |   |--PARAMETERS -> PARAMETERS [22:11]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [22:11]
+        |   |       |--MODIFIERS -> MODIFIERS [22:11]
+        |   |       |--TYPE -> TYPE [22:11]
+        |   |       |   |--IDENT -> Box [22:11]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [22:14]
+        |   |       |       |--GENERIC_START -> < [22:14]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [22:15]
+        |   |       |       |   `--IDENT -> String [22:15]
+        |   |       |       `--GENERIC_END -> > [22:21]
+        |   |       `--IDENT -> b [22:23]
+        |   |--RPAREN -> ) [22:24]
+        |   `--SLIST -> { [22:26]
+        |       |--LITERAL_SWITCH -> switch [23:8]
+        |       |   |--LPAREN -> ( [23:15]
+        |       |   |--EXPR -> EXPR [23:16]
+        |       |   |   `--IDENT -> b [23:16]
+        |       |   |--RPAREN -> ) [23:17]
+        |       |   |--LCURLY -> { [23:19]
+        |       |   |--CASE_GROUP -> CASE_GROUP [24:12]
+        |       |   |   |--LITERAL_CASE -> case [24:12]
+        |       |   |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:17]
+        |       |   |   |   |   |--MODIFIERS -> MODIFIERS [24:17]
+        |       |   |   |   |   |--TYPE -> TYPE [24:17]
+        |       |   |   |   |   |   |--IDENT -> Box [24:17]
+        |       |   |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [24:20]
+        |       |   |   |   |   |       |--GENERIC_START -> < [24:20]
+        |       |   |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [24:21]
+        |       |   |   |   |   |       |   `--IDENT -> String [24:21]
+        |       |   |   |   |   |       `--GENERIC_END -> > [24:27]
+        |       |   |   |   |   |--LPAREN -> ( [24:28]
+        |       |   |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:29]
+        |       |   |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:29]
+        |       |   |   |   |   |       |--MODIFIERS -> MODIFIERS [24:29]
+        |       |   |   |   |   |       |--TYPE -> TYPE [24:29]
+        |       |   |   |   |   |       |   `--IDENT -> String [24:29]
+        |       |   |   |   |   |       `--IDENT -> s [24:36]
+        |       |   |   |   |   `--RPAREN -> ) [24:37]
+        |       |   |   |   `--COLON -> : [24:38]
+        |       |   |   `--SLIST -> SLIST [24:40]
+        |       |   |       `--LITERAL_RETURN -> return [24:40]
+        |       |   |           |--EXPR -> EXPR [24:47]
+        |       |   |           |   `--NUM_INT -> 1 [24:47]
+        |       |   |           `--SEMI -> ; [24:48]
+        |       |   |--CASE_GROUP -> CASE_GROUP [25:12]
+        |       |   |   |--LITERAL_DEFAULT -> default [25:12]
+        |       |   |   |   `--COLON -> : [25:19]
+        |       |   |   `--SLIST -> SLIST [25:21]
+        |       |   |       `--LITERAL_RETURN -> return [25:21]
+        |       |   |           |--EXPR -> EXPR [25:28]
+        |       |   |           |   `--UNARY_MINUS -> - [25:28]
+        |       |   |           |       `--NUM_INT -> 1 [25:29]
+        |       |   |           `--SEMI -> ; [25:30]
+        |       |   `--RCURLY -> } [26:8]
+        |       `--RCURLY -> } [27:4]
+        |--METHOD_DEF -> METHOD_DEF [29:4]
+        |   |--MODIFIERS -> MODIFIERS [29:4]
+        |   |--TYPE -> TYPE [29:4]
+        |   |   `--LITERAL_INT -> int [29:4]
+        |   |--IDENT -> m4 [29:8]
+        |   |--LPAREN -> ( [29:10]
+        |   |--PARAMETERS -> PARAMETERS [29:11]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [29:11]
+        |   |       |--MODIFIERS -> MODIFIERS [29:11]
+        |   |       |--TYPE -> TYPE [29:11]
+        |   |       |   |--IDENT -> Box [29:11]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [29:14]
+        |   |       |       |--GENERIC_START -> < [29:14]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [29:15]
+        |   |       |       |   `--IDENT -> String [29:15]
+        |   |       |       `--GENERIC_END -> > [29:21]
+        |   |       `--IDENT -> b [29:23]
+        |   |--RPAREN -> ) [29:24]
+        |   `--SLIST -> { [29:26]
+        |       |--LITERAL_RETURN -> return [30:8]
+        |       |   |--EXPR -> EXPR [30:15]
+        |       |   |   `--LITERAL_SWITCH -> switch [30:15]
+        |       |   |       |--LPAREN -> ( [30:22]
+        |       |   |       |--EXPR -> EXPR [30:23]
+        |       |   |       |   `--IDENT -> b [30:23]
+        |       |   |       |--RPAREN -> ) [30:24]
+        |       |   |       |--LCURLY -> { [30:26]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [31:12]
+        |       |   |       |   |--LITERAL_CASE -> case [31:12]
+        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [31:17]
+        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [31:17]
+        |       |   |       |   |       |--TYPE -> TYPE [31:17]
+        |       |   |       |   |       |   |--IDENT -> Box [31:17]
+        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:20]
+        |       |   |       |   |       |       |--GENERIC_START -> < [31:20]
+        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:21]
+        |       |   |       |   |       |       |   `--IDENT -> String [31:21]
+        |       |   |       |   |       |       `--GENERIC_END -> > [31:27]
+        |       |   |       |   |       |--LPAREN -> ( [31:28]
+        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [31:29]
+        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [31:29]
+        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [31:29]
+        |       |   |       |   |       |       |--TYPE -> TYPE [31:29]
+        |       |   |       |   |       |       |   `--IDENT -> String [31:29]
+        |       |   |       |   |       |       `--IDENT -> s [31:36]
+        |       |   |       |   |       `--RPAREN -> ) [31:37]
+        |       |   |       |   |--LAMBDA -> -> [31:39]
+        |       |   |       |   |--EXPR -> EXPR [31:42]
+        |       |   |       |   |   `--NUM_INT -> 1 [31:42]
+        |       |   |       |   `--SEMI -> ; [31:43]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [32:12]
+        |       |   |       |   |--LITERAL_DEFAULT -> default [32:12]
+        |       |   |       |   |--LAMBDA -> -> [32:20]
+        |       |   |       |   |--EXPR -> EXPR [32:23]
+        |       |   |       |   |   `--UNARY_MINUS -> - [32:23]
+        |       |   |       |   |       `--NUM_INT -> 1 [32:24]
+        |       |   |       |   `--SEMI -> ; [32:25]
+        |       |   |       `--RCURLY -> } [33:8]
+        |       |   `--SEMI -> ; [33:9]
+        |       `--RCURLY -> } [34:4]
+        |--METHOD_DEF -> METHOD_DEF [36:4]
+        |   |--MODIFIERS -> MODIFIERS [36:4]
+        |   |--TYPE -> TYPE [36:4]
+        |   |   `--LITERAL_INT -> int [36:4]
+        |   |--IDENT -> m5 [36:8]
+        |   |--LPAREN -> ( [36:10]
+        |   |--PARAMETERS -> PARAMETERS [36:11]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [36:11]
+        |   |       |--MODIFIERS -> MODIFIERS [36:11]
+        |   |       |--TYPE -> TYPE [36:11]
+        |   |       |   |--IDENT -> Box [36:11]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:14]
+        |   |       |       |--GENERIC_START -> < [36:14]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:15]
+        |   |       |       |   |--IDENT -> Box [36:15]
+        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:18]
+        |   |       |       |       |--GENERIC_START -> < [36:18]
+        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:19]
+        |   |       |       |       |   `--IDENT -> String [36:19]
+        |   |       |       |       `--GENERIC_END -> > [36:25]
+        |   |       |       `--GENERIC_END -> > [36:26]
+        |   |       `--IDENT -> b [36:28]
+        |   |--RPAREN -> ) [36:29]
+        |   `--SLIST -> { [36:31]
+        |       |--LITERAL_RETURN -> return [37:8]
+        |       |   |--EXPR -> EXPR [37:15]
+        |       |   |   `--LITERAL_SWITCH -> switch [37:15]
+        |       |   |       |--LPAREN -> ( [37:22]
+        |       |   |       |--EXPR -> EXPR [37:23]
+        |       |   |       |   `--IDENT -> b [37:23]
+        |       |   |       |--RPAREN -> ) [37:24]
+        |       |   |       |--LCURLY -> { [37:26]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [38:12]
+        |       |   |       |   |--LITERAL_CASE -> case [38:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [39:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [39:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [38:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [38:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [38:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [38:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [38:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [38:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [38:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [38:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [38:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [38:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [38:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [38:34]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [38:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [38:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [38:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [38:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [38:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:38]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [38:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [38:44]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [38:45]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [38:46]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [38:46]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [38:46]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [38:46]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [38:46]
+        |       |   |       |   |           |   |       |       `--IDENT -> s [38:53]
+        |       |   |       |   |           |   |       |--RPAREN -> ) [38:54]
+        |       |   |       |   |           |   |       `--IDENT -> box [38:55]
+        |       |   |       |   |           |   `--RPAREN -> ) [38:58]
+        |       |   |       |   |           `--LAND -> && [39:42]
+        |       |   |       |   |               |--METHOD_CALL -> ( [39:38]
+        |       |   |       |   |               |   |--DOT -> . [39:31]
+        |       |   |       |   |               |   |   |--STRING_LITERAL -> "test" [39:25]
+        |       |   |       |   |               |   |   `--IDENT -> equals [39:32]
+        |       |   |       |   |               |   |--ELIST -> ELIST [39:39]
+        |       |   |       |   |               |   |   `--EXPR -> EXPR [39:39]
+        |       |   |       |   |               |   |       `--IDENT -> s [39:39]
+        |       |   |       |   |               |   `--RPAREN -> ) [39:40]
+        |       |   |       |   |               `--NOT_EQUAL -> != [39:51]
+        |       |   |       |   |                   |--DOT -> . [39:48]
+        |       |   |       |   |                   |   |--IDENT -> box [39:45]
+        |       |   |       |   |                   |   `--IDENT -> x [39:49]
+        |       |   |       |   |                   `--NUM_INT -> 7 [39:54]
+        |       |   |       |   |--LAMBDA -> -> [39:57]
+        |       |   |       |   |--EXPR -> EXPR [39:60]
+        |       |   |       |   |   `--NUM_INT -> 1 [39:60]
+        |       |   |       |   `--SEMI -> ; [39:61]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [40:12]
+        |       |   |       |   |--LITERAL_CASE -> case [40:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [41:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [41:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [40:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [40:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [40:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [40:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [40:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [40:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [40:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [40:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [40:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [40:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [40:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [40:34]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [40:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [40:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [40:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [40:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [40:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:38]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [40:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [40:44]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [40:45]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [40:46]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [40:46]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [40:46]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [40:46]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [40:46]
+        |       |   |       |   |           |   |       |       `--IDENT -> s [40:53]
+        |       |   |       |   |           |   |       |--RPAREN -> ) [40:54]
+        |       |   |       |   |           |   |       `--IDENT -> box [40:55]
+        |       |   |       |   |           |   `--RPAREN -> ) [40:58]
+        |       |   |       |   |           `--LAND -> && [41:42]
+        |       |   |       |   |               |--METHOD_CALL -> ( [41:38]
+        |       |   |       |   |               |   |--DOT -> . [41:31]
+        |       |   |       |   |               |   |   |--STRING_LITERAL -> "test" [41:25]
+        |       |   |       |   |               |   |   `--IDENT -> equals [41:32]
+        |       |   |       |   |               |   |--ELIST -> ELIST [41:39]
+        |       |   |       |   |               |   |   `--EXPR -> EXPR [41:39]
+        |       |   |       |   |               |   |       `--IDENT -> s [41:39]
+        |       |   |       |   |               |   `--RPAREN -> ) [41:40]
+        |       |   |       |   |               `--NOT_EQUAL -> != [41:57]
+        |       |   |       |   |                   |--TYPECAST -> ( [41:45]
+        |       |   |       |   |                   |   |--TYPE -> TYPE [41:46]
+        |       |   |       |   |                   |   |   `--LITERAL_INT -> int [41:46]
+        |       |   |       |   |                   |   |--RPAREN -> ) [41:49]
+        |       |   |       |   |                   |   `--DOT -> . [41:54]
+        |       |   |       |   |                   |       |--IDENT -> box [41:51]
+        |       |   |       |   |                   |       `--IDENT -> x [41:55]
+        |       |   |       |   |                   `--NUM_INT -> 7 [41:60]
+        |       |   |       |   |--LAMBDA -> -> [41:63]
+        |       |   |       |   |--EXPR -> EXPR [41:66]
+        |       |   |       |   |   `--NUM_INT -> 1 [41:66]
+        |       |   |       |   `--SEMI -> ; [41:67]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [42:12]
+        |       |   |       |   |--LITERAL_CASE -> case [42:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [43:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [43:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [42:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [42:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [42:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [42:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [42:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [42:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [42:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [42:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [42:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [42:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [42:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [42:34]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [42:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [42:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [42:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [42:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [42:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:38]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [42:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [42:44]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [42:45]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [42:46]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [42:46]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [42:46]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [42:46]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [42:46]
+        |       |   |       |   |           |   |       |       `--IDENT -> s [42:53]
+        |       |   |       |   |           |   |       |--RPAREN -> ) [42:54]
+        |       |   |       |   |           |   |       `--IDENT -> box [42:55]
+        |       |   |       |   |           |   `--RPAREN -> ) [42:58]
+        |       |   |       |   |           `--LAND -> && [43:42]
+        |       |   |       |   |               |--METHOD_CALL -> ( [43:38]
+        |       |   |       |   |               |   |--DOT -> . [43:31]
+        |       |   |       |   |               |   |   |--STRING_LITERAL -> "test" [43:25]
+        |       |   |       |   |               |   |   `--IDENT -> equals [43:32]
+        |       |   |       |   |               |   |--ELIST -> ELIST [43:39]
+        |       |   |       |   |               |   |   `--EXPR -> EXPR [43:39]
+        |       |   |       |   |               |   |       `--IDENT -> s [43:39]
+        |       |   |       |   |               |   `--RPAREN -> ) [43:40]
+        |       |   |       |   |               `--METHOD_CALL -> ( [43:59]
+        |       |   |       |   |                   |--DOT -> . [43:52]
+        |       |   |       |   |                   |   |--IDENT -> Objects [43:45]
+        |       |   |       |   |                   |   `--IDENT -> equals [43:53]
+        |       |   |       |   |                   |--ELIST -> ELIST [43:63]
+        |       |   |       |   |                   |   |--EXPR -> EXPR [43:63]
+        |       |   |       |   |                   |   |   `--DOT -> . [43:63]
+        |       |   |       |   |                   |   |       |--IDENT -> box [43:60]
+        |       |   |       |   |                   |   |       `--IDENT -> v [43:64]
+        |       |   |       |   |                   |   |--COMMA -> , [43:65]
+        |       |   |       |   |                   |   `--EXPR -> EXPR [43:67]
+        |       |   |       |   |                   |       `--STRING_LITERAL -> "box" [43:67]
+        |       |   |       |   |                   `--RPAREN -> ) [43:72]
+        |       |   |       |   |--LAMBDA -> -> [43:74]
+        |       |   |       |   |--EXPR -> EXPR [43:77]
+        |       |   |       |   |   `--NUM_INT -> 1 [43:77]
+        |       |   |       |   `--SEMI -> ; [43:78]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [44:12]
+        |       |   |       |   |--LITERAL_CASE -> case [44:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [45:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [45:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [44:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [44:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [44:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [44:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [44:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [44:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [44:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [44:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [44:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [44:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [44:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [44:34]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [44:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [44:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [44:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [44:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [44:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:38]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [44:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [44:44]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [44:45]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [44:46]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [44:46]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [44:46]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [44:46]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [44:46]
+        |       |   |       |   |           |   |       |       `--IDENT -> s [44:53]
+        |       |   |       |   |           |   |       |--RPAREN -> ) [44:54]
+        |       |   |       |   |           |   |       `--IDENT -> box [44:55]
+        |       |   |       |   |           |   `--RPAREN -> ) [44:58]
+        |       |   |       |   |           `--LOR -> || [46:24]
+        |       |   |       |   |               |--LAND -> && [45:42]
+        |       |   |       |   |               |   |--METHOD_CALL -> ( [45:38]
+        |       |   |       |   |               |   |   |--DOT -> . [45:31]
+        |       |   |       |   |               |   |   |   |--STRING_LITERAL -> "test" [45:25]
+        |       |   |       |   |               |   |   |   `--IDENT -> equals [45:32]
+        |       |   |       |   |               |   |   |--ELIST -> ELIST [45:39]
+        |       |   |       |   |               |   |   |   `--EXPR -> EXPR [45:39]
+        |       |   |       |   |               |   |   |       `--IDENT -> s [45:39]
+        |       |   |       |   |               |   |   `--RPAREN -> ) [45:40]
+        |       |   |       |   |               |   `--METHOD_CALL -> ( [45:59]
+        |       |   |       |   |               |       |--DOT -> . [45:52]
+        |       |   |       |   |               |       |   |--IDENT -> Objects [45:45]
+        |       |   |       |   |               |       |   `--IDENT -> equals [45:53]
+        |       |   |       |   |               |       |--ELIST -> ELIST [45:63]
+        |       |   |       |   |               |       |   |--EXPR -> EXPR [45:63]
+        |       |   |       |   |               |       |   |   `--DOT -> . [45:63]
+        |       |   |       |   |               |       |   |       |--IDENT -> box [45:60]
+        |       |   |       |   |               |       |   |       `--IDENT -> v [45:64]
+        |       |   |       |   |               |       |   |--COMMA -> , [45:65]
+        |       |   |       |   |               |       |   `--EXPR -> EXPR [45:67]
+        |       |   |       |   |               |       |       `--STRING_LITERAL -> "box" [45:67]
+        |       |   |       |   |               |       `--RPAREN -> ) [45:72]
+        |       |   |       |   |               `--METHOD_CALL -> ( [46:50]
+        |       |   |       |   |                   |--DOT -> . [46:43]
+        |       |   |       |   |                   |   |--STRING_LITERAL -> "something else" [46:27]
+        |       |   |       |   |                   |   `--IDENT -> equals [46:44]
+        |       |   |       |   |                   |--ELIST -> ELIST [46:51]
+        |       |   |       |   |                   |   `--EXPR -> EXPR [46:51]
+        |       |   |       |   |                   |       `--IDENT -> s [46:51]
+        |       |   |       |   |                   `--RPAREN -> ) [46:52]
+        |       |   |       |   |--LAMBDA -> -> [46:54]
+        |       |   |       |   |--EXPR -> EXPR [46:57]
+        |       |   |       |   |   `--NUM_INT -> 1 [46:57]
+        |       |   |       |   `--SEMI -> ; [46:58]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [47:12]
+        |       |   |       |   |--LITERAL_CASE -> case [47:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [48:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [48:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [47:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [47:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [47:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [47:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [47:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [47:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [47:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [47:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [47:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [47:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [47:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [47:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [47:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [47:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [47:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [47:34]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [47:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [47:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [47:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [47:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [47:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [47:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [47:38]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [47:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [47:44]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [47:45]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [47:46]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [47:46]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [47:46]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [47:46]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [47:46]
+        |       |   |       |   |           |   |       |       `--IDENT -> s [47:53]
+        |       |   |       |   |           |   |       `--RPAREN -> ) [47:54]
+        |       |   |       |   |           |   `--RPAREN -> ) [47:55]
+        |       |   |       |   |           `--METHOD_CALL -> ( [48:38]
+        |       |   |       |   |               |--DOT -> . [48:31]
+        |       |   |       |   |               |   |--STRING_LITERAL -> "test" [48:25]
+        |       |   |       |   |               |   `--IDENT -> equals [48:32]
+        |       |   |       |   |               |--ELIST -> ELIST [48:39]
+        |       |   |       |   |               |   `--EXPR -> EXPR [48:39]
+        |       |   |       |   |               |       `--IDENT -> s [48:39]
+        |       |   |       |   |               `--RPAREN -> ) [48:40]
+        |       |   |       |   |--LAMBDA -> -> [48:42]
+        |       |   |       |   |--EXPR -> EXPR [48:45]
+        |       |   |       |   |   `--NUM_INT -> 1 [48:45]
+        |       |   |       |   `--SEMI -> ; [48:46]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [49:12]
+        |       |   |       |   |--LITERAL_CASE -> case [49:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [50:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [50:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [49:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [49:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [49:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [49:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [49:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [49:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [49:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [49:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [49:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [49:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [49:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [49:34]
+        |       |   |       |   |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [49:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [49:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [49:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [49:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [49:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:38]
+        |       |   |       |   |           |   |       |       |   `--WILDCARD_TYPE -> ? [49:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [49:39]
+        |       |   |       |   |           |   |       `--IDENT -> b2 [49:41]
+        |       |   |       |   |           |   `--RPAREN -> ) [49:43]
+        |       |   |       |   |           `--METHOD_CALL -> ( [50:38]
+        |       |   |       |   |               |--DOT -> . [50:31]
+        |       |   |       |   |               |   |--STRING_LITERAL -> "test" [50:25]
+        |       |   |       |   |               |   `--IDENT -> equals [50:32]
+        |       |   |       |   |               |--ELIST -> ELIST [50:41]
+        |       |   |       |   |               |   `--EXPR -> EXPR [50:41]
+        |       |   |       |   |               |       `--DOT -> . [50:41]
+        |       |   |       |   |               |           |--IDENT -> b2 [50:39]
+        |       |   |       |   |               |           `--IDENT -> v [50:42]
+        |       |   |       |   |               `--RPAREN -> ) [50:43]
+        |       |   |       |   |--LAMBDA -> -> [50:45]
+        |       |   |       |   |--EXPR -> EXPR [50:48]
+        |       |   |       |   |   `--NUM_INT -> 1 [50:48]
+        |       |   |       |   `--SEMI -> ; [50:49]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [51:12]
+        |       |   |       |   |--LITERAL_CASE -> case [51:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [52:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [52:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [51:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [51:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [51:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [51:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [51:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [51:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [51:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [51:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [51:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [51:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [51:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [51:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [51:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [51:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [51:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [51:34]
+        |       |   |       |   |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [51:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [51:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [51:34]
+        |       |   |       |   |           |   |       |   `--IDENT -> Object [51:34]
+        |       |   |       |   |           |   |       `--IDENT -> o [51:41]
+        |       |   |       |   |           |   |--RPAREN -> ) [51:42]
+        |       |   |       |   |           |   `--IDENT -> b2 [51:44]
+        |       |   |       |   |           `--LAND -> && [52:38]
+        |       |   |       |   |               |--NOT_EQUAL -> != [52:30]
+        |       |   |       |   |               |   |--DOT -> . [52:27]
+        |       |   |       |   |               |   |   |--IDENT -> b2 [52:25]
+        |       |   |       |   |               |   |   `--IDENT -> v [52:28]
+        |       |   |       |   |               |   `--LITERAL_NULL -> null [52:33]
+        |       |   |       |   |               `--METHOD_CALL -> ( [52:58]
+        |       |   |       |   |                   |--DOT -> . [52:51]
+        |       |   |       |   |                   |   |--STRING_LITERAL -> "whatever" [52:41]
+        |       |   |       |   |                   |   `--IDENT -> equals [52:52]
+        |       |   |       |   |                   |--ELIST -> ELIST [52:69]
+        |       |   |       |   |                   |   `--EXPR -> EXPR [52:69]
+        |       |   |       |   |                   |       `--METHOD_CALL -> ( [52:69]
+        |       |   |       |   |                   |           |--DOT -> . [52:60]
+        |       |   |       |   |                   |           |   |--IDENT -> o [52:59]
+        |       |   |       |   |                   |           |   `--IDENT -> toString [52:61]
+        |       |   |       |   |                   |           |--ELIST -> ELIST [52:70]
+        |       |   |       |   |                   |           `--RPAREN -> ) [52:70]
+        |       |   |       |   |                   `--RPAREN -> ) [52:71]
+        |       |   |       |   |--LAMBDA -> -> [52:72]
+        |       |   |       |   |--EXPR -> EXPR [52:75]
+        |       |   |       |   |   `--NUM_INT -> 1 [52:75]
+        |       |   |       |   `--SEMI -> ; [52:76]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [53:12]
+        |       |   |       |   |--LITERAL_DEFAULT -> default [53:12]
+        |       |   |       |   |--LAMBDA -> -> [53:20]
+        |       |   |       |   |--EXPR -> EXPR [53:23]
+        |       |   |       |   |   `--UNARY_MINUS -> - [53:23]
+        |       |   |       |   |       `--NUM_INT -> 1 [53:24]
+        |       |   |       |   `--SEMI -> ; [53:25]
+        |       |   |       `--RCURLY -> } [54:8]
+        |       |   `--SEMI -> ; [54:9]
+        |       `--RCURLY -> } [55:4]
+        |--RECORD_DEF -> RECORD_DEF [57:4]
+        |   |--MODIFIERS -> MODIFIERS [57:4]
+        |   |--LITERAL_RECORD -> record [57:4]
+        |   |--IDENT -> Box [57:11]
+        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [57:14]
+        |   |   |--GENERIC_START -> < [57:14]
+        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [57:15]
+        |   |   |   `--IDENT -> V [57:15]
+        |   |   `--GENERIC_END -> > [57:16]
+        |   |--LPAREN -> ( [57:17]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [57:18]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [57:18]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [57:18]
+        |   |       |--TYPE -> TYPE [57:18]
+        |   |       |   `--IDENT -> V [57:18]
+        |   |       `--IDENT -> v [57:20]
+        |   |--RPAREN -> ) [57:21]
+        |   `--OBJBLOCK -> OBJBLOCK [57:23]
+        |       |--LCURLY -> { [57:23]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [58:8]
+        |       |   |--MODIFIERS -> MODIFIERS [58:8]
+        |       |   |   `--LITERAL_STATIC -> static [58:8]
+        |       |   |--TYPE -> TYPE [58:15]
+        |       |   |   `--LITERAL_INT -> int [58:15]
+        |       |   |--IDENT -> x [58:19]
+        |       |   |--ASSIGN -> = [58:21]
+        |       |   |   `--EXPR -> EXPR [58:23]
+        |       |   |       `--NUM_INT -> 5 [58:23]
+        |       |   `--SEMI -> ; [58:24]
+        |       `--RCURLY -> } [59:4]
+        `--RCURLY -> } [61:0]
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19BindingWithModifiers.txt b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19BindingWithModifiers.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19BindingWithModifiers.txt
@@ -0,0 +1,1176 @@
+COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
+|--PACKAGE_DEF -> package [2:0]
+|   |--ANNOTATIONS -> ANNOTATIONS [2:47]
+|   |--DOT -> . [2:47]
+|   |   |--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]
+|   |   `--IDENT -> java19 [2:48]
+|   `--SEMI -> ; [2:54]
+`--CLASS_DEF -> CLASS_DEF [4:0]
+    |--MODIFIERS -> MODIFIERS [4:0]
+    |   `--LITERAL_PUBLIC -> public [4:0]
+    |--LITERAL_CLASS -> class [4:7]
+    |--IDENT -> InputJava19BindingWithModifiers [4:13]
+    `--OBJBLOCK -> OBJBLOCK [4:45]
+        |--LCURLY -> { [4:45]
+        |--RECORD_DEF -> RECORD_DEF [5:4]
+        |   |--MODIFIERS -> MODIFIERS [5:4]
+        |   |--LITERAL_RECORD -> record [5:4]
+        |   |--IDENT -> Box [5:11]
+        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [5:14]
+        |   |   |--GENERIC_START -> < [5:14]
+        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [5:15]
+        |   |   |   `--IDENT -> T [5:15]
+        |   |   `--GENERIC_END -> > [5:16]
+        |   |--LPAREN -> ( [5:17]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [5:18]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [5:18]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [5:18]
+        |   |       |--TYPE -> TYPE [5:18]
+        |   |       |   `--IDENT -> T [5:18]
+        |   |       `--IDENT -> t [5:20]
+        |   |--RPAREN -> ) [5:21]
+        |   `--OBJBLOCK -> OBJBLOCK [5:23]
+        |       |--LCURLY -> { [5:23]
+        |       `--RCURLY -> } [6:4]
+        |--CLASS_DEF -> CLASS_DEF [8:4]
+        |   |--MODIFIERS -> MODIFIERS [8:4]
+        |   |--LITERAL_CLASS -> class [8:4]
+        |   |--IDENT -> A [8:10]
+        |   `--OBJBLOCK -> OBJBLOCK [8:12]
+        |       |--LCURLY -> { [8:12]
+        |       `--RCURLY -> } [9:4]
+        |--CLASS_DEF -> CLASS_DEF [11:4]
+        |   |--MODIFIERS -> MODIFIERS [11:4]
+        |   |--LITERAL_CLASS -> class [11:4]
+        |   |--IDENT -> B [11:10]
+        |   |--EXTENDS_CLAUSE -> extends [11:12]
+        |   |   `--IDENT -> A [11:20]
+        |   `--OBJBLOCK -> OBJBLOCK [11:22]
+        |       |--LCURLY -> { [11:22]
+        |       `--RCURLY -> } [12:4]
+        |--INTERFACE_DEF -> INTERFACE_DEF [14:4]
+        |   |--MODIFIERS -> MODIFIERS [14:4]
+        |   |   `--LITERAL_SEALED -> sealed [14:4]
+        |   |--LITERAL_INTERFACE -> interface [14:11]
+        |   |--IDENT -> I [14:21]
+        |   |--PERMITS_CLAUSE -> permits [14:23]
+        |   |   |--IDENT -> C [14:31]
+        |   |   |--COMMA -> , [14:32]
+        |   |   `--IDENT -> D [14:34]
+        |   `--OBJBLOCK -> OBJBLOCK [14:36]
+        |       |--LCURLY -> { [14:36]
+        |       `--RCURLY -> } [15:4]
+        |--CLASS_DEF -> CLASS_DEF [17:4]
+        |   |--MODIFIERS -> MODIFIERS [17:4]
+        |   |   `--FINAL -> final [17:4]
+        |   |--LITERAL_CLASS -> class [17:10]
+        |   |--IDENT -> C [17:16]
+        |   |--IMPLEMENTS_CLAUSE -> implements [17:18]
+        |   |   `--IDENT -> I [17:29]
+        |   `--OBJBLOCK -> OBJBLOCK [17:31]
+        |       |--LCURLY -> { [17:31]
+        |       `--RCURLY -> } [18:4]
+        |--CLASS_DEF -> CLASS_DEF [20:4]
+        |   |--MODIFIERS -> MODIFIERS [20:4]
+        |   |   `--FINAL -> final [20:4]
+        |   |--LITERAL_CLASS -> class [20:10]
+        |   |--IDENT -> D [20:16]
+        |   |--IMPLEMENTS_CLAUSE -> implements [20:18]
+        |   |   `--IDENT -> I [20:29]
+        |   `--OBJBLOCK -> OBJBLOCK [20:31]
+        |       |--LCURLY -> { [20:31]
+        |       `--RCURLY -> } [21:4]
+        |--RECORD_DEF -> RECORD_DEF [23:4]
+        |   |--MODIFIERS -> MODIFIERS [23:4]
+        |   |--LITERAL_RECORD -> record [23:4]
+        |   |--IDENT -> Pair [23:11]
+        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [23:15]
+        |   |   |--GENERIC_START -> < [23:15]
+        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [23:16]
+        |   |   |   `--IDENT -> T [23:16]
+        |   |   `--GENERIC_END -> > [23:17]
+        |   |--LPAREN -> ( [23:18]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [23:19]
+        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [23:19]
+        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [23:19]
+        |   |   |   |--TYPE -> TYPE [23:19]
+        |   |   |   |   `--IDENT -> T [23:19]
+        |   |   |   `--IDENT -> x [23:21]
+        |   |   |--COMMA -> , [23:22]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [23:24]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [23:24]
+        |   |       |--TYPE -> TYPE [23:24]
+        |   |       |   `--IDENT -> T [23:24]
+        |   |       `--IDENT -> y [23:26]
+        |   |--RPAREN -> ) [23:27]
+        |   `--OBJBLOCK -> OBJBLOCK [23:29]
+        |       |--LCURLY -> { [23:29]
+        |       `--RCURLY -> } [24:4]
+        |--ANNOTATION_DEF -> ANNOTATION_DEF [26:4]
+        |   |--MODIFIERS -> MODIFIERS [26:4]
+        |   |--AT -> @ [26:4]
+        |   |--LITERAL_INTERFACE -> interface [26:5]
+        |   |--IDENT -> MyAnno1 [26:15]
+        |   `--OBJBLOCK -> OBJBLOCK [26:22]
+        |       |--LCURLY -> { [26:22]
+        |       `--RCURLY -> } [26:23]
+        |--ANNOTATION_DEF -> ANNOTATION_DEF [27:4]
+        |   |--MODIFIERS -> MODIFIERS [27:4]
+        |   |--AT -> @ [27:4]
+        |   |--LITERAL_INTERFACE -> interface [27:5]
+        |   |--IDENT -> MyAnno2 [27:15]
+        |   `--OBJBLOCK -> OBJBLOCK [27:22]
+        |       |--LCURLY -> { [27:22]
+        |       `--RCURLY -> } [27:23]
+        |--ANNOTATION_DEF -> ANNOTATION_DEF [29:4]
+        |   |--MODIFIERS -> MODIFIERS [29:4]
+        |   |--AT -> @ [29:4]
+        |   |--LITERAL_INTERFACE -> interface [29:5]
+        |   |--IDENT -> MyAnno3 [29:15]
+        |   `--OBJBLOCK -> OBJBLOCK [29:22]
+        |       |--LCURLY -> { [29:22]
+        |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [30:8]
+        |       |   |--MODIFIERS -> MODIFIERS [30:8]
+        |       |   |--TYPE -> TYPE [30:8]
+        |       |   |   `--IDENT -> String [30:8]
+        |       |   |--IDENT -> value [30:15]
+        |       |   |--LPAREN -> ( [30:20]
+        |       |   |--RPAREN -> ) [30:21]
+        |       |   `--SEMI -> ; [30:22]
+        |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [31:8]
+        |       |   |--MODIFIERS -> MODIFIERS [31:8]
+        |       |   |--TYPE -> TYPE [31:8]
+        |       |   |   |--IDENT -> String [31:8]
+        |       |   |   `--ARRAY_DECLARATOR -> [ [31:14]
+        |       |   |       `--RBRACK -> ] [31:15]
+        |       |   |--IDENT -> values [31:17]
+        |       |   |--LPAREN -> ( [31:23]
+        |       |   |--RPAREN -> ) [31:24]
+        |       |   `--SEMI -> ; [31:25]
+        |       `--RCURLY -> } [32:4]
+        |--RECORD_DEF -> RECORD_DEF [34:4]
+        |   |--MODIFIERS -> MODIFIERS [34:4]
+        |   |--LITERAL_RECORD -> record [34:4]
+        |   |--IDENT -> Tuple [34:11]
+        |   |--LPAREN -> ( [34:16]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [34:17]
+        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [34:17]
+        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [34:17]
+        |   |   |   |--TYPE -> TYPE [34:17]
+        |   |   |   |   `--IDENT -> Object [34:17]
+        |   |   |   `--IDENT -> o1 [34:24]
+        |   |   |--COMMA -> , [34:26]
+        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [34:28]
+        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [34:28]
+        |   |   |   |--TYPE -> TYPE [34:28]
+        |   |   |   |   `--IDENT -> Object [34:28]
+        |   |   |   `--IDENT -> o2 [34:35]
+        |   |   |--COMMA -> , [34:37]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [34:39]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [34:39]
+        |   |       |--TYPE -> TYPE [34:39]
+        |   |       |   `--IDENT -> Object [34:39]
+        |   |       `--IDENT -> o3 [34:46]
+        |   |--RPAREN -> ) [34:48]
+        |   `--OBJBLOCK -> OBJBLOCK [34:50]
+        |       |--LCURLY -> { [34:50]
+        |       `--RCURLY -> } [34:51]
+        |--RECORD_DEF -> RECORD_DEF [35:4]
+        |   |--MODIFIERS -> MODIFIERS [35:4]
+        |   |--LITERAL_RECORD -> record [35:4]
+        |   |--IDENT -> VarArgs [35:11]
+        |   |--LPAREN -> ( [35:18]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [35:19]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [35:19]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [35:19]
+        |   |       |--TYPE -> TYPE [35:19]
+        |   |       |   `--IDENT -> Object [35:19]
+        |   |       |--ELLIPSIS -> ... [35:25]
+        |   |       `--IDENT -> objArgs [35:29]
+        |   |--RPAREN -> ) [35:36]
+        |   `--OBJBLOCK -> OBJBLOCK [35:37]
+        |       |--LCURLY -> { [35:37]
+        |       `--RCURLY -> } [35:38]
+        |--METHOD_DEF -> METHOD_DEF [38:4]
+        |   |--MODIFIERS -> MODIFIERS [38:4]
+        |   |   `--LITERAL_STATIC -> static [38:4]
+        |   |--TYPE -> TYPE [38:11]
+        |   |   `--LITERAL_VOID -> void [38:11]
+        |   |--IDENT -> test1 [38:16]
+        |   |--LPAREN -> ( [38:21]
+        |   |--PARAMETERS -> PARAMETERS [38:22]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [38:22]
+        |   |       |--MODIFIERS -> MODIFIERS [38:22]
+        |   |       |--TYPE -> TYPE [38:22]
+        |   |       |   |--IDENT -> Box [38:22]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:25]
+        |   |       |       |--GENERIC_START -> < [38:25]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:26]
+        |   |       |       |   `--IDENT -> Object [38:26]
+        |   |       |       `--GENERIC_END -> > [38:32]
+        |   |       `--IDENT -> bo [38:34]
+        |   |--RPAREN -> ) [38:36]
+        |   `--SLIST -> { [38:38]
+        |       |--LITERAL_IF -> if [39:8]
+        |       |   |--LPAREN -> ( [39:11]
+        |       |   |--EXPR -> EXPR [39:15]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [39:15]
+        |       |   |       |--IDENT -> bo [39:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [39:26]
+        |       |   |           |--MODIFIERS -> MODIFIERS [39:26]
+        |       |   |           |   |--ANNOTATION -> ANNOTATION [39:26]
+        |       |   |           |   |   |--AT -> @ [39:26]
+        |       |   |           |   |   `--IDENT -> MyAnno1 [39:27]
+        |       |   |           |   `--ANNOTATION -> ANNOTATION [39:35]
+        |       |   |           |       |--AT -> @ [39:35]
+        |       |   |           |       `--IDENT -> MyAnno2 [39:36]
+        |       |   |           |--TYPE -> TYPE [39:44]
+        |       |   |           |   |--IDENT -> Box [39:44]
+        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:47]
+        |       |   |           |       |--GENERIC_START -> < [39:47]
+        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:48]
+        |       |   |           |       |   `--IDENT -> Object [39:48]
+        |       |   |           |       `--GENERIC_END -> > [39:54]
+        |       |   |           |--LPAREN -> ( [39:55]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [39:56]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [39:56]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [39:56]
+        |       |   |           |       |--TYPE -> TYPE [39:56]
+        |       |   |           |       |   `--IDENT -> String [39:56]
+        |       |   |           |       `--IDENT -> s [39:63]
+        |       |   |           `--RPAREN -> ) [39:64]
+        |       |   |--RPAREN -> ) [39:65]
+        |       |   `--SLIST -> { [39:67]
+        |       |       |--EXPR -> EXPR [40:30]
+        |       |       |   `--METHOD_CALL -> ( [40:30]
+        |       |       |       |--DOT -> . [40:22]
+        |       |       |       |   |--DOT -> . [40:18]
+        |       |       |       |   |   |--IDENT -> System [40:12]
+        |       |       |       |   |   `--IDENT -> out [40:19]
+        |       |       |       |   `--IDENT -> println [40:23]
+        |       |       |       |--ELIST -> ELIST [40:41]
+        |       |       |       |   `--EXPR -> EXPR [40:41]
+        |       |       |       |       `--PLUS -> + [40:41]
+        |       |       |       |           |--STRING_LITERAL -> "String " [40:31]
+        |       |       |       |           `--IDENT -> s [40:43]
+        |       |       |       `--RPAREN -> ) [40:44]
+        |       |       |--SEMI -> ; [40:45]
+        |       |       `--RCURLY -> } [41:8]
+        |       `--RCURLY -> } [42:4]
+        |--METHOD_DEF -> METHOD_DEF [44:4]
+        |   |--MODIFIERS -> MODIFIERS [44:4]
+        |   |   `--LITERAL_STATIC -> static [44:4]
+        |   |--TYPE -> TYPE [44:11]
+        |   |   `--LITERAL_VOID -> void [44:11]
+        |   |--IDENT -> test2 [44:16]
+        |   |--LPAREN -> ( [44:21]
+        |   |--PARAMETERS -> PARAMETERS [44:22]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [44:22]
+        |   |       |--MODIFIERS -> MODIFIERS [44:22]
+        |   |       |--TYPE -> TYPE [44:22]
+        |   |       |   |--IDENT -> Box [44:22]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:25]
+        |   |       |       |--GENERIC_START -> < [44:25]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:26]
+        |   |       |       |   `--IDENT -> Object [44:26]
+        |   |       |       `--GENERIC_END -> > [44:32]
+        |   |       `--IDENT -> bo [44:34]
+        |   |--RPAREN -> ) [44:36]
+        |   `--SLIST -> { [44:38]
+        |       |--LITERAL_IF -> if [45:8]
+        |       |   |--LPAREN -> ( [45:11]
+        |       |   |--EXPR -> EXPR [45:15]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [45:15]
+        |       |   |       |--IDENT -> bo [45:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [45:26]
+        |       |   |           |--MODIFIERS -> MODIFIERS [45:26]
+        |       |   |           |   |--ANNOTATION -> ANNOTATION [45:26]
+        |       |   |           |   |   |--AT -> @ [45:26]
+        |       |   |           |   |   `--IDENT -> MyAnno2 [45:27]
+        |       |   |           |   |--FINAL -> final [45:35]
+        |       |   |           |   `--ANNOTATION -> ANNOTATION [45:41]
+        |       |   |           |       |--AT -> @ [45:41]
+        |       |   |           |       `--IDENT -> MyAnno1 [45:42]
+        |       |   |           |--TYPE -> TYPE [45:50]
+        |       |   |           |   |--IDENT -> Box [45:50]
+        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:53]
+        |       |   |           |       |--GENERIC_START -> < [45:53]
+        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:54]
+        |       |   |           |       |   `--WILDCARD_TYPE -> ? [45:54]
+        |       |   |           |       `--GENERIC_END -> > [45:55]
+        |       |   |           |--LPAREN -> ( [45:56]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [45:57]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [45:57]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [45:57]
+        |       |   |           |       |--TYPE -> TYPE [45:57]
+        |       |   |           |       |   `--IDENT -> var [45:57]
+        |       |   |           |       `--IDENT -> s [45:61]
+        |       |   |           `--RPAREN -> ) [45:62]
+        |       |   |--RPAREN -> ) [45:63]
+        |       |   `--SLIST -> { [45:65]
+        |       |       |--EXPR -> EXPR [46:30]
+        |       |       |   `--METHOD_CALL -> ( [46:30]
+        |       |       |       |--DOT -> . [46:22]
+        |       |       |       |   |--DOT -> . [46:18]
+        |       |       |       |   |   |--IDENT -> System [46:12]
+        |       |       |       |   |   `--IDENT -> out [46:19]
+        |       |       |       |   `--IDENT -> println [46:23]
+        |       |       |       |--ELIST -> ELIST [46:41]
+        |       |       |       |   `--EXPR -> EXPR [46:41]
+        |       |       |       |       `--PLUS -> + [46:41]
+        |       |       |       |           |--STRING_LITERAL -> "String " [46:31]
+        |       |       |       |           `--IDENT -> s [46:43]
+        |       |       |       `--RPAREN -> ) [46:44]
+        |       |       |--SEMI -> ; [46:45]
+        |       |       `--RCURLY -> } [47:8]
+        |       `--RCURLY -> } [48:4]
+        |--METHOD_DEF -> METHOD_DEF [50:4]
+        |   |--MODIFIERS -> MODIFIERS [50:4]
+        |   |--TYPE -> TYPE [50:4]
+        |   |   `--LITERAL_VOID -> void [50:4]
+        |   |--IDENT -> test3 [50:9]
+        |   |--LPAREN -> ( [50:14]
+        |   |--PARAMETERS -> PARAMETERS [50:15]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [50:15]
+        |   |       |--MODIFIERS -> MODIFIERS [50:15]
+        |   |       |--TYPE -> TYPE [50:15]
+        |   |       |   |--IDENT -> Box [50:15]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [50:18]
+        |   |       |       |--GENERIC_START -> < [50:18]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [50:19]
+        |   |       |       |   `--IDENT -> I [50:19]
+        |   |       |       `--GENERIC_END -> > [50:20]
+        |   |       `--IDENT -> bo [50:22]
+        |   |--RPAREN -> ) [50:24]
+        |   `--SLIST -> { [50:26]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [51:8]
+        |       |   |--MODIFIERS -> MODIFIERS [51:8]
+        |       |   |--TYPE -> TYPE [51:8]
+        |       |   |   `--IDENT -> C [51:8]
+        |       |   |--IDENT -> c [51:10]
+        |       |   `--ASSIGN -> = [51:12]
+        |       |       `--EXPR -> EXPR [51:14]
+        |       |           `--LITERAL_NEW -> new [51:14]
+        |       |               |--IDENT -> C [51:18]
+        |       |               |--LPAREN -> ( [51:19]
+        |       |               |--ELIST -> ELIST [51:20]
+        |       |               `--RPAREN -> ) [51:20]
+        |       |--SEMI -> ; [51:21]
+        |       |--LITERAL_IF -> if [52:8]
+        |       |   |--LPAREN -> ( [52:11]
+        |       |   |--EXPR -> EXPR [52:15]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [52:15]
+        |       |   |       |--IDENT -> bo [52:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [52:26]
+        |       |   |           |--MODIFIERS -> MODIFIERS [52:26]
+        |       |   |           |   `--ANNOTATION -> ANNOTATION [52:26]
+        |       |   |           |       |--AT -> @ [52:26]
+        |       |   |           |       `--IDENT -> MyAnno1 [52:27]
+        |       |   |           |--TYPE -> TYPE [52:35]
+        |       |   |           |   |--IDENT -> Box [52:35]
+        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [52:38]
+        |       |   |           |       |--GENERIC_START -> < [52:38]
+        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [52:39]
+        |       |   |           |       |   `--IDENT -> I [52:39]
+        |       |   |           |       `--GENERIC_END -> > [52:40]
+        |       |   |           |--LPAREN -> ( [52:41]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [52:42]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [52:42]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [52:42]
+        |       |   |           |       |--TYPE -> TYPE [52:42]
+        |       |   |           |       |   `--IDENT -> var [52:42]
+        |       |   |           |       `--IDENT -> s [52:46]
+        |       |   |           `--RPAREN -> ) [52:47]
+        |       |   |--RPAREN -> ) [52:48]
+        |       |   |--SLIST -> { [52:50]
+        |       |   |   |--EXPR -> EXPR [53:30]
+        |       |   |   |   `--METHOD_CALL -> ( [53:30]
+        |       |   |   |       |--DOT -> . [53:22]
+        |       |   |   |       |   |--DOT -> . [53:18]
+        |       |   |   |       |   |   |--IDENT -> System [53:12]
+        |       |   |   |       |   |   `--IDENT -> out [53:19]
+        |       |   |   |       |   `--IDENT -> println [53:23]
+        |       |   |   |       |--ELIST -> ELIST [53:41]
+        |       |   |   |       |   `--EXPR -> EXPR [53:41]
+        |       |   |   |       |       `--PLUS -> + [53:41]
+        |       |   |   |       |           |--STRING_LITERAL -> "String " [53:31]
+        |       |   |   |       |           `--IDENT -> s [53:43]
+        |       |   |   |       `--RPAREN -> ) [53:44]
+        |       |   |   |--SEMI -> ; [53:45]
+        |       |   |   `--RCURLY -> } [54:8]
+        |       |   `--LITERAL_ELSE -> else [55:8]
+        |       |       `--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]
+        |       |           |   `--RCURLY -> } [57:8]
+        |       |           `--LITERAL_ELSE -> else [58:8]
+        |       |               `--LITERAL_IF -> if [58:13]
+        |       |                   |--LPAREN -> ( [58:16]
+        |       |                   |--EXPR -> EXPR [58:40]
+        |       |                   |   `--LAND -> && [58:40]
+        |       |                   |       |--LITERAL_INSTANCEOF -> instanceof [58:20]
+        |       |                   |       |   |--IDENT -> bo [58:17]
+        |       |                   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [58:31]
+        |       |                   |       |       |--MODIFIERS -> MODIFIERS [58:31]
+        |       |                   |       |       |--TYPE -> TYPE [58:31]
+        |       |                   |       |       |   |--IDENT -> Box [58:31]
+        |       |                   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [58:34]
+        |       |                   |       |       |       |--GENERIC_START -> < [58:34]
+        |       |                   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [58:35]
+        |       |                   |       |       |       |   `--IDENT -> I [58:35]
+        |       |                   |       |       |       `--GENERIC_END -> > [58:36]
+        |       |                   |       |       `--IDENT -> b [58:38]
+        |       |                   |       `--METHOD_CALL -> ( [58:54]
+        |       |                   |           |--DOT -> . [58:47]
+        |       |                   |           |   |--DOT -> . [58:45]
+        |       |                   |           |   |   |--IDENT -> bo [58:43]
+        |       |                   |           |   |   `--IDENT -> t [58:46]
+        |       |                   |           |   `--IDENT -> equals [58:48]
+        |       |                   |           |--ELIST -> ELIST [58:55]
+        |       |                   |           |   `--EXPR -> EXPR [58:55]
+        |       |                   |           |       `--IDENT -> c [58:55]
+        |       |                   |           `--RPAREN -> ) [58:56]
+        |       |                   |--RPAREN -> ) [58:57]
+        |       |                   |--SLIST -> { [58:59]
+        |       |                   |   `--RCURLY -> } [60:8]
+        |       |                   `--LITERAL_ELSE -> else [61:8]
+        |       |                       `--LITERAL_IF -> if [61:13]
+        |       |                           |--LPAREN -> ( [61:16]
+        |       |                           |--EXPR -> EXPR [61:28]
+        |       |                           |   `--LAND -> && [61:28]
+        |       |                           |       |--NOT_EQUAL -> != [61:20]
+        |       |                           |       |   |--IDENT -> bo [61:17]
+        |       |                           |       |   `--LITERAL_NULL -> null [61:23]
+        |       |                           |       `--METHOD_CALL -> ( [61:42]
+        |       |                           |           |--DOT -> . [61:35]
+        |       |                           |           |   |--DOT -> . [61:33]
+        |       |                           |           |   |   |--IDENT -> bo [61:31]
+        |       |                           |           |   |   `--IDENT -> t [61:34]
+        |       |                           |           |   `--IDENT -> equals [61:36]
+        |       |                           |           |--ELIST -> ELIST [61:43]
+        |       |                           |           |   `--EXPR -> EXPR [61:43]
+        |       |                           |           |       `--IDENT -> c [61:43]
+        |       |                           |           `--RPAREN -> ) [61:44]
+        |       |                           |--RPAREN -> ) [61:45]
+        |       |                           `--SLIST -> { [61:47]
+        |       |                               `--RCURLY -> } [63:8]
+        |       `--RCURLY -> } [64:4]
+        |--METHOD_DEF -> METHOD_DEF [66:4]
+        |   |--MODIFIERS -> MODIFIERS [66:4]
+        |   |   `--LITERAL_STATIC -> static [66:4]
+        |   |--TYPE -> TYPE [66:11]
+        |   |   `--LITERAL_VOID -> void [66:11]
+        |   |--IDENT -> test4 [66:16]
+        |   |--LPAREN -> ( [66:21]
+        |   |--PARAMETERS -> PARAMETERS [66:22]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [66:22]
+        |   |       |--MODIFIERS -> MODIFIERS [66:22]
+        |   |       |--TYPE -> TYPE [66:22]
+        |   |       |   |--IDENT -> Pair [66:22]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [66:26]
+        |   |       |       |--GENERIC_START -> < [66:26]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [66:27]
+        |   |       |       |   `--IDENT -> I [66:27]
+        |   |       |       `--GENERIC_END -> > [66:28]
+        |   |       `--IDENT -> p [66:30]
+        |   |--RPAREN -> ) [66:31]
+        |   `--SLIST -> { [66:33]
+        |       |--LITERAL_IF -> if [67:8]
+        |       |   |--LPAREN -> ( [67:11]
+        |       |   |--EXPR -> EXPR [67:14]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [67:14]
+        |       |   |       |--IDENT -> p [67:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [67:25]
+        |       |   |           |--MODIFIERS -> MODIFIERS [67:25]
+        |       |   |           |   `--FINAL -> final [67:25]
+        |       |   |           |--TYPE -> TYPE [67:31]
+        |       |   |           |   |--IDENT -> Pair [67:31]
+        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [67:35]
+        |       |   |           |       |--GENERIC_START -> < [67:35]
+        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [67:36]
+        |       |   |           |       |   `--IDENT -> I [67:36]
+        |       |   |           |       `--GENERIC_END -> > [67:37]
+        |       |   |           |--LPAREN -> ( [67:38]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [67:39]
+        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [67:39]
+        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [67:39]
+        |       |   |           |   |   |--TYPE -> TYPE [67:39]
+        |       |   |           |   |   |   `--IDENT -> C [67:39]
+        |       |   |           |   |   `--IDENT -> t1 [67:41]
+        |       |   |           |   |--COMMA -> , [67:43]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [67:45]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [67:45]
+        |       |   |           |       |--TYPE -> TYPE [67:45]
+        |       |   |           |       |   `--IDENT -> C [67:45]
+        |       |   |           |       `--IDENT -> t2 [67:47]
+        |       |   |           `--RPAREN -> ) [67:49]
+        |       |   |--RPAREN -> ) [67:50]
+        |       |   |--SLIST -> { [67:52]
+        |       |   |   |--EXPR -> EXPR [68:30]
+        |       |   |   |   `--METHOD_CALL -> ( [68:30]
+        |       |   |   |       |--DOT -> . [68:22]
+        |       |   |   |       |   |--DOT -> . [68:18]
+        |       |   |   |       |   |   |--IDENT -> System [68:12]
+        |       |   |   |       |   |   `--IDENT -> out [68:19]
+        |       |   |   |       |   `--IDENT -> println [68:23]
+        |       |   |   |       |--ELIST -> ELIST [68:31]
+        |       |   |   |       |   `--EXPR -> EXPR [68:31]
+        |       |   |   |       |       `--IDENT -> t2 [68:31]
+        |       |   |   |       `--RPAREN -> ) [68:33]
+        |       |   |   |--SEMI -> ; [68:34]
+        |       |   |   `--RCURLY -> } [69:8]
+        |       |   `--LITERAL_ELSE -> else [70:8]
+        |       |       `--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]
+        |       |           `--SLIST -> { [70:66]
+        |       |               |--EXPR -> EXPR [71:30]
+        |       |               |   `--METHOD_CALL -> ( [71:30]
+        |       |               |       |--DOT -> . [71:22]
+        |       |               |       |   |--DOT -> . [71:18]
+        |       |               |       |   |   |--IDENT -> System [71:12]
+        |       |               |       |   |   `--IDENT -> out [71:19]
+        |       |               |       |   `--IDENT -> println [71:23]
+        |       |               |       |--ELIST -> ELIST [71:31]
+        |       |               |       |   `--EXPR -> EXPR [71:31]
+        |       |               |       |       `--IDENT -> t1 [71:31]
+        |       |               |       `--RPAREN -> ) [71:33]
+        |       |               |--SEMI -> ; [71:34]
+        |       |               `--RCURLY -> } [72:8]
+        |       `--RCURLY -> } [73:4]
+        |--METHOD_DEF -> METHOD_DEF [75:4]
+        |   |--MODIFIERS -> MODIFIERS [75:4]
+        |   |   `--LITERAL_STATIC -> static [75:4]
+        |   |--TYPE -> TYPE [75:11]
+        |   |   `--LITERAL_VOID -> void [75:11]
+        |   |--IDENT -> test5 [75:16]
+        |   |--LPAREN -> ( [75:21]
+        |   |--PARAMETERS -> PARAMETERS [75:22]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [75:22]
+        |   |       |--MODIFIERS -> MODIFIERS [75:22]
+        |   |       |--TYPE -> TYPE [75:22]
+        |   |       |   `--IDENT -> Tuple [75:22]
+        |   |       `--IDENT -> t [75:28]
+        |   |--RPAREN -> ) [75:29]
+        |   `--SLIST -> { [75:31]
+        |       |--LITERAL_IF -> if [76:8]
+        |       |   |--LPAREN -> ( [76:11]
+        |       |   |--EXPR -> EXPR [76:14]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [76:14]
+        |       |   |       |--IDENT -> t [76:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [76:25]
+        |       |   |           |--MODIFIERS -> MODIFIERS [76:25]
+        |       |   |           |--TYPE -> TYPE [76:25]
+        |       |   |           |   `--IDENT -> Tuple [76:25]
+        |       |   |           |--LPAREN -> ( [76:30]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [76:31]
+        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [76:31]
+        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [76:31]
+        |       |   |           |   |   |--TYPE -> TYPE [76:31]
+        |       |   |           |   |   |   `--IDENT -> String [76:31]
+        |       |   |           |   |   `--IDENT -> x [76:38]
+        |       |   |           |   |--COMMA -> , [76:39]
+        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [76:41]
+        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [76:41]
+        |       |   |           |   |   |--TYPE -> TYPE [76:41]
+        |       |   |           |   |   |   `--IDENT -> String [76:41]
+        |       |   |           |   |   `--IDENT -> y [76:48]
+        |       |   |           |   |--COMMA -> , [76:49]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [76:51]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [76:51]
+        |       |   |           |       |--TYPE -> TYPE [76:51]
+        |       |   |           |       |   `--IDENT -> String [76:51]
+        |       |   |           |       `--IDENT -> z [76:58]
+        |       |   |           `--RPAREN -> ) [76:59]
+        |       |   |--RPAREN -> ) [76:60]
+        |       |   |--SLIST -> { [76:62]
+        |       |   |   |--EXPR -> EXPR [77:30]
+        |       |   |   |   `--METHOD_CALL -> ( [77:30]
+        |       |   |   |       |--DOT -> . [77:22]
+        |       |   |   |       |   |--DOT -> . [77:18]
+        |       |   |   |       |   |   |--IDENT -> System [77:12]
+        |       |   |   |       |   |   `--IDENT -> out [77:19]
+        |       |   |   |       |   `--IDENT -> println [77:23]
+        |       |   |   |       |--ELIST -> ELIST [77:37]
+        |       |   |   |       |   `--EXPR -> EXPR [77:37]
+        |       |   |   |       |       `--PLUS -> + [77:37]
+        |       |   |   |       |           |--PLUS -> + [77:33]
+        |       |   |   |       |           |   |--IDENT -> x [77:31]
+        |       |   |   |       |           |   `--IDENT -> y [77:35]
+        |       |   |   |       |           `--IDENT -> z [77:39]
+        |       |   |   |       `--RPAREN -> ) [77:40]
+        |       |   |   |--SEMI -> ; [77:41]
+        |       |   |   `--RCURLY -> } [78:8]
+        |       |   `--LITERAL_ELSE -> else [79:8]
+        |       |       `--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]
+        |       |           `--SLIST -> { [82:52]
+        |       |               |--EXPR -> EXPR [83:30]
+        |       |               |   `--METHOD_CALL -> ( [83:30]
+        |       |               |       |--DOT -> . [83:22]
+        |       |               |       |   |--DOT -> . [83:18]
+        |       |               |       |   |   |--IDENT -> System [83:12]
+        |       |               |       |   |   `--IDENT -> out [83:19]
+        |       |               |       |   `--IDENT -> println [83:23]
+        |       |               |       |--ELIST -> ELIST [83:37]
+        |       |               |       |   `--EXPR -> EXPR [83:37]
+        |       |               |       |       `--PLUS -> + [83:37]
+        |       |               |       |           |--PLUS -> + [83:33]
+        |       |               |       |           |   |--IDENT -> x [83:31]
+        |       |               |       |           |   `--IDENT -> y [83:35]
+        |       |               |       |           `--IDENT -> z [83:39]
+        |       |               |       `--RPAREN -> ) [83:40]
+        |       |               |--SEMI -> ; [83:41]
+        |       |               `--RCURLY -> } [84:8]
+        |       `--RCURLY -> } [85:4]
+        |--METHOD_DEF -> METHOD_DEF [87:4]
+        |   |--MODIFIERS -> MODIFIERS [87:4]
+        |   |--TYPE -> TYPE [87:4]
+        |   |   `--IDENT -> String [87:4]
+        |   |--IDENT -> m2 [87:11]
+        |   |--LPAREN -> ( [87:13]
+        |   |--PARAMETERS -> PARAMETERS [87:14]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [87:14]
+        |   |       |--MODIFIERS -> MODIFIERS [87:14]
+        |   |       |--TYPE -> TYPE [87:14]
+        |   |       |   |--IDENT -> Pair [87:14]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [87:18]
+        |   |       |       |--GENERIC_START -> < [87:18]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [87:19]
+        |   |       |       |   `--IDENT -> I [87:19]
+        |   |       |       `--GENERIC_END -> > [87:20]
+        |   |       `--IDENT -> p1 [87:22]
+        |   |--RPAREN -> ) [87:24]
+        |   `--SLIST -> { [87:26]
+        |       |--LITERAL_RETURN -> return [88:8]
+        |       |   |--EXPR -> EXPR [88:15]
+        |       |   |   `--LITERAL_SWITCH -> switch [88:15]
+        |       |   |       |--LPAREN -> ( [88:22]
+        |       |   |       |--EXPR -> EXPR [88:23]
+        |       |   |       |   `--IDENT -> p1 [88:23]
+        |       |   |       |--RPAREN -> ) [88:25]
+        |       |   |       |--LCURLY -> { [88:27]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [89:12]
+        |       |   |       |   |--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]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [90:12]
+        |       |   |       |   |--LITERAL_CASE -> case [90:12]
+        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [90:17]
+        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [90:17]
+        |       |   |       |   |       |   `--FINAL -> final [90:17]
+        |       |   |       |   |       |--TYPE -> TYPE [90:23]
+        |       |   |       |   |       |   |--IDENT -> Pair [90:23]
+        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [90:27]
+        |       |   |       |   |       |       |--GENERIC_START -> < [90:27]
+        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [90:28]
+        |       |   |       |   |       |       |   `--IDENT -> I [90:28]
+        |       |   |       |   |       |       `--GENERIC_END -> > [90:29]
+        |       |   |       |   |       |--LPAREN -> ( [90:30]
+        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [91:20]
+        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [91:20]
+        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [91:20]
+        |       |   |       |   |       |   |   |   |--FINAL -> final [91:20]
+        |       |   |       |   |       |   |   |   `--ANNOTATION -> ANNOTATION [91:26]
+        |       |   |       |   |       |   |   |       |--AT -> @ [91:26]
+        |       |   |       |   |       |   |   |       |--IDENT -> MyAnno3 [91:27]
+        |       |   |       |   |       |   |   |       |--LPAREN -> ( [91:34]
+        |       |   |       |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [91:35]
+        |       |   |       |   |       |   |   |       |   |--IDENT -> value [91:35]
+        |       |   |       |   |       |   |   |       |   |--ASSIGN -> = [91:41]
+        |       |   |       |   |       |   |   |       |   `--EXPR -> EXPR [91:43]
+        |       |   |       |   |       |   |   |       |       `--STRING_LITERAL -> "some value" [91:43]
+        |       |   |       |   |       |   |   |       |--COMMA -> , [91:55]
+        |       |   |       |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [91:57]
+        |       |   |       |   |       |   |   |       |   |--IDENT -> values [91:57]
+        |       |   |       |   |       |   |   |       |   |--ASSIGN -> = [91:64]
+        |       |   |       |   |       |   |   |       |   `--ANNOTATION_ARRAY_INIT -> { [91:66]
+        |       |   |       |   |       |   |   |       |       `--RCURLY -> } [91:67]
+        |       |   |       |   |       |   |   |       `--RPAREN -> ) [91:68]
+        |       |   |       |   |       |   |   |--TYPE -> TYPE [91:70]
+        |       |   |       |   |       |   |   |   `--IDENT -> D [91:70]
+        |       |   |       |   |       |   |   `--IDENT -> d [91:72]
+        |       |   |       |   |       |   |--COMMA -> , [91:73]
+        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [92:20]
+        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [92:20]
+        |       |   |       |   |       |       |   `--FINAL -> final [92:20]
+        |       |   |       |   |       |       |--TYPE -> TYPE [92:26]
+        |       |   |       |   |       |       |   `--IDENT -> C [92:26]
+        |       |   |       |   |       |       `--IDENT -> c [92:28]
+        |       |   |       |   |       `--RPAREN -> ) [92:29]
+        |       |   |       |   |--LAMBDA -> -> [92:31]
+        |       |   |       |   |--EXPR -> EXPR [92:34]
+        |       |   |       |   |   `--STRING_LITERAL -> "C!" [92:34]
+        |       |   |       |   `--SEMI -> ; [92:38]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [93:12]
+        |       |   |       |   |--LITERAL_CASE -> case [93:12]
+        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [93:17]
+        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [93:17]
+        |       |   |       |   |       |--TYPE -> TYPE [93:17]
+        |       |   |       |   |       |   |--IDENT -> Pair [93:17]
+        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [93:21]
+        |       |   |       |   |       |       |--GENERIC_START -> < [93:21]
+        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [93:22]
+        |       |   |       |   |       |       |   `--IDENT -> I [93:22]
+        |       |   |       |   |       |       `--GENERIC_END -> > [93:23]
+        |       |   |       |   |       |--LPAREN -> ( [93:24]
+        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [94:20]
+        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [94:20]
+        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [94:20]
+        |       |   |       |   |       |   |   |   `--ANNOTATION -> ANNOTATION [94:20]
+        |       |   |       |   |       |   |   |       |--AT -> @ [94:20]
+        |       |   |       |   |       |   |   |       |--IDENT -> MyAnno3 [94:21]
+        |       |   |       |   |       |   |   |       |--LPAREN -> ( [94:28]
+        |       |   |       |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [94:29]
+        |       |   |       |   |       |   |   |       |   |--IDENT -> value [94:29]
+        |       |   |       |   |       |   |   |       |   |--ASSIGN -> = [94:35]
+        |       |   |       |   |       |   |   |       |   `--EXPR -> EXPR [94:37]
+        |       |   |       |   |       |   |   |       |       `--STRING_LITERAL -> "val" [94:37]
+        |       |   |       |   |       |   |   |       |--COMMA -> , [94:42]
+        |       |   |       |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [94:44]
+        |       |   |       |   |       |   |   |       |   |--IDENT -> values [94:44]
+        |       |   |       |   |       |   |   |       |   |--ASSIGN -> = [94:51]
+        |       |   |       |   |       |   |   |       |   `--ANNOTATION_ARRAY_INIT -> { [94:53]
+        |       |   |       |   |       |   |   |       |       |--EXPR -> EXPR [94:54]
+        |       |   |       |   |       |   |   |       |       |   `--STRING_LITERAL -> "1" [94:54]
+        |       |   |       |   |       |   |   |       |       |--COMMA -> , [94:57]
+        |       |   |       |   |       |   |   |       |       |--EXPR -> EXPR [94:59]
+        |       |   |       |   |       |   |   |       |       |   `--STRING_LITERAL -> "2" [94:59]
+        |       |   |       |   |       |   |   |       |       `--RCURLY -> } [94:62]
+        |       |   |       |   |       |   |   |       `--RPAREN -> ) [94:63]
+        |       |   |       |   |       |   |   |--TYPE -> TYPE [94:65]
+        |       |   |       |   |       |   |   |   `--IDENT -> D [94:65]
+        |       |   |       |   |       |   |   `--IDENT -> d1 [94:67]
+        |       |   |       |   |       |   |--COMMA -> , [94:69]
+        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [94:70]
+        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [94:70]
+        |       |   |       |   |       |       |--TYPE -> TYPE [94:70]
+        |       |   |       |   |       |       |   `--IDENT -> D [94:70]
+        |       |   |       |   |       |       `--IDENT -> d2 [94:72]
+        |       |   |       |   |       `--RPAREN -> ) [94:74]
+        |       |   |       |   |--LAMBDA -> -> [94:76]
+        |       |   |       |   |--EXPR -> EXPR [94:79]
+        |       |   |       |   |   `--STRING_LITERAL -> "D!" [94:79]
+        |       |   |       |   `--SEMI -> ; [94:83]
+        |       |   |       `--RCURLY -> } [95:8]
+        |       |   `--SEMI -> ; [95:9]
+        |       `--RCURLY -> } [96:4]
+        |--METHOD_DEF -> METHOD_DEF [98:4]
+        |   |--MODIFIERS -> MODIFIERS [98:4]
+        |   |--TYPE -> TYPE [98:4]
+        |   |   `--LITERAL_VOID -> void [98:4]
+        |   |--IDENT -> m3 [98:9]
+        |   |--LPAREN -> ( [98:12]
+        |   |--PARAMETERS -> PARAMETERS [98:13]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [98:13]
+        |   |       |--MODIFIERS -> MODIFIERS [98:13]
+        |   |       |--TYPE -> TYPE [98:13]
+        |   |       |   |--IDENT -> Pair [98:13]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [98:17]
+        |   |       |       |--GENERIC_START -> < [98:17]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [98:18]
+        |   |       |       |   |--IDENT -> Pair [98:18]
+        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [98:22]
+        |   |       |       |       |--GENERIC_START -> < [98:22]
+        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [98:23]
+        |   |       |       |       |   `--IDENT -> Integer [98:23]
+        |   |       |       |       `--GENERIC_END -> > [98:30]
+        |   |       |       `--GENERIC_END -> > [98:31]
+        |   |       `--IDENT -> s [98:33]
+        |   |--RPAREN -> ) [98:34]
+        |   `--SLIST -> { [98:36]
+        |       |--LITERAL_SWITCH -> switch [99:8]
+        |       |   |--LPAREN -> ( [99:15]
+        |       |   |--EXPR -> EXPR [99:16]
+        |       |   |   `--IDENT -> s [99:16]
+        |       |   |--RPAREN -> ) [99:17]
+        |       |   |--LCURLY -> { [99:19]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [100:12]
+        |       |   |   |--LITERAL_CASE -> case [100:12]
+        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [100:17]
+        |       |   |   |       |--MODIFIERS -> MODIFIERS [100:17]
+        |       |   |   |       |   `--FINAL -> final [100:17]
+        |       |   |   |       |--TYPE -> TYPE [100:23]
+        |       |   |   |       |   |--IDENT -> Pair [100:23]
+        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [100:27]
+        |       |   |   |       |       |--GENERIC_START -> < [100:27]
+        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [100:28]
+        |       |   |   |       |       |   |--IDENT -> Pair [100:28]
+        |       |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [100:32]
+        |       |   |   |       |       |       |--GENERIC_START -> < [100:32]
+        |       |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [100:33]
+        |       |   |   |       |       |       |   `--IDENT -> Integer [100:33]
+        |       |   |   |       |       |       `--GENERIC_END -> > [100:40]
+        |       |   |   |       |       `--GENERIC_END -> > [100:41]
+        |       |   |   |       |--LPAREN -> ( [100:42]
+        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [101:20]
+        |       |   |   |       |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [101:20]
+        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [101:20]
+        |       |   |   |       |   |   |   `--ANNOTATION -> ANNOTATION [101:20]
+        |       |   |   |       |   |   |       |--AT -> @ [101:20]
+        |       |   |   |       |   |   |       `--IDENT -> MyAnno1 [101:21]
+        |       |   |   |       |   |   |--TYPE -> TYPE [101:29]
+        |       |   |   |       |   |   |   |--IDENT -> Pair [101:29]
+        |       |   |   |       |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [101:33]
+        |       |   |   |       |   |   |       |--GENERIC_START -> < [101:33]
+        |       |   |   |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [101:34]
+        |       |   |   |       |   |   |       |   `--IDENT -> Integer [101:34]
+        |       |   |   |       |   |   |       `--GENERIC_END -> > [101:41]
+        |       |   |   |       |   |   |--LPAREN -> ( [101:42]
+        |       |   |   |       |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [101:43]
+        |       |   |   |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [101:43]
+        |       |   |   |       |   |   |   |   |--MODIFIERS -> MODIFIERS [101:43]
+        |       |   |   |       |   |   |   |   |   `--ANNOTATION -> ANNOTATION [101:43]
+        |       |   |   |       |   |   |   |   |       |--AT -> @ [101:43]
+        |       |   |   |       |   |   |   |   |       `--IDENT -> MyAnno1 [101:44]
+        |       |   |   |       |   |   |   |   |--TYPE -> TYPE [101:52]
+        |       |   |   |       |   |   |   |   |   `--IDENT -> Integer [101:52]
+        |       |   |   |       |   |   |   |   `--IDENT -> x1 [101:60]
+        |       |   |   |       |   |   |   |--COMMA -> , [101:62]
+        |       |   |   |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [101:64]
+        |       |   |   |       |   |   |       |--MODIFIERS -> MODIFIERS [101:64]
+        |       |   |   |       |   |   |       |   `--FINAL -> final [101:64]
+        |       |   |   |       |   |   |       |--TYPE -> TYPE [101:70]
+        |       |   |   |       |   |   |       |   `--IDENT -> Integer [101:70]
+        |       |   |   |       |   |   |       `--IDENT -> y1 [101:78]
+        |       |   |   |       |   |   |--RPAREN -> ) [101:80]
+        |       |   |   |       |   |   `--IDENT -> x [101:82]
+        |       |   |   |       |   |--COMMA -> , [101:83]
+        |       |   |   |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [102:20]
+        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [102:20]
+        |       |   |   |       |       |   `--FINAL -> final [102:20]
+        |       |   |   |       |       |--TYPE -> TYPE [102:26]
+        |       |   |   |       |       |   |--IDENT -> Pair [102:26]
+        |       |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [102:30]
+        |       |   |   |       |       |       |--GENERIC_START -> < [102:30]
+        |       |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [102:31]
+        |       |   |   |       |       |       |   `--IDENT -> Integer [102:31]
+        |       |   |   |       |       |       `--GENERIC_END -> > [102:38]
+        |       |   |   |       |       |--LPAREN -> ( [102:39]
+        |       |   |   |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [102:40]
+        |       |   |   |       |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [102:40]
+        |       |   |   |       |       |   |   |--MODIFIERS -> MODIFIERS [102:40]
+        |       |   |   |       |       |   |   |--TYPE -> TYPE [102:40]
+        |       |   |   |       |       |   |   |   `--IDENT -> Integer [102:40]
+        |       |   |   |       |       |   |   `--IDENT -> x2 [102:48]
+        |       |   |   |       |       |   |--COMMA -> , [102:50]
+        |       |   |   |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [102:52]
+        |       |   |   |       |       |       |--MODIFIERS -> MODIFIERS [102:52]
+        |       |   |   |       |       |       |--TYPE -> TYPE [102:52]
+        |       |   |   |       |       |       |   `--IDENT -> Integer [102:52]
+        |       |   |   |       |       |       `--IDENT -> y2 [102:60]
+        |       |   |   |       |       |--RPAREN -> ) [102:62]
+        |       |   |   |       |       `--IDENT -> p2 [102:64]
+        |       |   |   |       |--RPAREN -> ) [102:66]
+        |       |   |   |       `--IDENT -> y [102:68]
+        |       |   |   |--LAMBDA -> -> [103:24]
+        |       |   |   |--EXPR -> EXPR [103:45]
+        |       |   |   |   `--METHOD_CALL -> ( [103:45]
+        |       |   |   |       |--DOT -> . [103:37]
+        |       |   |   |       |   |--DOT -> . [103:33]
+        |       |   |   |       |   |   |--IDENT -> System [103:27]
+        |       |   |   |       |   |   `--IDENT -> out [103:34]
+        |       |   |   |       |   `--IDENT -> println [103:38]
+        |       |   |   |       |--ELIST -> ELIST [103:46]
+        |       |   |   |       `--RPAREN -> ) [103:46]
+        |       |   |   `--SEMI -> ; [103:47]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [104:12]
+        |       |   |   |--LITERAL_CASE -> case [104:12]
+        |       |   |   |   `--LITERAL_DEFAULT -> default [104:17]
+        |       |   |   |--LAMBDA -> -> [104:25]
+        |       |   |   |--EXPR -> EXPR [104:46]
+        |       |   |   |   `--METHOD_CALL -> ( [104:46]
+        |       |   |   |       |--DOT -> . [104:38]
+        |       |   |   |       |   |--DOT -> . [104:34]
+        |       |   |   |       |   |   |--IDENT -> System [104:28]
+        |       |   |   |       |   |   `--IDENT -> out [104:35]
+        |       |   |   |       |   `--IDENT -> println [104:39]
+        |       |   |   |       |--ELIST -> ELIST [104:47]
+        |       |   |   |       `--RPAREN -> ) [104:47]
+        |       |   |   `--SEMI -> ; [104:48]
+        |       |   `--RCURLY -> } [105:8]
+        |       `--RCURLY -> } [106:4]
+        |--METHOD_DEF -> METHOD_DEF [108:4]
+        |   |--MODIFIERS -> MODIFIERS [108:4]
+        |   |--TYPE -> TYPE [108:4]
+        |   |   `--LITERAL_VOID -> void [108:4]
+        |   |--IDENT -> m4 [108:9]
+        |   |--LPAREN -> ( [108:12]
+        |   |--PARAMETERS -> PARAMETERS [108:13]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [108:13]
+        |   |       |--MODIFIERS -> MODIFIERS [108:13]
+        |   |       |--TYPE -> TYPE [108:13]
+        |   |       |   |--IDENT -> Pair [108:13]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [108:17]
+        |   |       |       |--GENERIC_START -> < [108:17]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [108:18]
+        |   |       |       |   |--IDENT -> Pair [108:18]
+        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [108:22]
+        |   |       |       |       |--GENERIC_START -> < [108:22]
+        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [108:23]
+        |   |       |       |       |   `--IDENT -> Integer [108:23]
+        |   |       |       |       `--GENERIC_END -> > [108:30]
+        |   |       |       `--GENERIC_END -> > [108:31]
+        |   |       `--IDENT -> s [108:33]
+        |   |--RPAREN -> ) [108:34]
+        |   `--SLIST -> { [108:36]
+        |       |--LITERAL_SWITCH -> switch [109:8]
+        |       |   |--LPAREN -> ( [109:15]
+        |       |   |--EXPR -> EXPR [109:16]
+        |       |   |   `--IDENT -> s [109:16]
+        |       |   |--RPAREN -> ) [109:17]
+        |       |   |--LCURLY -> { [109:19]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [110:12]
+        |       |   |   |--LITERAL_CASE -> case [110:12]
+        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [110:17]
+        |       |   |   |       |--MODIFIERS -> MODIFIERS [110:17]
+        |       |   |   |       |   `--ANNOTATION -> ANNOTATION [110:17]
+        |       |   |   |       |       |--AT -> @ [110:17]
+        |       |   |   |       |       `--IDENT -> MyAnno2 [110:18]
+        |       |   |   |       |--TYPE -> TYPE [110:26]
+        |       |   |   |       |   |--IDENT -> Pair [110:26]
+        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [110:30]
+        |       |   |   |       |       |--GENERIC_START -> < [110:30]
+        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [110:31]
+        |       |   |   |       |       |   |--IDENT -> Pair [110:31]
+        |       |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [110:35]
+        |       |   |   |       |       |       |--GENERIC_START -> < [110:35]
+        |       |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [110:36]
+        |       |   |   |       |       |       |   `--IDENT -> Integer [110:36]
+        |       |   |   |       |       |       `--GENERIC_END -> > [110:43]
+        |       |   |   |       |       `--GENERIC_END -> > [110:44]
+        |       |   |   |       |--LPAREN -> ( [110:45]
+        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [111:20]
+        |       |   |   |       |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [111:20]
+        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [111:20]
+        |       |   |   |       |   |   |   `--ANNOTATION -> ANNOTATION [111:20]
+        |       |   |   |       |   |   |       |--AT -> @ [111:20]
+        |       |   |   |       |   |   |       |--IDENT -> MyAnno3 [111:21]
+        |       |   |   |       |   |   |       |--LPAREN -> ( [111:28]
+        |       |   |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [111:29]
+        |       |   |   |       |   |   |       |   |--IDENT -> value [111:29]
+        |       |   |   |       |   |   |       |   |--ASSIGN -> = [111:35]
+        |       |   |   |       |   |   |       |   `--EXPR -> EXPR [111:37]
+        |       |   |   |       |   |   |       |       `--STRING_LITERAL -> "" [111:37]
+        |       |   |   |       |   |   |       |--COMMA -> , [111:39]
+        |       |   |   |       |   |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [111:41]
+        |       |   |   |       |   |   |       |   |--IDENT -> values [111:41]
+        |       |   |   |       |   |   |       |   |--ASSIGN -> = [111:48]
+        |       |   |   |       |   |   |       |   `--ANNOTATION_ARRAY_INIT -> { [111:50]
+        |       |   |   |       |   |   |       |       `--RCURLY -> } [111:51]
+        |       |   |   |       |   |   |       `--RPAREN -> ) [111:52]
+        |       |   |   |       |   |   |--TYPE -> TYPE [111:54]
+        |       |   |   |       |   |   |   |--IDENT -> Pair [111:54]
+        |       |   |   |       |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [111:58]
+        |       |   |   |       |   |   |       |--GENERIC_START -> < [111:58]
+        |       |   |   |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [111:59]
+        |       |   |   |       |   |   |       |   `--IDENT -> Integer [111:59]
+        |       |   |   |       |   |   |       `--GENERIC_END -> > [111:66]
+        |       |   |   |       |   |   |--LPAREN -> ( [111:67]
+        |       |   |   |       |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [112:28]
+        |       |   |   |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [112:28]
+        |       |   |   |       |   |   |   |   |--MODIFIERS -> MODIFIERS [112:28]
+        |       |   |   |       |   |   |   |   |   `--FINAL -> final [112:28]
+        |       |   |   |       |   |   |   |   |--TYPE -> TYPE [112:34]
+        |       |   |   |       |   |   |   |   |   `--IDENT -> Integer [112:34]
+        |       |   |   |       |   |   |   |   `--IDENT -> x1 [112:42]
+        |       |   |   |       |   |   |   |--COMMA -> , [112:44]
+        |       |   |   |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [112:45]
+        |       |   |   |       |   |   |       |--MODIFIERS -> MODIFIERS [112:45]
+        |       |   |   |       |   |   |       |--TYPE -> TYPE [112:45]
+        |       |   |   |       |   |   |       |   `--IDENT -> Integer [112:45]
+        |       |   |   |       |   |   |       `--IDENT -> y1 [112:53]
+        |       |   |   |       |   |   |--RPAREN -> ) [112:55]
+        |       |   |   |       |   |   `--IDENT -> x [112:57]
+        |       |   |   |       |   |--COMMA -> , [112:58]
+        |       |   |   |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [113:21]
+        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [113:21]
+        |       |   |   |       |       |   |--ANNOTATION -> ANNOTATION [113:21]
+        |       |   |   |       |       |   |   |--AT -> @ [113:21]
+        |       |   |   |       |       |   |   |--IDENT -> MyAnno3 [113:22]
+        |       |   |   |       |       |   |   |--LPAREN -> ( [113:29]
+        |       |   |   |       |       |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [113:30]
+        |       |   |   |       |       |   |   |   |--IDENT -> value [113:30]
+        |       |   |   |       |       |   |   |   |--ASSIGN -> = [113:36]
+        |       |   |   |       |       |   |   |   `--EXPR -> EXPR [113:38]
+        |       |   |   |       |       |   |   |       `--STRING_LITERAL -> "" [113:38]
+        |       |   |   |       |       |   |   |--COMMA -> , [113:40]
+        |       |   |   |       |       |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [113:42]
+        |       |   |   |       |       |   |   |   |--IDENT -> values [113:42]
+        |       |   |   |       |       |   |   |   |--ASSIGN -> = [113:49]
+        |       |   |   |       |       |   |   |   `--ANNOTATION_ARRAY_INIT -> { [113:51]
+        |       |   |   |       |       |   |   |       `--RCURLY -> } [113:52]
+        |       |   |   |       |       |   |   `--RPAREN -> ) [113:53]
+        |       |   |   |       |       |   `--FINAL -> final [113:55]
+        |       |   |   |       |       |--TYPE -> TYPE [113:61]
+        |       |   |   |       |       |   |--IDENT -> Pair [113:61]
+        |       |   |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [113:65]
+        |       |   |   |       |       |       |--GENERIC_START -> < [113:65]
+        |       |   |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [113:66]
+        |       |   |   |       |       |       |   `--IDENT -> Integer [113:66]
+        |       |   |   |       |       |       `--GENERIC_END -> > [113:73]
+        |       |   |   |       |       |--LPAREN -> ( [113:74]
+        |       |   |   |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [114:29]
+        |       |   |   |       |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [114:29]
+        |       |   |   |       |       |   |   |--MODIFIERS -> MODIFIERS [114:29]
+        |       |   |   |       |       |   |   |   |--ANNOTATION -> ANNOTATION [114:29]
+        |       |   |   |       |       |   |   |   |   |--AT -> @ [114:29]
+        |       |   |   |       |       |   |   |   |   `--IDENT -> MyAnno2 [114:30]
+        |       |   |   |       |       |   |   |   `--FINAL -> final [114:38]
+        |       |   |   |       |       |   |   |--TYPE -> TYPE [114:44]
+        |       |   |   |       |       |   |   |   `--IDENT -> Integer [114:44]
+        |       |   |   |       |       |   |   `--IDENT -> x2 [114:52]
+        |       |   |   |       |       |   |--COMMA -> , [114:54]
+        |       |   |   |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [114:55]
+        |       |   |   |       |       |       |--MODIFIERS -> MODIFIERS [114:55]
+        |       |   |   |       |       |       |--TYPE -> TYPE [114:55]
+        |       |   |   |       |       |       |   `--IDENT -> Integer [114:55]
+        |       |   |   |       |       |       `--IDENT -> y2 [114:63]
+        |       |   |   |       |       |--RPAREN -> ) [114:65]
+        |       |   |   |       |       `--IDENT -> p2 [114:67]
+        |       |   |   |       |--RPAREN -> ) [114:69]
+        |       |   |   |       `--IDENT -> y [114:71]
+        |       |   |   |--LAMBDA -> -> [115:36]
+        |       |   |   |--EXPR -> EXPR [115:57]
+        |       |   |   |   `--METHOD_CALL -> ( [115:57]
+        |       |   |   |       |--DOT -> . [115:49]
+        |       |   |   |       |   |--DOT -> . [115:45]
+        |       |   |   |       |   |   |--IDENT -> System [115:39]
+        |       |   |   |       |   |   `--IDENT -> out [115:46]
+        |       |   |   |       |   `--IDENT -> println [115:50]
+        |       |   |   |       |--ELIST -> ELIST [115:58]
+        |       |   |   |       `--RPAREN -> ) [115:58]
+        |       |   |   `--SEMI -> ; [115:59]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [116:12]
+        |       |   |   |--LITERAL_CASE -> case [116:12]
+        |       |   |   |   `--LITERAL_DEFAULT -> default [116:17]
+        |       |   |   |--LAMBDA -> -> [116:25]
+        |       |   |   |--EXPR -> EXPR [116:46]
+        |       |   |   |   `--METHOD_CALL -> ( [116:46]
+        |       |   |   |       |--DOT -> . [116:38]
+        |       |   |   |       |   |--DOT -> . [116:34]
+        |       |   |   |       |   |   |--IDENT -> System [116:28]
+        |       |   |   |       |   |   `--IDENT -> out [116:35]
+        |       |   |   |       |   `--IDENT -> println [116:39]
+        |       |   |   |       |--ELIST -> ELIST [116:47]
+        |       |   |   |       `--RPAREN -> ) [116:47]
+        |       |   |   `--SEMI -> ; [116:48]
+        |       |   `--RCURLY -> } [117:8]
+        |       `--RCURLY -> } [118:4]
+        `--RCURLY -> } [119:0]
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19GuardsWithExtraParenthesis.txt b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19GuardsWithExtraParenthesis.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19GuardsWithExtraParenthesis.txt
@@ -0,0 +1,1250 @@
+COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
+|--PACKAGE_DEF -> package [2:0]
+|   |--ANNOTATIONS -> ANNOTATIONS [2:47]
+|   |--DOT -> . [2:47]
+|   |   |--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]
+|   |   `--IDENT -> java19 [2:48]
+|   `--SEMI -> ; [2:54]
+|--IMPORT -> import [4:0]
+|   |--DOT -> . [4:16]
+|   |   |--DOT -> . [4:11]
+|   |   |   |--IDENT -> java [4:7]
+|   |   |   `--IDENT -> util [4:12]
+|   |   `--IDENT -> Objects [4:17]
+|   `--SEMI -> ; [4:24]
+`--CLASS_DEF -> CLASS_DEF [6:0]
+    |--MODIFIERS -> MODIFIERS [6:0]
+    |   `--LITERAL_PUBLIC -> public [6:0]
+    |--LITERAL_CLASS -> class [6:7]
+    |--IDENT -> InputJava19GuardsWithExtraParenthesis [6:13]
+    `--OBJBLOCK -> OBJBLOCK [6:51]
+        |--LCURLY -> { [6:51]
+        |--RECORD_DEF -> RECORD_DEF [8:4]
+        |   |--MODIFIERS -> MODIFIERS [8:4]
+        |   |--LITERAL_RECORD -> record [8:4]
+        |   |--IDENT -> Box [8:11]
+        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [8:14]
+        |   |   |--GENERIC_START -> < [8:14]
+        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [8:15]
+        |   |   |   `--IDENT -> V [8:15]
+        |   |   `--GENERIC_END -> > [8:16]
+        |   |--LPAREN -> ( [8:17]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [8:18]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [8:18]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [8:18]
+        |   |       |--TYPE -> TYPE [8:18]
+        |   |       |   `--IDENT -> V [8:18]
+        |   |       `--IDENT -> v [8:20]
+        |   |--RPAREN -> ) [8:21]
+        |   `--OBJBLOCK -> OBJBLOCK [8:23]
+        |       |--LCURLY -> { [8:23]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [9:8]
+        |       |   |--MODIFIERS -> MODIFIERS [9:8]
+        |       |   |   `--LITERAL_STATIC -> static [9:8]
+        |       |   |--TYPE -> TYPE [9:15]
+        |       |   |   `--LITERAL_INT -> int [9:15]
+        |       |   |--IDENT -> x [9:19]
+        |       |   |--ASSIGN -> = [9:21]
+        |       |   |   `--EXPR -> EXPR [9:23]
+        |       |   |       `--NUM_INT -> 5 [9:23]
+        |       |   `--SEMI -> ; [9:24]
+        |       `--RCURLY -> } [10:4]
+        |--METHOD_DEF -> METHOD_DEF [12:4]
+        |   |--MODIFIERS -> MODIFIERS [12:4]
+        |   |--TYPE -> TYPE [12:4]
+        |   |   `--LITERAL_INT -> int [12:4]
+        |   |--IDENT -> m1 [12:8]
+        |   |--LPAREN -> ( [12:10]
+        |   |--PARAMETERS -> PARAMETERS [12:11]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [12:11]
+        |   |       |--MODIFIERS -> MODIFIERS [12:11]
+        |   |       |--TYPE -> TYPE [12:11]
+        |   |       |   |--IDENT -> Box [12:11]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [12:14]
+        |   |       |       |--GENERIC_START -> < [12:14]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [12:15]
+        |   |       |       |   |--IDENT -> Box [12:15]
+        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [12:18]
+        |   |       |       |       |--GENERIC_START -> < [12:18]
+        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [12:19]
+        |   |       |       |       |   `--IDENT -> String [12:19]
+        |   |       |       |       `--GENERIC_END -> > [12:25]
+        |   |       |       `--GENERIC_END -> > [12:26]
+        |   |       `--IDENT -> b [12:28]
+        |   |--RPAREN -> ) [12:29]
+        |   `--SLIST -> { [12:31]
+        |       |--LITERAL_RETURN -> return [13:8]
+        |       |   |--EXPR -> EXPR [13:15]
+        |       |   |   `--LITERAL_SWITCH -> switch [13:15]
+        |       |   |       |--LPAREN -> ( [13:22]
+        |       |   |       |--EXPR -> EXPR [13:23]
+        |       |   |       |   `--IDENT -> b [13:23]
+        |       |   |       |--RPAREN -> ) [13:24]
+        |       |   |       |--LCURLY -> { [13:26]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [14:12]
+        |       |   |       |   |--LITERAL_CASE -> case [14:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [15:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [15:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [14:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [14:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [14:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [14:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [14:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [14:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [14:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [14:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [14:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [14:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [14:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [14:34]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [14:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [14:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [14:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [14:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [14:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:38]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [14:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [14:44]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [14:45]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [14:46]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:46]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [14:46]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [14:46]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [14:46]
+        |       |   |       |   |           |   |       |       `--IDENT -> s [14:53]
+        |       |   |       |   |           |   |       |--RPAREN -> ) [14:54]
+        |       |   |       |   |           |   |       `--IDENT -> box [14:55]
+        |       |   |       |   |           |   `--RPAREN -> ) [14:58]
+        |       |   |       |   |           |--LPAREN -> ( [15:25]
+        |       |   |       |   |           |--LPAREN -> ( [15:26]
+        |       |   |       |   |           |--LAND -> && [15:44]
+        |       |   |       |   |           |   |--METHOD_CALL -> ( [15:40]
+        |       |   |       |   |           |   |   |--DOT -> . [15:33]
+        |       |   |       |   |           |   |   |   |--STRING_LITERAL -> "test" [15:27]
+        |       |   |       |   |           |   |   |   `--IDENT -> equals [15:34]
+        |       |   |       |   |           |   |   |--ELIST -> ELIST [15:41]
+        |       |   |       |   |           |   |   |   `--EXPR -> EXPR [15:41]
+        |       |   |       |   |           |   |   |       `--IDENT -> s [15:41]
+        |       |   |       |   |           |   |   `--RPAREN -> ) [15:42]
+        |       |   |       |   |           |   `--NOT_EQUAL -> != [15:53]
+        |       |   |       |   |           |       |--DOT -> . [15:50]
+        |       |   |       |   |           |       |   |--IDENT -> box [15:47]
+        |       |   |       |   |           |       |   `--IDENT -> x [15:51]
+        |       |   |       |   |           |       `--NUM_INT -> 7 [15:56]
+        |       |   |       |   |           |--RPAREN -> ) [15:57]
+        |       |   |       |   |           `--RPAREN -> ) [15:58]
+        |       |   |       |   |--LAMBDA -> -> [15:61]
+        |       |   |       |   |--EXPR -> EXPR [15:64]
+        |       |   |       |   |   `--NUM_INT -> 1 [15:64]
+        |       |   |       |   `--SEMI -> ; [15:65]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [16:12]
+        |       |   |       |   |--LITERAL_CASE -> case [16:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [17:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [17:20]
+        |       |   |       |   |           |--LPAREN -> ( [16:17]
+        |       |   |       |   |           |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [16:18]
+        |       |   |       |   |           |   |   |--MODIFIERS -> MODIFIERS [16:18]
+        |       |   |       |   |           |   |   |--TYPE -> TYPE [16:18]
+        |       |   |       |   |           |   |   |   |--IDENT -> Box [16:18]
+        |       |   |       |   |           |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:21]
+        |       |   |       |   |           |   |   |       |--GENERIC_START -> < [16:21]
+        |       |   |       |   |           |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:22]
+        |       |   |       |   |           |   |   |       |   |--IDENT -> Box [16:22]
+        |       |   |       |   |           |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:25]
+        |       |   |       |   |           |   |   |       |       |--GENERIC_START -> < [16:25]
+        |       |   |       |   |           |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:26]
+        |       |   |       |   |           |   |   |       |       |   `--IDENT -> String [16:26]
+        |       |   |       |   |           |   |   |       |       `--GENERIC_END -> > [16:32]
+        |       |   |       |   |           |   |   |       `--GENERIC_END -> > [16:33]
+        |       |   |       |   |           |   |   |--LPAREN -> ( [16:34]
+        |       |   |       |   |           |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [16:35]
+        |       |   |       |   |           |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [16:35]
+        |       |   |       |   |           |   |   |       |--MODIFIERS -> MODIFIERS [16:35]
+        |       |   |       |   |           |   |   |       |--TYPE -> TYPE [16:35]
+        |       |   |       |   |           |   |   |       |   |--IDENT -> Box [16:35]
+        |       |   |       |   |           |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:38]
+        |       |   |       |   |           |   |   |       |       |--GENERIC_START -> < [16:38]
+        |       |   |       |   |           |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:39]
+        |       |   |       |   |           |   |   |       |       |   `--IDENT -> String [16:39]
+        |       |   |       |   |           |   |   |       |       `--GENERIC_END -> > [16:45]
+        |       |   |       |   |           |   |   |       |--LPAREN -> ( [16:46]
+        |       |   |       |   |           |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [16:47]
+        |       |   |       |   |           |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [16:47]
+        |       |   |       |   |           |   |   |       |       |--MODIFIERS -> MODIFIERS [16:47]
+        |       |   |       |   |           |   |   |       |       |--TYPE -> TYPE [16:47]
+        |       |   |       |   |           |   |   |       |       |   `--IDENT -> String [16:47]
+        |       |   |       |   |           |   |   |       |       `--IDENT -> s [16:54]
+        |       |   |       |   |           |   |   |       |--RPAREN -> ) [16:55]
+        |       |   |       |   |           |   |   |       `--IDENT -> box [16:56]
+        |       |   |       |   |           |   |   `--RPAREN -> ) [16:59]
+        |       |   |       |   |           |   `--RPAREN -> ) [16:60]
+        |       |   |       |   |           |--LPAREN -> ( [17:25]
+        |       |   |       |   |           |--LAND -> && [17:45]
+        |       |   |       |   |           |   |--LPAREN -> ( [17:26]
+        |       |   |       |   |           |   |--METHOD_CALL -> ( [17:40]
+        |       |   |       |   |           |   |   |--DOT -> . [17:33]
+        |       |   |       |   |           |   |   |   |--STRING_LITERAL -> "test" [17:27]
+        |       |   |       |   |           |   |   |   `--IDENT -> equals [17:34]
+        |       |   |       |   |           |   |   |--ELIST -> ELIST [17:41]
+        |       |   |       |   |           |   |   |   `--EXPR -> EXPR [17:41]
+        |       |   |       |   |           |   |   |       `--IDENT -> s [17:41]
+        |       |   |       |   |           |   |   `--RPAREN -> ) [17:42]
+        |       |   |       |   |           |   |--RPAREN -> ) [17:43]
+        |       |   |       |   |           |   |--LPAREN -> ( [17:48]
+        |       |   |       |   |           |   |--NOT_EQUAL -> != [17:61]
+        |       |   |       |   |           |   |   |--TYPECAST -> ( [17:49]
+        |       |   |       |   |           |   |   |   |--TYPE -> TYPE [17:50]
+        |       |   |       |   |           |   |   |   |   `--LITERAL_INT -> int [17:50]
+        |       |   |       |   |           |   |   |   |--RPAREN -> ) [17:53]
+        |       |   |       |   |           |   |   |   `--DOT -> . [17:58]
+        |       |   |       |   |           |   |   |       |--IDENT -> box [17:55]
+        |       |   |       |   |           |   |   |       `--IDENT -> x [17:59]
+        |       |   |       |   |           |   |   `--NUM_INT -> 7 [17:64]
+        |       |   |       |   |           |   `--RPAREN -> ) [17:65]
+        |       |   |       |   |           `--RPAREN -> ) [17:66]
+        |       |   |       |   |--LAMBDA -> -> [17:69]
+        |       |   |       |   |--EXPR -> EXPR [17:72]
+        |       |   |       |   |   `--NUM_INT -> 1 [17:72]
+        |       |   |       |   `--SEMI -> ; [17:73]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [18:12]
+        |       |   |       |   |--LITERAL_CASE -> case [18:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [19:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [19:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [18:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [18:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [18:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [18:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [18:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [18:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [18:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [18:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [18:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [18:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [18:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [18:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [18:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [18:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [18:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [18:34]
+        |       |   |       |   |           |   |   `--LPAREN -> ( [18:34]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [18:35]
+        |       |   |       |   |           |   |       |   |--MODIFIERS -> MODIFIERS [18:35]
+        |       |   |       |   |           |   |       |   |--TYPE -> TYPE [18:35]
+        |       |   |       |   |           |   |       |   |   |--IDENT -> Box [18:35]
+        |       |   |       |   |           |   |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [18:38]
+        |       |   |       |   |           |   |       |   |       |--GENERIC_START -> < [18:38]
+        |       |   |       |   |           |   |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [18:39]
+        |       |   |       |   |           |   |       |   |       |   `--IDENT -> String [18:39]
+        |       |   |       |   |           |   |       |   |       `--GENERIC_END -> > [18:45]
+        |       |   |       |   |           |   |       |   |--LPAREN -> ( [18:46]
+        |       |   |       |   |           |   |       |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [18:47]
+        |       |   |       |   |           |   |       |   |   `--LPAREN -> ( [18:47]
+        |       |   |       |   |           |   |       |   |       |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [18:48]
+        |       |   |       |   |           |   |       |   |       |   |--MODIFIERS -> MODIFIERS [18:48]
+        |       |   |       |   |           |   |       |   |       |   |--TYPE -> TYPE [18:48]
+        |       |   |       |   |           |   |       |   |       |   |   `--IDENT -> String [18:48]
+        |       |   |       |   |           |   |       |   |       |   `--IDENT -> s [18:55]
+        |       |   |       |   |           |   |       |   |       `--RPAREN -> ) [18:56]
+        |       |   |       |   |           |   |       |   |--RPAREN -> ) [18:57]
+        |       |   |       |   |           |   |       |   `--IDENT -> box [18:58]
+        |       |   |       |   |           |   |       `--RPAREN -> ) [18:61]
+        |       |   |       |   |           |   `--RPAREN -> ) [18:62]
+        |       |   |       |   |           `--LAND -> && [19:51]
+        |       |   |       |   |               |--TYPECAST -> ( [19:25]
+        |       |   |       |   |               |   |--TYPE -> TYPE [19:26]
+        |       |   |       |   |               |   |   `--LITERAL_BOOLEAN -> boolean [19:26]
+        |       |   |       |   |               |   |--RPAREN -> ) [19:33]
+        |       |   |       |   |               |   `--METHOD_CALL -> ( [19:47]
+        |       |   |       |   |               |       |--DOT -> . [19:40]
+        |       |   |       |   |               |       |   |--STRING_LITERAL -> "test" [19:34]
+        |       |   |       |   |               |       |   `--IDENT -> equals [19:41]
+        |       |   |       |   |               |       |--ELIST -> ELIST [19:48]
+        |       |   |       |   |               |       |   `--EXPR -> EXPR [19:48]
+        |       |   |       |   |               |       |       `--IDENT -> s [19:48]
+        |       |   |       |   |               |       `--RPAREN -> ) [19:49]
+        |       |   |       |   |               `--TYPECAST -> ( [19:54]
+        |       |   |       |   |                   |--TYPE -> TYPE [19:55]
+        |       |   |       |   |                   |   `--LITERAL_BOOLEAN -> boolean [19:55]
+        |       |   |       |   |                   |--RPAREN -> ) [19:62]
+        |       |   |       |   |                   `--METHOD_CALL -> ( [19:77]
+        |       |   |       |   |                       |--DOT -> . [19:70]
+        |       |   |       |   |                       |   |--IDENT -> Objects [19:63]
+        |       |   |       |   |                       |   `--IDENT -> equals [19:71]
+        |       |   |       |   |                       |--ELIST -> ELIST [19:81]
+        |       |   |       |   |                       |   |--EXPR -> EXPR [19:81]
+        |       |   |       |   |                       |   |   `--DOT -> . [19:81]
+        |       |   |       |   |                       |   |       |--IDENT -> box [19:78]
+        |       |   |       |   |                       |   |       `--IDENT -> v [19:82]
+        |       |   |       |   |                       |   |--COMMA -> , [19:83]
+        |       |   |       |   |                       |   `--EXPR -> EXPR [19:85]
+        |       |   |       |   |                       |       `--STRING_LITERAL -> "box" [19:85]
+        |       |   |       |   |                       `--RPAREN -> ) [19:90]
+        |       |   |       |   |--LAMBDA -> -> [19:92]
+        |       |   |       |   |--EXPR -> EXPR [19:95]
+        |       |   |       |   |   |--LPAREN -> ( [19:95]
+        |       |   |       |   |   |--NUM_INT -> 1 [19:96]
+        |       |   |       |   |   `--RPAREN -> ) [19:97]
+        |       |   |       |   `--SEMI -> ; [19:98]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [20:12]
+        |       |   |       |   |--LITERAL_CASE -> case [20:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [21:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [21:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [20:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [20:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [20:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [20:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [20:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [20:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [20:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [20:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [20:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [20:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [20:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [20:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [20:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [20:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [20:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [20:34]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [20:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [20:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [20:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [20:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [20:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [20:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [20:38]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [20:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [20:44]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [20:45]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [20:46]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [20:46]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [20:46]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [20:46]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [20:46]
+        |       |   |       |   |           |   |       |       `--IDENT -> s [20:53]
+        |       |   |       |   |           |   |       |--RPAREN -> ) [20:54]
+        |       |   |       |   |           |   |       `--IDENT -> box [20:55]
+        |       |   |       |   |           |   `--RPAREN -> ) [20:58]
+        |       |   |       |   |           `--LOR -> || [22:24]
+        |       |   |       |   |               |--LAND -> && [21:42]
+        |       |   |       |   |               |   |--METHOD_CALL -> ( [21:38]
+        |       |   |       |   |               |   |   |--DOT -> . [21:31]
+        |       |   |       |   |               |   |   |   |--STRING_LITERAL -> "test" [21:25]
+        |       |   |       |   |               |   |   |   `--IDENT -> equals [21:32]
+        |       |   |       |   |               |   |   |--ELIST -> ELIST [21:39]
+        |       |   |       |   |               |   |   |   `--EXPR -> EXPR [21:39]
+        |       |   |       |   |               |   |   |       `--IDENT -> s [21:39]
+        |       |   |       |   |               |   |   `--RPAREN -> ) [21:40]
+        |       |   |       |   |               |   `--METHOD_CALL -> ( [21:59]
+        |       |   |       |   |               |       |--DOT -> . [21:52]
+        |       |   |       |   |               |       |   |--IDENT -> Objects [21:45]
+        |       |   |       |   |               |       |   `--IDENT -> equals [21:53]
+        |       |   |       |   |               |       |--ELIST -> ELIST [21:63]
+        |       |   |       |   |               |       |   |--EXPR -> EXPR [21:63]
+        |       |   |       |   |               |       |   |   `--DOT -> . [21:63]
+        |       |   |       |   |               |       |   |       |--IDENT -> box [21:60]
+        |       |   |       |   |               |       |   |       `--IDENT -> v [21:64]
+        |       |   |       |   |               |       |   |--COMMA -> , [21:65]
+        |       |   |       |   |               |       |   `--EXPR -> EXPR [21:67]
+        |       |   |       |   |               |       |       `--STRING_LITERAL -> "box" [21:67]
+        |       |   |       |   |               |       `--RPAREN -> ) [21:72]
+        |       |   |       |   |               `--METHOD_CALL -> ( [22:50]
+        |       |   |       |   |                   |--DOT -> . [22:43]
+        |       |   |       |   |                   |   |--STRING_LITERAL -> "something else" [22:27]
+        |       |   |       |   |                   |   `--IDENT -> equals [22:44]
+        |       |   |       |   |                   |--ELIST -> ELIST [22:51]
+        |       |   |       |   |                   |   `--EXPR -> EXPR [22:51]
+        |       |   |       |   |                   |       `--IDENT -> s [22:51]
+        |       |   |       |   |                   `--RPAREN -> ) [22:52]
+        |       |   |       |   |--LAMBDA -> -> [22:54]
+        |       |   |       |   |--EXPR -> EXPR [22:57]
+        |       |   |       |   |   `--NUM_INT -> 1 [22:57]
+        |       |   |       |   `--SEMI -> ; [22:58]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [23:12]
+        |       |   |       |   |--LITERAL_CASE -> case [23:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [24:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [24:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [23:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [23:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [23:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [23:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [23:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [23:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [23:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [23:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [23:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [23:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [23:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [23:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [23:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [23:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [23:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [23:34]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [23:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [23:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [23:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [23:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [23:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [23:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [23:38]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [23:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [23:44]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [23:45]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [23:46]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [23:46]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [23:46]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [23:46]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [23:46]
+        |       |   |       |   |           |   |       |       `--IDENT -> s [23:53]
+        |       |   |       |   |           |   |       `--RPAREN -> ) [23:54]
+        |       |   |       |   |           |   `--RPAREN -> ) [23:55]
+        |       |   |       |   |           `--METHOD_CALL -> ( [24:38]
+        |       |   |       |   |               |--DOT -> . [24:31]
+        |       |   |       |   |               |   |--STRING_LITERAL -> "test" [24:25]
+        |       |   |       |   |               |   `--IDENT -> equals [24:32]
+        |       |   |       |   |               |--ELIST -> ELIST [24:39]
+        |       |   |       |   |               |   `--EXPR -> EXPR [24:39]
+        |       |   |       |   |               |       `--IDENT -> s [24:39]
+        |       |   |       |   |               `--RPAREN -> ) [24:40]
+        |       |   |       |   |--LAMBDA -> -> [24:42]
+        |       |   |       |   |--EXPR -> EXPR [24:45]
+        |       |   |       |   |   `--NUM_INT -> 1 [24:45]
+        |       |   |       |   `--SEMI -> ; [24:46]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [25:12]
+        |       |   |       |   |--LITERAL_CASE -> case [25:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [26:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [26:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [25:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [25:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [25:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [25:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [25:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [25:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [25:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [25:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [25:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [25:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [25:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [25:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [25:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [25:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [25:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [25:34]
+        |       |   |       |   |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [25:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [25:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [25:34]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [25:34]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [25:37]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [25:37]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [25:38]
+        |       |   |       |   |           |   |       |       |   `--WILDCARD_TYPE -> ? [25:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [25:39]
+        |       |   |       |   |           |   |       `--IDENT -> b2 [25:41]
+        |       |   |       |   |           |   `--RPAREN -> ) [25:43]
+        |       |   |       |   |           `--METHOD_CALL -> ( [26:38]
+        |       |   |       |   |               |--DOT -> . [26:31]
+        |       |   |       |   |               |   |--STRING_LITERAL -> "test" [26:25]
+        |       |   |       |   |               |   `--IDENT -> equals [26:32]
+        |       |   |       |   |               |--ELIST -> ELIST [26:41]
+        |       |   |       |   |               |   `--EXPR -> EXPR [26:41]
+        |       |   |       |   |               |       `--DOT -> . [26:41]
+        |       |   |       |   |               |           |--IDENT -> b2 [26:39]
+        |       |   |       |   |               |           `--IDENT -> v [26:42]
+        |       |   |       |   |               `--RPAREN -> ) [26:43]
+        |       |   |       |   |--LAMBDA -> -> [26:45]
+        |       |   |       |   |--EXPR -> EXPR [26:48]
+        |       |   |       |   |   `--NUM_INT -> 1 [26:48]
+        |       |   |       |   `--SEMI -> ; [26:49]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [27:12]
+        |       |   |       |   |--LITERAL_CASE -> case [27:12]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [28:20]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [28:20]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:17]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [27:17]
+        |       |   |       |   |           |   |--TYPE -> TYPE [27:17]
+        |       |   |       |   |           |   |   |--IDENT -> Box [27:17]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [27:20]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [27:20]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [27:21]
+        |       |   |       |   |           |   |       |   |--IDENT -> Box [27:21]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [27:24]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [27:24]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [27:25]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> String [27:25]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [27:31]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [27:32]
+        |       |   |       |   |           |   |--LPAREN -> ( [27:33]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:34]
+        |       |   |       |   |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [27:34]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [27:34]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [27:34]
+        |       |   |       |   |           |   |       |   `--IDENT -> Object [27:34]
+        |       |   |       |   |           |   |       `--IDENT -> o [27:41]
+        |       |   |       |   |           |   |--RPAREN -> ) [27:42]
+        |       |   |       |   |           |   `--IDENT -> b2 [27:44]
+        |       |   |       |   |           `--LAND -> && [28:38]
+        |       |   |       |   |               |--NOT_EQUAL -> != [28:30]
+        |       |   |       |   |               |   |--DOT -> . [28:27]
+        |       |   |       |   |               |   |   |--IDENT -> b2 [28:25]
+        |       |   |       |   |               |   |   `--IDENT -> v [28:28]
+        |       |   |       |   |               |   `--LITERAL_NULL -> null [28:33]
+        |       |   |       |   |               `--METHOD_CALL -> ( [28:58]
+        |       |   |       |   |                   |--DOT -> . [28:51]
+        |       |   |       |   |                   |   |--STRING_LITERAL -> "whatever" [28:41]
+        |       |   |       |   |                   |   `--IDENT -> equals [28:52]
+        |       |   |       |   |                   |--ELIST -> ELIST [28:69]
+        |       |   |       |   |                   |   `--EXPR -> EXPR [28:69]
+        |       |   |       |   |                   |       `--METHOD_CALL -> ( [28:69]
+        |       |   |       |   |                   |           |--DOT -> . [28:60]
+        |       |   |       |   |                   |           |   |--IDENT -> o [28:59]
+        |       |   |       |   |                   |           |   `--IDENT -> toString [28:61]
+        |       |   |       |   |                   |           |--ELIST -> ELIST [28:70]
+        |       |   |       |   |                   |           `--RPAREN -> ) [28:70]
+        |       |   |       |   |                   `--RPAREN -> ) [28:71]
+        |       |   |       |   |--LAMBDA -> -> [28:72]
+        |       |   |       |   |--EXPR -> EXPR [28:75]
+        |       |   |       |   |   `--NUM_INT -> 1 [28:75]
+        |       |   |       |   `--SEMI -> ; [28:76]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [29:12]
+        |       |   |       |   |--LITERAL_DEFAULT -> default [29:12]
+        |       |   |       |   |--LAMBDA -> -> [29:20]
+        |       |   |       |   |--EXPR -> EXPR [29:23]
+        |       |   |       |   |   `--UNARY_MINUS -> - [29:23]
+        |       |   |       |   |       `--NUM_INT -> 1 [29:24]
+        |       |   |       |   `--SEMI -> ; [29:25]
+        |       |   |       `--RCURLY -> } [30:8]
+        |       |   `--SEMI -> ; [30:9]
+        |       `--RCURLY -> } [31:4]
+        |--RECORD_DEF -> RECORD_DEF [33:4]
+        |   |--MODIFIERS -> MODIFIERS [33:4]
+        |   |--LITERAL_RECORD -> record [33:4]
+        |   |--IDENT -> when [33:11]
+        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [33:15]
+        |   |   |--GENERIC_START -> < [33:15]
+        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [33:16]
+        |   |   |   `--IDENT -> T [33:16]
+        |   |   `--GENERIC_END -> > [33:17]
+        |   |--LPAREN -> ( [33:18]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [33:19]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [33:19]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [33:19]
+        |   |       |--TYPE -> TYPE [33:19]
+        |   |       |   |--IDENT -> when [33:19]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [33:23]
+        |   |       |       |--GENERIC_START -> < [33:23]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [33:24]
+        |   |       |       |   `--IDENT -> T [33:24]
+        |   |       |       `--GENERIC_END -> > [33:25]
+        |   |       `--IDENT -> when [33:27]
+        |   |--RPAREN -> ) [33:31]
+        |   `--OBJBLOCK -> OBJBLOCK [33:32]
+        |       |--LCURLY -> { [33:32]
+        |       `--RCURLY -> } [33:33]
+        |--METHOD_DEF -> METHOD_DEF [35:4]
+        |   |--MODIFIERS -> MODIFIERS [35:4]
+        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [35:4]
+        |   |   |--GENERIC_START -> < [35:4]
+        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [35:5]
+        |   |   |   `--IDENT -> T [35:5]
+        |   |   `--GENERIC_END -> > [35:6]
+        |   |--TYPE -> TYPE [35:8]
+        |   |   `--LITERAL_INT -> int [35:8]
+        |   |--IDENT -> moreTrickyWhen [35:12]
+        |   |--LPAREN -> ( [35:26]
+        |   |--PARAMETERS -> PARAMETERS [35:27]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [35:27]
+        |   |       |--MODIFIERS -> MODIFIERS [35:27]
+        |   |       |--TYPE -> TYPE [35:27]
+        |   |       |   |--IDENT -> when [35:27]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:31]
+        |   |       |       |--GENERIC_START -> < [35:31]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:32]
+        |   |       |       |   |--IDENT -> when [35:32]
+        |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:36]
+        |   |       |       |       |--GENERIC_START -> < [35:36]
+        |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:37]
+        |   |       |       |       |   `--IDENT -> T [35:37]
+        |   |       |       |       `--GENERIC_END -> > [35:38]
+        |   |       |       `--GENERIC_END -> > [35:39]
+        |   |       `--IDENT -> when [35:41]
+        |   |--RPAREN -> ) [35:45]
+        |   `--SLIST -> { [35:46]
+        |       |--LITERAL_RETURN -> return [36:8]
+        |       |   |--EXPR -> EXPR [36:15]
+        |       |   |   `--LITERAL_SWITCH -> switch [36:15]
+        |       |   |       |--LPAREN -> ( [36:21]
+        |       |   |       |--EXPR -> EXPR [36:22]
+        |       |   |       |   `--IDENT -> when [36:22]
+        |       |   |       |--RPAREN -> ) [36:26]
+        |       |   |       |--LCURLY -> { [36:28]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [37:8]
+        |       |   |       |   |--LITERAL_CASE -> case [37:8]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [38:18]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [38:18]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [37:13]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [37:13]
+        |       |   |       |   |           |   |--TYPE -> TYPE [37:13]
+        |       |   |       |   |           |   |   |--IDENT -> when [37:13]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [37:17]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [37:17]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [37:18]
+        |       |   |       |   |           |   |       |   |--IDENT -> when [37:18]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [37:22]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [37:22]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [37:23]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> T [37:23]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [37:24]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [37:25]
+        |       |   |       |   |           |   |--LPAREN -> ( [37:26]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [37:27]
+        |       |   |       |   |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:27]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [37:27]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [37:27]
+        |       |   |       |   |           |   |       |   |--IDENT -> when [37:27]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [37:31]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [37:31]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [37:32]
+        |       |   |       |   |           |   |       |       |   |--IDENT -> when [37:32]
+        |       |   |       |   |           |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [37:36]
+        |       |   |       |   |           |   |       |       |       |--GENERIC_START -> < [37:36]
+        |       |   |       |   |           |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [37:37]
+        |       |   |       |   |           |   |       |       |       |   `--IDENT -> T [37:37]
+        |       |   |       |   |           |   |       |       |       `--GENERIC_END -> > [37:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [37:39]
+        |       |   |       |   |           |   |       `--IDENT -> w1 [37:41]
+        |       |   |       |   |           |   `--RPAREN -> ) [37:43]
+        |       |   |       |   |           `--METHOD_CALL -> ( [38:65]
+        |       |   |       |   |               |--DOT -> . [38:58]
+        |       |   |       |   |               |   |--DOT -> . [38:53]
+        |       |   |       |   |               |   |   |--DOT -> . [38:48]
+        |       |   |       |   |               |   |   |   |--DOT -> . [38:43]
+        |       |   |       |   |               |   |   |   |   |--DOT -> . [38:38]
+        |       |   |       |   |               |   |   |   |   |   |--DOT -> . [38:33]
+        |       |   |       |   |               |   |   |   |   |   |   |--LPAREN -> ( [38:23]
+        |       |   |       |   |               |   |   |   |   |   |   |--TYPECAST -> ( [38:24]
+        |       |   |       |   |               |   |   |   |   |   |   |   |--TYPE -> TYPE [38:25]
+        |       |   |       |   |               |   |   |   |   |   |   |   |   `--IDENT -> when [38:25]
+        |       |   |       |   |               |   |   |   |   |   |   |   |--RPAREN -> ) [38:29]
+        |       |   |       |   |               |   |   |   |   |   |   |   `--IDENT -> w1 [38:30]
+        |       |   |       |   |               |   |   |   |   |   |   |--RPAREN -> ) [38:32]
+        |       |   |       |   |               |   |   |   |   |   |   `--IDENT -> when [38:34]
+        |       |   |       |   |               |   |   |   |   |   `--IDENT -> when [38:39]
+        |       |   |       |   |               |   |   |   |   `--IDENT -> when [38:44]
+        |       |   |       |   |               |   |   |   `--IDENT -> when [38:49]
+        |       |   |       |   |               |   |   `--IDENT -> when [38:54]
+        |       |   |       |   |               |   `--IDENT -> equals [38:59]
+        |       |   |       |   |               |--ELIST -> ELIST [38:66]
+        |       |   |       |   |               |   `--EXPR -> EXPR [38:66]
+        |       |   |       |   |               |       `--LITERAL_NULL -> null [38:66]
+        |       |   |       |   |               `--RPAREN -> ) [38:70]
+        |       |   |       |   |--LAMBDA -> -> [38:71]
+        |       |   |       |   |--EXPR -> EXPR [38:74]
+        |       |   |       |   |   `--NUM_INT -> 2 [38:74]
+        |       |   |       |   `--SEMI -> ; [38:75]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [39:8]
+        |       |   |       |   |--LITERAL_CASE -> case [39:8]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [40:18]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [40:18]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [39:13]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [39:13]
+        |       |   |       |   |           |   |--TYPE -> TYPE [39:13]
+        |       |   |       |   |           |   |   |--IDENT -> when [39:13]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:17]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [39:17]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:18]
+        |       |   |       |   |           |   |       |   |--IDENT -> when [39:18]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:22]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [39:22]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:23]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> T [39:23]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [39:24]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [39:25]
+        |       |   |       |   |           |   |--LPAREN -> ( [39:26]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [39:27]
+        |       |   |       |   |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [39:27]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [39:27]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [39:27]
+        |       |   |       |   |           |   |       |   |--IDENT -> when [39:27]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:31]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [39:31]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:32]
+        |       |   |       |   |           |   |       |       |   |--IDENT -> when [39:32]
+        |       |   |       |   |           |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:36]
+        |       |   |       |   |           |   |       |       |       |--GENERIC_START -> < [39:36]
+        |       |   |       |   |           |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:37]
+        |       |   |       |   |           |   |       |       |       |   `--IDENT -> T [39:37]
+        |       |   |       |   |           |   |       |       |       `--GENERIC_END -> > [39:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [39:39]
+        |       |   |       |   |           |   |       `--IDENT -> w1 [39:41]
+        |       |   |       |   |           |   `--RPAREN -> ) [39:43]
+        |       |   |       |   |           |--LPAREN -> ( [40:23]
+        |       |   |       |   |           |--LPAREN -> ( [40:24]
+        |       |   |       |   |           |--LPAREN -> ( [40:25]
+        |       |   |       |   |           |--METHOD_CALL -> ( [40:60]
+        |       |   |       |   |           |   |--DOT -> . [40:53]
+        |       |   |       |   |           |   |   |--DOT -> . [40:48]
+        |       |   |       |   |           |   |   |   |--DOT -> . [40:43]
+        |       |   |       |   |           |   |   |   |   |--DOT -> . [40:38]
+        |       |   |       |   |           |   |   |   |   |   |--DOT -> . [40:33]
+        |       |   |       |   |           |   |   |   |   |   |   |--DOT -> . [40:28]
+        |       |   |       |   |           |   |   |   |   |   |   |   |--IDENT -> w1 [40:26]
+        |       |   |       |   |           |   |   |   |   |   |   |   `--IDENT -> when [40:29]
+        |       |   |       |   |           |   |   |   |   |   |   `--IDENT -> when [40:34]
+        |       |   |       |   |           |   |   |   |   |   `--IDENT -> when [40:39]
+        |       |   |       |   |           |   |   |   |   `--IDENT -> when [40:44]
+        |       |   |       |   |           |   |   |   `--IDENT -> when [40:49]
+        |       |   |       |   |           |   |   `--IDENT -> equals [40:54]
+        |       |   |       |   |           |   |--ELIST -> ELIST [40:61]
+        |       |   |       |   |           |   |   `--EXPR -> EXPR [40:61]
+        |       |   |       |   |           |   |       `--LITERAL_NULL -> null [40:61]
+        |       |   |       |   |           |   `--RPAREN -> ) [40:65]
+        |       |   |       |   |           |--RPAREN -> ) [40:66]
+        |       |   |       |   |           |--RPAREN -> ) [40:67]
+        |       |   |       |   |           `--RPAREN -> ) [40:68]
+        |       |   |       |   |--LAMBDA -> -> [41:24]
+        |       |   |       |   |--EXPR -> EXPR [41:27]
+        |       |   |       |   |   `--NUM_INT -> 2 [41:27]
+        |       |   |       |   `--SEMI -> ; [41:28]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [42:8]
+        |       |   |       |   |--LITERAL_CASE -> case [42:8]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [43:18]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [43:18]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [42:13]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [42:13]
+        |       |   |       |   |           |   |--TYPE -> TYPE [42:13]
+        |       |   |       |   |           |   |   |--IDENT -> when [42:13]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:17]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [42:17]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:18]
+        |       |   |       |   |           |   |       |   |--IDENT -> when [42:18]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:22]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [42:22]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:23]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> T [42:23]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [42:24]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [42:25]
+        |       |   |       |   |           |   |--LPAREN -> ( [42:26]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [42:27]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [42:27]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [42:27]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [42:27]
+        |       |   |       |   |           |   |       |   |--IDENT -> when [42:27]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:31]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [42:31]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:32]
+        |       |   |       |   |           |   |       |       |   |--IDENT -> when [42:32]
+        |       |   |       |   |           |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:36]
+        |       |   |       |   |           |   |       |       |       |--GENERIC_START -> < [42:36]
+        |       |   |       |   |           |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:37]
+        |       |   |       |   |           |   |       |       |       |   `--IDENT -> T [42:37]
+        |       |   |       |   |           |   |       |       |       `--GENERIC_END -> > [42:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [42:39]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [42:40]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [42:41]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [42:41]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [42:41]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [42:41]
+        |       |   |       |   |           |   |       |       |   |--IDENT -> when [42:41]
+        |       |   |       |   |           |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:45]
+        |       |   |       |   |           |   |       |       |       |--GENERIC_START -> < [42:45]
+        |       |   |       |   |           |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:46]
+        |       |   |       |   |           |   |       |       |       |   |--IDENT -> when [42:46]
+        |       |   |       |   |           |   |       |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:50]
+        |       |   |       |   |           |   |       |       |       |       |--GENERIC_START -> < [42:50]
+        |       |   |       |   |           |   |       |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:51]
+        |       |   |       |   |           |   |       |       |       |       |   `--IDENT -> T [42:51]
+        |       |   |       |   |           |   |       |       |       |       `--GENERIC_END -> > [42:52]
+        |       |   |       |   |           |   |       |       |       `--GENERIC_END -> > [42:53]
+        |       |   |       |   |           |   |       |       `--IDENT -> w2 [42:55]
+        |       |   |       |   |           |   |       |--RPAREN -> ) [42:57]
+        |       |   |       |   |           |   |       `--IDENT -> w1 [42:59]
+        |       |   |       |   |           |   `--RPAREN -> ) [42:61]
+        |       |   |       |   |           `--LOR -> || [44:24]
+        |       |   |       |   |               |--LPAREN -> ( [43:23]
+        |       |   |       |   |               |--LPAREN -> ( [43:24]
+        |       |   |       |   |               |--LPAREN -> ( [43:25]
+        |       |   |       |   |               |--METHOD_CALL -> ( [43:60]
+        |       |   |       |   |               |   |--DOT -> . [43:53]
+        |       |   |       |   |               |   |   |--DOT -> . [43:48]
+        |       |   |       |   |               |   |   |   |--DOT -> . [43:43]
+        |       |   |       |   |               |   |   |   |   |--DOT -> . [43:38]
+        |       |   |       |   |               |   |   |   |   |   |--DOT -> . [43:33]
+        |       |   |       |   |               |   |   |   |   |   |   |--DOT -> . [43:28]
+        |       |   |       |   |               |   |   |   |   |   |   |   |--IDENT -> w1 [43:26]
+        |       |   |       |   |               |   |   |   |   |   |   |   `--IDENT -> when [43:29]
+        |       |   |       |   |               |   |   |   |   |   |   `--IDENT -> when [43:34]
+        |       |   |       |   |               |   |   |   |   |   `--IDENT -> when [43:39]
+        |       |   |       |   |               |   |   |   |   `--IDENT -> when [43:44]
+        |       |   |       |   |               |   |   |   `--IDENT -> when [43:49]
+        |       |   |       |   |               |   |   `--IDENT -> equals [43:54]
+        |       |   |       |   |               |   |--ELIST -> ELIST [43:61]
+        |       |   |       |   |               |   |   `--EXPR -> EXPR [43:61]
+        |       |   |       |   |               |   |       `--LITERAL_NULL -> null [43:61]
+        |       |   |       |   |               |   `--RPAREN -> ) [43:65]
+        |       |   |       |   |               |--RPAREN -> ) [43:66]
+        |       |   |       |   |               |--RPAREN -> ) [43:67]
+        |       |   |       |   |               |--RPAREN -> ) [43:68]
+        |       |   |       |   |               `--METHOD_CALL -> ( [44:44]
+        |       |   |       |   |                   |--DOT -> . [44:37]
+        |       |   |       |   |                   |   |--LPAREN -> ( [44:27]
+        |       |   |       |   |                   |   |--TYPECAST -> ( [44:28]
+        |       |   |       |   |                   |   |   |--TYPE -> TYPE [44:29]
+        |       |   |       |   |                   |   |   |   `--IDENT -> when [44:29]
+        |       |   |       |   |                   |   |   |--RPAREN -> ) [44:33]
+        |       |   |       |   |                   |   |   `--IDENT -> w2 [44:34]
+        |       |   |       |   |                   |   |--RPAREN -> ) [44:36]
+        |       |   |       |   |                   |   `--IDENT -> equals [44:38]
+        |       |   |       |   |                   |--ELIST -> ELIST [44:45]
+        |       |   |       |   |                   |   `--EXPR -> EXPR [44:45]
+        |       |   |       |   |                   |       |--LPAREN -> ( [44:45]
+        |       |   |       |   |                   |       |--TYPECAST -> ( [44:46]
+        |       |   |       |   |                   |       |   |--TYPE -> TYPE [44:47]
+        |       |   |       |   |                   |       |   |   `--IDENT -> when [44:47]
+        |       |   |       |   |                   |       |   |--RPAREN -> ) [44:51]
+        |       |   |       |   |                   |       |   `--IDENT -> w1 [44:52]
+        |       |   |       |   |                   |       `--RPAREN -> ) [44:54]
+        |       |   |       |   |                   `--RPAREN -> ) [44:55]
+        |       |   |       |   |--LAMBDA -> -> [44:56]
+        |       |   |       |   |--EXPR -> EXPR [44:59]
+        |       |   |       |   |   `--NUM_INT -> 2 [44:59]
+        |       |   |       |   `--SEMI -> ; [44:60]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [45:8]
+        |       |   |       |   |--LITERAL_CASE -> case [45:8]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [46:18]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [46:18]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [45:13]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [45:13]
+        |       |   |       |   |           |   |--TYPE -> TYPE [45:13]
+        |       |   |       |   |           |   |   |--IDENT -> when [45:13]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:17]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [45:17]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:18]
+        |       |   |       |   |           |   |       |   |--IDENT -> when [45:18]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:22]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [45:22]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:23]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> T [45:23]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [45:24]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [45:25]
+        |       |   |       |   |           |   |--LPAREN -> ( [45:26]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [45:27]
+        |       |   |       |   |           |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [45:27]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [45:27]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [45:27]
+        |       |   |       |   |           |   |       |   |--IDENT -> when [45:27]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:31]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [45:31]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:32]
+        |       |   |       |   |           |   |       |       |   |--IDENT -> when [45:32]
+        |       |   |       |   |           |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:36]
+        |       |   |       |   |           |   |       |       |       |--GENERIC_START -> < [45:36]
+        |       |   |       |   |           |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:37]
+        |       |   |       |   |           |   |       |       |       |   `--IDENT -> T [45:37]
+        |       |   |       |   |           |   |       |       |       `--GENERIC_END -> > [45:38]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [45:39]
+        |       |   |       |   |           |   |       |--LPAREN -> ( [45:40]
+        |       |   |       |   |           |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [45:41]
+        |       |   |       |   |           |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [45:41]
+        |       |   |       |   |           |   |       |       |--MODIFIERS -> MODIFIERS [45:41]
+        |       |   |       |   |           |   |       |       |--TYPE -> TYPE [45:41]
+        |       |   |       |   |           |   |       |       |   |--IDENT -> when [45:41]
+        |       |   |       |   |           |   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:45]
+        |       |   |       |   |           |   |       |       |       |--GENERIC_START -> < [45:45]
+        |       |   |       |   |           |   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:46]
+        |       |   |       |   |           |   |       |       |       |   |--IDENT -> when [45:46]
+        |       |   |       |   |           |   |       |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:50]
+        |       |   |       |   |           |   |       |       |       |       |--GENERIC_START -> < [45:50]
+        |       |   |       |   |           |   |       |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:51]
+        |       |   |       |   |           |   |       |       |       |       |   `--IDENT -> T [45:51]
+        |       |   |       |   |           |   |       |       |       |       `--GENERIC_END -> > [45:52]
+        |       |   |       |   |           |   |       |       |       `--GENERIC_END -> > [45:53]
+        |       |   |       |   |           |   |       |       `--IDENT -> w2 [45:55]
+        |       |   |       |   |           |   |       |--RPAREN -> ) [45:57]
+        |       |   |       |   |           |   |       `--IDENT -> w1 [45:59]
+        |       |   |       |   |           |   `--RPAREN -> ) [45:61]
+        |       |   |       |   |           `--LOR -> || [47:24]
+        |       |   |       |   |               |--NOT_EQUAL -> != [46:28]
+        |       |   |       |   |               |   |--IDENT -> when [46:23]
+        |       |   |       |   |               |   `--LITERAL_NULL -> null [46:31]
+        |       |   |       |   |               `--METHOD_CALL -> ( [47:44]
+        |       |   |       |   |                   |--DOT -> . [47:37]
+        |       |   |       |   |                   |   |--LPAREN -> ( [47:27]
+        |       |   |       |   |                   |   |--TYPECAST -> ( [47:28]
+        |       |   |       |   |                   |   |   |--TYPE -> TYPE [47:29]
+        |       |   |       |   |                   |   |   |   `--IDENT -> when [47:29]
+        |       |   |       |   |                   |   |   |--RPAREN -> ) [47:33]
+        |       |   |       |   |                   |   |   `--IDENT -> w2 [47:34]
+        |       |   |       |   |                   |   |--RPAREN -> ) [47:36]
+        |       |   |       |   |                   |   `--IDENT -> equals [47:38]
+        |       |   |       |   |                   |--ELIST -> ELIST [47:45]
+        |       |   |       |   |                   |   `--EXPR -> EXPR [47:45]
+        |       |   |       |   |                   |       |--LPAREN -> ( [47:45]
+        |       |   |       |   |                   |       |--TYPECAST -> ( [47:46]
+        |       |   |       |   |                   |       |   |--TYPE -> TYPE [47:47]
+        |       |   |       |   |                   |       |   |   `--IDENT -> when [47:47]
+        |       |   |       |   |                   |       |   |--RPAREN -> ) [47:51]
+        |       |   |       |   |                   |       |   `--IDENT -> w1 [47:52]
+        |       |   |       |   |                   |       `--RPAREN -> ) [47:54]
+        |       |   |       |   |                   `--RPAREN -> ) [47:55]
+        |       |   |       |   |--LAMBDA -> -> [47:56]
+        |       |   |       |   |--EXPR -> EXPR [47:59]
+        |       |   |       |   |   `--NUM_INT -> 2 [47:59]
+        |       |   |       |   `--SEMI -> ; [47:60]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [48:8]
+        |       |   |       |   |--LITERAL_CASE -> case [48:8]
+        |       |   |       |   |   `--PATTERN_DEF -> PATTERN_DEF [48:37]
+        |       |   |       |   |       `--LITERAL_WHEN -> when [48:37]
+        |       |   |       |   |           |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [48:13]
+        |       |   |       |   |           |   |--MODIFIERS -> MODIFIERS [48:13]
+        |       |   |       |   |           |   |--TYPE -> TYPE [48:13]
+        |       |   |       |   |           |   |   |--IDENT -> when [48:13]
+        |       |   |       |   |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:17]
+        |       |   |       |   |           |   |       |--GENERIC_START -> < [48:17]
+        |       |   |       |   |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [48:18]
+        |       |   |       |   |           |   |       |   |--IDENT -> when [48:18]
+        |       |   |       |   |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:22]
+        |       |   |       |   |           |   |       |       |--GENERIC_START -> < [48:22]
+        |       |   |       |   |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [48:23]
+        |       |   |       |   |           |   |       |       |   `--IDENT -> T [48:23]
+        |       |   |       |   |           |   |       |       `--GENERIC_END -> > [48:24]
+        |       |   |       |   |           |   |       `--GENERIC_END -> > [48:25]
+        |       |   |       |   |           |   |--LPAREN -> ( [48:26]
+        |       |   |       |   |           |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [48:27]
+        |       |   |       |   |           |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [48:27]
+        |       |   |       |   |           |   |       |--MODIFIERS -> MODIFIERS [48:27]
+        |       |   |       |   |           |   |       |--TYPE -> TYPE [48:27]
+        |       |   |       |   |           |   |       |   `--IDENT -> Object [48:27]
+        |       |   |       |   |           |   |       `--IDENT -> w [48:34]
+        |       |   |       |   |           |   `--RPAREN -> ) [48:35]
+        |       |   |       |   |           `--NOT_EQUAL -> != [48:47]
+        |       |   |       |   |               |--IDENT -> when [48:42]
+        |       |   |       |   |               `--LITERAL_NULL -> null [48:50]
+        |       |   |       |   |--LAMBDA -> -> [48:55]
+        |       |   |       |   |--EXPR -> EXPR [48:58]
+        |       |   |       |   |   `--NUM_INT -> 9 [48:58]
+        |       |   |       |   `--SEMI -> ; [48:59]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [49:10]
+        |       |   |       |   |--LITERAL_CASE -> case [49:10]
+        |       |   |       |   |   |--LITERAL_DEFAULT -> default [49:15]
+        |       |   |       |   |   |--COMMA -> , [49:22]
+        |       |   |       |   |   `--EXPR -> EXPR [49:24]
+        |       |   |       |   |       `--LITERAL_NULL -> null [49:24]
+        |       |   |       |   |--LAMBDA -> -> [49:29]
+        |       |   |       |   |--EXPR -> EXPR [49:32]
+        |       |   |       |   |   `--NUM_INT -> 1 [49:32]
+        |       |   |       |   `--SEMI -> ; [49:33]
+        |       |   |       `--RCURLY -> } [50:8]
+        |       |   `--SEMI -> ; [50:9]
+        |       `--RCURLY -> } [51:4]
+        |--METHOD_DEF -> METHOD_DEF [53:4]
+        |   |--MODIFIERS -> MODIFIERS [53:4]
+        |   |--TYPE -> TYPE [53:4]
+        |   |   `--IDENT -> Object [53:4]
+        |   |--IDENT -> m3 [53:11]
+        |   |--LPAREN -> ( [53:13]
+        |   |--PARAMETERS -> PARAMETERS [53:14]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [53:14]
+        |   |       |--MODIFIERS -> MODIFIERS [53:14]
+        |   |       |--TYPE -> TYPE [53:14]
+        |   |       |   |--IDENT -> when [53:14]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [53:18]
+        |   |       |       |--GENERIC_START -> < [53:18]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [53:19]
+        |   |       |       |   `--IDENT -> String [53:19]
+        |   |       |       `--GENERIC_END -> > [53:25]
+        |   |       `--IDENT -> when [53:27]
+        |   |--RPAREN -> ) [53:31]
+        |   `--SLIST -> { [53:33]
+        |       |--LITERAL_IF -> if [54:8]
+        |       |   |--LPAREN -> ( [54:11]
+        |       |   |--EXPR -> EXPR [54:17]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [54:17]
+        |       |   |       |--IDENT -> when [54:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [54:28]
+        |       |   |           |--MODIFIERS -> MODIFIERS [54:28]
+        |       |   |           |--TYPE -> TYPE [54:28]
+        |       |   |           |   |--IDENT -> when [54:28]
+        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [54:32]
+        |       |   |           |       |--GENERIC_START -> < [54:32]
+        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [54:33]
+        |       |   |           |       |   `--IDENT -> String [54:33]
+        |       |   |           |       `--GENERIC_END -> > [54:39]
+        |       |   |           |--LPAREN -> ( [54:40]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [54:41]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [54:41]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [54:41]
+        |       |   |           |       |--TYPE -> TYPE [54:41]
+        |       |   |           |       |   |--IDENT -> when [54:41]
+        |       |   |           |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [54:45]
+        |       |   |           |       |       |--GENERIC_START -> < [54:45]
+        |       |   |           |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [54:46]
+        |       |   |           |       |       |   `--IDENT -> String [54:46]
+        |       |   |           |       |       `--GENERIC_END -> > [54:52]
+        |       |   |           |       `--IDENT -> w1 [54:54]
+        |       |   |           `--RPAREN -> ) [54:56]
+        |       |   |--RPAREN -> ) [54:57]
+        |       |   |--SLIST -> { [54:59]
+        |       |   |   |--LITERAL_RETURN -> return [55:12]
+        |       |   |   |   |--EXPR -> EXPR [55:33]
+        |       |   |   |   |   `--DOT -> . [55:33]
+        |       |   |   |   |       |--METHOD_CALL -> ( [55:31]
+        |       |   |   |   |       |   |--DOT -> . [55:26]
+        |       |   |   |   |       |   |   |--DOT -> . [55:21]
+        |       |   |   |   |       |   |   |   |--IDENT -> w1 [55:19]
+        |       |   |   |   |       |   |   |   `--IDENT -> when [55:22]
+        |       |   |   |   |       |   |   `--IDENT -> when [55:27]
+        |       |   |   |   |       |   |--ELIST -> ELIST [55:32]
+        |       |   |   |   |       |   `--RPAREN -> ) [55:32]
+        |       |   |   |   |       `--IDENT -> when [55:34]
+        |       |   |   |   `--SEMI -> ; [55:38]
+        |       |   |   `--RCURLY -> } [56:8]
+        |       |   `--LITERAL_ELSE -> else [57:8]
+        |       |       `--LITERAL_IF -> if [57:13]
+        |       |           |--LPAREN -> ( [57:16]
+        |       |           |--EXPR -> EXPR [57:22]
+        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [57:22]
+        |       |           |       |--IDENT -> when [57:17]
+        |       |           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [57:33]
+        |       |           |           |--MODIFIERS -> MODIFIERS [57:33]
+        |       |           |           |--TYPE -> TYPE [57:33]
+        |       |           |           |   |--IDENT -> when [57:33]
+        |       |           |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [57:37]
+        |       |           |           |       |--GENERIC_START -> < [57:37]
+        |       |           |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [57:38]
+        |       |           |           |       |   `--IDENT -> String [57:38]
+        |       |           |           |       `--GENERIC_END -> > [57:44]
+        |       |           |           |--LPAREN -> ( [57:45]
+        |       |           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [57:46]
+        |       |           |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [57:46]
+        |       |           |           |       |--MODIFIERS -> MODIFIERS [57:46]
+        |       |           |           |       |--TYPE -> TYPE [57:46]
+        |       |           |           |       |   |--IDENT -> when [57:46]
+        |       |           |           |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [57:50]
+        |       |           |           |       |       |--GENERIC_START -> < [57:50]
+        |       |           |           |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [57:51]
+        |       |           |           |       |       |   `--IDENT -> String [57:51]
+        |       |           |           |       |       `--GENERIC_END -> > [57:57]
+        |       |           |           |       |--LPAREN -> ( [57:58]
+        |       |           |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [57:59]
+        |       |           |           |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [57:59]
+        |       |           |           |       |       |--MODIFIERS -> MODIFIERS [57:59]
+        |       |           |           |       |       |--TYPE -> TYPE [57:59]
+        |       |           |           |       |       |   |--IDENT -> when [57:59]
+        |       |           |           |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [57:63]
+        |       |           |           |       |       |       |--GENERIC_START -> < [57:63]
+        |       |           |           |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [57:64]
+        |       |           |           |       |       |       |   `--IDENT -> String [57:64]
+        |       |           |           |       |       |       `--GENERIC_END -> > [57:70]
+        |       |           |           |       |       `--IDENT -> s1 [57:72]
+        |       |           |           |       `--RPAREN -> ) [57:74]
+        |       |           |           |--RPAREN -> ) [57:75]
+        |       |           |           `--IDENT -> w1 [57:77]
+        |       |           |--RPAREN -> ) [57:79]
+        |       |           |--SLIST -> { [57:81]
+        |       |           |   |--LITERAL_IF -> if [58:12]
+        |       |           |   |   |--LPAREN -> ( [58:15]
+        |       |           |   |   |--EXPR -> EXPR [58:27]
+        |       |           |   |   |   `--METHOD_CALL -> ( [58:27]
+        |       |           |   |   |       |--DOT -> . [58:20]
+        |       |           |   |   |       |   |--STRING_LITERAL -> "s1" [58:16]
+        |       |           |   |   |       |   `--IDENT -> equals [58:21]
+        |       |           |   |   |       |--ELIST -> ELIST [58:28]
+        |       |           |   |   |       |   `--EXPR -> EXPR [58:28]
+        |       |           |   |   |       |       `--IDENT -> s1 [58:28]
+        |       |           |   |   |       `--RPAREN -> ) [58:30]
+        |       |           |   |   |--RPAREN -> ) [58:31]
+        |       |           |   |   |--SLIST -> { [58:33]
+        |       |           |   |   |   |--LITERAL_RETURN -> return [59:16]
+        |       |           |   |   |   |   |--EXPR -> EXPR [59:23]
+        |       |           |   |   |   |   |   `--IDENT -> s1 [59:23]
+        |       |           |   |   |   |   `--SEMI -> ; [59:25]
+        |       |           |   |   |   `--RCURLY -> } [60:12]
+        |       |           |   |   `--LITERAL_ELSE -> else [60:14]
+        |       |           |   |       `--SLIST -> { [60:19]
+        |       |           |   |           |--LITERAL_RETURN -> return [61:16]
+        |       |           |   |           |   |--EXPR -> EXPR [61:23]
+        |       |           |   |           |   |   `--IDENT -> w1 [61:23]
+        |       |           |   |           |   `--SEMI -> ; [61:25]
+        |       |           |   |           `--RCURLY -> } [62:12]
+        |       |           |   `--RCURLY -> } [63:8]
+        |       |           `--LITERAL_ELSE -> else [64:8]
+        |       |               `--LITERAL_IF -> if [64:13]
+        |       |                   |--LPAREN -> ( [64:16]
+        |       |                   |--EXPR -> EXPR [65:20]
+        |       |                   |   `--LAND -> && [65:20]
+        |       |                   |       |--LITERAL_INSTANCEOF -> instanceof [64:22]
+        |       |                   |       |   |--IDENT -> when [64:17]
+        |       |                   |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [64:33]
+        |       |                   |       |       |--MODIFIERS -> MODIFIERS [64:33]
+        |       |                   |       |       |--TYPE -> TYPE [64:33]
+        |       |                   |       |       |   |--IDENT -> when [64:33]
+        |       |                   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [64:37]
+        |       |                   |       |       |       |--GENERIC_START -> < [64:37]
+        |       |                   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [64:38]
+        |       |                   |       |       |       |   `--IDENT -> String [64:38]
+        |       |                   |       |       |       `--GENERIC_END -> > [64:44]
+        |       |                   |       |       |--LPAREN -> ( [64:45]
+        |       |                   |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [64:46]
+        |       |                   |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [64:46]
+        |       |                   |       |       |       |--MODIFIERS -> MODIFIERS [64:46]
+        |       |                   |       |       |       |--TYPE -> TYPE [64:46]
+        |       |                   |       |       |       |   |--IDENT -> when [64:46]
+        |       |                   |       |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [64:50]
+        |       |                   |       |       |       |       |--GENERIC_START -> < [64:50]
+        |       |                   |       |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [64:51]
+        |       |                   |       |       |       |       |   `--IDENT -> String [64:51]
+        |       |                   |       |       |       |       `--GENERIC_END -> > [64:57]
+        |       |                   |       |       |       |--LPAREN -> ( [64:58]
+        |       |                   |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [64:59]
+        |       |                   |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [64:59]
+        |       |                   |       |       |       |       |--MODIFIERS -> MODIFIERS [64:59]
+        |       |                   |       |       |       |       |--TYPE -> TYPE [64:59]
+        |       |                   |       |       |       |       |   |--IDENT -> when [64:59]
+        |       |                   |       |       |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [64:63]
+        |       |                   |       |       |       |       |       |--GENERIC_START -> < [64:63]
+        |       |                   |       |       |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [64:64]
+        |       |                   |       |       |       |       |       |   `--IDENT -> String [64:64]
+        |       |                   |       |       |       |       |       `--GENERIC_END -> > [64:70]
+        |       |                   |       |       |       |       `--IDENT -> s1 [64:72]
+        |       |                   |       |       |       `--RPAREN -> ) [64:74]
+        |       |                   |       |       |--RPAREN -> ) [64:75]
+        |       |                   |       |       `--IDENT -> w1 [64:77]
+        |       |                   |       `--METHOD_CALL -> ( [65:43]
+        |       |                   |           |--DOT -> . [65:36]
+        |       |                   |           |   |--METHOD_CALL -> ( [65:34]
+        |       |                   |           |   |   |--DOT -> . [65:25]
+        |       |                   |           |   |   |   |--IDENT -> s1 [65:23]
+        |       |                   |           |   |   |   `--IDENT -> toString [65:26]
+        |       |                   |           |   |   |--ELIST -> ELIST [65:35]
+        |       |                   |           |   |   `--RPAREN -> ) [65:35]
+        |       |                   |           |   `--IDENT -> equals [65:37]
+        |       |                   |           |--ELIST -> ELIST [65:55]
+        |       |                   |           |   `--EXPR -> EXPR [65:55]
+        |       |                   |           |       `--METHOD_CALL -> ( [65:55]
+        |       |                   |           |           |--DOT -> . [65:46]
+        |       |                   |           |           |   |--IDENT -> w1 [65:44]
+        |       |                   |           |           |   `--IDENT -> toString [65:47]
+        |       |                   |           |           |--ELIST -> ELIST [65:56]
+        |       |                   |           |           `--RPAREN -> ) [65:56]
+        |       |                   |           `--RPAREN -> ) [65:57]
+        |       |                   |--RPAREN -> ) [65:58]
+        |       |                   |--SLIST -> { [65:60]
+        |       |                   |   |--LITERAL_IF -> if [66:12]
+        |       |                   |   |   |--LPAREN -> ( [66:15]
+        |       |                   |   |   |--EXPR -> EXPR [66:27]
+        |       |                   |   |   |   `--METHOD_CALL -> ( [66:27]
+        |       |                   |   |   |       |--DOT -> . [66:20]
+        |       |                   |   |   |       |   |--STRING_LITERAL -> "s1" [66:16]
+        |       |                   |   |   |       |   `--IDENT -> equals [66:21]
+        |       |                   |   |   |       |--ELIST -> ELIST [66:28]
+        |       |                   |   |   |       |   `--EXPR -> EXPR [66:28]
+        |       |                   |   |   |       |       `--IDENT -> s1 [66:28]
+        |       |                   |   |   |       `--RPAREN -> ) [66:30]
+        |       |                   |   |   |--RPAREN -> ) [66:31]
+        |       |                   |   |   |--SLIST -> { [66:33]
+        |       |                   |   |   |   |--LITERAL_RETURN -> return [67:16]
+        |       |                   |   |   |   |   |--EXPR -> EXPR [67:23]
+        |       |                   |   |   |   |   |   `--IDENT -> s1 [67:23]
+        |       |                   |   |   |   |   `--SEMI -> ; [67:25]
+        |       |                   |   |   |   `--RCURLY -> } [68:12]
+        |       |                   |   |   `--LITERAL_ELSE -> else [68:14]
+        |       |                   |   |       `--SLIST -> { [68:19]
+        |       |                   |   |           |--LITERAL_RETURN -> return [69:16]
+        |       |                   |   |           |   |--EXPR -> EXPR [69:23]
+        |       |                   |   |           |   |   `--IDENT -> w1 [69:23]
+        |       |                   |   |           |   `--SEMI -> ; [69:25]
+        |       |                   |   |           `--RCURLY -> } [70:12]
+        |       |                   |   `--RCURLY -> } [71:8]
+        |       |                   `--LITERAL_ELSE -> else [72:8]
+        |       |                       `--LITERAL_IF -> if [72:13]
+        |       |                           |--LPAREN -> ( [72:16]
+        |       |                           |--EXPR -> EXPR [72:17]
+        |       |                           |   `--LNOT -> ! [72:17]
+        |       |                           |       |--LPAREN -> ( [72:18]
+        |       |                           |       |--LITERAL_INSTANCEOF -> instanceof [72:24]
+        |       |                           |       |   |--IDENT -> when [72:19]
+        |       |                           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [72:35]
+        |       |                           |       |       |--MODIFIERS -> MODIFIERS [72:35]
+        |       |                           |       |       |--TYPE -> TYPE [72:35]
+        |       |                           |       |       |   |--IDENT -> when [72:35]
+        |       |                           |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [72:39]
+        |       |                           |       |       |       |--GENERIC_START -> < [72:39]
+        |       |                           |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [72:40]
+        |       |                           |       |       |       |   `--IDENT -> String [72:40]
+        |       |                           |       |       |       `--GENERIC_END -> > [72:46]
+        |       |                           |       |       |--LPAREN -> ( [72:47]
+        |       |                           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [72:48]
+        |       |                           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [72:48]
+        |       |                           |       |       |       |--MODIFIERS -> MODIFIERS [72:48]
+        |       |                           |       |       |       |--TYPE -> TYPE [72:48]
+        |       |                           |       |       |       |   |--IDENT -> when [72:48]
+        |       |                           |       |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [72:52]
+        |       |                           |       |       |       |       |--GENERIC_START -> < [72:52]
+        |       |                           |       |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [72:53]
+        |       |                           |       |       |       |       |   `--IDENT -> String [72:53]
+        |       |                           |       |       |       |       `--GENERIC_END -> > [72:59]
+        |       |                           |       |       |       |--LPAREN -> ( [72:60]
+        |       |                           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [72:61]
+        |       |                           |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [72:61]
+        |       |                           |       |       |       |       |--MODIFIERS -> MODIFIERS [72:61]
+        |       |                           |       |       |       |       |--TYPE -> TYPE [72:61]
+        |       |                           |       |       |       |       |   |--IDENT -> when [72:61]
+        |       |                           |       |       |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [72:65]
+        |       |                           |       |       |       |       |       |--GENERIC_START -> < [72:65]
+        |       |                           |       |       |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [72:66]
+        |       |                           |       |       |       |       |       |   `--IDENT -> String [72:66]
+        |       |                           |       |       |       |       |       `--GENERIC_END -> > [72:72]
+        |       |                           |       |       |       |       `--IDENT -> s1 [72:74]
+        |       |                           |       |       |       `--RPAREN -> ) [72:76]
+        |       |                           |       |       |--RPAREN -> ) [72:77]
+        |       |                           |       |       `--IDENT -> w1 [72:79]
+        |       |                           |       `--RPAREN -> ) [72:81]
+        |       |                           |--RPAREN -> ) [72:82]
+        |       |                           |--SLIST -> { [72:84]
+        |       |                           |   |--LITERAL_RETURN -> return [73:12]
+        |       |                           |   |   |--EXPR -> EXPR [73:19]
+        |       |                           |   |   |   `--LITERAL_NEW -> new [73:19]
+        |       |                           |   |   |       |--IDENT -> Object [73:23]
+        |       |                           |   |   |       |--LPAREN -> ( [73:29]
+        |       |                           |   |   |       |--ELIST -> ELIST [73:30]
+        |       |                           |   |   |       `--RPAREN -> ) [73:30]
+        |       |                           |   |   `--SEMI -> ; [73:31]
+        |       |                           |   `--RCURLY -> } [74:8]
+        |       |                           `--LITERAL_ELSE -> else [75:8]
+        |       |                               `--SLIST -> { [75:13]
+        |       |                                   |--LITERAL_RETURN -> return [76:12]
+        |       |                                   |   |--EXPR -> EXPR [76:39]
+        |       |                                   |   |   `--METHOD_CALL -> ( [76:39]
+        |       |                                   |   |       |--DOT -> . [76:32]
+        |       |                                   |   |       |   |--METHOD_CALL -> ( [76:30]
+        |       |                                   |   |       |   |   |--DOT -> . [76:21]
+        |       |                                   |   |       |   |   |   |--IDENT -> s1 [76:19]
+        |       |                                   |   |       |   |   |   `--IDENT -> toString [76:22]
+        |       |                                   |   |       |   |   |--ELIST -> ELIST [76:31]
+        |       |                                   |   |       |   |   `--RPAREN -> ) [76:31]
+        |       |                                   |   |       |   `--IDENT -> equals [76:33]
+        |       |                                   |   |       |--ELIST -> ELIST [76:51]
+        |       |                                   |   |       |   `--EXPR -> EXPR [76:51]
+        |       |                                   |   |       |       `--METHOD_CALL -> ( [76:51]
+        |       |                                   |   |       |           |--DOT -> . [76:42]
+        |       |                                   |   |       |           |   |--IDENT -> w1 [76:40]
+        |       |                                   |   |       |           |   `--IDENT -> toString [76:43]
+        |       |                                   |   |       |           |--ELIST -> ELIST [76:52]
+        |       |                                   |   |       |           `--RPAREN -> ) [76:52]
+        |       |                                   |   |       `--RPAREN -> ) [76:53]
+        |       |                                   |   `--SEMI -> ; [76:54]
+        |       |                                   `--RCURLY -> } [77:8]
+        |       `--RCURLY -> } [78:4]
+        `--RCURLY -> } [79:0]
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19PatternsInNullSwitch1.txt b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19PatternsInNullSwitch1.txt
--- a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19PatternsInNullSwitch1.txt
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19PatternsInNullSwitch1.txt
@@ -51,6 +51,106 @@ COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
         |   `--OBJBLOCK -> OBJBLOCK [8:22]
         |       |--LCURLY -> { [8:22]
         |       `--RCURLY -> } [8:23]
+        |--METHOD_DEF -> METHOD_DEF [10:4]
+        |   |--MODIFIERS -> MODIFIERS [10:4]
+        |   |   `--LITERAL_PRIVATE -> private [10:4]
+        |   |--TYPE -> TYPE [10:12]
+        |   |   `--LITERAL_INT -> int [10:12]
+        |   |--IDENT -> matchingSwitch14 [10:16]
+        |   |--LPAREN -> ( [10:32]
+        |   |--PARAMETERS -> PARAMETERS [10:33]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [10:33]
+        |   |       |--MODIFIERS -> MODIFIERS [10:33]
+        |   |       |--TYPE -> TYPE [10:33]
+        |   |       |   `--IDENT -> R [10:33]
+        |   |       `--IDENT -> r [10:35]
+        |   |--RPAREN -> ) [10:36]
+        |   `--SLIST -> { [10:38]
+        |       |--LITERAL_RETURN -> return [11:8]
+        |       |   |--EXPR -> EXPR [11:15]
+        |       |   |   `--LITERAL_SWITCH -> switch [11:15]
+        |       |   |       |--LPAREN -> ( [11:21]
+        |       |   |       |--EXPR -> EXPR [11:22]
+        |       |   |       |   `--IDENT -> r [11:22]
+        |       |   |       |--RPAREN -> ) [11:23]
+        |       |   |       |--LCURLY -> { [11:25]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [12:12]
+        |       |   |       |   |--LITERAL_CASE -> case [12:12]
+        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [12:17]
+        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [12:17]
+        |       |   |       |   |       |--TYPE -> TYPE [12:17]
+        |       |   |       |   |       |   `--IDENT -> R [12:17]
+        |       |   |       |   |       |--LPAREN -> ( [12:18]
+        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [12:19]
+        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [12:19]
+        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [12:19]
+        |       |   |       |   |       |       |--TYPE -> TYPE [12:19]
+        |       |   |       |   |       |       |   `--IDENT -> Super [12:19]
+        |       |   |       |   |       |       `--IDENT -> s [12:25]
+        |       |   |       |   |       `--RPAREN -> ) [12:26]
+        |       |   |       |   |--LAMBDA -> -> [12:28]
+        |       |   |       |   |--EXPR -> EXPR [12:31]
+        |       |   |       |   |   `--NUM_INT -> 1 [12:31]
+        |       |   |       |   `--SEMI -> ; [12:32]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [13:12]
+        |       |   |       |   |--LITERAL_DEFAULT -> default [13:12]
+        |       |   |       |   |--LAMBDA -> -> [13:20]
+        |       |   |       |   |--EXPR -> EXPR [13:23]
+        |       |   |       |   |   `--NUM_INT -> 2 [13:23]
+        |       |   |       |   `--SEMI -> ; [13:24]
+        |       |   |       `--RCURLY -> } [14:8]
+        |       |   `--SEMI -> ; [14:9]
+        |       `--RCURLY -> } [15:4]
+        |--METHOD_DEF -> METHOD_DEF [17:4]
+        |   |--MODIFIERS -> MODIFIERS [17:4]
+        |   |   `--LITERAL_PRIVATE -> private [17:4]
+        |   |--TYPE -> TYPE [17:12]
+        |   |   `--LITERAL_INT -> int [17:12]
+        |   |--IDENT -> matchingSwitch15 [17:16]
+        |   |--LPAREN -> ( [17:32]
+        |   |--PARAMETERS -> PARAMETERS [17:33]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [17:33]
+        |   |       |--MODIFIERS -> MODIFIERS [17:33]
+        |   |       |--TYPE -> TYPE [17:33]
+        |   |       |   `--IDENT -> R [17:33]
+        |   |       `--IDENT -> r [17:35]
+        |   |--RPAREN -> ) [17:36]
+        |   `--SLIST -> { [17:38]
+        |       |--LITERAL_RETURN -> return [18:8]
+        |       |   |--EXPR -> EXPR [18:15]
+        |       |   |   `--LITERAL_SWITCH -> switch [18:15]
+        |       |   |       |--LPAREN -> ( [18:21]
+        |       |   |       |--EXPR -> EXPR [18:22]
+        |       |   |       |   `--IDENT -> r [18:22]
+        |       |   |       |--RPAREN -> ) [18:23]
+        |       |   |       |--LCURLY -> { [18:25]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [19:12]
+        |       |   |       |   |--LITERAL_CASE -> case [19:12]
+        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [19:17]
+        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [19:17]
+        |       |   |       |   |       |--TYPE -> TYPE [19:17]
+        |       |   |       |   |       |   `--IDENT -> R [19:17]
+        |       |   |       |   |       |--LPAREN -> ( [19:18]
+        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [19:19]
+        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [19:19]
+        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [19:19]
+        |       |   |       |   |       |       |--TYPE -> TYPE [19:19]
+        |       |   |       |   |       |       |   `--IDENT -> Sub [19:19]
+        |       |   |       |   |       |       `--IDENT -> s [19:23]
+        |       |   |       |   |       `--RPAREN -> ) [19:24]
+        |       |   |       |   |--LAMBDA -> -> [19:26]
+        |       |   |       |   |--EXPR -> EXPR [19:29]
+        |       |   |       |   |   `--NUM_INT -> 1 [19:29]
+        |       |   |       |   `--SEMI -> ; [19:30]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [20:12]
+        |       |   |       |   |--LITERAL_DEFAULT -> default [20:12]
+        |       |   |       |   |--LAMBDA -> -> [20:20]
+        |       |   |       |   |--EXPR -> EXPR [20:23]
+        |       |   |       |   |   `--NUM_INT -> 2 [20:23]
+        |       |   |       |   `--SEMI -> ; [20:24]
+        |       |   |       `--RCURLY -> } [21:8]
+        |       |   `--SEMI -> ; [21:9]
+        |       `--RCURLY -> } [22:4]
         |--METHOD_DEF -> METHOD_DEF [24:4]
         |   |--MODIFIERS -> MODIFIERS [24:4]
         |   |   `--LITERAL_PRIVATE -> private [24:4]
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19RecordDecompositionWithConditionInLoops.txt b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19RecordDecompositionWithConditionInLoops.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedJava19RecordDecompositionWithConditionInLoops.txt
@@ -0,0 +1,1124 @@
+COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
+|--PACKAGE_DEF -> package [2:0]
+|   |--ANNOTATIONS -> ANNOTATIONS [2:47]
+|   |--DOT -> . [2:47]
+|   |   |--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]
+|   |   `--IDENT -> java19 [2:48]
+|   `--SEMI -> ; [2:54]
+|--IMPORT -> import [4:0]
+|   |--DOT -> . [4:16]
+|   |   |--DOT -> . [4:11]
+|   |   |   |--IDENT -> java [4:7]
+|   |   |   `--IDENT -> util [4:12]
+|   |   `--IDENT -> Iterator [4:17]
+|   `--SEMI -> ; [4:25]
+|--IMPORT -> import [5:0]
+|   |--DOT -> . [5:16]
+|   |   |--DOT -> . [5:11]
+|   |   |   |--IDENT -> java [5:7]
+|   |   |   `--IDENT -> util [5:12]
+|   |   `--IDENT -> List [5:17]
+|   `--SEMI -> ; [5:21]
+`--CLASS_DEF -> CLASS_DEF [7:0]
+    |--MODIFIERS -> MODIFIERS [7:0]
+    |   `--LITERAL_PUBLIC -> public [7:0]
+    |--LITERAL_CLASS -> class [7:7]
+    |--IDENT -> InputJava19RecordDecompositionWithConditionInLoops [7:13]
+    `--OBJBLOCK -> OBJBLOCK [7:64]
+        |--LCURLY -> { [7:64]
+        |--RECORD_DEF -> RECORD_DEF [8:4]
+        |   |--MODIFIERS -> MODIFIERS [8:4]
+        |   |--LITERAL_RECORD -> record [8:4]
+        |   |--IDENT -> R [8:11]
+        |   |--LPAREN -> ( [8:12]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [8:13]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [8:13]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [8:13]
+        |   |       |--TYPE -> TYPE [8:13]
+        |   |       |   `--IDENT -> R [8:13]
+        |   |       `--IDENT -> r [8:15]
+        |   |--RPAREN -> ) [8:16]
+        |   `--OBJBLOCK -> OBJBLOCK [8:18]
+        |       |--LCURLY -> { [8:18]
+        |       `--RCURLY -> } [10:4]
+        |--METHOD_DEF -> METHOD_DEF [12:4]
+        |   |--MODIFIERS -> MODIFIERS [12:4]
+        |   |   |--LITERAL_PUBLIC -> public [12:4]
+        |   |   `--LITERAL_STATIC -> static [12:11]
+        |   |--TYPE -> TYPE [12:18]
+        |   |   `--LITERAL_VOID -> void [12:18]
+        |   |--IDENT -> main [12:23]
+        |   |--LPAREN -> ( [12:27]
+        |   |--PARAMETERS -> PARAMETERS [12:28]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [12:28]
+        |   |       |--MODIFIERS -> MODIFIERS [12:28]
+        |   |       |--TYPE -> TYPE [12:28]
+        |   |       |   `--IDENT -> String [12:28]
+        |   |       |--ELLIPSIS -> ... [12:34]
+        |   |       `--IDENT -> args [12:38]
+        |   |--RPAREN -> ) [12:42]
+        |   `--SLIST -> { [12:44]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [13:8]
+        |       |   |--MODIFIERS -> MODIFIERS [13:8]
+        |       |   |--TYPE -> TYPE [13:8]
+        |       |   |   `--IDENT -> R [13:8]
+        |       |   |--IDENT -> r [13:10]
+        |       |   `--ASSIGN -> = [13:12]
+        |       |       `--EXPR -> EXPR [13:14]
+        |       |           `--LITERAL_NEW -> new [13:14]
+        |       |               |--IDENT -> R [13:18]
+        |       |               |--LPAREN -> ( [13:19]
+        |       |               |--ELIST -> ELIST [13:20]
+        |       |               |   `--EXPR -> EXPR [13:20]
+        |       |               |       `--LITERAL_NEW -> new [13:20]
+        |       |               |           |--IDENT -> R [13:24]
+        |       |               |           |--LPAREN -> ( [13:25]
+        |       |               |           |--ELIST -> ELIST [13:26]
+        |       |               |           |   `--EXPR -> EXPR [13:26]
+        |       |               |           |       `--LITERAL_NULL -> null [13:26]
+        |       |               |           `--RPAREN -> ) [13:30]
+        |       |               `--RPAREN -> ) [13:31]
+        |       |--SEMI -> ; [13:32]
+        |       |--LITERAL_IF -> if [14:8]
+        |       |   |--LPAREN -> ( [14:11]
+        |       |   |--EXPR -> EXPR [14:14]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [14:14]
+        |       |   |       |--IDENT -> r [14:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [14:25]
+        |       |   |           |--MODIFIERS -> MODIFIERS [14:25]
+        |       |   |           |--TYPE -> TYPE [14:25]
+        |       |   |           |   `--IDENT -> R [14:25]
+        |       |   |           |--LPAREN -> ( [14:26]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [14:27]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [14:27]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [14:27]
+        |       |   |           |       |--TYPE -> TYPE [14:27]
+        |       |   |           |       |   `--IDENT -> R [14:27]
+        |       |   |           |       `--IDENT -> recordComponent [14:29]
+        |       |   |           |--RPAREN -> ) [14:44]
+        |       |   |           `--IDENT -> r1 [14:46]
+        |       |   |--RPAREN -> ) [14:48]
+        |       |   |--SLIST -> { [14:50]
+        |       |   |   |--EXPR -> EXPR [15:30]
+        |       |   |   |   `--METHOD_CALL -> ( [15:30]
+        |       |   |   |       |--DOT -> . [15:22]
+        |       |   |   |       |   |--DOT -> . [15:18]
+        |       |   |   |       |   |   |--IDENT -> System [15:12]
+        |       |   |   |       |   |   `--IDENT -> out [15:19]
+        |       |   |   |       |   `--IDENT -> println [15:23]
+        |       |   |   |       |--ELIST -> ELIST [15:31]
+        |       |   |   |       |   `--EXPR -> EXPR [15:31]
+        |       |   |   |       |       `--IDENT -> recordComponent [15:31]
+        |       |   |   |       `--RPAREN -> ) [15:46]
+        |       |   |   |--SEMI -> ; [15:47]
+        |       |   |   `--RCURLY -> } [16:8]
+        |       |   `--LITERAL_ELSE -> else [16:10]
+        |       |       `--LITERAL_IF -> if [16:15]
+        |       |           |--LPAREN -> ( [16:18]
+        |       |           |--EXPR -> EXPR [16:21]
+        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [16:21]
+        |       |           |       |--IDENT -> r [16:19]
+        |       |           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [16:32]
+        |       |           |           |--MODIFIERS -> MODIFIERS [16:32]
+        |       |           |           |--TYPE -> TYPE [16:32]
+        |       |           |           |   `--IDENT -> R [16:32]
+        |       |           |           |--LPAREN -> ( [16:33]
+        |       |           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [16:34]
+        |       |           |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [16:34]
+        |       |           |           |       |--MODIFIERS -> MODIFIERS [16:34]
+        |       |           |           |       |--TYPE -> TYPE [16:34]
+        |       |           |           |       |   `--IDENT -> R [16:34]
+        |       |           |           |       |--LPAREN -> ( [16:35]
+        |       |           |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [16:36]
+        |       |           |           |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [16:36]
+        |       |           |           |       |       |--MODIFIERS -> MODIFIERS [16:36]
+        |       |           |           |       |       |--TYPE -> TYPE [16:36]
+        |       |           |           |       |       |   `--IDENT -> R [16:36]
+        |       |           |           |       |       `--IDENT -> innerRecordComponent [16:38]
+        |       |           |           |       |--RPAREN -> ) [16:58]
+        |       |           |           |       `--IDENT -> r2 [16:60]
+        |       |           |           |--RPAREN -> ) [16:62]
+        |       |           |           `--IDENT -> r3 [16:64]
+        |       |           |--RPAREN -> ) [16:66]
+        |       |           |--SLIST -> { [16:68]
+        |       |           |   |--EXPR -> EXPR [17:30]
+        |       |           |   |   `--METHOD_CALL -> ( [17:30]
+        |       |           |   |       |--DOT -> . [17:22]
+        |       |           |   |       |   |--DOT -> . [17:18]
+        |       |           |   |       |   |   |--IDENT -> System [17:12]
+        |       |           |   |       |   |   `--IDENT -> out [17:19]
+        |       |           |   |       |   `--IDENT -> println [17:23]
+        |       |           |   |       |--ELIST -> ELIST [17:31]
+        |       |           |   |       |   `--EXPR -> EXPR [17:31]
+        |       |           |   |       |       `--IDENT -> innerRecordComponent [17:31]
+        |       |           |   |       `--RPAREN -> ) [17:51]
+        |       |           |   |--SEMI -> ; [17:52]
+        |       |           |   `--RCURLY -> } [18:8]
+        |       |           `--LITERAL_ELSE -> else [18:10]
+        |       |               `--LITERAL_IF -> if [18:15]
+        |       |                   |--LPAREN -> ( [18:18]
+        |       |                   |--EXPR -> EXPR [18:21]
+        |       |                   |   `--LITERAL_INSTANCEOF -> instanceof [18:21]
+        |       |                   |       |--IDENT -> r [18:19]
+        |       |                   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [18:32]
+        |       |                   |           |--MODIFIERS -> MODIFIERS [18:32]
+        |       |                   |           |--TYPE -> TYPE [18:32]
+        |       |                   |           |   `--IDENT -> R [18:32]
+        |       |                   |           |--LPAREN -> ( [18:33]
+        |       |                   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [18:34]
+        |       |                   |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [18:34]
+        |       |                   |           |       |--MODIFIERS -> MODIFIERS [18:34]
+        |       |                   |           |       |--TYPE -> TYPE [18:34]
+        |       |                   |           |       |   `--IDENT -> R [18:34]
+        |       |                   |           |       |--LPAREN -> ( [18:35]
+        |       |                   |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [18:36]
+        |       |                   |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [18:36]
+        |       |                   |           |       |       |--MODIFIERS -> MODIFIERS [18:36]
+        |       |                   |           |       |       |--TYPE -> TYPE [18:36]
+        |       |                   |           |       |       |   `--IDENT -> R [18:36]
+        |       |                   |           |       |       |--LPAREN -> ( [18:37]
+        |       |                   |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [18:38]
+        |       |                   |           |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [18:38]
+        |       |                   |           |       |       |       |--MODIFIERS -> MODIFIERS [18:38]
+        |       |                   |           |       |       |       |--TYPE -> TYPE [18:38]
+        |       |                   |           |       |       |       |   `--IDENT -> R [18:38]
+        |       |                   |           |       |       |       `--IDENT -> innerInnerRecordComponent [18:40]
+        |       |                   |           |       |       `--RPAREN -> ) [18:65]
+        |       |                   |           |       `--RPAREN -> ) [18:66]
+        |       |                   |           `--RPAREN -> ) [18:67]
+        |       |                   |--RPAREN -> ) [18:68]
+        |       |                   |--SLIST -> { [18:70]
+        |       |                   |   |--EXPR -> EXPR [19:30]
+        |       |                   |   |   `--METHOD_CALL -> ( [19:30]
+        |       |                   |   |       |--DOT -> . [19:22]
+        |       |                   |   |       |   |--DOT -> . [19:18]
+        |       |                   |   |       |   |   |--IDENT -> System [19:12]
+        |       |                   |   |       |   |   `--IDENT -> out [19:19]
+        |       |                   |   |       |   `--IDENT -> println [19:23]
+        |       |                   |   |       |--ELIST -> ELIST [19:31]
+        |       |                   |   |       |   `--EXPR -> EXPR [19:31]
+        |       |                   |   |       |       `--IDENT -> innerInnerRecordComponent [19:31]
+        |       |                   |   |       `--RPAREN -> ) [19:56]
+        |       |                   |   |--SEMI -> ; [19:57]
+        |       |                   |   `--RCURLY -> } [20:8]
+        |       |                   `--LITERAL_ELSE -> else [20:10]
+        |       |                       `--LITERAL_IF -> if [20:15]
+        |       |                           |--LPAREN -> ( [20:18]
+        |       |                           |--EXPR -> EXPR [20:21]
+        |       |                           |   `--LITERAL_INSTANCEOF -> instanceof [20:21]
+        |       |                           |       |--IDENT -> r [20:19]
+        |       |                           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:16]
+        |       |                           |           |--MODIFIERS -> MODIFIERS [21:16]
+        |       |                           |           |--TYPE -> TYPE [21:16]
+        |       |                           |           |   `--IDENT -> R [21:16]
+        |       |                           |           |--LPAREN -> ( [21:17]
+        |       |                           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:18]
+        |       |                           |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:18]
+        |       |                           |           |       |--MODIFIERS -> MODIFIERS [21:18]
+        |       |                           |           |       |--TYPE -> TYPE [21:18]
+        |       |                           |           |       |   `--IDENT -> R [21:18]
+        |       |                           |           |       |--LPAREN -> ( [21:19]
+        |       |                           |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:20]
+        |       |                           |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:20]
+        |       |                           |           |       |       |--MODIFIERS -> MODIFIERS [21:20]
+        |       |                           |           |       |       |--TYPE -> TYPE [21:20]
+        |       |                           |           |       |       |   `--IDENT -> R [21:20]
+        |       |                           |           |       |       |--LPAREN -> ( [21:21]
+        |       |                           |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:22]
+        |       |                           |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [21:22]
+        |       |                           |           |       |       |       |--MODIFIERS -> MODIFIERS [21:22]
+        |       |                           |           |       |       |       |--TYPE -> TYPE [21:22]
+        |       |                           |           |       |       |       |   `--IDENT -> R [21:22]
+        |       |                           |           |       |       |       |--LPAREN -> ( [21:23]
+        |       |                           |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [21:24]
+        |       |                           |           |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [21:24]
+        |       |                           |           |       |       |       |       |--MODIFIERS -> MODIFIERS [21:24]
+        |       |                           |           |       |       |       |       |--TYPE -> TYPE [21:24]
+        |       |                           |           |       |       |       |       |   `--IDENT -> R [21:24]
+        |       |                           |           |       |       |       |       `--IDENT -> innerInnerInnerRecordComponent [21:26]
+        |       |                           |           |       |       |       `--RPAREN -> ) [21:56]
+        |       |                           |           |       |       `--RPAREN -> ) [21:57]
+        |       |                           |           |       `--RPAREN -> ) [21:58]
+        |       |                           |           `--RPAREN -> ) [21:59]
+        |       |                           |--RPAREN -> ) [21:60]
+        |       |                           |--SLIST -> { [21:62]
+        |       |                           |   |--EXPR -> EXPR [22:30]
+        |       |                           |   |   `--METHOD_CALL -> ( [22:30]
+        |       |                           |   |       |--DOT -> . [22:22]
+        |       |                           |   |       |   |--DOT -> . [22:18]
+        |       |                           |   |       |   |   |--IDENT -> System [22:12]
+        |       |                           |   |       |   |   `--IDENT -> out [22:19]
+        |       |                           |   |       |   `--IDENT -> println [22:23]
+        |       |                           |   |       |--ELIST -> ELIST [22:31]
+        |       |                           |   |       |   `--EXPR -> EXPR [22:31]
+        |       |                           |   |       |       `--IDENT -> innerInnerInnerRecordComponent [22:31]
+        |       |                           |   |       `--RPAREN -> ) [22:61]
+        |       |                           |   |--SEMI -> ; [22:62]
+        |       |                           |   `--RCURLY -> } [23:8]
+        |       |                           `--LITERAL_ELSE -> else [23:10]
+        |       |                               `--LITERAL_IF -> if [23:15]
+        |       |                                   |--LPAREN -> ( [23:18]
+        |       |                                   |--EXPR -> EXPR [23:21]
+        |       |                                   |   `--LITERAL_INSTANCEOF -> instanceof [23:21]
+        |       |                                   |       |--IDENT -> r [23:19]
+        |       |                                   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:16]
+        |       |                                   |           |--MODIFIERS -> MODIFIERS [24:16]
+        |       |                                   |           |--TYPE -> TYPE [24:16]
+        |       |                                   |           |   `--IDENT -> R [24:16]
+        |       |                                   |           |--LPAREN -> ( [24:17]
+        |       |                                   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:18]
+        |       |                                   |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:18]
+        |       |                                   |           |       |--MODIFIERS -> MODIFIERS [24:18]
+        |       |                                   |           |       |--TYPE -> TYPE [24:18]
+        |       |                                   |           |       |   `--IDENT -> R [24:18]
+        |       |                                   |           |       |--LPAREN -> ( [24:19]
+        |       |                                   |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:20]
+        |       |                                   |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:20]
+        |       |                                   |           |       |       |--MODIFIERS -> MODIFIERS [24:20]
+        |       |                                   |           |       |       |--TYPE -> TYPE [24:20]
+        |       |                                   |           |       |       |   `--IDENT -> R [24:20]
+        |       |                                   |           |       |       |--LPAREN -> ( [24:21]
+        |       |                                   |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:22]
+        |       |                                   |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:22]
+        |       |                                   |           |       |       |       |--MODIFIERS -> MODIFIERS [24:22]
+        |       |                                   |           |       |       |       |--TYPE -> TYPE [24:22]
+        |       |                                   |           |       |       |       |   `--IDENT -> R [24:22]
+        |       |                                   |           |       |       |       |--LPAREN -> ( [24:23]
+        |       |                                   |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:24]
+        |       |                                   |           |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:24]
+        |       |                                   |           |       |       |       |       |--MODIFIERS -> MODIFIERS [24:24]
+        |       |                                   |           |       |       |       |       |--TYPE -> TYPE [24:24]
+        |       |                                   |           |       |       |       |       |   `--IDENT -> R [24:24]
+        |       |                                   |           |       |       |       |       |--LPAREN -> ( [24:25]
+        |       |                                   |           |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:26]
+        |       |                                   |           |       |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:26]
+        |       |                                   |           |       |       |       |       |       |--MODIFIERS -> MODIFIERS [24:26]
+        |       |                                   |           |       |       |       |       |       |--TYPE -> TYPE [24:26]
+        |       |                                   |           |       |       |       |       |       |   `--IDENT -> R [24:26]
+        |       |                                   |           |       |       |       |       |       `--IDENT -> innerInnerInnerInnerRecordComponent [24:28]
+        |       |                                   |           |       |       |       |       `--RPAREN -> ) [24:63]
+        |       |                                   |           |       |       |       `--RPAREN -> ) [24:64]
+        |       |                                   |           |       |       `--RPAREN -> ) [24:65]
+        |       |                                   |           |       `--RPAREN -> ) [24:66]
+        |       |                                   |           `--RPAREN -> ) [24:67]
+        |       |                                   |--RPAREN -> ) [24:68]
+        |       |                                   |--SLIST -> { [24:70]
+        |       |                                   |   |--EXPR -> EXPR [25:30]
+        |       |                                   |   |   `--METHOD_CALL -> ( [25:30]
+        |       |                                   |   |       |--DOT -> . [25:22]
+        |       |                                   |   |       |   |--DOT -> . [25:18]
+        |       |                                   |   |       |   |   |--IDENT -> System [25:12]
+        |       |                                   |   |       |   |   `--IDENT -> out [25:19]
+        |       |                                   |   |       |   `--IDENT -> println [25:23]
+        |       |                                   |   |       |--ELIST -> ELIST [25:31]
+        |       |                                   |   |       |   `--EXPR -> EXPR [25:31]
+        |       |                                   |   |       |       `--IDENT -> innerInnerInnerInnerRecordComponent [25:31]
+        |       |                                   |   |       `--RPAREN -> ) [25:66]
+        |       |                                   |   |--SEMI -> ; [25:67]
+        |       |                                   |   `--RCURLY -> } [26:8]
+        |       |                                   `--LITERAL_ELSE -> else [26:10]
+        |       |                                       `--LITERAL_IF -> if [26:15]
+        |       |                                           |--LPAREN -> ( [26:18]
+        |       |                                           |--EXPR -> EXPR [26:21]
+        |       |                                           |   `--LITERAL_INSTANCEOF -> instanceof [26:21]
+        |       |                                           |       |--IDENT -> r [26:19]
+        |       |                                           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:16]
+        |       |                                           |           |--MODIFIERS -> MODIFIERS [27:16]
+        |       |                                           |           |--TYPE -> TYPE [27:16]
+        |       |                                           |           |   `--IDENT -> R [27:16]
+        |       |                                           |           |--LPAREN -> ( [27:17]
+        |       |                                           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:18]
+        |       |                                           |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:18]
+        |       |                                           |           |       |--MODIFIERS -> MODIFIERS [27:18]
+        |       |                                           |           |       |--TYPE -> TYPE [27:18]
+        |       |                                           |           |       |   `--IDENT -> R [27:18]
+        |       |                                           |           |       |--LPAREN -> ( [27:19]
+        |       |                                           |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:20]
+        |       |                                           |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:20]
+        |       |                                           |           |       |       |--MODIFIERS -> MODIFIERS [27:20]
+        |       |                                           |           |       |       |--TYPE -> TYPE [27:20]
+        |       |                                           |           |       |       |   `--IDENT -> R [27:20]
+        |       |                                           |           |       |       |--LPAREN -> ( [27:21]
+        |       |                                           |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:22]
+        |       |                                           |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:22]
+        |       |                                           |           |       |       |       |--MODIFIERS -> MODIFIERS [27:22]
+        |       |                                           |           |       |       |       |--TYPE -> TYPE [27:22]
+        |       |                                           |           |       |       |       |   `--IDENT -> R [27:22]
+        |       |                                           |           |       |       |       |--LPAREN -> ( [27:23]
+        |       |                                           |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:24]
+        |       |                                           |           |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:24]
+        |       |                                           |           |       |       |       |       |--MODIFIERS -> MODIFIERS [27:24]
+        |       |                                           |           |       |       |       |       |--TYPE -> TYPE [27:24]
+        |       |                                           |           |       |       |       |       |   `--IDENT -> R [27:24]
+        |       |                                           |           |       |       |       |       |--LPAREN -> ( [27:25]
+        |       |                                           |           |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:26]
+        |       |                                           |           |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [27:26]
+        |       |                                           |           |       |       |       |       |       |--MODIFIERS -> MODIFIERS [27:26]
+        |       |                                           |           |       |       |       |       |       |--TYPE -> TYPE [27:26]
+        |       |                                           |           |       |       |       |       |       |   `--IDENT -> R [27:26]
+        |       |                                           |           |       |       |       |       |       |--LPAREN -> ( [27:27]
+        |       |                                           |           |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [27:28]
+        |       |                                           |           |       |       |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [27:28]
+        |       |                                           |           |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [27:28]
+        |       |                                           |           |       |       |       |       |       |       |--TYPE -> TYPE [27:28]
+        |       |                                           |           |       |       |       |       |       |       |   `--IDENT -> R [27:28]
+        |       |                                           |           |       |       |       |       |       |       `--IDENT -> innerInnerInnerInnerInnerRecordComponent [27:30]
+        |       |                                           |           |       |       |       |       |       `--RPAREN -> ) [27:70]
+        |       |                                           |           |       |       |       |       `--RPAREN -> ) [27:71]
+        |       |                                           |           |       |       |       `--RPAREN -> ) [27:72]
+        |       |                                           |           |       |       `--RPAREN -> ) [27:73]
+        |       |                                           |           |       `--RPAREN -> ) [27:74]
+        |       |                                           |           `--RPAREN -> ) [27:75]
+        |       |                                           |--RPAREN -> ) [27:76]
+        |       |                                           |--SLIST -> { [27:78]
+        |       |                                           |   |--EXPR -> EXPR [28:30]
+        |       |                                           |   |   `--METHOD_CALL -> ( [28:30]
+        |       |                                           |   |       |--DOT -> . [28:22]
+        |       |                                           |   |       |   |--DOT -> . [28:18]
+        |       |                                           |   |       |   |   |--IDENT -> System [28:12]
+        |       |                                           |   |       |   |   `--IDENT -> out [28:19]
+        |       |                                           |   |       |   `--IDENT -> println [28:23]
+        |       |                                           |   |       |--ELIST -> ELIST [28:31]
+        |       |                                           |   |       |   `--EXPR -> EXPR [28:31]
+        |       |                                           |   |       |       `--IDENT -> innerInnerInnerInnerInnerRecordComponent [28:31]
+        |       |                                           |   |       `--RPAREN -> ) [28:71]
+        |       |                                           |   |--SEMI -> ; [28:72]
+        |       |                                           |   `--RCURLY -> } [29:8]
+        |       |                                           `--LITERAL_ELSE -> else [29:10]
+        |       |                                               `--LITERAL_IF -> if [29:15]
+        |       |                                                   |--LPAREN -> ( [29:18]
+        |       |                                                   |--EXPR -> EXPR [29:21]
+        |       |                                                   |   `--LITERAL_INSTANCEOF -> instanceof [29:21]
+        |       |                                                   |       |--IDENT -> r [29:19]
+        |       |                                                   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:16]
+        |       |                                                   |           |--MODIFIERS -> MODIFIERS [30:16]
+        |       |                                                   |           |--TYPE -> TYPE [30:16]
+        |       |                                                   |           |   `--IDENT -> R [30:16]
+        |       |                                                   |           |--LPAREN -> ( [30:17]
+        |       |                                                   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:18]
+        |       |                                                   |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:18]
+        |       |                                                   |           |       |--MODIFIERS -> MODIFIERS [30:18]
+        |       |                                                   |           |       |--TYPE -> TYPE [30:18]
+        |       |                                                   |           |       |   `--IDENT -> R [30:18]
+        |       |                                                   |           |       |--LPAREN -> ( [30:19]
+        |       |                                                   |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:20]
+        |       |                                                   |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:20]
+        |       |                                                   |           |       |       |--MODIFIERS -> MODIFIERS [30:20]
+        |       |                                                   |           |       |       |--TYPE -> TYPE [30:20]
+        |       |                                                   |           |       |       |   `--IDENT -> R [30:20]
+        |       |                                                   |           |       |       |--LPAREN -> ( [30:21]
+        |       |                                                   |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:22]
+        |       |                                                   |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:22]
+        |       |                                                   |           |       |       |       |--MODIFIERS -> MODIFIERS [30:22]
+        |       |                                                   |           |       |       |       |--TYPE -> TYPE [30:22]
+        |       |                                                   |           |       |       |       |   `--IDENT -> R [30:22]
+        |       |                                                   |           |       |       |       |--LPAREN -> ( [30:23]
+        |       |                                                   |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:24]
+        |       |                                                   |           |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:24]
+        |       |                                                   |           |       |       |       |       |--MODIFIERS -> MODIFIERS [30:24]
+        |       |                                                   |           |       |       |       |       |--TYPE -> TYPE [30:24]
+        |       |                                                   |           |       |       |       |       |   `--IDENT -> R [30:24]
+        |       |                                                   |           |       |       |       |       |--LPAREN -> ( [30:25]
+        |       |                                                   |           |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:26]
+        |       |                                                   |           |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:26]
+        |       |                                                   |           |       |       |       |       |       |--MODIFIERS -> MODIFIERS [30:26]
+        |       |                                                   |           |       |       |       |       |       |--TYPE -> TYPE [30:26]
+        |       |                                                   |           |       |       |       |       |       |   `--IDENT -> R [30:26]
+        |       |                                                   |           |       |       |       |       |       |--LPAREN -> ( [30:27]
+        |       |                                                   |           |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:28]
+        |       |                                                   |           |       |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [30:28]
+        |       |                                                   |           |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [30:28]
+        |       |                                                   |           |       |       |       |       |       |       |--TYPE -> TYPE [30:28]
+        |       |                                                   |           |       |       |       |       |       |       |   `--IDENT -> R [30:28]
+        |       |                                                   |           |       |       |       |       |       |       |--LPAREN -> ( [30:29]
+        |       |                                                   |           |       |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [30:30]
+        |       |                                                   |           |       |       |       |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [30:30]
+        |       |                                                   |           |       |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [30:30]
+        |       |                                                   |           |       |       |       |       |       |       |       |--TYPE -> TYPE [30:30]
+        |       |                                                   |           |       |       |       |       |       |       |       |   `--IDENT -> R [30:30]
+        |       |                                                   |           |       |       |       |       |       |       |       `--IDENT -> innerInnerInnerInnerInnerInnerRecordComponent [30:32]
+        |       |                                                   |           |       |       |       |       |       |       `--RPAREN -> ) [30:77]
+        |       |                                                   |           |       |       |       |       |       `--RPAREN -> ) [30:78]
+        |       |                                                   |           |       |       |       |       `--RPAREN -> ) [30:79]
+        |       |                                                   |           |       |       |       `--RPAREN -> ) [30:80]
+        |       |                                                   |           |       |       `--RPAREN -> ) [30:81]
+        |       |                                                   |           |       `--RPAREN -> ) [30:82]
+        |       |                                                   |           `--RPAREN -> ) [30:83]
+        |       |                                                   |--RPAREN -> ) [30:84]
+        |       |                                                   |--SLIST -> { [30:86]
+        |       |                                                   |   |--EXPR -> EXPR [31:30]
+        |       |                                                   |   |   `--METHOD_CALL -> ( [31:30]
+        |       |                                                   |   |       |--DOT -> . [31:22]
+        |       |                                                   |   |       |   |--DOT -> . [31:18]
+        |       |                                                   |   |       |   |   |--IDENT -> System [31:12]
+        |       |                                                   |   |       |   |   `--IDENT -> out [31:19]
+        |       |                                                   |   |       |   `--IDENT -> println [31:23]
+        |       |                                                   |   |       |--ELIST -> ELIST [31:31]
+        |       |                                                   |   |       |   `--EXPR -> EXPR [31:31]
+        |       |                                                   |   |       |       `--IDENT -> innerInnerInnerInnerInnerInnerRecordComponent [31:31]
+        |       |                                                   |   |       `--RPAREN -> ) [31:76]
+        |       |                                                   |   |--SEMI -> ; [31:77]
+        |       |                                                   |   `--RCURLY -> } [32:8]
+        |       |                                                   `--LITERAL_ELSE -> else [32:10]
+        |       |                                                       `--LITERAL_IF -> if [32:15]
+        |       |                                                           |--LPAREN -> ( [32:18]
+        |       |                                                           |--EXPR -> EXPR [32:21]
+        |       |                                                           |   `--LITERAL_INSTANCEOF -> instanceof [32:21]
+        |       |                                                           |       |--IDENT -> r [32:19]
+        |       |                                                           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:16]
+        |       |                                                           |           |--MODIFIERS -> MODIFIERS [33:16]
+        |       |                                                           |           |--TYPE -> TYPE [33:16]
+        |       |                                                           |           |   `--IDENT -> R [33:16]
+        |       |                                                           |           |--LPAREN -> ( [33:17]
+        |       |                                                           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:18]
+        |       |                                                           |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:18]
+        |       |                                                           |           |       |--MODIFIERS -> MODIFIERS [33:18]
+        |       |                                                           |           |       |--TYPE -> TYPE [33:18]
+        |       |                                                           |           |       |   `--IDENT -> R [33:18]
+        |       |                                                           |           |       |--LPAREN -> ( [33:19]
+        |       |                                                           |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:20]
+        |       |                                                           |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:20]
+        |       |                                                           |           |       |       |--MODIFIERS -> MODIFIERS [33:20]
+        |       |                                                           |           |       |       |--TYPE -> TYPE [33:20]
+        |       |                                                           |           |       |       |   `--IDENT -> R [33:20]
+        |       |                                                           |           |       |       |--LPAREN -> ( [33:21]
+        |       |                                                           |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:22]
+        |       |                                                           |           |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:22]
+        |       |                                                           |           |       |       |       |--MODIFIERS -> MODIFIERS [33:22]
+        |       |                                                           |           |       |       |       |--TYPE -> TYPE [33:22]
+        |       |                                                           |           |       |       |       |   `--IDENT -> R [33:22]
+        |       |                                                           |           |       |       |       |--LPAREN -> ( [33:23]
+        |       |                                                           |           |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:24]
+        |       |                                                           |           |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:24]
+        |       |                                                           |           |       |       |       |       |--MODIFIERS -> MODIFIERS [33:24]
+        |       |                                                           |           |       |       |       |       |--TYPE -> TYPE [33:24]
+        |       |                                                           |           |       |       |       |       |   `--IDENT -> R [33:24]
+        |       |                                                           |           |       |       |       |       |--LPAREN -> ( [33:25]
+        |       |                                                           |           |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:26]
+        |       |                                                           |           |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:26]
+        |       |                                                           |           |       |       |       |       |       |--MODIFIERS -> MODIFIERS [33:26]
+        |       |                                                           |           |       |       |       |       |       |--TYPE -> TYPE [33:26]
+        |       |                                                           |           |       |       |       |       |       |   `--IDENT -> R [33:26]
+        |       |                                                           |           |       |       |       |       |       |--LPAREN -> ( [33:27]
+        |       |                                                           |           |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:28]
+        |       |                                                           |           |       |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:28]
+        |       |                                                           |           |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [33:28]
+        |       |                                                           |           |       |       |       |       |       |       |--TYPE -> TYPE [33:28]
+        |       |                                                           |           |       |       |       |       |       |       |   `--IDENT -> R [33:28]
+        |       |                                                           |           |       |       |       |       |       |       |--LPAREN -> ( [33:29]
+        |       |                                                           |           |       |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:30]
+        |       |                                                           |           |       |       |       |       |       |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [33:30]
+        |       |                                                           |           |       |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [33:30]
+        |       |                                                           |           |       |       |       |       |       |       |       |--TYPE -> TYPE [33:30]
+        |       |                                                           |           |       |       |       |       |       |       |       |   `--IDENT -> R [33:30]
+        |       |                                                           |           |       |       |       |       |       |       |       |--LPAREN -> ( [33:31]
+        |       |                                                           |           |       |       |       |       |       |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [33:32]
+        |       |                                                           |           |       |       |       |       |       |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [33:32]
+        |       |                                                           |           |       |       |       |       |       |       |       |       |--MODIFIERS -> MODIFIERS [33:32]
+        |       |                                                           |           |       |       |       |       |       |       |       |       |--TYPE -> TYPE [33:32]
+        |       |                                                           |           |       |       |       |       |       |       |       |       |   `--IDENT -> R [33:32]
+        |       |                                                           |           |       |       |       |       |       |       |       |       `--IDENT -> innerInnerInnerInnerInnerInnerInnerRecordComponent [33:34]
+        |       |                                                           |           |       |       |       |       |       |       |       `--RPAREN -> ) [33:84]
+        |       |                                                           |           |       |       |       |       |       |       `--RPAREN -> ) [33:85]
+        |       |                                                           |           |       |       |       |       |       `--RPAREN -> ) [33:86]
+        |       |                                                           |           |       |       |       |       `--RPAREN -> ) [33:87]
+        |       |                                                           |           |       |       |       `--RPAREN -> ) [33:88]
+        |       |                                                           |           |       |       `--RPAREN -> ) [33:89]
+        |       |                                                           |           |       `--RPAREN -> ) [33:90]
+        |       |                                                           |           `--RPAREN -> ) [33:91]
+        |       |                                                           |--RPAREN -> ) [33:92]
+        |       |                                                           |--SLIST -> { [33:94]
+        |       |                                                           |   |--EXPR -> EXPR [34:30]
+        |       |                                                           |   |   `--METHOD_CALL -> ( [34:30]
+        |       |                                                           |   |       |--DOT -> . [34:22]
+        |       |                                                           |   |       |   |--DOT -> . [34:18]
+        |       |                                                           |   |       |   |   |--IDENT -> System [34:12]
+        |       |                                                           |   |       |   |   `--IDENT -> out [34:19]
+        |       |                                                           |   |       |   `--IDENT -> println [34:23]
+        |       |                                                           |   |       |--ELIST -> ELIST [34:31]
+        |       |                                                           |   |       |   `--EXPR -> EXPR [34:31]
+        |       |                                                           |   |       |       `--IDENT -> innerInnerInnerInnerInnerInnerInnerRecordComponent [34:31]
+        |       |                                                           |   |       `--RPAREN -> ) [34:81]
+        |       |                                                           |   |--SEMI -> ; [34:82]
+        |       |                                                           |   `--RCURLY -> } [35:8]
+        |       |                                                           `--LITERAL_ELSE -> else [35:10]
+        |       |                                                               `--LITERAL_IF -> if [35:15]
+        |       |                                                                   |--LPAREN -> ( [35:18]
+        |       |                                                                   |--EXPR -> EXPR [35:21]
+        |       |                                                                   |   `--LITERAL_INSTANCEOF -> instanceof [35:21]
+        |       |                                                                   |       |--IDENT -> r [35:19]
+        |       |                                                                   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [35:32]
+        |       |                                                                   |           |--MODIFIERS -> MODIFIERS [35:32]
+        |       |                                                                   |           |--TYPE -> TYPE [35:32]
+        |       |                                                                   |           |   `--IDENT -> R [35:32]
+        |       |                                                                   |           |--LPAREN -> ( [35:33]
+        |       |                                                                   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [35:34]
+        |       |                                                                   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [35:34]
+        |       |                                                                   |           |       |--MODIFIERS -> MODIFIERS [35:34]
+        |       |                                                                   |           |       |--TYPE -> TYPE [35:34]
+        |       |                                                                   |           |       |   `--IDENT -> R [35:34]
+        |       |                                                                   |           |       `--IDENT -> myRecord [35:36]
+        |       |                                                                   |           `--RPAREN -> ) [35:44]
+        |       |                                                                   |--RPAREN -> ) [35:45]
+        |       |                                                                   `--SLIST -> { [35:47]
+        |       |                                                                       |--LITERAL_IF -> if [36:12]
+        |       |                                                                       |   |--LPAREN -> ( [36:15]
+        |       |                                                                       |   |--EXPR -> EXPR [36:25]
+        |       |                                                                       |   |   `--LITERAL_INSTANCEOF -> instanceof [36:25]
+        |       |                                                                       |   |       |--IDENT -> myRecord [36:16]
+        |       |                                                                       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [36:36]
+        |       |                                                                       |   |           |--MODIFIERS -> MODIFIERS [36:36]
+        |       |                                                                       |   |           |--TYPE -> TYPE [36:36]
+        |       |                                                                       |   |           |   `--IDENT -> R [36:36]
+        |       |                                                                       |   |           |--LPAREN -> ( [36:37]
+        |       |                                                                       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [36:38]
+        |       |                                                                       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [36:38]
+        |       |                                                                       |   |           |       |--MODIFIERS -> MODIFIERS [36:38]
+        |       |                                                                       |   |           |       |--TYPE -> TYPE [36:38]
+        |       |                                                                       |   |           |       |   `--IDENT -> R [36:38]
+        |       |                                                                       |   |           |       `--IDENT -> myInnerRecord [36:40]
+        |       |                                                                       |   |           `--RPAREN -> ) [36:53]
+        |       |                                                                       |   |--RPAREN -> ) [36:54]
+        |       |                                                                       |   `--SLIST -> { [36:56]
+        |       |                                                                       |       |--LITERAL_IF -> if [37:16]
+        |       |                                                                       |       |   |--LPAREN -> ( [37:19]
+        |       |                                                                       |       |   |--EXPR -> EXPR [37:34]
+        |       |                                                                       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [37:34]
+        |       |                                                                       |       |   |       |--IDENT -> myInnerRecord [37:20]
+        |       |                                                                       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [37:45]
+        |       |                                                                       |       |   |           |--MODIFIERS -> MODIFIERS [37:45]
+        |       |                                                                       |       |   |           |--TYPE -> TYPE [37:45]
+        |       |                                                                       |       |   |           |   `--IDENT -> R [37:45]
+        |       |                                                                       |       |   |           |--LPAREN -> ( [37:46]
+        |       |                                                                       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [37:47]
+        |       |                                                                       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:47]
+        |       |                                                                       |       |   |           |       |--MODIFIERS -> MODIFIERS [37:47]
+        |       |                                                                       |       |   |           |       |--TYPE -> TYPE [37:47]
+        |       |                                                                       |       |   |           |       |   `--IDENT -> R [37:47]
+        |       |                                                                       |       |   |           |       `--IDENT -> myInnerInnerRecord [37:49]
+        |       |                                                                       |       |   |           `--RPAREN -> ) [37:67]
+        |       |                                                                       |       |   |--RPAREN -> ) [37:68]
+        |       |                                                                       |       |   `--SLIST -> { [37:70]
+        |       |                                                                       |       |       |--LITERAL_IF -> if [38:20]
+        |       |                                                                       |       |       |   |--LPAREN -> ( [38:23]
+        |       |                                                                       |       |       |   |--EXPR -> EXPR [38:43]
+        |       |                                                                       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [38:43]
+        |       |                                                                       |       |       |   |       |--IDENT -> myInnerInnerRecord [38:24]
+        |       |                                                                       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [38:54]
+        |       |                                                                       |       |       |   |           |--MODIFIERS -> MODIFIERS [38:54]
+        |       |                                                                       |       |       |   |           |--TYPE -> TYPE [38:54]
+        |       |                                                                       |       |       |   |           |   `--IDENT -> R [38:54]
+        |       |                                                                       |       |       |   |           |--LPAREN -> ( [38:55]
+        |       |                                                                       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [38:56]
+        |       |                                                                       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [38:56]
+        |       |                                                                       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [38:56]
+        |       |                                                                       |       |       |   |           |       |--TYPE -> TYPE [38:56]
+        |       |                                                                       |       |       |   |           |       |   `--IDENT -> R [38:56]
+        |       |                                                                       |       |       |   |           |       `--IDENT -> myInnerInnerInnerRecord [38:58]
+        |       |                                                                       |       |       |   |           `--RPAREN -> ) [38:81]
+        |       |                                                                       |       |       |   |--RPAREN -> ) [38:82]
+        |       |                                                                       |       |       |   `--SLIST -> { [38:84]
+        |       |                                                                       |       |       |       |--LITERAL_IF -> if [39:24]
+        |       |                                                                       |       |       |       |   |--LPAREN -> ( [39:27]
+        |       |                                                                       |       |       |       |   |--EXPR -> EXPR [39:52]
+        |       |                                                                       |       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [39:52]
+        |       |                                                                       |       |       |       |   |       |--IDENT -> myInnerInnerInnerRecord [39:28]
+        |       |                                                                       |       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [39:63]
+        |       |                                                                       |       |       |       |   |           |--MODIFIERS -> MODIFIERS [39:63]
+        |       |                                                                       |       |       |       |   |           |--TYPE -> TYPE [39:63]
+        |       |                                                                       |       |       |       |   |           |   `--IDENT -> R [39:63]
+        |       |                                                                       |       |       |       |   |           |--LPAREN -> ( [39:64]
+        |       |                                                                       |       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [39:65]
+        |       |                                                                       |       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [39:65]
+        |       |                                                                       |       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [39:65]
+        |       |                                                                       |       |       |       |   |           |       |--TYPE -> TYPE [39:65]
+        |       |                                                                       |       |       |       |   |           |       |   `--IDENT -> R [39:65]
+        |       |                                                                       |       |       |       |   |           |       `--IDENT -> myInnerInnerInnerInnerRecord [39:67]
+        |       |                                                                       |       |       |       |   |           `--RPAREN -> ) [39:95]
+        |       |                                                                       |       |       |       |   |--RPAREN -> ) [39:96]
+        |       |                                                                       |       |       |       |   `--SLIST -> { [39:98]
+        |       |                                                                       |       |       |       |       |--LITERAL_IF -> if [40:28]
+        |       |                                                                       |       |       |       |       |   |--LPAREN -> ( [40:31]
+        |       |                                                                       |       |       |       |       |   |--EXPR -> EXPR [40:61]
+        |       |                                                                       |       |       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [40:61]
+        |       |                                                                       |       |       |       |       |   |       |--IDENT -> myInnerInnerInnerInnerRecord [40:32]
+        |       |                                                                       |       |       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [41:36]
+        |       |                                                                       |       |       |       |       |   |           |--MODIFIERS -> MODIFIERS [41:36]
+        |       |                                                                       |       |       |       |       |   |           |--TYPE -> TYPE [41:36]
+        |       |                                                                       |       |       |       |       |   |           |   `--IDENT -> R [41:36]
+        |       |                                                                       |       |       |       |       |   |           |--LPAREN -> ( [41:37]
+        |       |                                                                       |       |       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [41:38]
+        |       |                                                                       |       |       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [41:38]
+        |       |                                                                       |       |       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [41:38]
+        |       |                                                                       |       |       |       |       |   |           |       |--TYPE -> TYPE [41:38]
+        |       |                                                                       |       |       |       |       |   |           |       |   `--IDENT -> R [41:38]
+        |       |                                                                       |       |       |       |       |   |           |       `--IDENT -> myInnerInnerInnerInnerInnerRecord [41:40]
+        |       |                                                                       |       |       |       |       |   |           `--RPAREN -> ) [41:73]
+        |       |                                                                       |       |       |       |       |   |--RPAREN -> ) [41:74]
+        |       |                                                                       |       |       |       |       |   `--SLIST -> { [41:76]
+        |       |                                                                       |       |       |       |       |       |--LITERAL_IF -> if [42:32]
+        |       |                                                                       |       |       |       |       |       |   |--LPAREN -> ( [42:35]
+        |       |                                                                       |       |       |       |       |       |   |--EXPR -> EXPR [43:40]
+        |       |                                                                       |       |       |       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [43:40]
+        |       |                                                                       |       |       |       |       |       |   |       |--IDENT -> myInnerInnerInnerInnerInnerRecord [42:36]
+        |       |                                                                       |       |       |       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [43:51]
+        |       |                                                                       |       |       |       |       |       |   |           |--MODIFIERS -> MODIFIERS [43:51]
+        |       |                                                                       |       |       |       |       |       |   |           |--TYPE -> TYPE [43:51]
+        |       |                                                                       |       |       |       |       |       |   |           |   `--IDENT -> R [43:51]
+        |       |                                                                       |       |       |       |       |       |   |           |--LPAREN -> ( [43:52]
+        |       |                                                                       |       |       |       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [43:53]
+        |       |                                                                       |       |       |       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [43:53]
+        |       |                                                                       |       |       |       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [43:53]
+        |       |                                                                       |       |       |       |       |       |   |           |       |--TYPE -> TYPE [43:53]
+        |       |                                                                       |       |       |       |       |       |   |           |       |   `--IDENT -> R [43:53]
+        |       |                                                                       |       |       |       |       |       |   |           |       `--IDENT -> myInnerInnerInnerInnerInnerInnerRecord [43:55]
+        |       |                                                                       |       |       |       |       |       |   |           `--RPAREN -> ) [43:93]
+        |       |                                                                       |       |       |       |       |       |   |--RPAREN -> ) [43:94]
+        |       |                                                                       |       |       |       |       |       |   `--SLIST -> { [43:96]
+        |       |                                                                       |       |       |       |       |       |       |--LITERAL_IF -> if [44:36]
+        |       |                                                                       |       |       |       |       |       |       |   |--LPAREN -> ( [44:39]
+        |       |                                                                       |       |       |       |       |       |       |   |--EXPR -> EXPR [45:44]
+        |       |                                                                       |       |       |       |       |       |       |   |   `--LITERAL_INSTANCEOF -> instanceof [45:44]
+        |       |                                                                       |       |       |       |       |       |       |   |       |--IDENT -> myInnerInnerInnerInnerInnerInnerRecord [44:40]
+        |       |                                                                       |       |       |       |       |       |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [45:55]
+        |       |                                                                       |       |       |       |       |       |       |   |           |--MODIFIERS -> MODIFIERS [45:55]
+        |       |                                                                       |       |       |       |       |       |       |   |           |--TYPE -> TYPE [45:55]
+        |       |                                                                       |       |       |       |       |       |       |   |           |   `--IDENT -> R [45:55]
+        |       |                                                                       |       |       |       |       |       |       |   |           |--LPAREN -> ( [45:56]
+        |       |                                                                       |       |       |       |       |       |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [46:44]
+        |       |                                                                       |       |       |       |       |       |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [46:44]
+        |       |                                                                       |       |       |       |       |       |       |   |           |       |--MODIFIERS -> MODIFIERS [46:44]
+        |       |                                                                       |       |       |       |       |       |       |   |           |       |--TYPE -> TYPE [46:44]
+        |       |                                                                       |       |       |       |       |       |       |   |           |       |   `--IDENT -> R [46:44]
+        |       |                                                                       |       |       |       |       |       |       |   |           |       `--IDENT -> myInnerInnerInnerInnerInnerInnerInnerRecord [47:52]
+        |       |                                                                       |       |       |       |       |       |       |   |           `--RPAREN -> ) [48:36]
+        |       |                                                                       |       |       |       |       |       |       |   |--RPAREN -> ) [48:37]
+        |       |                                                                       |       |       |       |       |       |       |   `--SLIST -> { [48:39]
+        |       |                                                                       |       |       |       |       |       |       |       `--RCURLY -> } [50:36]
+        |       |                                                                       |       |       |       |       |       |       `--RCURLY -> } [51:32]
+        |       |                                                                       |       |       |       |       |       `--RCURLY -> } [52:28]
+        |       |                                                                       |       |       |       |       `--RCURLY -> } [53:24]
+        |       |                                                                       |       |       |       `--RCURLY -> } [54:20]
+        |       |                                                                       |       |       `--RCURLY -> } [55:16]
+        |       |                                                                       |       `--RCURLY -> } [56:12]
+        |       |                                                                       `--RCURLY -> } [57:8]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [60:8]
+        |       |   |--MODIFIERS -> MODIFIERS [60:8]
+        |       |   |   `--FINAL -> final [60:8]
+        |       |   |--TYPE -> TYPE [60:14]
+        |       |   |   |--IDENT -> List [60:14]
+        |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [60:18]
+        |       |   |       |--GENERIC_START -> < [60:18]
+        |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [60:19]
+        |       |   |       |   `--IDENT -> R [60:19]
+        |       |   |       `--GENERIC_END -> > [60:20]
+        |       |   |--IDENT -> list [60:22]
+        |       |   `--ASSIGN -> = [60:27]
+        |       |       `--EXPR -> EXPR [61:23]
+        |       |           `--METHOD_CALL -> ( [61:23]
+        |       |               |--DOT -> . [61:20]
+        |       |               |   |--IDENT -> List [61:16]
+        |       |               |   `--IDENT -> of [61:21]
+        |       |               |--ELIST -> ELIST [61:24]
+        |       |               |   `--EXPR -> EXPR [61:24]
+        |       |               |       `--LITERAL_NEW -> new [61:24]
+        |       |               |           |--IDENT -> R [61:28]
+        |       |               |           |--LPAREN -> ( [61:29]
+        |       |               |           |--ELIST -> ELIST [61:30]
+        |       |               |           |   `--EXPR -> EXPR [61:30]
+        |       |               |           |       `--LITERAL_NEW -> new [61:30]
+        |       |               |           |           |--IDENT -> R [61:34]
+        |       |               |           |           |--LPAREN -> ( [61:35]
+        |       |               |           |           |--ELIST -> ELIST [61:36]
+        |       |               |           |           |   `--EXPR -> EXPR [61:36]
+        |       |               |           |           |       `--LITERAL_NEW -> new [61:36]
+        |       |               |           |           |           |--IDENT -> R [61:40]
+        |       |               |           |           |           |--LPAREN -> ( [61:41]
+        |       |               |           |           |           |--ELIST -> ELIST [61:42]
+        |       |               |           |           |           |   `--EXPR -> EXPR [61:42]
+        |       |               |           |           |           |       `--LITERAL_NEW -> new [61:42]
+        |       |               |           |           |           |           |--IDENT -> R [61:46]
+        |       |               |           |           |           |           |--LPAREN -> ( [61:47]
+        |       |               |           |           |           |           |--ELIST -> ELIST [61:48]
+        |       |               |           |           |           |           |   `--EXPR -> EXPR [61:48]
+        |       |               |           |           |           |           |       `--LITERAL_NEW -> new [61:48]
+        |       |               |           |           |           |           |           |--IDENT -> R [62:24]
+        |       |               |           |           |           |           |           |--LPAREN -> ( [62:25]
+        |       |               |           |           |           |           |           |--ELIST -> ELIST [62:26]
+        |       |               |           |           |           |           |           |   `--EXPR -> EXPR [62:26]
+        |       |               |           |           |           |           |           |       `--LITERAL_NEW -> new [62:26]
+        |       |               |           |           |           |           |           |           |--IDENT -> R [62:30]
+        |       |               |           |           |           |           |           |           |--LPAREN -> ( [62:31]
+        |       |               |           |           |           |           |           |           |--ELIST -> ELIST [62:32]
+        |       |               |           |           |           |           |           |           |   `--EXPR -> EXPR [62:32]
+        |       |               |           |           |           |           |           |           |       `--LITERAL_NEW -> new [62:32]
+        |       |               |           |           |           |           |           |           |           |--IDENT -> R [62:36]
+        |       |               |           |           |           |           |           |           |           |--LPAREN -> ( [62:37]
+        |       |               |           |           |           |           |           |           |           |--ELIST -> ELIST [62:38]
+        |       |               |           |           |           |           |           |           |           |   `--EXPR -> EXPR [62:38]
+        |       |               |           |           |           |           |           |           |           |       `--LITERAL_NEW -> new [62:38]
+        |       |               |           |           |           |           |           |           |           |           |--IDENT -> R [62:42]
+        |       |               |           |           |           |           |           |           |           |           |--LPAREN -> ( [62:43]
+        |       |               |           |           |           |           |           |           |           |           |--ELIST -> ELIST [62:44]
+        |       |               |           |           |           |           |           |           |           |           |   `--EXPR -> EXPR [62:44]
+        |       |               |           |           |           |           |           |           |           |           |       `--LITERAL_NEW -> new [62:44]
+        |       |               |           |           |           |           |           |           |           |           |           |--IDENT -> R [62:48]
+        |       |               |           |           |           |           |           |           |           |           |           |--LPAREN -> ( [62:49]
+        |       |               |           |           |           |           |           |           |           |           |           |--ELIST -> ELIST [62:50]
+        |       |               |           |           |           |           |           |           |           |           |           |   `--EXPR -> EXPR [62:50]
+        |       |               |           |           |           |           |           |           |           |           |           |       `--LITERAL_NULL -> null [62:50]
+        |       |               |           |           |           |           |           |           |           |           |           `--RPAREN -> ) [62:54]
+        |       |               |           |           |           |           |           |           |           |           `--RPAREN -> ) [62:55]
+        |       |               |           |           |           |           |           |           |           `--RPAREN -> ) [62:56]
+        |       |               |           |           |           |           |           |           `--RPAREN -> ) [62:57]
+        |       |               |           |           |           |           |           `--RPAREN -> ) [62:58]
+        |       |               |           |           |           |           `--RPAREN -> ) [62:59]
+        |       |               |           |           |           `--RPAREN -> ) [62:60]
+        |       |               |           |           `--RPAREN -> ) [62:61]
+        |       |               |           `--RPAREN -> ) [62:62]
+        |       |               `--RPAREN -> ) [62:63]
+        |       |--SEMI -> ; [62:64]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [64:8]
+        |       |   |--MODIFIERS -> MODIFIERS [64:8]
+        |       |   |   `--FINAL -> final [64:8]
+        |       |   |--TYPE -> TYPE [64:14]
+        |       |   |   `--IDENT -> Object [64:14]
+        |       |   |--IDENT -> o [64:21]
+        |       |   `--ASSIGN -> = [64:23]
+        |       |       `--EXPR -> EXPR [64:33]
+        |       |           `--METHOD_CALL -> ( [64:33]
+        |       |               |--DOT -> . [64:29]
+        |       |               |   |--IDENT -> list [64:25]
+        |       |               |   `--IDENT -> get [64:30]
+        |       |               |--ELIST -> ELIST [64:34]
+        |       |               |   `--EXPR -> EXPR [64:34]
+        |       |               |       `--NUM_INT -> 0 [64:34]
+        |       |               `--RPAREN -> ) [64:35]
+        |       |--SEMI -> ; [64:36]
+        |       |--LITERAL_FOR -> for [65:8]
+        |       |   |--LPAREN -> ( [65:12]
+        |       |   |--FOR_INIT -> FOR_INIT [65:13]
+        |       |   |--SEMI -> ; [65:13]
+        |       |   |--FOR_CONDITION -> FOR_CONDITION [65:17]
+        |       |   |   `--EXPR -> EXPR [65:17]
+        |       |   |       `--LITERAL_INSTANCEOF -> instanceof [65:17]
+        |       |   |           |--IDENT -> o [65:15]
+        |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [65:28]
+        |       |   |               |--MODIFIERS -> MODIFIERS [65:28]
+        |       |   |               |--TYPE -> TYPE [65:28]
+        |       |   |               |   `--IDENT -> R [65:28]
+        |       |   |               |--LPAREN -> ( [65:29]
+        |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [65:30]
+        |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [65:30]
+        |       |   |               |       |--MODIFIERS -> MODIFIERS [65:30]
+        |       |   |               |       |--TYPE -> TYPE [65:30]
+        |       |   |               |       |   `--IDENT -> R [65:30]
+        |       |   |               |       `--IDENT -> rListElement [65:32]
+        |       |   |               `--RPAREN -> ) [65:44]
+        |       |   |--SEMI -> ; [65:45]
+        |       |   |--FOR_ITERATOR -> FOR_ITERATOR [65:47]
+        |       |   |--RPAREN -> ) [65:47]
+        |       |   `--SLIST -> { [65:49]
+        |       |       |--LITERAL_FOR -> for [66:12]
+        |       |       |   |--LPAREN -> ( [66:16]
+        |       |       |   |--FOR_INIT -> FOR_INIT [66:17]
+        |       |       |   |--SEMI -> ; [66:17]
+        |       |       |   |--FOR_CONDITION -> FOR_CONDITION [66:32]
+        |       |       |   |   `--EXPR -> EXPR [66:32]
+        |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [66:32]
+        |       |       |   |           |--IDENT -> rListElement [66:19]
+        |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [66:43]
+        |       |       |   |               |--MODIFIERS -> MODIFIERS [66:43]
+        |       |       |   |               |--TYPE -> TYPE [66:43]
+        |       |       |   |               |   `--IDENT -> R [66:43]
+        |       |       |   |               |--LPAREN -> ( [66:44]
+        |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [66:45]
+        |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [66:45]
+        |       |       |   |               |       |--MODIFIERS -> MODIFIERS [66:45]
+        |       |       |   |               |       |--TYPE -> TYPE [66:45]
+        |       |       |   |               |       |   `--IDENT -> R [66:45]
+        |       |       |   |               |       `--IDENT -> rListElementInner [66:47]
+        |       |       |   |               |--RPAREN -> ) [66:64]
+        |       |       |   |               `--IDENT -> r5 [66:66]
+        |       |       |   |--SEMI -> ; [66:68]
+        |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [66:70]
+        |       |       |   |--RPAREN -> ) [66:70]
+        |       |       |   `--SLIST -> { [66:72]
+        |       |       |       |--LITERAL_FOR -> for [67:16]
+        |       |       |       |   |--LPAREN -> ( [67:20]
+        |       |       |       |   |--FOR_INIT -> FOR_INIT [67:21]
+        |       |       |       |   |--SEMI -> ; [67:21]
+        |       |       |       |   |--FOR_CONDITION -> FOR_CONDITION [67:41]
+        |       |       |       |   |   `--EXPR -> EXPR [67:41]
+        |       |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [67:41]
+        |       |       |       |   |           |--IDENT -> rListElementInner [67:23]
+        |       |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [67:52]
+        |       |       |       |   |               |--MODIFIERS -> MODIFIERS [67:52]
+        |       |       |       |   |               |--TYPE -> TYPE [67:52]
+        |       |       |       |   |               |   `--IDENT -> R [67:52]
+        |       |       |       |   |               |--LPAREN -> ( [67:53]
+        |       |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [67:54]
+        |       |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [67:54]
+        |       |       |       |   |               |       |--MODIFIERS -> MODIFIERS [67:54]
+        |       |       |       |   |               |       |--TYPE -> TYPE [67:54]
+        |       |       |       |   |               |       |   `--IDENT -> R [67:54]
+        |       |       |       |   |               |       `--IDENT -> rListElementInnerInner [67:56]
+        |       |       |       |   |               `--RPAREN -> ) [67:78]
+        |       |       |       |   |--SEMI -> ; [67:79]
+        |       |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [67:81]
+        |       |       |       |   |--RPAREN -> ) [67:81]
+        |       |       |       |   `--SLIST -> { [67:83]
+        |       |       |       |       |--LITERAL_FOR -> for [68:20]
+        |       |       |       |       |   |--LPAREN -> ( [68:24]
+        |       |       |       |       |   |--FOR_INIT -> FOR_INIT [68:25]
+        |       |       |       |       |   |--SEMI -> ; [68:25]
+        |       |       |       |       |   |--FOR_CONDITION -> FOR_CONDITION [68:50]
+        |       |       |       |       |   |   `--EXPR -> EXPR [68:50]
+        |       |       |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [68:50]
+        |       |       |       |       |   |           |--IDENT -> rListElementInnerInner [68:27]
+        |       |       |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [68:61]
+        |       |       |       |       |   |               |--MODIFIERS -> MODIFIERS [68:61]
+        |       |       |       |       |   |               |--TYPE -> TYPE [68:61]
+        |       |       |       |       |   |               |   `--IDENT -> R [68:61]
+        |       |       |       |       |   |               |--LPAREN -> ( [68:62]
+        |       |       |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [68:63]
+        |       |       |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [68:63]
+        |       |       |       |       |   |               |       |--MODIFIERS -> MODIFIERS [68:63]
+        |       |       |       |       |   |               |       |--TYPE -> TYPE [68:63]
+        |       |       |       |       |   |               |       |   `--IDENT -> R [68:63]
+        |       |       |       |       |   |               |       `--IDENT -> rListElementInnerInnerInner [68:65]
+        |       |       |       |       |   |               `--RPAREN -> ) [68:92]
+        |       |       |       |       |   |--SEMI -> ; [68:93]
+        |       |       |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [68:95]
+        |       |       |       |       |   |--RPAREN -> ) [68:95]
+        |       |       |       |       |   `--SLIST -> { [68:97]
+        |       |       |       |       |       `--RCURLY -> } [69:20]
+        |       |       |       |       `--RCURLY -> } [70:16]
+        |       |       |       `--RCURLY -> } [71:12]
+        |       |       `--RCURLY -> } [72:8]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [74:8]
+        |       |   |--MODIFIERS -> MODIFIERS [74:8]
+        |       |   |   `--FINAL -> final [74:8]
+        |       |   |--TYPE -> TYPE [74:14]
+        |       |   |   `--IDENT -> Iterator [74:14]
+        |       |   |--IDENT -> it [74:23]
+        |       |   `--ASSIGN -> = [74:26]
+        |       |       `--EXPR -> EXPR [74:41]
+        |       |           `--METHOD_CALL -> ( [74:41]
+        |       |               |--DOT -> . [74:32]
+        |       |               |   |--IDENT -> list [74:28]
+        |       |               |   `--IDENT -> iterator [74:33]
+        |       |               |--ELIST -> ELIST [74:42]
+        |       |               `--RPAREN -> ) [74:42]
+        |       |--SEMI -> ; [74:43]
+        |       |--LITERAL_WHILE -> while [75:8]
+        |       |   |--LPAREN -> ( [75:14]
+        |       |   |--EXPR -> EXPR [75:28]
+        |       |   |   `--LAND -> && [75:28]
+        |       |   |       |--METHOD_CALL -> ( [75:25]
+        |       |   |       |   |--DOT -> . [75:17]
+        |       |   |       |   |   |--IDENT -> it [75:15]
+        |       |   |       |   |   `--IDENT -> hasNext [75:18]
+        |       |   |       |   |--ELIST -> ELIST [75:26]
+        |       |   |       |   `--RPAREN -> ) [75:26]
+        |       |   |       `--LITERAL_INSTANCEOF -> instanceof [75:41]
+        |       |   |           |--METHOD_CALL -> ( [75:38]
+        |       |   |           |   |--DOT -> . [75:33]
+        |       |   |           |   |   |--IDENT -> it [75:31]
+        |       |   |           |   |   `--IDENT -> next [75:34]
+        |       |   |           |   |--ELIST -> ELIST [75:39]
+        |       |   |           |   `--RPAREN -> ) [75:39]
+        |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [75:52]
+        |       |   |               |--MODIFIERS -> MODIFIERS [75:52]
+        |       |   |               |--TYPE -> TYPE [75:52]
+        |       |   |               |   `--IDENT -> R [75:52]
+        |       |   |               |--LPAREN -> ( [75:53]
+        |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [75:54]
+        |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [75:54]
+        |       |   |               |       |--MODIFIERS -> MODIFIERS [75:54]
+        |       |   |               |       |--TYPE -> TYPE [75:54]
+        |       |   |               |       |   `--IDENT -> R [75:54]
+        |       |   |               |       `--IDENT -> rListElement2 [75:56]
+        |       |   |               |--RPAREN -> ) [75:69]
+        |       |   |               `--IDENT -> r6 [75:71]
+        |       |   |--RPAREN -> ) [75:73]
+        |       |   `--SLIST -> { [75:75]
+        |       |       |--LITERAL_WHILE -> while [76:12]
+        |       |       |   |--LPAREN -> ( [76:18]
+        |       |       |   |--EXPR -> EXPR [76:32]
+        |       |       |   |   `--LAND -> && [76:32]
+        |       |       |   |       |--METHOD_CALL -> ( [76:29]
+        |       |       |   |       |   |--DOT -> . [76:21]
+        |       |       |   |       |   |   |--IDENT -> it [76:19]
+        |       |       |   |       |   |   `--IDENT -> hasNext [76:22]
+        |       |       |   |       |   |--ELIST -> ELIST [76:30]
+        |       |       |   |       |   `--RPAREN -> ) [76:30]
+        |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [76:45]
+        |       |       |   |           |--METHOD_CALL -> ( [76:42]
+        |       |       |   |           |   |--DOT -> . [76:37]
+        |       |       |   |           |   |   |--IDENT -> it [76:35]
+        |       |       |   |           |   |   `--IDENT -> next [76:38]
+        |       |       |   |           |   |--ELIST -> ELIST [76:43]
+        |       |       |   |           |   `--RPAREN -> ) [76:43]
+        |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [76:56]
+        |       |       |   |               |--MODIFIERS -> MODIFIERS [76:56]
+        |       |       |   |               |--TYPE -> TYPE [76:56]
+        |       |       |   |               |   `--IDENT -> R [76:56]
+        |       |       |   |               |--LPAREN -> ( [76:57]
+        |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [76:58]
+        |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [76:58]
+        |       |       |   |               |       |--MODIFIERS -> MODIFIERS [76:58]
+        |       |       |   |               |       |--TYPE -> TYPE [76:58]
+        |       |       |   |               |       |   `--IDENT -> R [76:58]
+        |       |       |   |               |       `--IDENT -> rListElementInner2 [76:60]
+        |       |       |   |               `--RPAREN -> ) [76:78]
+        |       |       |   |--RPAREN -> ) [76:79]
+        |       |       |   `--SLIST -> { [76:81]
+        |       |       |       |--LITERAL_WHILE -> while [77:16]
+        |       |       |       |   |--LPAREN -> ( [77:22]
+        |       |       |       |   |--EXPR -> EXPR [77:36]
+        |       |       |       |   |   `--LAND -> && [77:36]
+        |       |       |       |   |       |--METHOD_CALL -> ( [77:33]
+        |       |       |       |   |       |   |--DOT -> . [77:25]
+        |       |       |       |   |       |   |   |--IDENT -> it [77:23]
+        |       |       |       |   |       |   |   `--IDENT -> hasNext [77:26]
+        |       |       |       |   |       |   |--ELIST -> ELIST [77:34]
+        |       |       |       |   |       |   `--RPAREN -> ) [77:34]
+        |       |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [77:49]
+        |       |       |       |   |           |--METHOD_CALL -> ( [77:46]
+        |       |       |       |   |           |   |--DOT -> . [77:41]
+        |       |       |       |   |           |   |   |--IDENT -> it [77:39]
+        |       |       |       |   |           |   |   `--IDENT -> next [77:42]
+        |       |       |       |   |           |   |--ELIST -> ELIST [77:47]
+        |       |       |       |   |           |   `--RPAREN -> ) [77:47]
+        |       |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [77:60]
+        |       |       |       |   |               |--MODIFIERS -> MODIFIERS [77:60]
+        |       |       |       |   |               |--TYPE -> TYPE [77:60]
+        |       |       |       |   |               |   `--IDENT -> R [77:60]
+        |       |       |       |   |               |--LPAREN -> ( [77:61]
+        |       |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [77:62]
+        |       |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [77:62]
+        |       |       |       |   |               |       |--MODIFIERS -> MODIFIERS [77:62]
+        |       |       |       |   |               |       |--TYPE -> TYPE [77:62]
+        |       |       |       |   |               |       |   `--IDENT -> R [77:62]
+        |       |       |       |   |               |       `--IDENT -> rListElementInnerInner2 [77:64]
+        |       |       |       |   |               `--RPAREN -> ) [77:87]
+        |       |       |       |   |--RPAREN -> ) [77:88]
+        |       |       |       |   `--SLIST -> { [77:90]
+        |       |       |       |       |--LITERAL_WHILE -> while [78:20]
+        |       |       |       |       |   |--LPAREN -> ( [78:26]
+        |       |       |       |       |   |--EXPR -> EXPR [78:40]
+        |       |       |       |       |   |   `--LAND -> && [78:40]
+        |       |       |       |       |   |       |--METHOD_CALL -> ( [78:37]
+        |       |       |       |       |   |       |   |--DOT -> . [78:29]
+        |       |       |       |       |   |       |   |   |--IDENT -> it [78:27]
+        |       |       |       |       |   |       |   |   `--IDENT -> hasNext [78:30]
+        |       |       |       |       |   |       |   |--ELIST -> ELIST [78:38]
+        |       |       |       |       |   |       |   `--RPAREN -> ) [78:38]
+        |       |       |       |       |   |       `--LITERAL_INSTANCEOF -> instanceof [78:53]
+        |       |       |       |       |   |           |--METHOD_CALL -> ( [78:50]
+        |       |       |       |       |   |           |   |--DOT -> . [78:45]
+        |       |       |       |       |   |           |   |   |--IDENT -> it [78:43]
+        |       |       |       |       |   |           |   |   `--IDENT -> next [78:46]
+        |       |       |       |       |   |           |   |--ELIST -> ELIST [78:51]
+        |       |       |       |       |   |           |   `--RPAREN -> ) [78:51]
+        |       |       |       |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [78:64]
+        |       |       |       |       |   |               |--MODIFIERS -> MODIFIERS [78:64]
+        |       |       |       |       |   |               |--TYPE -> TYPE [78:64]
+        |       |       |       |       |   |               |   `--IDENT -> R [78:64]
+        |       |       |       |       |   |               |--LPAREN -> ( [78:65]
+        |       |       |       |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [78:66]
+        |       |       |       |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [78:66]
+        |       |       |       |       |   |               |       |--MODIFIERS -> MODIFIERS [78:66]
+        |       |       |       |       |   |               |       |--TYPE -> TYPE [78:66]
+        |       |       |       |       |   |               |       |   `--IDENT -> R [78:66]
+        |       |       |       |       |   |               |       `--IDENT -> rListElementInnerInnerInner2 [78:68]
+        |       |       |       |       |   |               `--RPAREN -> ) [78:96]
+        |       |       |       |       |   |--RPAREN -> ) [78:97]
+        |       |       |       |       |   `--SLIST -> { [78:99]
+        |       |       |       |       |       `--RCURLY -> } [79:20]
+        |       |       |       |       `--RCURLY -> } [80:16]
+        |       |       |       `--RCURLY -> } [81:12]
+        |       |       `--RCURLY -> } [82:8]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [84:8]
+        |       |   |--MODIFIERS -> MODIFIERS [84:8]
+        |       |   |   `--FINAL -> final [84:8]
+        |       |   |--TYPE -> TYPE [84:14]
+        |       |   |   `--IDENT -> Object [84:14]
+        |       |   |--IDENT -> myObj [84:21]
+        |       |   `--ASSIGN -> = [84:27]
+        |       |       `--EXPR -> EXPR [87:16]
+        |       |           `--QUESTION -> ? [87:16]
+        |       |               |--LAND -> && [86:16]
+        |       |               |   |--LAND -> && [85:16]
+        |       |               |   |   |--LITERAL_INSTANCEOF -> instanceof [84:41]
+        |       |               |   |   |   |--METHOD_CALL -> ( [84:37]
+        |       |               |   |   |   |   |--DOT -> . [84:33]
+        |       |               |   |   |   |   |   |--IDENT -> list [84:29]
+        |       |               |   |   |   |   |   `--IDENT -> get [84:34]
+        |       |               |   |   |   |   |--ELIST -> ELIST [84:38]
+        |       |               |   |   |   |   |   `--EXPR -> EXPR [84:38]
+        |       |               |   |   |   |   |       `--NUM_INT -> 0 [84:38]
+        |       |               |   |   |   |   `--RPAREN -> ) [84:39]
+        |       |               |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [84:52]
+        |       |               |   |   |       |--MODIFIERS -> MODIFIERS [84:52]
+        |       |               |   |   |       |--TYPE -> TYPE [84:52]
+        |       |               |   |   |       |   `--IDENT -> R [84:52]
+        |       |               |   |   |       |--LPAREN -> ( [84:53]
+        |       |               |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [84:54]
+        |       |               |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:54]
+        |       |               |   |   |       |       |--MODIFIERS -> MODIFIERS [84:54]
+        |       |               |   |   |       |       |--TYPE -> TYPE [84:54]
+        |       |               |   |   |       |       |   `--IDENT -> R [84:54]
+        |       |               |   |   |       |       `--IDENT -> myRecord2 [84:56]
+        |       |               |   |   |       |--RPAREN -> ) [84:65]
+        |       |               |   |   |       `--IDENT -> r7 [84:67]
+        |       |               |   |   `--LITERAL_INSTANCEOF -> instanceof [85:29]
+        |       |               |   |       |--IDENT -> myRecord2 [85:19]
+        |       |               |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [85:40]
+        |       |               |   |           |--MODIFIERS -> MODIFIERS [85:40]
+        |       |               |   |           |--TYPE -> TYPE [85:40]
+        |       |               |   |           |   `--IDENT -> R [85:40]
+        |       |               |   |           |--LPAREN -> ( [85:41]
+        |       |               |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [85:42]
+        |       |               |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [85:42]
+        |       |               |   |           |       |--MODIFIERS -> MODIFIERS [85:42]
+        |       |               |   |           |       |--TYPE -> TYPE [85:42]
+        |       |               |   |           |       |   `--IDENT -> R [85:42]
+        |       |               |   |           |       `--IDENT -> someComponent [85:44]
+        |       |               |   |           `--RPAREN -> ) [85:57]
+        |       |               |   `--LITERAL_INSTANCEOF -> instanceof [86:33]
+        |       |               |       |--IDENT -> someComponent [86:19]
+        |       |               |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [86:44]
+        |       |               |           |--MODIFIERS -> MODIFIERS [86:44]
+        |       |               |           |--TYPE -> TYPE [86:44]
+        |       |               |           |   `--IDENT -> R [86:44]
+        |       |               |           |--LPAREN -> ( [86:45]
+        |       |               |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [86:46]
+        |       |               |           |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [86:46]
+        |       |               |           |       |--MODIFIERS -> MODIFIERS [86:46]
+        |       |               |           |       |--TYPE -> TYPE [86:46]
+        |       |               |           |       |   `--IDENT -> R [86:46]
+        |       |               |           |       |--LPAREN -> ( [86:47]
+        |       |               |           |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [86:48]
+        |       |               |           |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [86:48]
+        |       |               |           |       |       |--MODIFIERS -> MODIFIERS [86:48]
+        |       |               |           |       |       |--TYPE -> TYPE [86:48]
+        |       |               |           |       |       |   `--IDENT -> R [86:48]
+        |       |               |           |       |       `--IDENT -> someComponent2 [86:50]
+        |       |               |           |       `--RPAREN -> ) [86:64]
+        |       |               |           `--RPAREN -> ) [86:65]
+        |       |               |--IDENT -> myRecord2 [87:18]
+        |       |               |--COLON -> : [87:28]
+        |       |               `--LITERAL_NULL -> null [87:30]
+        |       |--SEMI -> ; [87:34]
+        |       `--RCURLY -> } [88:4]
+        `--RCURLY -> } [89:0]
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputGenericRecordDeconstructionPattern.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputGenericRecordDeconstructionPattern.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputGenericRecordDeconstructionPattern.java
@@ -0,0 +1,61 @@
+//non-compiled with javac: Compilable with Java19
+package com.puppycrawl.tools.checkstyle.grammar.java19;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+public class InputGenericRecordDeconstructionPattern {
+
+    void m1(Function<Box<String>, Integer> test) {
+        Box<String> b = new Box<>(null);
+    }
+
+    int m2(Box<String> b) {
+        if (b instanceof Box<String>(String s)) return 1;
+        if (b instanceof Box<String>(String s)
+            && b.v != null
+            && b.v() != null
+            && "whatever".equals(b.v)) return 1;
+        return -1;
+    }
+
+    int m3(Box<String> b) {
+        switch (b) {
+            case Box<String>(String s): return 1;
+            default: return -1;
+        }
+    }
+
+    int m4(Box<String> b) {
+        return switch (b) {
+            case Box<String>(String s) -> 1;
+            default -> -1;
+        };
+    }
+
+    int m5(Box<Box<String>> b) {
+        return switch (b) {
+            case Box<Box<String>>(Box<String>(String s)box)
+                    when "test".equals(s) && box.x != 7  -> 1;
+            case Box<Box<String>>(Box<String>(String s)box)
+                    when "test".equals(s) && (int) box.x != 7  -> 1;
+            case Box<Box<String>>(Box<String>(String s)box)
+                    when "test".equals(s) && Objects.equals(box.v, "box") -> 1;
+            case Box<Box<String>>(Box<String>(String s)box)
+                    when "test".equals(s) && Objects.equals(box.v, "box")
+                        || "something else".equals(s) -> 1;
+            case Box<Box<String>>(Box<String>(String s))
+                    when "test".equals(s) -> 1;
+            case Box<Box<String>>(Box<?> b2)
+                    when "test".equals(b2.v) -> 1;
+            case Box<Box<String>>(Object o) b2
+                    when b2.v != null && "whatever".equals(o.toString())-> 1;
+            default -> -1;
+        };
+    }
+
+    record Box<V>(V v) {
+        static int x = 5;
+    }
+
+}
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19BindingWithModifiers.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19BindingWithModifiers.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19BindingWithModifiers.java
@@ -0,0 +1,119 @@
+//non-compiled with javac: Compilable with Java19
+package com.puppycrawl.tools.checkstyle.grammar.java19;
+
+public class InputJava19BindingWithModifiers {
+    record Box<T>(T t) {
+    }
+
+    class A {
+    }
+
+    class B extends A {
+    }
+
+    sealed interface I permits C, D {
+    }
+
+    final class C implements I {
+    }
+
+    final class D implements I {
+    }
+
+    record Pair<T>(T x, T y) {
+    }
+
+    @interface MyAnno1{}
+    @interface MyAnno2{}
+
+    @interface MyAnno3{
+        String value();
+        String[] values();
+    }
+
+    record Tuple(Object o1, Object o2, Object o3) {}
+    record VarArgs(Object... objArgs){}
+
+
+    static void test1(Box<Object> bo) {
+        if (bo instanceof @MyAnno1 @MyAnno2 Box<Object>(String s)) {
+            System.out.println("String " + s);
+        }
+    }
+
+    static void test2(Box<Object> bo) {
+        if (bo instanceof @MyAnno2 final @MyAnno1 Box<?>(var s)) {
+            System.out.println("String " + s);
+        }
+    }
+
+    void test3(Box<I> bo) {
+        C c = new C();
+        if (bo instanceof @MyAnno1 Box<I>(var s)) {
+            System.out.println("String " + s);
+        }
+        else if (bo instanceof Box b) {
+
+        }
+        else if (bo instanceof Box<I> b && bo.t.equals(c)) {
+
+        }
+        else if (bo != null && bo.t.equals(c)) {
+
+        }
+    }
+
+    static void test4(Pair<I> p) {
+        if (p instanceof final Pair<I>(C t1, C t2)) {
+            System.out.println(t2);
+        }
+        else if (p instanceof @MyAnno2 final Pair<I>(D t1, D t2)) {
+            System.out.println(t1);
+        }
+    }
+
+    static void test5(Tuple t) {
+        if (t instanceof Tuple(String x, String y, String z)) {
+            System.out.println(x + y + z);
+        }
+        else if (t instanceof final Tuple(
+                final Integer x,
+                @MyAnno1 Integer y,
+                final @MyAnno1 @MyAnno2 Integer z)) {
+            System.out.println(x + y + z);
+        }
+    }
+
+    String m2(Pair<I> p1) {
+        return switch (p1) {
+            case Pair<I>(final C c,@MyAnno2 I i) -> "T!";
+            case final Pair<I>(
+                    final @MyAnno3(value = "some value", values = {}) D d,
+                    final C c) -> "C!";
+            case Pair<I>(
+                    @MyAnno3(value = "val", values = {"1", "2"}) D d1,D d2) -> "D!";
+        };
+    }
+
+    void m3 (Pair<Pair<Integer>> s) {
+        switch (s) {
+            case final Pair<Pair<Integer>>(
+                    @MyAnno1 Pair<Integer>(@MyAnno1 Integer x1, final Integer y1) x,
+                    final Pair<Integer>(Integer x2, Integer y2) p2) y
+                        -> System.out.println();
+            case default -> System.out.println();
+        }
+    }
+
+    void m4 (Pair<Pair<Integer>> s) {
+        switch (s) {
+            case @MyAnno2 Pair<Pair<Integer>>(
+                    @MyAnno3(value = "", values = {}) Pair<Integer>(
+                            final Integer x1,Integer y1) x,
+                     @MyAnno3(value = "", values = {}) final Pair<Integer>(
+                             @MyAnno2 final Integer x2,Integer y2) p2) y
+                                    -> System.out.println();
+            case default -> System.out.println();
+        }
+    }
+}
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19GuardsWithExtraParenthesis.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19GuardsWithExtraParenthesis.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19GuardsWithExtraParenthesis.java
@@ -0,0 +1,79 @@
+//non-compiled with javac: Compilable with Java19
+package com.puppycrawl.tools.checkstyle.grammar.java19;
+
+import java.util.Objects;
+
+public class InputJava19GuardsWithExtraParenthesis {
+
+    record Box<V>(V v) {
+        static int x = 5;
+    }
+
+    int m1(Box<Box<String>> b) {
+        return switch (b) {
+            case Box<Box<String>>(Box<String>(String s)box)
+                    when (("test".equals(s) && box.x != 7))  -> 1;
+            case (Box<Box<String>>(Box<String>(String s)box))
+                    when (("test".equals(s)) && ((int) box.x != 7))  -> 1;
+            case Box<Box<String>>((Box<String>((String s))box))
+                    when (boolean)"test".equals(s) && (boolean)Objects.equals(box.v, "box") -> (1);
+            case Box<Box<String>>(Box<String>(String s)box)
+                    when "test".equals(s) && Objects.equals(box.v, "box")
+                        || "something else".equals(s) -> 1;
+            case Box<Box<String>>(Box<String>(String s))
+                    when "test".equals(s) -> 1;
+            case Box<Box<String>>(Box<?> b2)
+                    when "test".equals(b2.v) -> 1;
+            case Box<Box<String>>(Object o) b2
+                    when b2.v != null && "whatever".equals(o.toString())-> 1;
+            default -> -1;
+        };
+    }
+
+    record when<T>(when<T> when){}
+
+    <T> int moreTrickyWhen(when<when<T>> when){
+        return switch(when) {
+        case when<when<T>>(when<when<T>> w1)
+                  when ((when)w1).when.when.when.when.when.equals(null)-> 2;
+        case when<when<T>>(when<when<T>> w1)
+                  when (((w1.when.when.when.when.when.equals(null))))
+                        -> 2;
+        case when<when<T>>(when<when<T>>(when<when<T>> w2) w1)
+                  when (((w1.when.when.when.when.when.equals(null))))
+                        || ((when)w2).equals(((when)w1))-> 2;
+        case when<when<T>>(when<when<T>>(when<when<T>> w2) w1)
+                  when when != null
+                        || ((when)w2).equals(((when)w1))-> 2;
+        case when<when<T>>(Object w) when when != null -> 9;
+          case default, null -> 1;
+        };
+    }
+
+    Object m3(when<String> when) {
+        if (when instanceof when<String>(when<String> w1)) {
+            return w1.when.when().when;
+        }
+        else if (when instanceof when<String>(when<String>(when<String> s1)) w1) {
+            if ("s1".equals(s1)) {
+                return s1;
+            } else {
+                return w1;
+            }
+        }
+        else if (when instanceof when<String>(when<String>(when<String> s1)) w1
+                    && s1.toString().equals(w1.toString())) {
+            if ("s1".equals(s1)) {
+                return s1;
+            } else {
+                return w1;
+            }
+        }
+        else if (!(when instanceof when<String>(when<String>(when<String> s1)) w1)) {
+            return new Object();
+        }
+        else {
+            return s1.toString().equals(w1.toString());
+        }
+    }
+}
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19PatternsInNullSwitch1.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19PatternsInNullSwitch1.java
--- a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19PatternsInNullSwitch1.java
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19PatternsInNullSwitch1.java
@@ -6,20 +6,20 @@ public class InputJava19PatternsInNullSwitch1 {
     class Super {}
     class Sub extends Super {}
     record R(Super s) {}
-// until https://github.com/checkstyle/checkstyle/issues/12507
-//    private int matchingSwitch14(R r) {
-//        return switch(r) {
-//            case R(Super s) -> 1;
-//            default -> 2;
-//        };
-//    }
-//
-//    private int matchingSwitch15(R r) {
-//        return switch(r) {
-//            case R(Sub s) -> 1;
-//            default -> 2;
-//        };
-//    }
+
+    private int matchingSwitch14(R r) {
+        return switch(r) {
+            case R(Super s) -> 1;
+            default -> 2;
+        };
+    }
+
+    private int matchingSwitch15(R r) {
+        return switch(r) {
+            case R(Sub s) -> 1;
+            default -> 2;
+        };
+    }
 
     private int matchingSwitch1(Object obj) {
         return switch (obj) {
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19RecordDecompositionWithConditionInLoops.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19RecordDecompositionWithConditionInLoops.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputJava19RecordDecompositionWithConditionInLoops.java
@@ -0,0 +1,89 @@
+//non-compiled with javac: Compilable with Java19
+package com.puppycrawl.tools.checkstyle.grammar.java19;
+
+import java.util.Iterator;
+import java.util.List;
+
+public class InputJava19RecordDecompositionWithConditionInLoops {
+    record R(R r) {
+
+    }
+
+    public static void main(String... args) {
+        R r = new R(new R(null));
+        if (r instanceof R(R recordComponent) r1) {
+            System.out.println(recordComponent);
+        } else if (r instanceof R(R(R innerRecordComponent) r2) r3) {
+            System.out.println(innerRecordComponent);
+        } else if (r instanceof R(R(R(R innerInnerRecordComponent)))) {
+            System.out.println(innerInnerRecordComponent);
+        } else if (r instanceof
+                R(R(R(R(R innerInnerInnerRecordComponent))))) {
+            System.out.println(innerInnerInnerRecordComponent);
+        } else if (r instanceof
+                R(R(R(R(R(R innerInnerInnerInnerRecordComponent)))))) {
+            System.out.println(innerInnerInnerInnerRecordComponent);
+        } else if (r instanceof
+                R(R(R(R(R(R(R innerInnerInnerInnerInnerRecordComponent))))))) {
+            System.out.println(innerInnerInnerInnerInnerRecordComponent);
+        } else if (r instanceof
+                R(R(R(R(R(R(R(R innerInnerInnerInnerInnerInnerRecordComponent)))))))) {
+            System.out.println(innerInnerInnerInnerInnerInnerRecordComponent);
+        } else if (r instanceof
+                R(R(R(R(R(R(R(R(R innerInnerInnerInnerInnerInnerInnerRecordComponent))))))))) {
+            System.out.println(innerInnerInnerInnerInnerInnerInnerRecordComponent);
+        } else if (r instanceof R(R myRecord)) {
+            if (myRecord instanceof R(R myInnerRecord)) {
+                if (myInnerRecord instanceof R(R myInnerInnerRecord)) {
+                    if (myInnerInnerRecord instanceof R(R myInnerInnerInnerRecord)) {
+                        if (myInnerInnerInnerRecord instanceof R(R myInnerInnerInnerInnerRecord)) {
+                            if (myInnerInnerInnerInnerRecord instanceof
+                                    R(R myInnerInnerInnerInnerInnerRecord)) {
+                                if (myInnerInnerInnerInnerInnerRecord
+                                        instanceof R(R myInnerInnerInnerInnerInnerInnerRecord)) {
+                                    if (myInnerInnerInnerInnerInnerInnerRecord
+                                            instanceof R(
+                                            R
+                                                    myInnerInnerInnerInnerInnerInnerInnerRecord
+                                    )) {
+
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+
+        final List<R> list =
+                List.of(new R(new R(new R(new R(new
+                        R(new R(new R(new R(new R(null))))))))));
+
+        final Object o = list.get(0);
+        for (; o instanceof R(R rListElement); ) {
+            for (; rListElement instanceof R(R rListElementInner) r5; ) {
+                for (; rListElementInner instanceof R(R rListElementInnerInner); ) {
+                    for (; rListElementInnerInner instanceof R(R rListElementInnerInnerInner); ) {
+                    }
+                }
+            }
+        }
+
+        final Iterator it = list.iterator();
+        while (it.hasNext() && it.next() instanceof R(R rListElement2) r6) {
+            while (it.hasNext() && it.next() instanceof R(R rListElementInner2)) {
+                while (it.hasNext() && it.next() instanceof R(R rListElementInnerInner2)) {
+                    while (it.hasNext() && it.next() instanceof R(R rListElementInnerInnerInner2)) {
+                    }
+                }
+            }
+        }
+
+        final Object myObj = list.get(0) instanceof R(R myRecord2) r7
+                && myRecord2 instanceof R(R someComponent)
+                && someComponent instanceof R(R(R someComponent2))
+                ? myRecord2 : null;
+    }
+}
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputRecordPatternsPreview.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputRecordPatternsPreview.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputRecordPatternsPreview.java
@@ -0,0 +1,116 @@
+//non-compiled with javac: Compilable with Java19
+package com.puppycrawl.tools.checkstyle.grammar.java19;
+
+public class InputRecordPatternsPreview {
+    record Box<T>(T t) {
+    }
+
+    class A {
+    }
+
+    class B extends A {
+    }
+
+    sealed interface I permits C, D {
+    }
+
+    final class C implements I {
+    }
+
+    final class D implements I {
+    }
+
+    record Pair<T>(T x, T y) {
+    }
+
+    record Tuple(Object o1, Object o2, Object o3) {}
+    record VarArgs(Object... objArgs){}
+
+
+    static void test1(Box<Object> bo) {
+        if (bo instanceof Box<Object>(String s)) {
+            System.out.println("String " + s);
+        }
+    }
+
+    static void test2(Box<Object> bo) {
+        if (bo instanceof Box<?>(var s)) {
+            System.out.println("String " + s);
+        }
+    }
+
+    void test3(Box<I> bo) {
+        C c = new C();
+        if (bo instanceof Box<I>(var s)) {
+            System.out.println("String " + s);
+        }
+        else if (bo instanceof Box b) {
+
+        }
+        else if (bo instanceof Box<I> b && bo.t.equals(c)) {
+
+        }
+        else if (bo != null && bo.t.equals(c)) {
+
+        }
+    }
+
+    static void test4(Pair<I> p) {
+        if (p instanceof Pair<I>(C t1, C t2)) {
+            System.out.println(t2);
+        }
+        else if (p instanceof Pair<I>(D t1, D t2)) {
+            System.out.println(t1);
+        }
+    }
+
+    static void test5(Tuple t) {
+        if (t instanceof Tuple(String x, String y, String z)) {
+            System.out.println(x + y + z);
+        }
+        else if (t instanceof Tuple(Integer x, Integer y, Integer z)) {
+            System.out.println(x + y + z);
+        }
+    }
+
+    static void test5(VarArgs v) {
+        if (v instanceof VarArgs(Integer[] ints)) {
+            int l = ints.length;
+        }
+        else if (v instanceof VarArgs(Object[] objects)
+            && objects.length > 2) {
+            int l = objects.length;
+        }
+        else if (v instanceof VarArgs(Object[] objects)
+            && objects.length < 2){
+            int l = objects.length;
+        }
+
+    }
+
+    static void m1(Pair<I> p1) {
+        switch (p1) {
+            case Pair<I>(I i,C c) ->
+                    System.out.println("C!");
+            case Pair<I>(I i,D d) ->
+                    System.out.println("D!");
+        }
+
+        switch (p1) {
+            case Pair<I>(C c,I i) ->
+                    System.out.println("T!");
+            case Pair<I>(D d,C c) ->
+                    System.out.println("C!");
+            case Pair<I>(D d1,D d2) ->
+                    System.out.println("D!");
+        }
+    }
+
+    String m2(Pair<I> p1) {
+        return switch (p1) {
+            case Pair<I>(C c,I i) -> "T!";
+            case Pair<I>(D d,C c) -> "C!";
+            case Pair<I>(D d1,D d2) -> "D!";
+        };
+    }
+}
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputRecordPatternsPreviewNestedDecomposition.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputRecordPatternsPreviewNestedDecomposition.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/java19/InputRecordPatternsPreviewNestedDecomposition.java
@@ -0,0 +1,80 @@
+//non-compiled with javac: Compilable with Java19
+package com.puppycrawl.tools.checkstyle.grammar.java19;
+
+public class InputRecordPatternsPreviewNestedDecomposition {
+    record A(Object o) {
+    }
+
+    record B(Object o) {
+    }
+
+    record Point(int x, int y) {
+    }
+
+    enum Color {RED, GREEN, BLUE}
+
+    record ColoredPoint(Point p, Color c) {
+    }
+
+    record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {
+    }
+
+    void method(Object param) {
+        switch (param) {
+            case A(Object o) -> {
+            }
+            case B(var o) -> {
+            }
+            default -> {
+            }
+        }
+        if (param instanceof A(var o)) {
+
+        }
+    }
+
+    // Decompose record
+    static void p1(Rectangle r) {
+        if (r instanceof Rectangle(ColoredPoint ul,ColoredPoint lr)) {
+            System.out.println(ul.c());
+        }
+    }
+
+    // We can decompose this record further, since Point is also
+    // a record
+    static void p2(Rectangle r) {
+        if (r instanceof Rectangle(ColoredPoint(Point p1,Color c1),
+                ColoredPoint lr1)
+                && r instanceof Rectangle(ColoredPoint(Point p2,Color c2),
+                ColoredPoint lr2) && lr2.c == Color.BLUE) {
+            System.out.println(r);
+        }
+    }
+
+    // We can keep decomposing down to the last "inner" record
+    static void p3(Rectangle r) {
+        if (r instanceof Rectangle(ColoredPoint(Point p1,Color c1),
+                ColoredPoint lr1)
+                && r instanceof Rectangle(
+                ColoredPoint(Point(int x,int y),Color c2),
+                ColoredPoint lr2)) {
+            System.out.println(r);
+        }
+    }
+
+    static void p4() {
+        int x1 = 0;
+        int x2 = 0;
+        int y1 = 0;
+        int y2 = 0;
+        Color c1 = Color.BLUE;
+        Color c2 = Color.GREEN;
+        Rectangle r = new Rectangle(new ColoredPoint(new Point(x1, y1), c1),
+                new ColoredPoint(new Point(x2, y2), c2));
+        if (r instanceof Rectangle(
+                ColoredPoint(Point(var x,var y),var c),
+                var lr)) {
+            System.out.println(x);
+        }
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/checks/coding/fallthrough/InputFallThroughWeird.java b/src/test/resources/com/puppycrawl/tools/checkstyle/checks/coding/fallthrough/InputFallThroughWeird.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/checks/coding/fallthrough/InputFallThroughWeird.java
@@ -0,0 +1,27 @@
+/*
+FallThrough
+checkLastCaseGroup = (default)false
+reliefPattern = (default)falls?[ -]?thr(u|ough)
+
+*/
+
+package com.puppycrawl.tools.checkstyle.checks.coding.fallthrough;
+
+public class InputFallThroughWeird {
+        void foo(int i){
+        switch(i) {
+            case 1:
+                 int fallthru = 2; // some comment
+            case 2: // violation 'Fall through from previous branch of the switch statement.'
+                 break;
+            case 3:
+                 int c = 2; // fall thru
+            case 4: // should be ok
+                break;
+            case 5:
+                 String x = "x"; // fall thru
+            case 6: // should be ok
+            default:
+            }
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedRecordPatternsPreview.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedRecordPatternsPreview.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedRecordPatternsPreview.txt
@@ -0,0 +1,1109 @@
+COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
+|--PACKAGE_DEF -> package [2:0]
+|   |--ANNOTATIONS -> ANNOTATIONS [2:47]
+|   |--DOT -> . [2:47]
+|   |   |--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]
+|   |   `--IDENT -> java19 [2:48]
+|   `--SEMI -> ; [2:54]
+`--CLASS_DEF -> CLASS_DEF [4:0]
+    |--MODIFIERS -> MODIFIERS [4:0]
+    |   `--LITERAL_PUBLIC -> public [4:0]
+    |--LITERAL_CLASS -> class [4:7]
+    |--IDENT -> InputRecordPatternsPreview [4:13]
+    `--OBJBLOCK -> OBJBLOCK [4:40]
+        |--LCURLY -> { [4:40]
+        |--RECORD_DEF -> RECORD_DEF [5:4]
+        |   |--MODIFIERS -> MODIFIERS [5:4]
+        |   |--LITERAL_RECORD -> record [5:4]
+        |   |--IDENT -> Box [5:11]
+        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [5:14]
+        |   |   |--GENERIC_START -> < [5:14]
+        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [5:15]
+        |   |   |   `--IDENT -> T [5:15]
+        |   |   `--GENERIC_END -> > [5:16]
+        |   |--LPAREN -> ( [5:17]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [5:18]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [5:18]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [5:18]
+        |   |       |--TYPE -> TYPE [5:18]
+        |   |       |   `--IDENT -> T [5:18]
+        |   |       `--IDENT -> t [5:20]
+        |   |--RPAREN -> ) [5:21]
+        |   `--OBJBLOCK -> OBJBLOCK [5:23]
+        |       |--LCURLY -> { [5:23]
+        |       `--RCURLY -> } [6:4]
+        |--CLASS_DEF -> CLASS_DEF [8:4]
+        |   |--MODIFIERS -> MODIFIERS [8:4]
+        |   |--LITERAL_CLASS -> class [8:4]
+        |   |--IDENT -> A [8:10]
+        |   `--OBJBLOCK -> OBJBLOCK [8:12]
+        |       |--LCURLY -> { [8:12]
+        |       `--RCURLY -> } [9:4]
+        |--CLASS_DEF -> CLASS_DEF [11:4]
+        |   |--MODIFIERS -> MODIFIERS [11:4]
+        |   |--LITERAL_CLASS -> class [11:4]
+        |   |--IDENT -> B [11:10]
+        |   |--EXTENDS_CLAUSE -> extends [11:12]
+        |   |   `--IDENT -> A [11:20]
+        |   `--OBJBLOCK -> OBJBLOCK [11:22]
+        |       |--LCURLY -> { [11:22]
+        |       `--RCURLY -> } [12:4]
+        |--INTERFACE_DEF -> INTERFACE_DEF [14:4]
+        |   |--MODIFIERS -> MODIFIERS [14:4]
+        |   |   `--LITERAL_SEALED -> sealed [14:4]
+        |   |--LITERAL_INTERFACE -> interface [14:11]
+        |   |--IDENT -> I [14:21]
+        |   |--PERMITS_CLAUSE -> permits [14:23]
+        |   |   |--IDENT -> C [14:31]
+        |   |   |--COMMA -> , [14:32]
+        |   |   `--IDENT -> D [14:34]
+        |   `--OBJBLOCK -> OBJBLOCK [14:36]
+        |       |--LCURLY -> { [14:36]
+        |       `--RCURLY -> } [15:4]
+        |--CLASS_DEF -> CLASS_DEF [17:4]
+        |   |--MODIFIERS -> MODIFIERS [17:4]
+        |   |   `--FINAL -> final [17:4]
+        |   |--LITERAL_CLASS -> class [17:10]
+        |   |--IDENT -> C [17:16]
+        |   |--IMPLEMENTS_CLAUSE -> implements [17:18]
+        |   |   `--IDENT -> I [17:29]
+        |   `--OBJBLOCK -> OBJBLOCK [17:31]
+        |       |--LCURLY -> { [17:31]
+        |       `--RCURLY -> } [18:4]
+        |--CLASS_DEF -> CLASS_DEF [20:4]
+        |   |--MODIFIERS -> MODIFIERS [20:4]
+        |   |   `--FINAL -> final [20:4]
+        |   |--LITERAL_CLASS -> class [20:10]
+        |   |--IDENT -> D [20:16]
+        |   |--IMPLEMENTS_CLAUSE -> implements [20:18]
+        |   |   `--IDENT -> I [20:29]
+        |   `--OBJBLOCK -> OBJBLOCK [20:31]
+        |       |--LCURLY -> { [20:31]
+        |       `--RCURLY -> } [21:4]
+        |--RECORD_DEF -> RECORD_DEF [23:4]
+        |   |--MODIFIERS -> MODIFIERS [23:4]
+        |   |--LITERAL_RECORD -> record [23:4]
+        |   |--IDENT -> Pair [23:11]
+        |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [23:15]
+        |   |   |--GENERIC_START -> < [23:15]
+        |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [23:16]
+        |   |   |   `--IDENT -> T [23:16]
+        |   |   `--GENERIC_END -> > [23:17]
+        |   |--LPAREN -> ( [23:18]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [23:19]
+        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [23:19]
+        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [23:19]
+        |   |   |   |--TYPE -> TYPE [23:19]
+        |   |   |   |   `--IDENT -> T [23:19]
+        |   |   |   `--IDENT -> x [23:21]
+        |   |   |--COMMA -> , [23:22]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [23:24]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [23:24]
+        |   |       |--TYPE -> TYPE [23:24]
+        |   |       |   `--IDENT -> T [23:24]
+        |   |       `--IDENT -> y [23:26]
+        |   |--RPAREN -> ) [23:27]
+        |   `--OBJBLOCK -> OBJBLOCK [23:29]
+        |       |--LCURLY -> { [23:29]
+        |       `--RCURLY -> } [24:4]
+        |--RECORD_DEF -> RECORD_DEF [26:4]
+        |   |--MODIFIERS -> MODIFIERS [26:4]
+        |   |--LITERAL_RECORD -> record [26:4]
+        |   |--IDENT -> Tuple [26:11]
+        |   |--LPAREN -> ( [26:16]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [26:17]
+        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [26:17]
+        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [26:17]
+        |   |   |   |--TYPE -> TYPE [26:17]
+        |   |   |   |   `--IDENT -> Object [26:17]
+        |   |   |   `--IDENT -> o1 [26:24]
+        |   |   |--COMMA -> , [26:26]
+        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [26:28]
+        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [26:28]
+        |   |   |   |--TYPE -> TYPE [26:28]
+        |   |   |   |   `--IDENT -> Object [26:28]
+        |   |   |   `--IDENT -> o2 [26:35]
+        |   |   |--COMMA -> , [26:37]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [26:39]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [26:39]
+        |   |       |--TYPE -> TYPE [26:39]
+        |   |       |   `--IDENT -> Object [26:39]
+        |   |       `--IDENT -> o3 [26:46]
+        |   |--RPAREN -> ) [26:48]
+        |   `--OBJBLOCK -> OBJBLOCK [26:50]
+        |       |--LCURLY -> { [26:50]
+        |       `--RCURLY -> } [26:51]
+        |--RECORD_DEF -> RECORD_DEF [27:4]
+        |   |--MODIFIERS -> MODIFIERS [27:4]
+        |   |--LITERAL_RECORD -> record [27:4]
+        |   |--IDENT -> VarArgs [27:11]
+        |   |--LPAREN -> ( [27:18]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [27:19]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [27:19]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [27:19]
+        |   |       |--TYPE -> TYPE [27:19]
+        |   |       |   `--IDENT -> Object [27:19]
+        |   |       |--ELLIPSIS -> ... [27:25]
+        |   |       `--IDENT -> objArgs [27:29]
+        |   |--RPAREN -> ) [27:36]
+        |   `--OBJBLOCK -> OBJBLOCK [27:37]
+        |       |--LCURLY -> { [27:37]
+        |       `--RCURLY -> } [27:38]
+        |--METHOD_DEF -> METHOD_DEF [30:4]
+        |   |--MODIFIERS -> MODIFIERS [30:4]
+        |   |   `--LITERAL_STATIC -> static [30:4]
+        |   |--TYPE -> TYPE [30:11]
+        |   |   `--LITERAL_VOID -> void [30:11]
+        |   |--IDENT -> test1 [30:16]
+        |   |--LPAREN -> ( [30:21]
+        |   |--PARAMETERS -> PARAMETERS [30:22]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [30:22]
+        |   |       |--MODIFIERS -> MODIFIERS [30:22]
+        |   |       |--TYPE -> TYPE [30:22]
+        |   |       |   |--IDENT -> Box [30:22]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [30:25]
+        |   |       |       |--GENERIC_START -> < [30:25]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:26]
+        |   |       |       |   `--IDENT -> Object [30:26]
+        |   |       |       `--GENERIC_END -> > [30:32]
+        |   |       `--IDENT -> bo [30:34]
+        |   |--RPAREN -> ) [30:36]
+        |   `--SLIST -> { [30:38]
+        |       |--LITERAL_IF -> if [31:8]
+        |       |   |--LPAREN -> ( [31:11]
+        |       |   |--EXPR -> EXPR [31:15]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [31:15]
+        |       |   |       |--IDENT -> bo [31:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [31:26]
+        |       |   |           |--MODIFIERS -> MODIFIERS [31:26]
+        |       |   |           |--TYPE -> TYPE [31:26]
+        |       |   |           |   |--IDENT -> Box [31:26]
+        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:29]
+        |       |   |           |       |--GENERIC_START -> < [31:29]
+        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:30]
+        |       |   |           |       |   `--IDENT -> Object [31:30]
+        |       |   |           |       `--GENERIC_END -> > [31:36]
+        |       |   |           |--LPAREN -> ( [31:37]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [31:38]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [31:38]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [31:38]
+        |       |   |           |       |--TYPE -> TYPE [31:38]
+        |       |   |           |       |   `--IDENT -> String [31:38]
+        |       |   |           |       `--IDENT -> s [31:45]
+        |       |   |           `--RPAREN -> ) [31:46]
+        |       |   |--RPAREN -> ) [31:47]
+        |       |   `--SLIST -> { [31:49]
+        |       |       |--EXPR -> EXPR [32:30]
+        |       |       |   `--METHOD_CALL -> ( [32:30]
+        |       |       |       |--DOT -> . [32:22]
+        |       |       |       |   |--DOT -> . [32:18]
+        |       |       |       |   |   |--IDENT -> System [32:12]
+        |       |       |       |   |   `--IDENT -> out [32:19]
+        |       |       |       |   `--IDENT -> println [32:23]
+        |       |       |       |--ELIST -> ELIST [32:41]
+        |       |       |       |   `--EXPR -> EXPR [32:41]
+        |       |       |       |       `--PLUS -> + [32:41]
+        |       |       |       |           |--STRING_LITERAL -> "String " [32:31]
+        |       |       |       |           `--IDENT -> s [32:43]
+        |       |       |       `--RPAREN -> ) [32:44]
+        |       |       |--SEMI -> ; [32:45]
+        |       |       `--RCURLY -> } [33:8]
+        |       `--RCURLY -> } [34:4]
+        |--METHOD_DEF -> METHOD_DEF [36:4]
+        |   |--MODIFIERS -> MODIFIERS [36:4]
+        |   |   `--LITERAL_STATIC -> static [36:4]
+        |   |--TYPE -> TYPE [36:11]
+        |   |   `--LITERAL_VOID -> void [36:11]
+        |   |--IDENT -> test2 [36:16]
+        |   |--LPAREN -> ( [36:21]
+        |   |--PARAMETERS -> PARAMETERS [36:22]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [36:22]
+        |   |       |--MODIFIERS -> MODIFIERS [36:22]
+        |   |       |--TYPE -> TYPE [36:22]
+        |   |       |   |--IDENT -> Box [36:22]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:25]
+        |   |       |       |--GENERIC_START -> < [36:25]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:26]
+        |   |       |       |   `--IDENT -> Object [36:26]
+        |   |       |       `--GENERIC_END -> > [36:32]
+        |   |       `--IDENT -> bo [36:34]
+        |   |--RPAREN -> ) [36:36]
+        |   `--SLIST -> { [36:38]
+        |       |--LITERAL_IF -> if [37:8]
+        |       |   |--LPAREN -> ( [37:11]
+        |       |   |--EXPR -> EXPR [37:15]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [37:15]
+        |       |   |       |--IDENT -> bo [37:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [37:26]
+        |       |   |           |--MODIFIERS -> MODIFIERS [37:26]
+        |       |   |           |--TYPE -> TYPE [37:26]
+        |       |   |           |   |--IDENT -> Box [37:26]
+        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [37:29]
+        |       |   |           |       |--GENERIC_START -> < [37:29]
+        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [37:30]
+        |       |   |           |       |   `--WILDCARD_TYPE -> ? [37:30]
+        |       |   |           |       `--GENERIC_END -> > [37:31]
+        |       |   |           |--LPAREN -> ( [37:32]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [37:33]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [37:33]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [37:33]
+        |       |   |           |       |--TYPE -> TYPE [37:33]
+        |       |   |           |       |   `--IDENT -> var [37:33]
+        |       |   |           |       `--IDENT -> s [37:37]
+        |       |   |           `--RPAREN -> ) [37:38]
+        |       |   |--RPAREN -> ) [37:39]
+        |       |   `--SLIST -> { [37:41]
+        |       |       |--EXPR -> EXPR [38:30]
+        |       |       |   `--METHOD_CALL -> ( [38:30]
+        |       |       |       |--DOT -> . [38:22]
+        |       |       |       |   |--DOT -> . [38:18]
+        |       |       |       |   |   |--IDENT -> System [38:12]
+        |       |       |       |   |   `--IDENT -> out [38:19]
+        |       |       |       |   `--IDENT -> println [38:23]
+        |       |       |       |--ELIST -> ELIST [38:41]
+        |       |       |       |   `--EXPR -> EXPR [38:41]
+        |       |       |       |       `--PLUS -> + [38:41]
+        |       |       |       |           |--STRING_LITERAL -> "String " [38:31]
+        |       |       |       |           `--IDENT -> s [38:43]
+        |       |       |       `--RPAREN -> ) [38:44]
+        |       |       |--SEMI -> ; [38:45]
+        |       |       `--RCURLY -> } [39:8]
+        |       `--RCURLY -> } [40:4]
+        |--METHOD_DEF -> METHOD_DEF [42:4]
+        |   |--MODIFIERS -> MODIFIERS [42:4]
+        |   |--TYPE -> TYPE [42:4]
+        |   |   `--LITERAL_VOID -> void [42:4]
+        |   |--IDENT -> test3 [42:9]
+        |   |--LPAREN -> ( [42:14]
+        |   |--PARAMETERS -> PARAMETERS [42:15]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [42:15]
+        |   |       |--MODIFIERS -> MODIFIERS [42:15]
+        |   |       |--TYPE -> TYPE [42:15]
+        |   |       |   |--IDENT -> Box [42:15]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:18]
+        |   |       |       |--GENERIC_START -> < [42:18]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:19]
+        |   |       |       |   `--IDENT -> I [42:19]
+        |   |       |       `--GENERIC_END -> > [42:20]
+        |   |       `--IDENT -> bo [42:22]
+        |   |--RPAREN -> ) [42:24]
+        |   `--SLIST -> { [42:26]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [43:8]
+        |       |   |--MODIFIERS -> MODIFIERS [43:8]
+        |       |   |--TYPE -> TYPE [43:8]
+        |       |   |   `--IDENT -> C [43:8]
+        |       |   |--IDENT -> c [43:10]
+        |       |   `--ASSIGN -> = [43:12]
+        |       |       `--EXPR -> EXPR [43:14]
+        |       |           `--LITERAL_NEW -> new [43:14]
+        |       |               |--IDENT -> C [43:18]
+        |       |               |--LPAREN -> ( [43:19]
+        |       |               |--ELIST -> ELIST [43:20]
+        |       |               `--RPAREN -> ) [43:20]
+        |       |--SEMI -> ; [43:21]
+        |       |--LITERAL_IF -> if [44:8]
+        |       |   |--LPAREN -> ( [44:11]
+        |       |   |--EXPR -> EXPR [44:15]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [44:15]
+        |       |   |       |--IDENT -> bo [44:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [44:26]
+        |       |   |           |--MODIFIERS -> MODIFIERS [44:26]
+        |       |   |           |--TYPE -> TYPE [44:26]
+        |       |   |           |   |--IDENT -> Box [44:26]
+        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:29]
+        |       |   |           |       |--GENERIC_START -> < [44:29]
+        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:30]
+        |       |   |           |       |   `--IDENT -> I [44:30]
+        |       |   |           |       `--GENERIC_END -> > [44:31]
+        |       |   |           |--LPAREN -> ( [44:32]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [44:33]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [44:33]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [44:33]
+        |       |   |           |       |--TYPE -> TYPE [44:33]
+        |       |   |           |       |   `--IDENT -> var [44:33]
+        |       |   |           |       `--IDENT -> s [44:37]
+        |       |   |           `--RPAREN -> ) [44:38]
+        |       |   |--RPAREN -> ) [44:39]
+        |       |   |--SLIST -> { [44:41]
+        |       |   |   |--EXPR -> EXPR [45:30]
+        |       |   |   |   `--METHOD_CALL -> ( [45:30]
+        |       |   |   |       |--DOT -> . [45:22]
+        |       |   |   |       |   |--DOT -> . [45:18]
+        |       |   |   |       |   |   |--IDENT -> System [45:12]
+        |       |   |   |       |   |   `--IDENT -> out [45:19]
+        |       |   |   |       |   `--IDENT -> println [45:23]
+        |       |   |   |       |--ELIST -> ELIST [45:41]
+        |       |   |   |       |   `--EXPR -> EXPR [45:41]
+        |       |   |   |       |       `--PLUS -> + [45:41]
+        |       |   |   |       |           |--STRING_LITERAL -> "String " [45:31]
+        |       |   |   |       |           `--IDENT -> s [45:43]
+        |       |   |   |       `--RPAREN -> ) [45:44]
+        |       |   |   |--SEMI -> ; [45:45]
+        |       |   |   `--RCURLY -> } [46:8]
+        |       |   `--LITERAL_ELSE -> else [47:8]
+        |       |       `--LITERAL_IF -> if [47:13]
+        |       |           |--LPAREN -> ( [47:16]
+        |       |           |--EXPR -> EXPR [47:20]
+        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [47:20]
+        |       |           |       |--IDENT -> bo [47:17]
+        |       |           |       `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [47:31]
+        |       |           |           |--MODIFIERS -> MODIFIERS [47:31]
+        |       |           |           |--TYPE -> TYPE [47:31]
+        |       |           |           |   `--IDENT -> Box [47:31]
+        |       |           |           `--IDENT -> b [47:35]
+        |       |           |--RPAREN -> ) [47:36]
+        |       |           |--SLIST -> { [47:38]
+        |       |           |   `--RCURLY -> } [49:8]
+        |       |           `--LITERAL_ELSE -> else [50:8]
+        |       |               `--LITERAL_IF -> if [50:13]
+        |       |                   |--LPAREN -> ( [50:16]
+        |       |                   |--EXPR -> EXPR [50:40]
+        |       |                   |   `--LAND -> && [50:40]
+        |       |                   |       |--LITERAL_INSTANCEOF -> instanceof [50:20]
+        |       |                   |       |   |--IDENT -> bo [50:17]
+        |       |                   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [50:31]
+        |       |                   |       |       |--MODIFIERS -> MODIFIERS [50:31]
+        |       |                   |       |       |--TYPE -> TYPE [50:31]
+        |       |                   |       |       |   |--IDENT -> Box [50:31]
+        |       |                   |       |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [50:34]
+        |       |                   |       |       |       |--GENERIC_START -> < [50:34]
+        |       |                   |       |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [50:35]
+        |       |                   |       |       |       |   `--IDENT -> I [50:35]
+        |       |                   |       |       |       `--GENERIC_END -> > [50:36]
+        |       |                   |       |       `--IDENT -> b [50:38]
+        |       |                   |       `--METHOD_CALL -> ( [50:54]
+        |       |                   |           |--DOT -> . [50:47]
+        |       |                   |           |   |--DOT -> . [50:45]
+        |       |                   |           |   |   |--IDENT -> bo [50:43]
+        |       |                   |           |   |   `--IDENT -> t [50:46]
+        |       |                   |           |   `--IDENT -> equals [50:48]
+        |       |                   |           |--ELIST -> ELIST [50:55]
+        |       |                   |           |   `--EXPR -> EXPR [50:55]
+        |       |                   |           |       `--IDENT -> c [50:55]
+        |       |                   |           `--RPAREN -> ) [50:56]
+        |       |                   |--RPAREN -> ) [50:57]
+        |       |                   |--SLIST -> { [50:59]
+        |       |                   |   `--RCURLY -> } [52:8]
+        |       |                   `--LITERAL_ELSE -> else [53:8]
+        |       |                       `--LITERAL_IF -> if [53:13]
+        |       |                           |--LPAREN -> ( [53:16]
+        |       |                           |--EXPR -> EXPR [53:28]
+        |       |                           |   `--LAND -> && [53:28]
+        |       |                           |       |--NOT_EQUAL -> != [53:20]
+        |       |                           |       |   |--IDENT -> bo [53:17]
+        |       |                           |       |   `--LITERAL_NULL -> null [53:23]
+        |       |                           |       `--METHOD_CALL -> ( [53:42]
+        |       |                           |           |--DOT -> . [53:35]
+        |       |                           |           |   |--DOT -> . [53:33]
+        |       |                           |           |   |   |--IDENT -> bo [53:31]
+        |       |                           |           |   |   `--IDENT -> t [53:34]
+        |       |                           |           |   `--IDENT -> equals [53:36]
+        |       |                           |           |--ELIST -> ELIST [53:43]
+        |       |                           |           |   `--EXPR -> EXPR [53:43]
+        |       |                           |           |       `--IDENT -> c [53:43]
+        |       |                           |           `--RPAREN -> ) [53:44]
+        |       |                           |--RPAREN -> ) [53:45]
+        |       |                           `--SLIST -> { [53:47]
+        |       |                               `--RCURLY -> } [55:8]
+        |       `--RCURLY -> } [56:4]
+        |--METHOD_DEF -> METHOD_DEF [58:4]
+        |   |--MODIFIERS -> MODIFIERS [58:4]
+        |   |   `--LITERAL_STATIC -> static [58:4]
+        |   |--TYPE -> TYPE [58:11]
+        |   |   `--LITERAL_VOID -> void [58:11]
+        |   |--IDENT -> test4 [58:16]
+        |   |--LPAREN -> ( [58:21]
+        |   |--PARAMETERS -> PARAMETERS [58:22]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [58:22]
+        |   |       |--MODIFIERS -> MODIFIERS [58:22]
+        |   |       |--TYPE -> TYPE [58:22]
+        |   |       |   |--IDENT -> Pair [58:22]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [58:26]
+        |   |       |       |--GENERIC_START -> < [58:26]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [58:27]
+        |   |       |       |   `--IDENT -> I [58:27]
+        |   |       |       `--GENERIC_END -> > [58:28]
+        |   |       `--IDENT -> p [58:30]
+        |   |--RPAREN -> ) [58:31]
+        |   `--SLIST -> { [58:33]
+        |       |--LITERAL_IF -> if [59:8]
+        |       |   |--LPAREN -> ( [59:11]
+        |       |   |--EXPR -> EXPR [59:14]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [59:14]
+        |       |   |       |--IDENT -> p [59:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [59:25]
+        |       |   |           |--MODIFIERS -> MODIFIERS [59:25]
+        |       |   |           |--TYPE -> TYPE [59:25]
+        |       |   |           |   |--IDENT -> Pair [59:25]
+        |       |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [59:29]
+        |       |   |           |       |--GENERIC_START -> < [59:29]
+        |       |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [59:30]
+        |       |   |           |       |   `--IDENT -> I [59:30]
+        |       |   |           |       `--GENERIC_END -> > [59:31]
+        |       |   |           |--LPAREN -> ( [59:32]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [59:33]
+        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [59:33]
+        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [59:33]
+        |       |   |           |   |   |--TYPE -> TYPE [59:33]
+        |       |   |           |   |   |   `--IDENT -> C [59:33]
+        |       |   |           |   |   `--IDENT -> t1 [59:35]
+        |       |   |           |   |--COMMA -> , [59:37]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [59:39]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [59:39]
+        |       |   |           |       |--TYPE -> TYPE [59:39]
+        |       |   |           |       |   `--IDENT -> C [59:39]
+        |       |   |           |       `--IDENT -> t2 [59:41]
+        |       |   |           `--RPAREN -> ) [59:43]
+        |       |   |--RPAREN -> ) [59:44]
+        |       |   |--SLIST -> { [59:46]
+        |       |   |   |--EXPR -> EXPR [60:30]
+        |       |   |   |   `--METHOD_CALL -> ( [60:30]
+        |       |   |   |       |--DOT -> . [60:22]
+        |       |   |   |       |   |--DOT -> . [60:18]
+        |       |   |   |       |   |   |--IDENT -> System [60:12]
+        |       |   |   |       |   |   `--IDENT -> out [60:19]
+        |       |   |   |       |   `--IDENT -> println [60:23]
+        |       |   |   |       |--ELIST -> ELIST [60:31]
+        |       |   |   |       |   `--EXPR -> EXPR [60:31]
+        |       |   |   |       |       `--IDENT -> t2 [60:31]
+        |       |   |   |       `--RPAREN -> ) [60:33]
+        |       |   |   |--SEMI -> ; [60:34]
+        |       |   |   `--RCURLY -> } [61:8]
+        |       |   `--LITERAL_ELSE -> else [62:8]
+        |       |       `--LITERAL_IF -> if [62:13]
+        |       |           |--LPAREN -> ( [62:16]
+        |       |           |--EXPR -> EXPR [62:19]
+        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [62:19]
+        |       |           |       |--IDENT -> p [62:17]
+        |       |           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [62:30]
+        |       |           |           |--MODIFIERS -> MODIFIERS [62:30]
+        |       |           |           |--TYPE -> TYPE [62:30]
+        |       |           |           |   |--IDENT -> Pair [62:30]
+        |       |           |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [62:34]
+        |       |           |           |       |--GENERIC_START -> < [62:34]
+        |       |           |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [62:35]
+        |       |           |           |       |   `--IDENT -> I [62:35]
+        |       |           |           |       `--GENERIC_END -> > [62:36]
+        |       |           |           |--LPAREN -> ( [62:37]
+        |       |           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [62:38]
+        |       |           |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:38]
+        |       |           |           |   |   |--MODIFIERS -> MODIFIERS [62:38]
+        |       |           |           |   |   |--TYPE -> TYPE [62:38]
+        |       |           |           |   |   |   `--IDENT -> D [62:38]
+        |       |           |           |   |   `--IDENT -> t1 [62:40]
+        |       |           |           |   |--COMMA -> , [62:42]
+        |       |           |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [62:44]
+        |       |           |           |       |--MODIFIERS -> MODIFIERS [62:44]
+        |       |           |           |       |--TYPE -> TYPE [62:44]
+        |       |           |           |       |   `--IDENT -> D [62:44]
+        |       |           |           |       `--IDENT -> t2 [62:46]
+        |       |           |           `--RPAREN -> ) [62:48]
+        |       |           |--RPAREN -> ) [62:49]
+        |       |           `--SLIST -> { [62:51]
+        |       |               |--EXPR -> EXPR [63:30]
+        |       |               |   `--METHOD_CALL -> ( [63:30]
+        |       |               |       |--DOT -> . [63:22]
+        |       |               |       |   |--DOT -> . [63:18]
+        |       |               |       |   |   |--IDENT -> System [63:12]
+        |       |               |       |   |   `--IDENT -> out [63:19]
+        |       |               |       |   `--IDENT -> println [63:23]
+        |       |               |       |--ELIST -> ELIST [63:31]
+        |       |               |       |   `--EXPR -> EXPR [63:31]
+        |       |               |       |       `--IDENT -> t1 [63:31]
+        |       |               |       `--RPAREN -> ) [63:33]
+        |       |               |--SEMI -> ; [63:34]
+        |       |               `--RCURLY -> } [64:8]
+        |       `--RCURLY -> } [65:4]
+        |--METHOD_DEF -> METHOD_DEF [67:4]
+        |   |--MODIFIERS -> MODIFIERS [67:4]
+        |   |   `--LITERAL_STATIC -> static [67:4]
+        |   |--TYPE -> TYPE [67:11]
+        |   |   `--LITERAL_VOID -> void [67:11]
+        |   |--IDENT -> test5 [67:16]
+        |   |--LPAREN -> ( [67:21]
+        |   |--PARAMETERS -> PARAMETERS [67:22]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [67:22]
+        |   |       |--MODIFIERS -> MODIFIERS [67:22]
+        |   |       |--TYPE -> TYPE [67:22]
+        |   |       |   `--IDENT -> Tuple [67:22]
+        |   |       `--IDENT -> t [67:28]
+        |   |--RPAREN -> ) [67:29]
+        |   `--SLIST -> { [67:31]
+        |       |--LITERAL_IF -> if [68:8]
+        |       |   |--LPAREN -> ( [68:11]
+        |       |   |--EXPR -> EXPR [68:14]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [68:14]
+        |       |   |       |--IDENT -> t [68:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [68:25]
+        |       |   |           |--MODIFIERS -> MODIFIERS [68:25]
+        |       |   |           |--TYPE -> TYPE [68:25]
+        |       |   |           |   `--IDENT -> Tuple [68:25]
+        |       |   |           |--LPAREN -> ( [68:30]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [68:31]
+        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [68:31]
+        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [68:31]
+        |       |   |           |   |   |--TYPE -> TYPE [68:31]
+        |       |   |           |   |   |   `--IDENT -> String [68:31]
+        |       |   |           |   |   `--IDENT -> x [68:38]
+        |       |   |           |   |--COMMA -> , [68:39]
+        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [68:41]
+        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [68:41]
+        |       |   |           |   |   |--TYPE -> TYPE [68:41]
+        |       |   |           |   |   |   `--IDENT -> String [68:41]
+        |       |   |           |   |   `--IDENT -> y [68:48]
+        |       |   |           |   |--COMMA -> , [68:49]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [68:51]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [68:51]
+        |       |   |           |       |--TYPE -> TYPE [68:51]
+        |       |   |           |       |   `--IDENT -> String [68:51]
+        |       |   |           |       `--IDENT -> z [68:58]
+        |       |   |           `--RPAREN -> ) [68:59]
+        |       |   |--RPAREN -> ) [68:60]
+        |       |   |--SLIST -> { [68:62]
+        |       |   |   |--EXPR -> EXPR [69:30]
+        |       |   |   |   `--METHOD_CALL -> ( [69:30]
+        |       |   |   |       |--DOT -> . [69:22]
+        |       |   |   |       |   |--DOT -> . [69:18]
+        |       |   |   |       |   |   |--IDENT -> System [69:12]
+        |       |   |   |       |   |   `--IDENT -> out [69:19]
+        |       |   |   |       |   `--IDENT -> println [69:23]
+        |       |   |   |       |--ELIST -> ELIST [69:37]
+        |       |   |   |       |   `--EXPR -> EXPR [69:37]
+        |       |   |   |       |       `--PLUS -> + [69:37]
+        |       |   |   |       |           |--PLUS -> + [69:33]
+        |       |   |   |       |           |   |--IDENT -> x [69:31]
+        |       |   |   |       |           |   `--IDENT -> y [69:35]
+        |       |   |   |       |           `--IDENT -> z [69:39]
+        |       |   |   |       `--RPAREN -> ) [69:40]
+        |       |   |   |--SEMI -> ; [69:41]
+        |       |   |   `--RCURLY -> } [70:8]
+        |       |   `--LITERAL_ELSE -> else [71:8]
+        |       |       `--LITERAL_IF -> if [71:13]
+        |       |           |--LPAREN -> ( [71:16]
+        |       |           |--EXPR -> EXPR [71:19]
+        |       |           |   `--LITERAL_INSTANCEOF -> instanceof [71:19]
+        |       |           |       |--IDENT -> t [71:17]
+        |       |           |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [71:30]
+        |       |           |           |--MODIFIERS -> MODIFIERS [71:30]
+        |       |           |           |--TYPE -> TYPE [71:30]
+        |       |           |           |   `--IDENT -> Tuple [71:30]
+        |       |           |           |--LPAREN -> ( [71:35]
+        |       |           |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [71:36]
+        |       |           |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [71:36]
+        |       |           |           |   |   |--MODIFIERS -> MODIFIERS [71:36]
+        |       |           |           |   |   |--TYPE -> TYPE [71:36]
+        |       |           |           |   |   |   `--IDENT -> Integer [71:36]
+        |       |           |           |   |   `--IDENT -> x [71:44]
+        |       |           |           |   |--COMMA -> , [71:45]
+        |       |           |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [71:47]
+        |       |           |           |   |   |--MODIFIERS -> MODIFIERS [71:47]
+        |       |           |           |   |   |--TYPE -> TYPE [71:47]
+        |       |           |           |   |   |   `--IDENT -> Integer [71:47]
+        |       |           |           |   |   `--IDENT -> y [71:55]
+        |       |           |           |   |--COMMA -> , [71:56]
+        |       |           |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [71:58]
+        |       |           |           |       |--MODIFIERS -> MODIFIERS [71:58]
+        |       |           |           |       |--TYPE -> TYPE [71:58]
+        |       |           |           |       |   `--IDENT -> Integer [71:58]
+        |       |           |           |       `--IDENT -> z [71:66]
+        |       |           |           `--RPAREN -> ) [71:67]
+        |       |           |--RPAREN -> ) [71:68]
+        |       |           `--SLIST -> { [71:70]
+        |       |               |--EXPR -> EXPR [72:30]
+        |       |               |   `--METHOD_CALL -> ( [72:30]
+        |       |               |       |--DOT -> . [72:22]
+        |       |               |       |   |--DOT -> . [72:18]
+        |       |               |       |   |   |--IDENT -> System [72:12]
+        |       |               |       |   |   `--IDENT -> out [72:19]
+        |       |               |       |   `--IDENT -> println [72:23]
+        |       |               |       |--ELIST -> ELIST [72:37]
+        |       |               |       |   `--EXPR -> EXPR [72:37]
+        |       |               |       |       `--PLUS -> + [72:37]
+        |       |               |       |           |--PLUS -> + [72:33]
+        |       |               |       |           |   |--IDENT -> x [72:31]
+        |       |               |       |           |   `--IDENT -> y [72:35]
+        |       |               |       |           `--IDENT -> z [72:39]
+        |       |               |       `--RPAREN -> ) [72:40]
+        |       |               |--SEMI -> ; [72:41]
+        |       |               `--RCURLY -> } [73:8]
+        |       `--RCURLY -> } [74:4]
+        |--METHOD_DEF -> METHOD_DEF [76:4]
+        |   |--MODIFIERS -> MODIFIERS [76:4]
+        |   |   `--LITERAL_STATIC -> static [76:4]
+        |   |--TYPE -> TYPE [76:11]
+        |   |   `--LITERAL_VOID -> void [76:11]
+        |   |--IDENT -> test5 [76:16]
+        |   |--LPAREN -> ( [76:21]
+        |   |--PARAMETERS -> PARAMETERS [76:22]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [76:22]
+        |   |       |--MODIFIERS -> MODIFIERS [76:22]
+        |   |       |--TYPE -> TYPE [76:22]
+        |   |       |   `--IDENT -> VarArgs [76:22]
+        |   |       `--IDENT -> v [76:30]
+        |   |--RPAREN -> ) [76:31]
+        |   `--SLIST -> { [76:33]
+        |       |--LITERAL_IF -> if [77:8]
+        |       |   |--LPAREN -> ( [77:11]
+        |       |   |--EXPR -> EXPR [77:14]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [77:14]
+        |       |   |       |--IDENT -> v [77:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [77:25]
+        |       |   |           |--MODIFIERS -> MODIFIERS [77:25]
+        |       |   |           |--TYPE -> TYPE [77:25]
+        |       |   |           |   `--IDENT -> VarArgs [77:25]
+        |       |   |           |--LPAREN -> ( [77:32]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [77:33]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [77:33]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [77:33]
+        |       |   |           |       |--TYPE -> TYPE [77:33]
+        |       |   |           |       |   |--IDENT -> Integer [77:33]
+        |       |   |           |       |   `--ARRAY_DECLARATOR -> [ [77:40]
+        |       |   |           |       |       `--RBRACK -> ] [77:41]
+        |       |   |           |       `--IDENT -> ints [77:43]
+        |       |   |           `--RPAREN -> ) [77:47]
+        |       |   |--RPAREN -> ) [77:48]
+        |       |   |--SLIST -> { [77:50]
+        |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [78:12]
+        |       |   |   |   |--MODIFIERS -> MODIFIERS [78:12]
+        |       |   |   |   |--TYPE -> TYPE [78:12]
+        |       |   |   |   |   `--LITERAL_INT -> int [78:12]
+        |       |   |   |   |--IDENT -> l [78:16]
+        |       |   |   |   `--ASSIGN -> = [78:18]
+        |       |   |   |       `--EXPR -> EXPR [78:24]
+        |       |   |   |           `--DOT -> . [78:24]
+        |       |   |   |               |--IDENT -> ints [78:20]
+        |       |   |   |               `--IDENT -> length [78:25]
+        |       |   |   |--SEMI -> ; [78:31]
+        |       |   |   `--RCURLY -> } [79:8]
+        |       |   `--LITERAL_ELSE -> else [80:8]
+        |       |       `--LITERAL_IF -> if [80:13]
+        |       |           |--LPAREN -> ( [80:16]
+        |       |           |--EXPR -> EXPR [81:12]
+        |       |           |   `--LAND -> && [81:12]
+        |       |           |       |--LITERAL_INSTANCEOF -> instanceof [80:19]
+        |       |           |       |   |--IDENT -> v [80:17]
+        |       |           |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [80:30]
+        |       |           |       |       |--MODIFIERS -> MODIFIERS [80:30]
+        |       |           |       |       |--TYPE -> TYPE [80:30]
+        |       |           |       |       |   `--IDENT -> VarArgs [80:30]
+        |       |           |       |       |--LPAREN -> ( [80:37]
+        |       |           |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [80:38]
+        |       |           |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [80:38]
+        |       |           |       |       |       |--MODIFIERS -> MODIFIERS [80:38]
+        |       |           |       |       |       |--TYPE -> TYPE [80:38]
+        |       |           |       |       |       |   |--IDENT -> Object [80:38]
+        |       |           |       |       |       |   `--ARRAY_DECLARATOR -> [ [80:44]
+        |       |           |       |       |       |       `--RBRACK -> ] [80:45]
+        |       |           |       |       |       `--IDENT -> objects [80:47]
+        |       |           |       |       `--RPAREN -> ) [80:54]
+        |       |           |       `--GT -> > [81:30]
+        |       |           |           |--DOT -> . [81:22]
+        |       |           |           |   |--IDENT -> objects [81:15]
+        |       |           |           |   `--IDENT -> length [81:23]
+        |       |           |           `--NUM_INT -> 2 [81:32]
+        |       |           |--RPAREN -> ) [81:33]
+        |       |           |--SLIST -> { [81:35]
+        |       |           |   |--VARIABLE_DEF -> VARIABLE_DEF [82:12]
+        |       |           |   |   |--MODIFIERS -> MODIFIERS [82:12]
+        |       |           |   |   |--TYPE -> TYPE [82:12]
+        |       |           |   |   |   `--LITERAL_INT -> int [82:12]
+        |       |           |   |   |--IDENT -> l [82:16]
+        |       |           |   |   `--ASSIGN -> = [82:18]
+        |       |           |   |       `--EXPR -> EXPR [82:27]
+        |       |           |   |           `--DOT -> . [82:27]
+        |       |           |   |               |--IDENT -> objects [82:20]
+        |       |           |   |               `--IDENT -> length [82:28]
+        |       |           |   |--SEMI -> ; [82:34]
+        |       |           |   `--RCURLY -> } [83:8]
+        |       |           `--LITERAL_ELSE -> else [84:8]
+        |       |               `--LITERAL_IF -> if [84:13]
+        |       |                   |--LPAREN -> ( [84:16]
+        |       |                   |--EXPR -> EXPR [85:12]
+        |       |                   |   `--LAND -> && [85:12]
+        |       |                   |       |--LITERAL_INSTANCEOF -> instanceof [84:19]
+        |       |                   |       |   |--IDENT -> v [84:17]
+        |       |                   |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [84:30]
+        |       |                   |       |       |--MODIFIERS -> MODIFIERS [84:30]
+        |       |                   |       |       |--TYPE -> TYPE [84:30]
+        |       |                   |       |       |   `--IDENT -> VarArgs [84:30]
+        |       |                   |       |       |--LPAREN -> ( [84:37]
+        |       |                   |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [84:38]
+        |       |                   |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [84:38]
+        |       |                   |       |       |       |--MODIFIERS -> MODIFIERS [84:38]
+        |       |                   |       |       |       |--TYPE -> TYPE [84:38]
+        |       |                   |       |       |       |   |--IDENT -> Object [84:38]
+        |       |                   |       |       |       |   `--ARRAY_DECLARATOR -> [ [84:44]
+        |       |                   |       |       |       |       `--RBRACK -> ] [84:45]
+        |       |                   |       |       |       `--IDENT -> objects [84:47]
+        |       |                   |       |       `--RPAREN -> ) [84:54]
+        |       |                   |       `--LT -> < [85:30]
+        |       |                   |           |--DOT -> . [85:22]
+        |       |                   |           |   |--IDENT -> objects [85:15]
+        |       |                   |           |   `--IDENT -> length [85:23]
+        |       |                   |           `--NUM_INT -> 2 [85:32]
+        |       |                   |--RPAREN -> ) [85:33]
+        |       |                   `--SLIST -> { [85:34]
+        |       |                       |--VARIABLE_DEF -> VARIABLE_DEF [86:12]
+        |       |                       |   |--MODIFIERS -> MODIFIERS [86:12]
+        |       |                       |   |--TYPE -> TYPE [86:12]
+        |       |                       |   |   `--LITERAL_INT -> int [86:12]
+        |       |                       |   |--IDENT -> l [86:16]
+        |       |                       |   `--ASSIGN -> = [86:18]
+        |       |                       |       `--EXPR -> EXPR [86:27]
+        |       |                       |           `--DOT -> . [86:27]
+        |       |                       |               |--IDENT -> objects [86:20]
+        |       |                       |               `--IDENT -> length [86:28]
+        |       |                       |--SEMI -> ; [86:34]
+        |       |                       `--RCURLY -> } [87:8]
+        |       `--RCURLY -> } [89:4]
+        |--METHOD_DEF -> METHOD_DEF [91:4]
+        |   |--MODIFIERS -> MODIFIERS [91:4]
+        |   |   `--LITERAL_STATIC -> static [91:4]
+        |   |--TYPE -> TYPE [91:11]
+        |   |   `--LITERAL_VOID -> void [91:11]
+        |   |--IDENT -> m1 [91:16]
+        |   |--LPAREN -> ( [91:18]
+        |   |--PARAMETERS -> PARAMETERS [91:19]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [91:19]
+        |   |       |--MODIFIERS -> MODIFIERS [91:19]
+        |   |       |--TYPE -> TYPE [91:19]
+        |   |       |   |--IDENT -> Pair [91:19]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [91:23]
+        |   |       |       |--GENERIC_START -> < [91:23]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [91:24]
+        |   |       |       |   `--IDENT -> I [91:24]
+        |   |       |       `--GENERIC_END -> > [91:25]
+        |   |       `--IDENT -> p1 [91:27]
+        |   |--RPAREN -> ) [91:29]
+        |   `--SLIST -> { [91:31]
+        |       |--LITERAL_SWITCH -> switch [92:8]
+        |       |   |--LPAREN -> ( [92:15]
+        |       |   |--EXPR -> EXPR [92:16]
+        |       |   |   `--IDENT -> p1 [92:16]
+        |       |   |--RPAREN -> ) [92:18]
+        |       |   |--LCURLY -> { [92:20]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [93:12]
+        |       |   |   |--LITERAL_CASE -> case [93:12]
+        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [93:17]
+        |       |   |   |       |--MODIFIERS -> MODIFIERS [93:17]
+        |       |   |   |       |--TYPE -> TYPE [93:17]
+        |       |   |   |       |   |--IDENT -> Pair [93:17]
+        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [93:21]
+        |       |   |   |       |       |--GENERIC_START -> < [93:21]
+        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [93:22]
+        |       |   |   |       |       |   `--IDENT -> I [93:22]
+        |       |   |   |       |       `--GENERIC_END -> > [93:23]
+        |       |   |   |       |--LPAREN -> ( [93:24]
+        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [93:25]
+        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [93:25]
+        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [93:25]
+        |       |   |   |       |   |   |--TYPE -> TYPE [93:25]
+        |       |   |   |       |   |   |   `--IDENT -> I [93:25]
+        |       |   |   |       |   |   `--IDENT -> i [93:27]
+        |       |   |   |       |   |--COMMA -> , [93:28]
+        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [93:29]
+        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [93:29]
+        |       |   |   |       |       |--TYPE -> TYPE [93:29]
+        |       |   |   |       |       |   `--IDENT -> C [93:29]
+        |       |   |   |       |       `--IDENT -> c [93:31]
+        |       |   |   |       `--RPAREN -> ) [93:32]
+        |       |   |   |--LAMBDA -> -> [93:34]
+        |       |   |   |--EXPR -> EXPR [94:38]
+        |       |   |   |   `--METHOD_CALL -> ( [94:38]
+        |       |   |   |       |--DOT -> . [94:30]
+        |       |   |   |       |   |--DOT -> . [94:26]
+        |       |   |   |       |   |   |--IDENT -> System [94:20]
+        |       |   |   |       |   |   `--IDENT -> out [94:27]
+        |       |   |   |       |   `--IDENT -> println [94:31]
+        |       |   |   |       |--ELIST -> ELIST [94:39]
+        |       |   |   |       |   `--EXPR -> EXPR [94:39]
+        |       |   |   |       |       `--STRING_LITERAL -> "C!" [94:39]
+        |       |   |   |       `--RPAREN -> ) [94:43]
+        |       |   |   `--SEMI -> ; [94:44]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [95:12]
+        |       |   |   |--LITERAL_CASE -> case [95:12]
+        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [95:17]
+        |       |   |   |       |--MODIFIERS -> MODIFIERS [95:17]
+        |       |   |   |       |--TYPE -> TYPE [95:17]
+        |       |   |   |       |   |--IDENT -> Pair [95:17]
+        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [95:21]
+        |       |   |   |       |       |--GENERIC_START -> < [95:21]
+        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [95:22]
+        |       |   |   |       |       |   `--IDENT -> I [95:22]
+        |       |   |   |       |       `--GENERIC_END -> > [95:23]
+        |       |   |   |       |--LPAREN -> ( [95:24]
+        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [95:25]
+        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [95:25]
+        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [95:25]
+        |       |   |   |       |   |   |--TYPE -> TYPE [95:25]
+        |       |   |   |       |   |   |   `--IDENT -> I [95:25]
+        |       |   |   |       |   |   `--IDENT -> i [95:27]
+        |       |   |   |       |   |--COMMA -> , [95:28]
+        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [95:29]
+        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [95:29]
+        |       |   |   |       |       |--TYPE -> TYPE [95:29]
+        |       |   |   |       |       |   `--IDENT -> D [95:29]
+        |       |   |   |       |       `--IDENT -> d [95:31]
+        |       |   |   |       `--RPAREN -> ) [95:32]
+        |       |   |   |--LAMBDA -> -> [95:34]
+        |       |   |   |--EXPR -> EXPR [96:38]
+        |       |   |   |   `--METHOD_CALL -> ( [96:38]
+        |       |   |   |       |--DOT -> . [96:30]
+        |       |   |   |       |   |--DOT -> . [96:26]
+        |       |   |   |       |   |   |--IDENT -> System [96:20]
+        |       |   |   |       |   |   `--IDENT -> out [96:27]
+        |       |   |   |       |   `--IDENT -> println [96:31]
+        |       |   |   |       |--ELIST -> ELIST [96:39]
+        |       |   |   |       |   `--EXPR -> EXPR [96:39]
+        |       |   |   |       |       `--STRING_LITERAL -> "D!" [96:39]
+        |       |   |   |       `--RPAREN -> ) [96:43]
+        |       |   |   `--SEMI -> ; [96:44]
+        |       |   `--RCURLY -> } [97:8]
+        |       |--LITERAL_SWITCH -> switch [99:8]
+        |       |   |--LPAREN -> ( [99:15]
+        |       |   |--EXPR -> EXPR [99:16]
+        |       |   |   `--IDENT -> p1 [99:16]
+        |       |   |--RPAREN -> ) [99:18]
+        |       |   |--LCURLY -> { [99:20]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [100:12]
+        |       |   |   |--LITERAL_CASE -> case [100:12]
+        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [100:17]
+        |       |   |   |       |--MODIFIERS -> MODIFIERS [100:17]
+        |       |   |   |       |--TYPE -> TYPE [100:17]
+        |       |   |   |       |   |--IDENT -> Pair [100:17]
+        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [100:21]
+        |       |   |   |       |       |--GENERIC_START -> < [100:21]
+        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [100:22]
+        |       |   |   |       |       |   `--IDENT -> I [100:22]
+        |       |   |   |       |       `--GENERIC_END -> > [100:23]
+        |       |   |   |       |--LPAREN -> ( [100:24]
+        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [100:25]
+        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [100:25]
+        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [100:25]
+        |       |   |   |       |   |   |--TYPE -> TYPE [100:25]
+        |       |   |   |       |   |   |   `--IDENT -> C [100:25]
+        |       |   |   |       |   |   `--IDENT -> c [100:27]
+        |       |   |   |       |   |--COMMA -> , [100:28]
+        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [100:29]
+        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [100:29]
+        |       |   |   |       |       |--TYPE -> TYPE [100:29]
+        |       |   |   |       |       |   `--IDENT -> I [100:29]
+        |       |   |   |       |       `--IDENT -> i [100:31]
+        |       |   |   |       `--RPAREN -> ) [100:32]
+        |       |   |   |--LAMBDA -> -> [100:34]
+        |       |   |   |--EXPR -> EXPR [101:38]
+        |       |   |   |   `--METHOD_CALL -> ( [101:38]
+        |       |   |   |       |--DOT -> . [101:30]
+        |       |   |   |       |   |--DOT -> . [101:26]
+        |       |   |   |       |   |   |--IDENT -> System [101:20]
+        |       |   |   |       |   |   `--IDENT -> out [101:27]
+        |       |   |   |       |   `--IDENT -> println [101:31]
+        |       |   |   |       |--ELIST -> ELIST [101:39]
+        |       |   |   |       |   `--EXPR -> EXPR [101:39]
+        |       |   |   |       |       `--STRING_LITERAL -> "T!" [101:39]
+        |       |   |   |       `--RPAREN -> ) [101:43]
+        |       |   |   `--SEMI -> ; [101:44]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [102:12]
+        |       |   |   |--LITERAL_CASE -> case [102:12]
+        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [102:17]
+        |       |   |   |       |--MODIFIERS -> MODIFIERS [102:17]
+        |       |   |   |       |--TYPE -> TYPE [102:17]
+        |       |   |   |       |   |--IDENT -> Pair [102:17]
+        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [102:21]
+        |       |   |   |       |       |--GENERIC_START -> < [102:21]
+        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [102:22]
+        |       |   |   |       |       |   `--IDENT -> I [102:22]
+        |       |   |   |       |       `--GENERIC_END -> > [102:23]
+        |       |   |   |       |--LPAREN -> ( [102:24]
+        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [102:25]
+        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [102:25]
+        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [102:25]
+        |       |   |   |       |   |   |--TYPE -> TYPE [102:25]
+        |       |   |   |       |   |   |   `--IDENT -> D [102:25]
+        |       |   |   |       |   |   `--IDENT -> d [102:27]
+        |       |   |   |       |   |--COMMA -> , [102:28]
+        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [102:29]
+        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [102:29]
+        |       |   |   |       |       |--TYPE -> TYPE [102:29]
+        |       |   |   |       |       |   `--IDENT -> C [102:29]
+        |       |   |   |       |       `--IDENT -> c [102:31]
+        |       |   |   |       `--RPAREN -> ) [102:32]
+        |       |   |   |--LAMBDA -> -> [102:34]
+        |       |   |   |--EXPR -> EXPR [103:38]
+        |       |   |   |   `--METHOD_CALL -> ( [103:38]
+        |       |   |   |       |--DOT -> . [103:30]
+        |       |   |   |       |   |--DOT -> . [103:26]
+        |       |   |   |       |   |   |--IDENT -> System [103:20]
+        |       |   |   |       |   |   `--IDENT -> out [103:27]
+        |       |   |   |       |   `--IDENT -> println [103:31]
+        |       |   |   |       |--ELIST -> ELIST [103:39]
+        |       |   |   |       |   `--EXPR -> EXPR [103:39]
+        |       |   |   |       |       `--STRING_LITERAL -> "C!" [103:39]
+        |       |   |   |       `--RPAREN -> ) [103:43]
+        |       |   |   `--SEMI -> ; [103:44]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [104:12]
+        |       |   |   |--LITERAL_CASE -> case [104:12]
+        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [104:17]
+        |       |   |   |       |--MODIFIERS -> MODIFIERS [104:17]
+        |       |   |   |       |--TYPE -> TYPE [104:17]
+        |       |   |   |       |   |--IDENT -> Pair [104:17]
+        |       |   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [104:21]
+        |       |   |   |       |       |--GENERIC_START -> < [104:21]
+        |       |   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [104:22]
+        |       |   |   |       |       |   `--IDENT -> I [104:22]
+        |       |   |   |       |       `--GENERIC_END -> > [104:23]
+        |       |   |   |       |--LPAREN -> ( [104:24]
+        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [104:25]
+        |       |   |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [104:25]
+        |       |   |   |       |   |   |--MODIFIERS -> MODIFIERS [104:25]
+        |       |   |   |       |   |   |--TYPE -> TYPE [104:25]
+        |       |   |   |       |   |   |   `--IDENT -> D [104:25]
+        |       |   |   |       |   |   `--IDENT -> d1 [104:27]
+        |       |   |   |       |   |--COMMA -> , [104:29]
+        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [104:30]
+        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [104:30]
+        |       |   |   |       |       |--TYPE -> TYPE [104:30]
+        |       |   |   |       |       |   `--IDENT -> D [104:30]
+        |       |   |   |       |       `--IDENT -> d2 [104:32]
+        |       |   |   |       `--RPAREN -> ) [104:34]
+        |       |   |   |--LAMBDA -> -> [104:36]
+        |       |   |   |--EXPR -> EXPR [105:38]
+        |       |   |   |   `--METHOD_CALL -> ( [105:38]
+        |       |   |   |       |--DOT -> . [105:30]
+        |       |   |   |       |   |--DOT -> . [105:26]
+        |       |   |   |       |   |   |--IDENT -> System [105:20]
+        |       |   |   |       |   |   `--IDENT -> out [105:27]
+        |       |   |   |       |   `--IDENT -> println [105:31]
+        |       |   |   |       |--ELIST -> ELIST [105:39]
+        |       |   |   |       |   `--EXPR -> EXPR [105:39]
+        |       |   |   |       |       `--STRING_LITERAL -> "D!" [105:39]
+        |       |   |   |       `--RPAREN -> ) [105:43]
+        |       |   |   `--SEMI -> ; [105:44]
+        |       |   `--RCURLY -> } [106:8]
+        |       `--RCURLY -> } [107:4]
+        |--METHOD_DEF -> METHOD_DEF [109:4]
+        |   |--MODIFIERS -> MODIFIERS [109:4]
+        |   |--TYPE -> TYPE [109:4]
+        |   |   `--IDENT -> String [109:4]
+        |   |--IDENT -> m2 [109:11]
+        |   |--LPAREN -> ( [109:13]
+        |   |--PARAMETERS -> PARAMETERS [109:14]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [109:14]
+        |   |       |--MODIFIERS -> MODIFIERS [109:14]
+        |   |       |--TYPE -> TYPE [109:14]
+        |   |       |   |--IDENT -> Pair [109:14]
+        |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [109:18]
+        |   |       |       |--GENERIC_START -> < [109:18]
+        |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [109:19]
+        |   |       |       |   `--IDENT -> I [109:19]
+        |   |       |       `--GENERIC_END -> > [109:20]
+        |   |       `--IDENT -> p1 [109:22]
+        |   |--RPAREN -> ) [109:24]
+        |   `--SLIST -> { [109:26]
+        |       |--LITERAL_RETURN -> return [110:8]
+        |       |   |--EXPR -> EXPR [110:15]
+        |       |   |   `--LITERAL_SWITCH -> switch [110:15]
+        |       |   |       |--LPAREN -> ( [110:22]
+        |       |   |       |--EXPR -> EXPR [110:23]
+        |       |   |       |   `--IDENT -> p1 [110:23]
+        |       |   |       |--RPAREN -> ) [110:25]
+        |       |   |       |--LCURLY -> { [110:27]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [111:12]
+        |       |   |       |   |--LITERAL_CASE -> case [111:12]
+        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [111:17]
+        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [111:17]
+        |       |   |       |   |       |--TYPE -> TYPE [111:17]
+        |       |   |       |   |       |   |--IDENT -> Pair [111:17]
+        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [111:21]
+        |       |   |       |   |       |       |--GENERIC_START -> < [111:21]
+        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [111:22]
+        |       |   |       |   |       |       |   `--IDENT -> I [111:22]
+        |       |   |       |   |       |       `--GENERIC_END -> > [111:23]
+        |       |   |       |   |       |--LPAREN -> ( [111:24]
+        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [111:25]
+        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [111:25]
+        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [111:25]
+        |       |   |       |   |       |   |   |--TYPE -> TYPE [111:25]
+        |       |   |       |   |       |   |   |   `--IDENT -> C [111:25]
+        |       |   |       |   |       |   |   `--IDENT -> c [111:27]
+        |       |   |       |   |       |   |--COMMA -> , [111:28]
+        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [111:29]
+        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [111:29]
+        |       |   |       |   |       |       |--TYPE -> TYPE [111:29]
+        |       |   |       |   |       |       |   `--IDENT -> I [111:29]
+        |       |   |       |   |       |       `--IDENT -> i [111:31]
+        |       |   |       |   |       `--RPAREN -> ) [111:32]
+        |       |   |       |   |--LAMBDA -> -> [111:34]
+        |       |   |       |   |--EXPR -> EXPR [111:37]
+        |       |   |       |   |   `--STRING_LITERAL -> "T!" [111:37]
+        |       |   |       |   `--SEMI -> ; [111:41]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [112:12]
+        |       |   |       |   |--LITERAL_CASE -> case [112:12]
+        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [112:17]
+        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [112:17]
+        |       |   |       |   |       |--TYPE -> TYPE [112:17]
+        |       |   |       |   |       |   |--IDENT -> Pair [112:17]
+        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [112:21]
+        |       |   |       |   |       |       |--GENERIC_START -> < [112:21]
+        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [112:22]
+        |       |   |       |   |       |       |   `--IDENT -> I [112:22]
+        |       |   |       |   |       |       `--GENERIC_END -> > [112:23]
+        |       |   |       |   |       |--LPAREN -> ( [112:24]
+        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [112:25]
+        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [112:25]
+        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [112:25]
+        |       |   |       |   |       |   |   |--TYPE -> TYPE [112:25]
+        |       |   |       |   |       |   |   |   `--IDENT -> D [112:25]
+        |       |   |       |   |       |   |   `--IDENT -> d [112:27]
+        |       |   |       |   |       |   |--COMMA -> , [112:28]
+        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [112:29]
+        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [112:29]
+        |       |   |       |   |       |       |--TYPE -> TYPE [112:29]
+        |       |   |       |   |       |       |   `--IDENT -> C [112:29]
+        |       |   |       |   |       |       `--IDENT -> c [112:31]
+        |       |   |       |   |       `--RPAREN -> ) [112:32]
+        |       |   |       |   |--LAMBDA -> -> [112:34]
+        |       |   |       |   |--EXPR -> EXPR [112:37]
+        |       |   |       |   |   `--STRING_LITERAL -> "C!" [112:37]
+        |       |   |       |   `--SEMI -> ; [112:41]
+        |       |   |       |--SWITCH_RULE -> SWITCH_RULE [113:12]
+        |       |   |       |   |--LITERAL_CASE -> case [113:12]
+        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [113:17]
+        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [113:17]
+        |       |   |       |   |       |--TYPE -> TYPE [113:17]
+        |       |   |       |   |       |   |--IDENT -> Pair [113:17]
+        |       |   |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [113:21]
+        |       |   |       |   |       |       |--GENERIC_START -> < [113:21]
+        |       |   |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [113:22]
+        |       |   |       |   |       |       |   `--IDENT -> I [113:22]
+        |       |   |       |   |       |       `--GENERIC_END -> > [113:23]
+        |       |   |       |   |       |--LPAREN -> ( [113:24]
+        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [113:25]
+        |       |   |       |   |       |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [113:25]
+        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [113:25]
+        |       |   |       |   |       |   |   |--TYPE -> TYPE [113:25]
+        |       |   |       |   |       |   |   |   `--IDENT -> D [113:25]
+        |       |   |       |   |       |   |   `--IDENT -> d1 [113:27]
+        |       |   |       |   |       |   |--COMMA -> , [113:29]
+        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [113:30]
+        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [113:30]
+        |       |   |       |   |       |       |--TYPE -> TYPE [113:30]
+        |       |   |       |   |       |       |   `--IDENT -> D [113:30]
+        |       |   |       |   |       |       `--IDENT -> d2 [113:32]
+        |       |   |       |   |       `--RPAREN -> ) [113:34]
+        |       |   |       |   |--LAMBDA -> -> [113:36]
+        |       |   |       |   |--EXPR -> EXPR [113:39]
+        |       |   |       |   |   `--STRING_LITERAL -> "D!" [113:39]
+        |       |   |       |   `--SEMI -> ; [113:43]
+        |       |   |       `--RCURLY -> } [114:8]
+        |       |   `--SEMI -> ; [114:9]
+        |       `--RCURLY -> } [115:4]
+        `--RCURLY -> } [116:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedRecordPatternsPreviewNestedDecomposition.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedRecordPatternsPreviewNestedDecomposition.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java19/ExpectedRecordPatternsPreviewNestedDecomposition.txt
@@ -0,0 +1,684 @@
+COMPILATION_UNIT -> COMPILATION_UNIT [2:0]
+|--PACKAGE_DEF -> package [2:0]
+|   |--ANNOTATIONS -> ANNOTATIONS [2:47]
+|   |--DOT -> . [2:47]
+|   |   |--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]
+|   |   `--IDENT -> java19 [2:48]
+|   `--SEMI -> ; [2:54]
+`--CLASS_DEF -> CLASS_DEF [4:0]
+    |--MODIFIERS -> MODIFIERS [4:0]
+    |   `--LITERAL_PUBLIC -> public [4:0]
+    |--LITERAL_CLASS -> class [4:7]
+    |--IDENT -> InputRecordPatternsPreviewNestedDecomposition [4:13]
+    `--OBJBLOCK -> OBJBLOCK [4:59]
+        |--LCURLY -> { [4:59]
+        |--RECORD_DEF -> RECORD_DEF [5:4]
+        |   |--MODIFIERS -> MODIFIERS [5:4]
+        |   |--LITERAL_RECORD -> record [5:4]
+        |   |--IDENT -> A [5:11]
+        |   |--LPAREN -> ( [5:12]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [5:13]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [5:13]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [5:13]
+        |   |       |--TYPE -> TYPE [5:13]
+        |   |       |   `--IDENT -> Object [5:13]
+        |   |       `--IDENT -> o [5:20]
+        |   |--RPAREN -> ) [5:21]
+        |   `--OBJBLOCK -> OBJBLOCK [5:23]
+        |       |--LCURLY -> { [5:23]
+        |       `--RCURLY -> } [6:4]
+        |--RECORD_DEF -> RECORD_DEF [8:4]
+        |   |--MODIFIERS -> MODIFIERS [8:4]
+        |   |--LITERAL_RECORD -> record [8:4]
+        |   |--IDENT -> B [8:11]
+        |   |--LPAREN -> ( [8:12]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [8:13]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [8:13]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [8:13]
+        |   |       |--TYPE -> TYPE [8:13]
+        |   |       |   `--IDENT -> Object [8:13]
+        |   |       `--IDENT -> o [8:20]
+        |   |--RPAREN -> ) [8:21]
+        |   `--OBJBLOCK -> OBJBLOCK [8:23]
+        |       |--LCURLY -> { [8:23]
+        |       `--RCURLY -> } [9:4]
+        |--RECORD_DEF -> RECORD_DEF [11:4]
+        |   |--MODIFIERS -> MODIFIERS [11:4]
+        |   |--LITERAL_RECORD -> record [11:4]
+        |   |--IDENT -> Point [11:11]
+        |   |--LPAREN -> ( [11:16]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [11:17]
+        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [11:17]
+        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [11:17]
+        |   |   |   |--TYPE -> TYPE [11:17]
+        |   |   |   |   `--LITERAL_INT -> int [11:17]
+        |   |   |   `--IDENT -> x [11:21]
+        |   |   |--COMMA -> , [11:22]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [11:24]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [11:24]
+        |   |       |--TYPE -> TYPE [11:24]
+        |   |       |   `--LITERAL_INT -> int [11:24]
+        |   |       `--IDENT -> y [11:28]
+        |   |--RPAREN -> ) [11:29]
+        |   `--OBJBLOCK -> OBJBLOCK [11:31]
+        |       |--LCURLY -> { [11:31]
+        |       `--RCURLY -> } [12:4]
+        |--ENUM_DEF -> ENUM_DEF [14:4]
+        |   |--MODIFIERS -> MODIFIERS [14:4]
+        |   |--ENUM -> enum [14:4]
+        |   |--IDENT -> Color [14:9]
+        |   `--OBJBLOCK -> OBJBLOCK [14:15]
+        |       |--LCURLY -> { [14:15]
+        |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [14:16]
+        |       |   |--ANNOTATIONS -> ANNOTATIONS [14:16]
+        |       |   `--IDENT -> RED [14:16]
+        |       |--COMMA -> , [14:19]
+        |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [14:21]
+        |       |   |--ANNOTATIONS -> ANNOTATIONS [14:21]
+        |       |   `--IDENT -> GREEN [14:21]
+        |       |--COMMA -> , [14:26]
+        |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [14:28]
+        |       |   |--ANNOTATIONS -> ANNOTATIONS [14:28]
+        |       |   `--IDENT -> BLUE [14:28]
+        |       `--RCURLY -> } [14:32]
+        |--RECORD_DEF -> RECORD_DEF [16:4]
+        |   |--MODIFIERS -> MODIFIERS [16:4]
+        |   |--LITERAL_RECORD -> record [16:4]
+        |   |--IDENT -> ColoredPoint [16:11]
+        |   |--LPAREN -> ( [16:23]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [16:24]
+        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [16:24]
+        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [16:24]
+        |   |   |   |--TYPE -> TYPE [16:24]
+        |   |   |   |   `--IDENT -> Point [16:24]
+        |   |   |   `--IDENT -> p [16:30]
+        |   |   |--COMMA -> , [16:31]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [16:33]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [16:33]
+        |   |       |--TYPE -> TYPE [16:33]
+        |   |       |   `--IDENT -> Color [16:33]
+        |   |       `--IDENT -> c [16:39]
+        |   |--RPAREN -> ) [16:40]
+        |   `--OBJBLOCK -> OBJBLOCK [16:42]
+        |       |--LCURLY -> { [16:42]
+        |       `--RCURLY -> } [17:4]
+        |--RECORD_DEF -> RECORD_DEF [19:4]
+        |   |--MODIFIERS -> MODIFIERS [19:4]
+        |   |--LITERAL_RECORD -> record [19:4]
+        |   |--IDENT -> Rectangle [19:11]
+        |   |--LPAREN -> ( [19:20]
+        |   |--RECORD_COMPONENTS -> RECORD_COMPONENTS [19:21]
+        |   |   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [19:21]
+        |   |   |   |--ANNOTATIONS -> ANNOTATIONS [19:21]
+        |   |   |   |--TYPE -> TYPE [19:21]
+        |   |   |   |   `--IDENT -> ColoredPoint [19:21]
+        |   |   |   `--IDENT -> upperLeft [19:34]
+        |   |   |--COMMA -> , [19:43]
+        |   |   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [19:45]
+        |   |       |--ANNOTATIONS -> ANNOTATIONS [19:45]
+        |   |       |--TYPE -> TYPE [19:45]
+        |   |       |   `--IDENT -> ColoredPoint [19:45]
+        |   |       `--IDENT -> lowerRight [19:58]
+        |   |--RPAREN -> ) [19:68]
+        |   `--OBJBLOCK -> OBJBLOCK [19:70]
+        |       |--LCURLY -> { [19:70]
+        |       `--RCURLY -> } [20:4]
+        |--METHOD_DEF -> METHOD_DEF [22:4]
+        |   |--MODIFIERS -> MODIFIERS [22:4]
+        |   |--TYPE -> TYPE [22:4]
+        |   |   `--LITERAL_VOID -> void [22:4]
+        |   |--IDENT -> method [22:9]
+        |   |--LPAREN -> ( [22:15]
+        |   |--PARAMETERS -> PARAMETERS [22:16]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [22:16]
+        |   |       |--MODIFIERS -> MODIFIERS [22:16]
+        |   |       |--TYPE -> TYPE [22:16]
+        |   |       |   `--IDENT -> Object [22:16]
+        |   |       `--IDENT -> param [22:23]
+        |   |--RPAREN -> ) [22:28]
+        |   `--SLIST -> { [22:30]
+        |       |--LITERAL_SWITCH -> switch [23:8]
+        |       |   |--LPAREN -> ( [23:15]
+        |       |   |--EXPR -> EXPR [23:16]
+        |       |   |   `--IDENT -> param [23:16]
+        |       |   |--RPAREN -> ) [23:21]
+        |       |   |--LCURLY -> { [23:23]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [24:12]
+        |       |   |   |--LITERAL_CASE -> case [24:12]
+        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [24:17]
+        |       |   |   |       |--MODIFIERS -> MODIFIERS [24:17]
+        |       |   |   |       |--TYPE -> TYPE [24:17]
+        |       |   |   |       |   `--IDENT -> A [24:17]
+        |       |   |   |       |--LPAREN -> ( [24:18]
+        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [24:19]
+        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [24:19]
+        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [24:19]
+        |       |   |   |       |       |--TYPE -> TYPE [24:19]
+        |       |   |   |       |       |   `--IDENT -> Object [24:19]
+        |       |   |   |       |       `--IDENT -> o [24:26]
+        |       |   |   |       `--RPAREN -> ) [24:27]
+        |       |   |   |--LAMBDA -> -> [24:29]
+        |       |   |   `--SLIST -> { [24:32]
+        |       |   |       `--RCURLY -> } [25:12]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [26:12]
+        |       |   |   |--LITERAL_CASE -> case [26:12]
+        |       |   |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [26:17]
+        |       |   |   |       |--MODIFIERS -> MODIFIERS [26:17]
+        |       |   |   |       |--TYPE -> TYPE [26:17]
+        |       |   |   |       |   `--IDENT -> B [26:17]
+        |       |   |   |       |--LPAREN -> ( [26:18]
+        |       |   |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [26:19]
+        |       |   |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [26:19]
+        |       |   |   |       |       |--MODIFIERS -> MODIFIERS [26:19]
+        |       |   |   |       |       |--TYPE -> TYPE [26:19]
+        |       |   |   |       |       |   `--IDENT -> var [26:19]
+        |       |   |   |       |       `--IDENT -> o [26:23]
+        |       |   |   |       `--RPAREN -> ) [26:24]
+        |       |   |   |--LAMBDA -> -> [26:26]
+        |       |   |   `--SLIST -> { [26:29]
+        |       |   |       `--RCURLY -> } [27:12]
+        |       |   |--SWITCH_RULE -> SWITCH_RULE [28:12]
+        |       |   |   |--LITERAL_DEFAULT -> default [28:12]
+        |       |   |   |--LAMBDA -> -> [28:20]
+        |       |   |   `--SLIST -> { [28:23]
+        |       |   |       `--RCURLY -> } [29:12]
+        |       |   `--RCURLY -> } [30:8]
+        |       |--LITERAL_IF -> if [31:8]
+        |       |   |--LPAREN -> ( [31:11]
+        |       |   |--EXPR -> EXPR [31:18]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [31:18]
+        |       |   |       |--IDENT -> param [31:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [31:29]
+        |       |   |           |--MODIFIERS -> MODIFIERS [31:29]
+        |       |   |           |--TYPE -> TYPE [31:29]
+        |       |   |           |   `--IDENT -> A [31:29]
+        |       |   |           |--LPAREN -> ( [31:30]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [31:31]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [31:31]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [31:31]
+        |       |   |           |       |--TYPE -> TYPE [31:31]
+        |       |   |           |       |   `--IDENT -> var [31:31]
+        |       |   |           |       `--IDENT -> o [31:35]
+        |       |   |           `--RPAREN -> ) [31:36]
+        |       |   |--RPAREN -> ) [31:37]
+        |       |   `--SLIST -> { [31:39]
+        |       |       `--RCURLY -> } [33:8]
+        |       `--RCURLY -> } [34:4]
+        |--METHOD_DEF -> METHOD_DEF [37:4]
+        |   |--MODIFIERS -> MODIFIERS [37:4]
+        |   |   `--LITERAL_STATIC -> static [37:4]
+        |   |--TYPE -> TYPE [37:11]
+        |   |   `--LITERAL_VOID -> void [37:11]
+        |   |--IDENT -> p1 [37:16]
+        |   |--LPAREN -> ( [37:18]
+        |   |--PARAMETERS -> PARAMETERS [37:19]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [37:19]
+        |   |       |--MODIFIERS -> MODIFIERS [37:19]
+        |   |       |--TYPE -> TYPE [37:19]
+        |   |       |   `--IDENT -> Rectangle [37:19]
+        |   |       `--IDENT -> r [37:29]
+        |   |--RPAREN -> ) [37:30]
+        |   `--SLIST -> { [37:32]
+        |       |--LITERAL_IF -> if [38:8]
+        |       |   |--LPAREN -> ( [38:11]
+        |       |   |--EXPR -> EXPR [38:14]
+        |       |   |   `--LITERAL_INSTANCEOF -> instanceof [38:14]
+        |       |   |       |--IDENT -> r [38:12]
+        |       |   |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [38:25]
+        |       |   |           |--MODIFIERS -> MODIFIERS [38:25]
+        |       |   |           |--TYPE -> TYPE [38:25]
+        |       |   |           |   `--IDENT -> Rectangle [38:25]
+        |       |   |           |--LPAREN -> ( [38:34]
+        |       |   |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [38:35]
+        |       |   |           |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [38:35]
+        |       |   |           |   |   |--MODIFIERS -> MODIFIERS [38:35]
+        |       |   |           |   |   |--TYPE -> TYPE [38:35]
+        |       |   |           |   |   |   `--IDENT -> ColoredPoint [38:35]
+        |       |   |           |   |   `--IDENT -> ul [38:48]
+        |       |   |           |   |--COMMA -> , [38:50]
+        |       |   |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [38:51]
+        |       |   |           |       |--MODIFIERS -> MODIFIERS [38:51]
+        |       |   |           |       |--TYPE -> TYPE [38:51]
+        |       |   |           |       |   `--IDENT -> ColoredPoint [38:51]
+        |       |   |           |       `--IDENT -> lr [38:64]
+        |       |   |           `--RPAREN -> ) [38:66]
+        |       |   |--RPAREN -> ) [38:67]
+        |       |   `--SLIST -> { [38:69]
+        |       |       |--EXPR -> EXPR [39:30]
+        |       |       |   `--METHOD_CALL -> ( [39:30]
+        |       |       |       |--DOT -> . [39:22]
+        |       |       |       |   |--DOT -> . [39:18]
+        |       |       |       |   |   |--IDENT -> System [39:12]
+        |       |       |       |   |   `--IDENT -> out [39:19]
+        |       |       |       |   `--IDENT -> println [39:23]
+        |       |       |       |--ELIST -> ELIST [39:35]
+        |       |       |       |   `--EXPR -> EXPR [39:35]
+        |       |       |       |       `--METHOD_CALL -> ( [39:35]
+        |       |       |       |           |--DOT -> . [39:33]
+        |       |       |       |           |   |--IDENT -> ul [39:31]
+        |       |       |       |           |   `--IDENT -> c [39:34]
+        |       |       |       |           |--ELIST -> ELIST [39:36]
+        |       |       |       |           `--RPAREN -> ) [39:36]
+        |       |       |       `--RPAREN -> ) [39:37]
+        |       |       |--SEMI -> ; [39:38]
+        |       |       `--RCURLY -> } [40:8]
+        |       `--RCURLY -> } [41:4]
+        |--METHOD_DEF -> METHOD_DEF [45:4]
+        |   |--MODIFIERS -> MODIFIERS [45:4]
+        |   |   `--LITERAL_STATIC -> static [45:4]
+        |   |--TYPE -> TYPE [45:11]
+        |   |   `--LITERAL_VOID -> void [45:11]
+        |   |--IDENT -> p2 [45:16]
+        |   |--LPAREN -> ( [45:18]
+        |   |--PARAMETERS -> PARAMETERS [45:19]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [45:19]
+        |   |       |--MODIFIERS -> MODIFIERS [45:19]
+        |   |       |--TYPE -> TYPE [45:19]
+        |   |       |   `--IDENT -> Rectangle [45:19]
+        |   |       `--IDENT -> r [45:29]
+        |   |--RPAREN -> ) [45:30]
+        |   `--SLIST -> { [45:32]
+        |       |--LITERAL_IF -> if [46:8]
+        |       |   |--LPAREN -> ( [46:11]
+        |       |   |--EXPR -> EXPR [49:34]
+        |       |   |   `--LAND -> && [49:34]
+        |       |   |       |--LAND -> && [48:16]
+        |       |   |       |   |--LITERAL_INSTANCEOF -> instanceof [46:14]
+        |       |   |       |   |   |--IDENT -> r [46:12]
+        |       |   |       |   |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [46:25]
+        |       |   |       |   |       |--MODIFIERS -> MODIFIERS [46:25]
+        |       |   |       |   |       |--TYPE -> TYPE [46:25]
+        |       |   |       |   |       |   `--IDENT -> Rectangle [46:25]
+        |       |   |       |   |       |--LPAREN -> ( [46:34]
+        |       |   |       |   |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [46:35]
+        |       |   |       |   |       |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [46:35]
+        |       |   |       |   |       |   |   |--MODIFIERS -> MODIFIERS [46:35]
+        |       |   |       |   |       |   |   |--TYPE -> TYPE [46:35]
+        |       |   |       |   |       |   |   |   `--IDENT -> ColoredPoint [46:35]
+        |       |   |       |   |       |   |   |--LPAREN -> ( [46:47]
+        |       |   |       |   |       |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [46:48]
+        |       |   |       |   |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [46:48]
+        |       |   |       |   |       |   |   |   |   |--MODIFIERS -> MODIFIERS [46:48]
+        |       |   |       |   |       |   |   |   |   |--TYPE -> TYPE [46:48]
+        |       |   |       |   |       |   |   |   |   |   `--IDENT -> Point [46:48]
+        |       |   |       |   |       |   |   |   |   `--IDENT -> p1 [46:54]
+        |       |   |       |   |       |   |   |   |--COMMA -> , [46:56]
+        |       |   |       |   |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [46:57]
+        |       |   |       |   |       |   |   |       |--MODIFIERS -> MODIFIERS [46:57]
+        |       |   |       |   |       |   |   |       |--TYPE -> TYPE [46:57]
+        |       |   |       |   |       |   |   |       |   `--IDENT -> Color [46:57]
+        |       |   |       |   |       |   |   |       `--IDENT -> c1 [46:63]
+        |       |   |       |   |       |   |   `--RPAREN -> ) [46:65]
+        |       |   |       |   |       |   |--COMMA -> , [46:66]
+        |       |   |       |   |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [47:16]
+        |       |   |       |   |       |       |--MODIFIERS -> MODIFIERS [47:16]
+        |       |   |       |   |       |       |--TYPE -> TYPE [47:16]
+        |       |   |       |   |       |       |   `--IDENT -> ColoredPoint [47:16]
+        |       |   |       |   |       |       `--IDENT -> lr1 [47:29]
+        |       |   |       |   |       `--RPAREN -> ) [47:32]
+        |       |   |       |   `--LITERAL_INSTANCEOF -> instanceof [48:21]
+        |       |   |       |       |--IDENT -> r [48:19]
+        |       |   |       |       `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [48:32]
+        |       |   |       |           |--MODIFIERS -> MODIFIERS [48:32]
+        |       |   |       |           |--TYPE -> TYPE [48:32]
+        |       |   |       |           |   `--IDENT -> Rectangle [48:32]
+        |       |   |       |           |--LPAREN -> ( [48:41]
+        |       |   |       |           |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [48:42]
+        |       |   |       |           |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [48:42]
+        |       |   |       |           |   |   |--MODIFIERS -> MODIFIERS [48:42]
+        |       |   |       |           |   |   |--TYPE -> TYPE [48:42]
+        |       |   |       |           |   |   |   `--IDENT -> ColoredPoint [48:42]
+        |       |   |       |           |   |   |--LPAREN -> ( [48:54]
+        |       |   |       |           |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [48:55]
+        |       |   |       |           |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [48:55]
+        |       |   |       |           |   |   |   |   |--MODIFIERS -> MODIFIERS [48:55]
+        |       |   |       |           |   |   |   |   |--TYPE -> TYPE [48:55]
+        |       |   |       |           |   |   |   |   |   `--IDENT -> Point [48:55]
+        |       |   |       |           |   |   |   |   `--IDENT -> p2 [48:61]
+        |       |   |       |           |   |   |   |--COMMA -> , [48:63]
+        |       |   |       |           |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [48:64]
+        |       |   |       |           |   |   |       |--MODIFIERS -> MODIFIERS [48:64]
+        |       |   |       |           |   |   |       |--TYPE -> TYPE [48:64]
+        |       |   |       |           |   |   |       |   `--IDENT -> Color [48:64]
+        |       |   |       |           |   |   |       `--IDENT -> c2 [48:70]
+        |       |   |       |           |   |   `--RPAREN -> ) [48:72]
+        |       |   |       |           |   |--COMMA -> , [48:73]
+        |       |   |       |           |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [49:16]
+        |       |   |       |           |       |--MODIFIERS -> MODIFIERS [49:16]
+        |       |   |       |           |       |--TYPE -> TYPE [49:16]
+        |       |   |       |           |       |   `--IDENT -> ColoredPoint [49:16]
+        |       |   |       |           |       `--IDENT -> lr2 [49:29]
+        |       |   |       |           `--RPAREN -> ) [49:32]
+        |       |   |       `--EQUAL -> == [49:43]
+        |       |   |           |--DOT -> . [49:40]
+        |       |   |           |   |--IDENT -> lr2 [49:37]
+        |       |   |           |   `--IDENT -> c [49:41]
+        |       |   |           `--DOT -> . [49:51]
+        |       |   |               |--IDENT -> Color [49:46]
+        |       |   |               `--IDENT -> BLUE [49:52]
+        |       |   |--RPAREN -> ) [49:56]
+        |       |   `--SLIST -> { [49:58]
+        |       |       |--EXPR -> EXPR [50:30]
+        |       |       |   `--METHOD_CALL -> ( [50:30]
+        |       |       |       |--DOT -> . [50:22]
+        |       |       |       |   |--DOT -> . [50:18]
+        |       |       |       |   |   |--IDENT -> System [50:12]
+        |       |       |       |   |   `--IDENT -> out [50:19]
+        |       |       |       |   `--IDENT -> println [50:23]
+        |       |       |       |--ELIST -> ELIST [50:31]
+        |       |       |       |   `--EXPR -> EXPR [50:31]
+        |       |       |       |       `--IDENT -> r [50:31]
+        |       |       |       `--RPAREN -> ) [50:32]
+        |       |       |--SEMI -> ; [50:33]
+        |       |       `--RCURLY -> } [51:8]
+        |       `--RCURLY -> } [52: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 -> p3 [55:16]
+        |   |--LPAREN -> ( [55:18]
+        |   |--PARAMETERS -> PARAMETERS [55:19]
+        |   |   `--PARAMETER_DEF -> PARAMETER_DEF [55:19]
+        |   |       |--MODIFIERS -> MODIFIERS [55:19]
+        |   |       |--TYPE -> TYPE [55:19]
+        |   |       |   `--IDENT -> Rectangle [55:19]
+        |   |       `--IDENT -> r [55:29]
+        |   |--RPAREN -> ) [55:30]
+        |   `--SLIST -> { [55:32]
+        |       |--LITERAL_IF -> if [56:8]
+        |       |   |--LPAREN -> ( [56:11]
+        |       |   |--EXPR -> EXPR [58:16]
+        |       |   |   `--LAND -> && [58:16]
+        |       |   |       |--LITERAL_INSTANCEOF -> instanceof [56:14]
+        |       |   |       |   |--IDENT -> r [56:12]
+        |       |   |       |   `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [56:25]
+        |       |   |       |       |--MODIFIERS -> MODIFIERS [56:25]
+        |       |   |       |       |--TYPE -> TYPE [56:25]
+        |       |   |       |       |   `--IDENT -> Rectangle [56:25]
+        |       |   |       |       |--LPAREN -> ( [56:34]
+        |       |   |       |       |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [56:35]
+        |       |   |       |       |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [56:35]
+        |       |   |       |       |   |   |--MODIFIERS -> MODIFIERS [56:35]
+        |       |   |       |       |   |   |--TYPE -> TYPE [56:35]
+        |       |   |       |       |   |   |   `--IDENT -> ColoredPoint [56:35]
+        |       |   |       |       |   |   |--LPAREN -> ( [56:47]
+        |       |   |       |       |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [56:48]
+        |       |   |       |       |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [56:48]
+        |       |   |       |       |   |   |   |   |--MODIFIERS -> MODIFIERS [56:48]
+        |       |   |       |       |   |   |   |   |--TYPE -> TYPE [56:48]
+        |       |   |       |       |   |   |   |   |   `--IDENT -> Point [56:48]
+        |       |   |       |       |   |   |   |   `--IDENT -> p1 [56:54]
+        |       |   |       |       |   |   |   |--COMMA -> , [56:56]
+        |       |   |       |       |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [56:57]
+        |       |   |       |       |   |   |       |--MODIFIERS -> MODIFIERS [56:57]
+        |       |   |       |       |   |   |       |--TYPE -> TYPE [56:57]
+        |       |   |       |       |   |   |       |   `--IDENT -> Color [56:57]
+        |       |   |       |       |   |   |       `--IDENT -> c1 [56:63]
+        |       |   |       |       |   |   `--RPAREN -> ) [56:65]
+        |       |   |       |       |   |--COMMA -> , [56:66]
+        |       |   |       |       |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [57:16]
+        |       |   |       |       |       |--MODIFIERS -> MODIFIERS [57:16]
+        |       |   |       |       |       |--TYPE -> TYPE [57:16]
+        |       |   |       |       |       |   `--IDENT -> ColoredPoint [57:16]
+        |       |   |       |       |       `--IDENT -> lr1 [57:29]
+        |       |   |       |       `--RPAREN -> ) [57:32]
+        |       |   |       `--LITERAL_INSTANCEOF -> instanceof [58:21]
+        |       |   |           |--IDENT -> r [58:19]
+        |       |   |           `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [58:32]
+        |       |   |               |--MODIFIERS -> MODIFIERS [58:32]
+        |       |   |               |--TYPE -> TYPE [58:32]
+        |       |   |               |   `--IDENT -> Rectangle [58:32]
+        |       |   |               |--LPAREN -> ( [58:41]
+        |       |   |               |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [59:16]
+        |       |   |               |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [59:16]
+        |       |   |               |   |   |--MODIFIERS -> MODIFIERS [59:16]
+        |       |   |               |   |   |--TYPE -> TYPE [59:16]
+        |       |   |               |   |   |   `--IDENT -> ColoredPoint [59:16]
+        |       |   |               |   |   |--LPAREN -> ( [59:28]
+        |       |   |               |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [59:29]
+        |       |   |               |   |   |   |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF [59:29]
+        |       |   |               |   |   |   |   |--MODIFIERS -> MODIFIERS [59:29]
+        |       |   |               |   |   |   |   |--TYPE -> TYPE [59:29]
+        |       |   |               |   |   |   |   |   `--IDENT -> Point [59:29]
+        |       |   |               |   |   |   |   |--LPAREN -> ( [59:34]
+        |       |   |               |   |   |   |   |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS [59:35]
+        |       |   |               |   |   |   |   |   |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [59:35]
+        |       |   |               |   |   |   |   |   |   |--MODIFIERS -> MODIFIERS [59:35]
+        |       |   |               |   |   |   |   |   |   |--TYPE -> TYPE [59:35]
+        |       |   |               |   |   |   |   |   |   |   `--LITERAL_INT -> int [59:35]
+        |       |   |               |   |   |   |   |   |   `--IDENT -> x [59:39]
+        |       |   |               |   |   |   |   |   |--COMMA -> , [59:40]
+        |       |   |               |   |   |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [59:41]
+        |       |   |               |   |   |   |   |       |--MODIFIERS -> MODIFIERS [59:41]
+        |       |   |               |   |   |   |   |       |--TYPE -> TYPE [59:41]
+        |       |   |               |   |   |   |   |       |   `--LITERAL_INT -> int [59:41]
+        |       |   |               |   |   |   |   |       `--IDENT -> y [59:45]
+        |       |   |               |   |   |   |   `--RPAREN -> ) [59:46]
+        |       |   |               |   |   |   |--COMMA -> , [59:47]
+        |       |   |               |   |   |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [59:48]
+        |       |   |               |   |   |       |--MODIFIERS -> MODIFIERS [59:48]
+        |       |   |               |   |   |       |--TYPE -> TYPE [59:48]
+        |       |   |               |   |   |       |   `--IDENT -> Color [59:48]
+        |       |   |               |   |   |       `--IDENT -> c2 [59:54]
+        |       |   |               |   |   `--RPAREN -> ) [59:56]
+        |       |   |               |   |--COMMA -> , [59:57]
+        |       |   |               |   `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF [60:16]
+        |       |   |               |       |--MODIFIERS -> MODIFIERS [60:16]
+        |       |   |               |       |--TYPE -> TYPE [60:16]
+        |       |   |               |       |   `--IDENT -> ColoredPoint [60:16]
+        |       |   |               |       `--IDENT -> lr2 [60:29]
+        |       |   |               `--RPAREN -> ) [60:32]
+        |       |   |--RPAREN -> ) [60:33]
+        |       |   `--SLIST -> { [60:35]
+        |       |       |--EXPR -> EXPR [61:30]
+        |       |       |   `--METHOD_CALL -> ( [61:30]
+        |       |       |       |--DOT -> . [61:22]
+        |       |       |       |   |--DOT -> . [61:18]
+        |       |       |       |   |   |--IDENT -> System [61:12]
+        |       |       |       |   |   `--IDENT -> out [61:19]
+        |       |       |       |   `--IDENT -> println [61:23]
+        |       |       |       |--ELIST -> ELIST [61:31]
+        |       |       |       |   `--EXPR -> EXPR [61:31]
+        |       |       |       |       `--IDENT -> r [61:31]
+        |       |       |       `--RPAREN -> ) [61:32]
+        |       |       |--SEMI -> ; [61:33]
+        |       |       `--RCURLY -> } [62:8]
+        |       `--RCURLY -> } [63:4]
+        |--METHOD_DEF -> METHOD_DEF [65:4]
+        |   |--MODIFIERS -> MODIFIERS [65:4]
+        |   |   `--LITERAL_STATIC -> static [65:4]
+        |   |--TYPE -> TYPE [65:11]
+        |   |   `--LITERAL_VOID -> void [65:11]
+        |   |--IDENT -> p4 [65:16]
+        |   |--LPAREN -> ( [65:18]
+        |   |--PARAMETERS -> PARAMETERS [65:19]
+        |   |--RPAREN -> ) [65:19]
+        |   `--SLIST -> { [65:21]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [66:8]
+        |       |   |--MODIFIERS -> MODIFIERS [66:8]
+        |       |   |--TYPE -> TYPE [66:8]
+        |       |   |   `--LITERAL_INT -> int [66:8]
+        |       |   |--IDENT -> x1 [66:12]
+        |       |   `--ASSIGN -> = [66:15]
+        |       |       `--EXPR -> EXPR [66:17]
+        |       |           `--NUM_INT -> 0 [66:17]
+        |       |--SEMI -> ; [66:18]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [67:8]
+        |       |   |--MODIFIERS -> MODIFIERS [67:8]
+        |       |   |--TYPE -> TYPE [67:8]
+        |       |   |   `--LITERAL_INT -> int [67:8]
+        |       |   |--IDENT -> x2 [67:12]
+        |       |   `--ASSIGN -> = [67:15]
+        |       |       `--EXPR -> EXPR [67:17]
+        |       |           `--NUM_INT -> 0 [67:17]
+        |       |--SEMI -> ; [67:18]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [68:8]
+        |       |   |--MODIFIERS -> MODIFIERS [68:8]
+        |       |   |--TYPE -> TYPE [68:8]
+        |       |   |   `--LITERAL_INT -> int [68:8]
+        |       |   |--IDENT -> y1 [68:12]
+        |       |   `--ASSIGN -> = [68:15]
+        |       |       `--EXPR -> EXPR [68:17]
+        |       |           `--NUM_INT -> 0 [68:17]
+        |       |--SEMI -> ; [68:18]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [69:8]
+        |       |   |--MODIFIERS -> MODIFIERS [69:8]
+        |       |   |--TYPE -> TYPE [69:8]
+        |       |   |   `--LITERAL_INT -> int [69:8]
+        |       |   |--IDENT -> y2 [69:12]
+        |       |   `--ASSIGN -> = [69:15]
+        |       |       `--EXPR -> EXPR [69:17]
+        |       |           `--NUM_INT -> 0 [69:17]
+        |       |--SEMI -> ; [69:18]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [70:8]
+        |       |   |--MODIFIERS -> MODIFIERS [70:8]
+        |       |   |--TYPE -> TYPE [70:8]
+        |       |   |   `--IDENT -> Color [70:8]
+        |       |   |--IDENT -> c1 [70:14]
+        |       |   `--ASSIGN -> = [70:17]
+        |       |       `--EXPR -> EXPR [70:24]
+        |       |           `--DOT -> . [70:24]
+        |       |               |--IDENT -> Color [70:19]
+        |       |               `--IDENT -> BLUE [70:25]
+        |       |--SEMI -> ; [70:29]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [71:8]
+        |       |   |--MODIFIERS -> MODIFIERS [71:8]
+        |       |   |--TYPE -> TYPE [71:8]
+        |       |   |   `--IDENT -> Color [71:8]
+        |       |   |--IDENT -> c2 [71:14]
+        |       |   `--ASSIGN -> = [71:17]
+        |       |       `--EXPR -> EXPR [71:24]
+        |       |           `--DOT -> . [71:24]
+        |       |               |--IDENT -> Color [71:19]
+        |       |               `--IDENT -> GREEN [71:25]
+        |       |--SEMI -> ; [71:30]
+        |       |--VARIABLE_DEF -> VARIABLE_DEF [72:8]
+        |       |   |--MODIFIERS -> MODIFIERS [72:8]
+        |       |   |--TYPE -> TYPE [72:8]
+        |       |   |   `--IDENT -> Rectangle [72:8]
+        |       |   |--IDENT -> r [72:18]
+        |       |   `--ASSIGN -> = [72:20]
+        |       |       `--EXPR -> EXPR [72:22]
+        |       |           `--LITERAL_NEW -> new [72:22]
+        |       |               |--IDENT -> Rectangle [72:26]
+        |       |               |--LPAREN -> ( [72:35]
+        |       |               |--ELIST -> ELIST [72:36]
+        |       |               |   |--EXPR -> EXPR [72:36]
+        |       |               |   |   `--LITERAL_NEW -> new [72:36]
+        |       |               |   |       |--IDENT -> ColoredPoint [72:40]
+        |       |               |   |       |--LPAREN -> ( [72:52]
+        |       |               |   |       |--ELIST -> ELIST [72:53]
+        |       |               |   |       |   |--EXPR -> EXPR [72:53]
+        |       |               |   |       |   |   `--LITERAL_NEW -> new [72:53]
+        |       |               |   |       |   |       |--IDENT -> Point [72:57]
+        |       |               |   |       |   |       |--LPAREN -> ( [72:62]
+        |       |               |   |       |   |       |--ELIST -> ELIST [72:63]
+        |       |               |   |       |   |       |   |--EXPR -> EXPR [72:63]
+        |       |               |   |       |   |       |   |   `--IDENT -> x1 [72:63]
+        |       |               |   |       |   |       |   |--COMMA -> , [72:65]
+        |       |               |   |       |   |       |   `--EXPR -> EXPR [72:67]
+        |       |               |   |       |   |       |       `--IDENT -> y1 [72:67]
+        |       |               |   |       |   |       `--RPAREN -> ) [72:69]
+        |       |               |   |       |   |--COMMA -> , [72:70]
+        |       |               |   |       |   `--EXPR -> EXPR [72:72]
+        |       |               |   |       |       `--IDENT -> c1 [72:72]
+        |       |               |   |       `--RPAREN -> ) [72:74]
+        |       |               |   |--COMMA -> , [72:75]
+        |       |               |   `--EXPR -> EXPR [73:16]
+        |       |               |       `--LITERAL_NEW -> new [73:16]
+        |       |               |           |--IDENT -> ColoredPoint [73:20]
+        |       |               |           |--LPAREN -> ( [73:32]
+        |       |               |           |--ELIST -> ELIST [73:33]
+        |       |               |           |   |--EXPR -> EXPR [73:33]
+        |       |               |           |   |   `--LITERAL_NEW -> new [73:33]
+        |       |               |           |   |       |--IDENT -> Point [73:37]
+        |       |               |           |   |       |--LPAREN -> ( [73:42]
+        |       |               |           |   |       |--ELIST -> ELIST [73:43]
+        |       |               |           |   |       |   |--EXPR -> EXPR [73:43]
+        |       |               |           |   |       |   |   `--IDENT -> x2 [73:43]
+        |       |               |           |   |       |   |--COMMA -> , [73:45]
+        |       |               |           |   |       |   `--EXPR -> EXPR [73:47]
+        |       |               |           |   |       |       `--IDENT -> y2 [73:47]
+        |       |               |           |   |       `--RPAREN -> ) [73:49]
+        |       |               |           |   |--COMMA -> , [73:50]
+        |       |               |           |   `--EXPR -> EXPR [73:52]
+        |       |               |           |       `--IDENT -> c2 [73:52]
+        |       |               |           `--RPAREN -> ) [73:54]
+        |       |               `--RPAREN -> ) [73:55]
+        |       |--SEMI -> ; [73:56]
+        |       |--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]
+        |       |   `--SLIST -> { [76:25]
+        |       |       |--EXPR -> EXPR [77:30]
+        |       |       |   `--METHOD_CALL -> ( [77:30]
+        |       |       |       |--DOT -> . [77:22]
+        |       |       |       |   |--DOT -> . [77:18]
+        |       |       |       |   |   |--IDENT -> System [77:12]
+        |       |       |       |   |   `--IDENT -> out [77:19]
+        |       |       |       |   `--IDENT -> println [77:23]
+        |       |       |       |--ELIST -> ELIST [77:31]
+        |       |       |       |   `--EXPR -> EXPR [77:31]
+        |       |       |       |       `--IDENT -> x [77:31]
+        |       |       |       `--RPAREN -> ) [77:32]
+        |       |       |--SEMI -> ; [77:33]
+        |       |       `--RCURLY -> } [78:8]
+        |       `--RCURLY -> } [79:4]
+        `--RCURLY -> } [80:0]