[ruby/yarp] Update pretty_print to use inspect

https://github.com/ruby/yarp/commit/c2b9b780c7

911 files changed, 75466 insertions, 58560 deletions

diff --git a/test/yarp/snapshots/alias.txt b/test/yarp/snapshots/alias.txt
index 224c2069a5..2444060064 100644
--- a/test/yarp/snapshots/alias.txt
+++ b/test/yarp/snapshots/alias.txt
@@ -1,74 +1,171 @@
-ProgramNode(0...199)(
-  [],
-  StatementsNode(0...199)(
-    [AliasNode(0...15)(
-       SymbolNode(6...10)((6...7), (7...10), nil, "foo"),
-       SymbolNode(11...15)((11...12), (12...15), nil, "bar"),
-       (0...5)
-     ),
-     AliasNode(17...38)(
-       SymbolNode(23...30)((23...26), (26...29), (29...30), "abc"),
-       SymbolNode(31...38)((31...34), (34...37), (37...38), "def"),
-       (17...22)
-     ),
-     AliasNode(40...59)(
-       SymbolNode(46...52)((46...48), (48...51), (51...52), "abc"),
-       SymbolNode(53...59)((53...55), (55...58), (58...59), "def"),
-       (40...45)
-     ),
-     AliasNode(61...84)(
-       InterpolatedSymbolNode(67...77)(
-         (67...69),
-         [StringNode(69...72)(nil, (69...72), nil, "abc"),
-          EmbeddedStatementsNode(72...76)(
-            (72...74),
-            StatementsNode(74...75)([IntegerNode(74...75)()]),
-            (75...76)
-          )],
-         (76...77)
-       ),
-       SymbolNode(78...84)((78...80), (80...83), (83...84), "def"),
-       (61...66)
-     ),
-     AliasNode(86...97)(
-       GlobalVariableReadNode(92...94)(:$a),
-       BackReferenceReadNode(95...97)(),
-       (86...91)
-     ),
-     AliasNode(99...112)(
-       SymbolNode(105...108)(nil, (105...108), nil, "foo"),
-       SymbolNode(109...112)(nil, (109...112), nil, "bar"),
-       (99...104)
-     ),
-     AliasNode(114...129)(
-       GlobalVariableReadNode(120...124)(:$foo),
-       GlobalVariableReadNode(125...129)(:$bar),
-       (114...119)
-     ),
-     AliasNode(131...143)(
-       SymbolNode(137...140)(nil, (137...140), nil, "foo"),
-       SymbolNode(141...143)(nil, (141...143), nil, "if"),
-       (131...136)
-     ),
-     AliasNode(145...158)(
-       SymbolNode(151...154)(nil, (151...154), nil, "foo"),
-       SymbolNode(155...158)(nil, (155...158), nil, "<=>"),
-       (145...150)
-     ),
-     AliasNode(160...175)(
-       SymbolNode(166...169)((166...167), (167...169), nil, "=="),
-       SymbolNode(170...175)((170...171), (171...175), nil, "eql?"),
-       (160...165)
-     ),
-     AliasNode(177...186)(
-       SymbolNode(183...184)(nil, (183...184), nil, "A"),
-       SymbolNode(185...186)(nil, (185...186), nil, "B"),
-       (177...182)
-     ),
-     AliasNode(188...199)(
-       SymbolNode(194...196)((194...195), (195...196), nil, "A"),
-       SymbolNode(197...199)((197...198), (198...199), nil, "B"),
-       (188...193)
-     )]
-  )
-)
+@ ProgramNode (location: (0...199))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...199))
+    └── body: (length: 12)
+        ├── @ AliasNode (location: (0...15))
+        │   ├── new_name:
+        │   │   @ SymbolNode (location: (6...10))
+        │   │   ├── opening_loc: (6...7) = ":"
+        │   │   ├── value_loc: (7...10) = "foo"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "foo"
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (11...15))
+        │   │   ├── opening_loc: (11...12) = ":"
+        │   │   ├── value_loc: (12...15) = "bar"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "bar"
+        │   └── keyword_loc: (0...5) = "alias"
+        ├── @ AliasNode (location: (17...38))
+        │   ├── new_name:
+        │   │   @ SymbolNode (location: (23...30))
+        │   │   ├── opening_loc: (23...26) = "%s["
+        │   │   ├── value_loc: (26...29) = "abc"
+        │   │   ├── closing_loc: (29...30) = "]"
+        │   │   └── unescaped: "abc"
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (31...38))
+        │   │   ├── opening_loc: (31...34) = "%s["
+        │   │   ├── value_loc: (34...37) = "def"
+        │   │   ├── closing_loc: (37...38) = "]"
+        │   │   └── unescaped: "def"
+        │   └── keyword_loc: (17...22) = "alias"
+        ├── @ AliasNode (location: (40...59))
+        │   ├── new_name:
+        │   │   @ SymbolNode (location: (46...52))
+        │   │   ├── opening_loc: (46...48) = ":'"
+        │   │   ├── value_loc: (48...51) = "abc"
+        │   │   ├── closing_loc: (51...52) = "'"
+        │   │   └── unescaped: "abc"
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (53...59))
+        │   │   ├── opening_loc: (53...55) = ":'"
+        │   │   ├── value_loc: (55...58) = "def"
+        │   │   ├── closing_loc: (58...59) = "'"
+        │   │   └── unescaped: "def"
+        │   └── keyword_loc: (40...45) = "alias"
+        ├── @ AliasNode (location: (61...84))
+        │   ├── new_name:
+        │   │   @ InterpolatedSymbolNode (location: (67...77))
+        │   │   ├── opening_loc: (67...69) = ":\""
+        │   │   ├── parts: (length: 2)
+        │   │   │   ├── @ StringNode (location: (69...72))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── content_loc: (69...72) = "abc"
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   └── unescaped: "abc"
+        │   │   │   └── @ EmbeddedStatementsNode (location: (72...76))
+        │   │   │       ├── opening_loc: (72...74) = "\#{"
+        │   │   │       ├── statements:
+        │   │   │       │   @ StatementsNode (location: (74...75))
+        │   │   │       │   └── body: (length: 1)
+        │   │   │       │       └── @ IntegerNode (location: (74...75))
+        │   │   │       └── closing_loc: (75...76) = "}"
+        │   │   └── closing_loc: (76...77) = "\""
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (78...84))
+        │   │   ├── opening_loc: (78...80) = ":'"
+        │   │   ├── value_loc: (80...83) = "def"
+        │   │   ├── closing_loc: (83...84) = "'"
+        │   │   └── unescaped: "def"
+        │   └── keyword_loc: (61...66) = "alias"
+        ├── @ AliasNode (location: (86...97))
+        │   ├── new_name:
+        │   │   @ GlobalVariableReadNode (location: (92...94))
+        │   │   └── name: :$a
+        │   ├── old_name:
+        │   │   @ BackReferenceReadNode (location: (95...97))
+        │   └── keyword_loc: (86...91) = "alias"
+        ├── @ AliasNode (location: (99...112))
+        │   ├── new_name:
+        │   │   @ SymbolNode (location: (105...108))
+        │   │   ├── opening_loc: ∅
+        │   │   ├── value_loc: (105...108) = "foo"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "foo"
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (109...112))
+        │   │   ├── opening_loc: ∅
+        │   │   ├── value_loc: (109...112) = "bar"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "bar"
+        │   └── keyword_loc: (99...104) = "alias"
+        ├── @ AliasNode (location: (114...129))
+        │   ├── new_name:
+        │   │   @ GlobalVariableReadNode (location: (120...124))
+        │   │   └── name: :$foo
+        │   ├── old_name:
+        │   │   @ GlobalVariableReadNode (location: (125...129))
+        │   │   └── name: :$bar
+        │   └── keyword_loc: (114...119) = "alias"
+        ├── @ AliasNode (location: (131...143))
+        │   ├── new_name:
+        │   │   @ SymbolNode (location: (137...140))
+        │   │   ├── opening_loc: ∅
+        │   │   ├── value_loc: (137...140) = "foo"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "foo"
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (141...143))
+        │   │   ├── opening_loc: ∅
+        │   │   ├── value_loc: (141...143) = "if"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "if"
+        │   └── keyword_loc: (131...136) = "alias"
+        ├── @ AliasNode (location: (145...158))
+        │   ├── new_name:
+        │   │   @ SymbolNode (location: (151...154))
+        │   │   ├── opening_loc: ∅
+        │   │   ├── value_loc: (151...154) = "foo"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "foo"
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (155...158))
+        │   │   ├── opening_loc: ∅
+        │   │   ├── value_loc: (155...158) = "<=>"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "<=>"
+        │   └── keyword_loc: (145...150) = "alias"
+        ├── @ AliasNode (location: (160...175))
+        │   ├── new_name:
+        │   │   @ SymbolNode (location: (166...169))
+        │   │   ├── opening_loc: (166...167) = ":"
+        │   │   ├── value_loc: (167...169) = "=="
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "=="
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (170...175))
+        │   │   ├── opening_loc: (170...171) = ":"
+        │   │   ├── value_loc: (171...175) = "eql?"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "eql?"
+        │   └── keyword_loc: (160...165) = "alias"
+        ├── @ AliasNode (location: (177...186))
+        │   ├── new_name:
+        │   │   @ SymbolNode (location: (183...184))
+        │   │   ├── opening_loc: ∅
+        │   │   ├── value_loc: (183...184) = "A"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "A"
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (185...186))
+        │   │   ├── opening_loc: ∅
+        │   │   ├── value_loc: (185...186) = "B"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "B"
+        │   └── keyword_loc: (177...182) = "alias"
+        └── @ AliasNode (location: (188...199))
+            ├── new_name:
+            │   @ SymbolNode (location: (194...196))
+            │   ├── opening_loc: (194...195) = ":"
+            │   ├── value_loc: (195...196) = "A"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "A"
+            ├── old_name:
+            │   @ SymbolNode (location: (197...199))
+            │   ├── opening_loc: (197...198) = ":"
+            │   ├── value_loc: (198...199) = "B"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "B"
+            └── keyword_loc: (188...193) = "alias"
diff --git a/test/yarp/snapshots/arithmetic.txt b/test/yarp/snapshots/arithmetic.txt
index c82760a7e3..c53bea419a 100644
--- a/test/yarp/snapshots/arithmetic.txt
+++ b/test/yarp/snapshots/arithmetic.txt
@@ -1,107 +1,153 @@
-ProgramNode(0...39)(
-  [],
-  StatementsNode(0...39)(
-    [CallNode(0...8)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...8)(
-         [CallNode(4...8)(
-            CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "bar"),
-            nil,
-            (4...5),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "!"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(10...18)(
-       CallNode(10...14)(
-         CallNode(11...14)(nil, nil, (11...14), nil, nil, nil, nil, 2, "foo"),
-         nil,
-         (10...11),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "-@"
-       ),
-       nil,
-       (14...15),
-       nil,
-       ArgumentsNode(15...18)(
-         [CallNode(15...18)(nil, nil, (15...18), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "*"
-     ),
-     CallNode(20...29)(
-       CallNode(20...24)(
-         CallNode(21...24)(nil, nil, (21...24), nil, nil, nil, nil, 2, "foo"),
-         nil,
-         (20...21),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "+@"
-       ),
-       nil,
-       (24...26),
-       nil,
-       ArgumentsNode(26...29)(
-         [CallNode(26...29)(nil, nil, (26...29), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "**"
-     ),
-     CallNode(31...39)(
-       nil,
-       nil,
-       (31...34),
-       nil,
-       ArgumentsNode(35...39)(
-         [CallNode(35...39)(
-            CallNode(36...39)(
-              nil,
-              nil,
-              (36...39),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            ),
-            nil,
-            (35...36),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "~"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     )]
-  )
-)
+@ ProgramNode (location: (0...39))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...39))
+    └── body: (length: 4)
+        ├── @ CallNode (location: (0...8))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...8))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (4...8))
+        │   │           ├── receiver:
+        │   │           │   @ CallNode (location: (5...8))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (5...8) = "bar"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "bar"
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (4...5) = "!"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "!"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (10...18))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (10...14))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (11...14))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (11...14) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (10...11) = "-"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "-@"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (14...15) = "*"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (15...18))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (15...18))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (15...18) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "*"
+        ├── @ CallNode (location: (20...29))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (20...24))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (21...24))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (21...24) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (20...21) = "+"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "+@"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (24...26) = "**"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (26...29))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (26...29))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (26...29) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "**"
+        └── @ CallNode (location: (31...39))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (31...34) = "foo"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (35...39))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (35...39))
+            │           ├── receiver:
+            │           │   @ CallNode (location: (36...39))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (36...39) = "bar"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "bar"
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (35...36) = "~"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "~"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "foo"
diff --git a/test/yarp/snapshots/arrays.txt b/test/yarp/snapshots/arrays.txt
index a29cbeecb5..19ca8dcb95 100644
--- a/test/yarp/snapshots/arrays.txt
+++ b/test/yarp/snapshots/arrays.txt
@@ -1,701 +1,852 @@
-ProgramNode(0...511)(
-  [],
-  StatementsNode(0...511)(
-    [ArrayNode(0...4)(
-       [SplatNode(1...3)(
-          (1...2),
-          CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "a")
-        )],
-       (0...1),
-       (3...4)
-     ),
-     CallNode(6...29)(
-       CallNode(6...9)(nil, nil, (6...9), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (9...19),
-       (9...10),
-       ArgumentsNode(10...29)(
-         [CallNode(10...13)(nil, nil, (10...13), nil, nil, nil, nil, 2, "bar"),
-          CallNode(15...18)(nil, nil, (15...18), nil, nil, nil, nil, 2, "baz"),
-          ArrayNode(22...29)(
-            [IntegerNode(22...23)(),
-             IntegerNode(25...26)(),
-             IntegerNode(28...29)()],
-            nil,
-            nil
-          )]
-       ),
-       (18...19),
-       nil,
-       0,
-       "[]="
-     ),
-     ArrayNode(31...44)(
-       [KeywordHashNode(32...43)(
-          [AssocNode(32...43)(
-             SymbolNode(32...34)(nil, (32...33), (33...34), "a"),
-             ArrayNode(35...43)(
-               [SymbolNode(36...38)((36...37), (37...38), nil, "b"),
-                SymbolNode(40...42)((40...41), (41...42), nil, "c")],
-               (35...36),
-               (42...43)
-             ),
-             nil
-           )]
-        )],
-       (31...32),
-       (43...44)
-     ),
-     ArrayNode(48...71)(
-       [SymbolNode(49...51)((49...50), (50...51), nil, "a"),
-        SymbolNode(53...55)((53...54), (54...55), nil, "b"),
-        SymbolNode(57...59)((57...58), (58...59), nil, "c"),
-        IntegerNode(60...61)(),
-        SymbolNode(66...68)((66...67), (67...68), nil, "d")],
-       (48...49),
-       (70...71)
-     ),
-     ArrayNode(74...98)(
-       [SymbolNode(75...77)((75...76), (76...77), nil, "a"),
-        SymbolNode(79...81)((79...80), (80...81), nil, "b"),
-        SymbolNode(83...85)((83...84), (84...85), nil, "c"),
-        IntegerNode(86...87)(),
-        SymbolNode(92...94)((92...93), (93...94), nil, "d")],
-       (74...75),
-       (97...98)
-     ),
-     ArrayNode(100...112)(
-       [KeywordHashNode(101...111)(
-          [AssocNode(101...111)(
-             CallNode(101...104)(
-               nil,
-               nil,
-               (101...104),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "foo"
-             ),
-             CallNode(108...111)(
-               nil,
-               nil,
-               (108...111),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             ),
-             (105...107)
-           )]
-        )],
-       (100...101),
-       (111...112)
-     ),
-     CallNode(114...133)(
-       CallNode(114...122)(
-         CallNode(114...117)(
-           nil,
-           nil,
-           (114...117),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         nil,
-         (117...122),
-         (117...118),
-         ArgumentsNode(118...121)(
-           [CallNode(118...121)(
-              nil,
-              nil,
-              (118...121),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         (121...122),
-         nil,
-         0,
-         "[]"
-       ),
-       nil,
-       (122...127),
-       (122...123),
-       ArgumentsNode(123...133)(
-         [CallNode(123...126)(
-            nil,
-            nil,
-            (123...126),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          ),
-          CallNode(130...133)(
-            nil,
-            nil,
-            (130...133),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "qux"
-          )]
-       ),
-       (126...127),
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(135...148)(
-       CallNode(135...143)(
-         CallNode(135...138)(
-           nil,
-           nil,
-           (135...138),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         nil,
-         (138...143),
-         (138...139),
-         ArgumentsNode(139...142)(
-           [CallNode(139...142)(
-              nil,
-              nil,
-              (139...142),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         (142...143),
-         nil,
-         0,
-         "[]"
-       ),
-       nil,
-       (143...148),
-       (143...144),
-       ArgumentsNode(144...147)(
-         [CallNode(144...147)(
-            nil,
-            nil,
-            (144...147),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          )]
-       ),
-       (147...148),
-       nil,
-       0,
-       "[]"
-     ),
-     ArrayNode(150...153)([], (150...151), (152...153)),
-     CallNode(155...168)(
-       CallNode(155...158)(
-         nil,
-         nil,
-         (155...158),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (158...168),
-       (158...159),
-       ArgumentsNode(159...167)(
-         [CallNode(159...162)(
-            nil,
-            nil,
-            (159...162),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          ),
-          CallNode(164...167)(
-            nil,
-            nil,
-            (164...167),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          )]
-       ),
-       (167...168),
-       nil,
-       0,
-       "[]"
-     ),
-     CallNode(170...189)(
-       CallNode(170...173)(
-         nil,
-         nil,
-         (170...173),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (173...183),
-       (173...174),
-       ArgumentsNode(174...189)(
-         [CallNode(174...177)(
-            nil,
-            nil,
-            (174...177),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          ),
-          CallNode(179...182)(
-            nil,
-            nil,
-            (179...182),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          ),
-          CallNode(186...189)(
-            nil,
-            nil,
-            (186...189),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "qux"
-          )]
-       ),
-       (182...183),
-       nil,
-       0,
-       "[]="
-     ),
-     MultiWriteNode(191...212)(
-       [CallNode(191...197)(
-          CallNode(191...194)(
-            nil,
-            nil,
-            (191...194),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          ),
-          nil,
-          (194...197),
-          (194...195),
-          ArgumentsNode(195...196)([IntegerNode(195...196)()]),
-          (196...197),
-          nil,
-          0,
-          "[]="
-        ),
-        CallNode(199...205)(
-          CallNode(199...202)(
-            nil,
-            nil,
-            (199...202),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          ),
-          nil,
-          (202...205),
-          (202...203),
-          ArgumentsNode(203...204)([IntegerNode(203...204)()]),
-          (204...205),
-          nil,
-          0,
-          "[]="
-        )],
-       nil,
-       nil,
-       (206...207),
-       ArrayNode(208...212)(
-         [IntegerNode(208...209)(), IntegerNode(211...212)()],
-         nil,
-         nil
-       )
-     ),
-     CallNode(214...233)(
-       CallNode(214...217)(
-         nil,
-         nil,
-         (214...217),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (217...233),
-       (217...218),
-       ArgumentsNode(218...232)(
-         [CallNode(218...232)(
-            CallNode(218...221)(
-              nil,
-              nil,
-              (218...221),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            ),
-            nil,
-            (221...226),
-            (221...222),
-            ArgumentsNode(222...232)(
-              [CallNode(222...225)(
-                 nil,
-                 nil,
-                 (222...225),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "baz"
-               ),
-               CallNode(229...232)(
-                 nil,
-                 nil,
-                 (229...232),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "qux"
-               )]
-            ),
-            (225...226),
-            nil,
-            0,
-            "[]="
-          )]
-       ),
-       (232...233),
-       nil,
-       0,
-       "[]"
-     ),
-     CallNode(235...243)(
-       CallNode(235...238)(
-         nil,
-         nil,
-         (235...238),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (238...243),
-       (238...239),
-       ArgumentsNode(239...242)(
-         [CallNode(239...242)(
-            nil,
-            nil,
-            (239...242),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       (242...243),
-       nil,
-       0,
-       "[]"
-     ),
-     CallNode(245...259)(
-       CallNode(245...248)(
-         nil,
-         nil,
-         (245...248),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (248...253),
-       (248...249),
-       ArgumentsNode(249...259)(
-         [CallNode(249...252)(
-            nil,
-            nil,
-            (249...252),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          ),
-          CallNode(256...259)(
-            nil,
-            nil,
-            (256...259),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          )]
-       ),
-       (252...253),
-       nil,
-       0,
-       "[]="
-     ),
-     ArrayNode(261...267)(
-       [KeywordHashNode(262...266)(
-          [AssocSplatNode(262...266)(
-             HashNode(264...266)((264...265), [], (265...266)),
-             (262...264)
-           )]
-        )],
-       (261...262),
-       (266...267)
-     ),
-     ArrayNode(269...275)(
-       [KeywordHashNode(270...274)(
-          [AssocSplatNode(270...274)(
-             CallNode(272...274)(
-               nil,
-               nil,
-               (272...274),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "kw"
-             ),
-             (270...272)
-           )]
-        )],
-       (269...270),
-       (274...275)
-     ),
-     ArrayNode(277...286)(
-       [IntegerNode(278...279)(),
-        KeywordHashNode(281...285)(
-          [AssocSplatNode(281...285)(
-             CallNode(283...285)(
-               nil,
-               nil,
-               (283...285),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "kw"
-             ),
-             (281...283)
-           )]
-        )],
-       (277...278),
-       (285...286)
-     ),
-     ArrayNode(288...309)(
-       [IntegerNode(289...290)(),
-        KeywordHashNode(292...308)(
-          [AssocSplatNode(292...296)(
-             CallNode(294...296)(
-               nil,
-               nil,
-               (294...296),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "kw"
-             ),
-             (292...294)
-           ),
-           AssocSplatNode(298...302)(
-             HashNode(300...302)((300...301), [], (301...302)),
-             (298...300)
-           ),
-           AssocSplatNode(304...308)(
-             CallNode(306...308)(
-               nil,
-               nil,
-               (306...308),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "kw"
-             ),
-             (304...306)
-           )]
-        )],
-       (288...289),
-       (308...309)
-     ),
-     ArrayNode(311...328)(
-       [KeywordHashNode(315...325)(
-          [AssocNode(315...325)(
-             CallNode(315...318)(
-               nil,
-               nil,
-               (315...318),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "foo"
-             ),
-             CallNode(322...325)(
-               nil,
-               nil,
-               (322...325),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             ),
-             (319...321)
-           )]
-        )],
-       (311...312),
-       (327...328)
-     ),
-     ArrayNode(331...348)(
-       [SymbolNode(334...337)(nil, (334...337), nil, "one"),
-        SymbolNode(338...341)(nil, (338...341), nil, "two"),
-        SymbolNode(342...347)(nil, (342...347), nil, "three")],
-       (331...334),
-       (347...348)
-     ),
-     ArrayNode(350...367)(
-       [StringNode(353...356)(nil, (353...356), nil, "one"),
-        StringNode(357...360)(nil, (357...360), nil, "two"),
-        StringNode(361...366)(nil, (361...366), nil, "three")],
-       (350...353),
-       (366...367)
-     ),
-     XStringNode(369...386)(
-       (369...372),
-       (372...385),
-       (385...386),
-       "one two three"
-     ),
-     ArrayNode(389...406)(
-       [SymbolNode(392...395)(nil, (392...395), nil, "one"),
-        SymbolNode(396...399)(nil, (396...399), nil, "two"),
-        SymbolNode(400...405)(nil, (400...405), nil, "three")],
-       (389...392),
-       (405...406)
-     ),
-     ArrayNode(408...425)(
-       [StringNode(411...414)(nil, (411...414), nil, "one"),
-        StringNode(415...418)(nil, (415...418), nil, "two"),
-        StringNode(419...424)(nil, (419...424), nil, "three")],
-       (408...411),
-       (424...425)
-     ),
-     XStringNode(427...444)(
-       (427...430),
-       (430...443),
-       (443...444),
-       "one two three"
-     ),
-     ArrayNode(447...464)(
-       [SymbolNode(450...453)(nil, (450...453), nil, "one"),
-        SymbolNode(454...457)(nil, (454...457), nil, "two"),
-        SymbolNode(458...463)(nil, (458...463), nil, "three")],
-       (447...450),
-       (463...464)
-     ),
-     ArrayNode(466...483)(
-       [StringNode(469...472)(nil, (469...472), nil, "one"),
-        StringNode(473...476)(nil, (473...476), nil, "two"),
-        StringNode(477...482)(nil, (477...482), nil, "three")],
-       (466...469),
-       (482...483)
-     ),
-     XStringNode(485...502)(
-       (485...488),
-       (488...501),
-       (501...502),
-       "one two three"
-     ),
-     ArrayNode(504...511)(
-       [StringNode(507...510)(nil, (507...510), nil, "\\C:")],
-       (504...507),
-       (510...511)
-     )]
-  )
-)
+@ ProgramNode (location: (0...511))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...511))
+    └── body: (length: 30)
+        ├── @ ArrayNode (location: (0...4))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SplatNode (location: (1...3))
+        │   │       ├── operator_loc: (1...2) = "*"
+        │   │       └── expression:
+        │   │           @ CallNode (location: (2...3))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (2...3) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── opening_loc: (0...1) = "["
+        │   └── closing_loc: (3...4) = "]"
+        ├── @ CallNode (location: (6...29))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (6...9))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (6...9) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (9...19) = "[bar, baz]"
+        │   ├── opening_loc: (9...10) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (10...29))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ CallNode (location: (10...13))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (10...13) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       ├── @ CallNode (location: (15...18))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (15...18) = "baz"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "baz"
+        │   │       └── @ ArrayNode (location: (22...29))
+        │   │           ├── elements: (length: 3)
+        │   │           │   ├── @ IntegerNode (location: (22...23))
+        │   │           │   ├── @ IntegerNode (location: (25...26))
+        │   │           │   └── @ IntegerNode (location: (28...29))
+        │   │           ├── opening_loc: ∅
+        │   │           └── closing_loc: ∅
+        │   ├── closing_loc: (18...19) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ ArrayNode (location: (31...44))
+        │   ├── elements: (length: 1)
+        │   │   └── @ KeywordHashNode (location: (32...43))
+        │   │       └── elements: (length: 1)
+        │   │           └── @ AssocNode (location: (32...43))
+        │   │               ├── key:
+        │   │               │   @ SymbolNode (location: (32...34))
+        │   │               │   ├── opening_loc: ∅
+        │   │               │   ├── value_loc: (32...33) = "a"
+        │   │               │   ├── closing_loc: (33...34) = ":"
+        │   │               │   └── unescaped: "a"
+        │   │               ├── value:
+        │   │               │   @ ArrayNode (location: (35...43))
+        │   │               │   ├── elements: (length: 2)
+        │   │               │   │   ├── @ SymbolNode (location: (36...38))
+        │   │               │   │   │   ├── opening_loc: (36...37) = ":"
+        │   │               │   │   │   ├── value_loc: (37...38) = "b"
+        │   │               │   │   │   ├── closing_loc: ∅
+        │   │               │   │   │   └── unescaped: "b"
+        │   │               │   │   └── @ SymbolNode (location: (40...42))
+        │   │               │   │       ├── opening_loc: (40...41) = ":"
+        │   │               │   │       ├── value_loc: (41...42) = "c"
+        │   │               │   │       ├── closing_loc: ∅
+        │   │               │   │       └── unescaped: "c"
+        │   │               │   ├── opening_loc: (35...36) = "["
+        │   │               │   └── closing_loc: (42...43) = "]"
+        │   │               └── operator_loc: ∅
+        │   ├── opening_loc: (31...32) = "["
+        │   └── closing_loc: (43...44) = "]"
+        ├── @ ArrayNode (location: (48...71))
+        │   ├── elements: (length: 5)
+        │   │   ├── @ SymbolNode (location: (49...51))
+        │   │   │   ├── opening_loc: (49...50) = ":"
+        │   │   │   ├── value_loc: (50...51) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ SymbolNode (location: (53...55))
+        │   │   │   ├── opening_loc: (53...54) = ":"
+        │   │   │   ├── value_loc: (54...55) = "b"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "b"
+        │   │   ├── @ SymbolNode (location: (57...59))
+        │   │   │   ├── opening_loc: (57...58) = ":"
+        │   │   │   ├── value_loc: (58...59) = "c"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "c"
+        │   │   ├── @ IntegerNode (location: (60...61))
+        │   │   └── @ SymbolNode (location: (66...68))
+        │   │       ├── opening_loc: (66...67) = ":"
+        │   │       ├── value_loc: (67...68) = "d"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "d"
+        │   ├── opening_loc: (48...49) = "["
+        │   └── closing_loc: (70...71) = "]"
+        ├── @ ArrayNode (location: (74...98))
+        │   ├── elements: (length: 5)
+        │   │   ├── @ SymbolNode (location: (75...77))
+        │   │   │   ├── opening_loc: (75...76) = ":"
+        │   │   │   ├── value_loc: (76...77) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ SymbolNode (location: (79...81))
+        │   │   │   ├── opening_loc: (79...80) = ":"
+        │   │   │   ├── value_loc: (80...81) = "b"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "b"
+        │   │   ├── @ SymbolNode (location: (83...85))
+        │   │   │   ├── opening_loc: (83...84) = ":"
+        │   │   │   ├── value_loc: (84...85) = "c"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "c"
+        │   │   ├── @ IntegerNode (location: (86...87))
+        │   │   └── @ SymbolNode (location: (92...94))
+        │   │       ├── opening_loc: (92...93) = ":"
+        │   │       ├── value_loc: (93...94) = "d"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "d"
+        │   ├── opening_loc: (74...75) = "["
+        │   └── closing_loc: (97...98) = "]"
+        ├── @ ArrayNode (location: (100...112))
+        │   ├── elements: (length: 1)
+        │   │   └── @ KeywordHashNode (location: (101...111))
+        │   │       └── elements: (length: 1)
+        │   │           └── @ AssocNode (location: (101...111))
+        │   │               ├── key:
+        │   │               │   @ CallNode (location: (101...104))
+        │   │               │   ├── receiver: ∅
+        │   │               │   ├── call_operator_loc: ∅
+        │   │               │   ├── message_loc: (101...104) = "foo"
+        │   │               │   ├── opening_loc: ∅
+        │   │               │   ├── arguments: ∅
+        │   │               │   ├── closing_loc: ∅
+        │   │               │   ├── block: ∅
+        │   │               │   ├── flags: variable_call
+        │   │               │   └── name: "foo"
+        │   │               ├── value:
+        │   │               │   @ CallNode (location: (108...111))
+        │   │               │   ├── receiver: ∅
+        │   │               │   ├── call_operator_loc: ∅
+        │   │               │   ├── message_loc: (108...111) = "bar"
+        │   │               │   ├── opening_loc: ∅
+        │   │               │   ├── arguments: ∅
+        │   │               │   ├── closing_loc: ∅
+        │   │               │   ├── block: ∅
+        │   │               │   ├── flags: variable_call
+        │   │               │   └── name: "bar"
+        │   │               └── operator_loc: (105...107) = "=>"
+        │   ├── opening_loc: (100...101) = "["
+        │   └── closing_loc: (111...112) = "]"
+        ├── @ CallNode (location: (114...133))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (114...122))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (114...117))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (114...117) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (117...122) = "[bar]"
+        │   │   ├── opening_loc: (117...118) = "["
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (118...121))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ CallNode (location: (118...121))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (118...121) = "bar"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "bar"
+        │   │   ├── closing_loc: (121...122) = "]"
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "[]"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (122...127) = "[baz]"
+        │   ├── opening_loc: (122...123) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (123...133))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (123...126))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (123...126) = "baz"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "baz"
+        │   │       └── @ CallNode (location: (130...133))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (130...133) = "qux"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "qux"
+        │   ├── closing_loc: (126...127) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (135...148))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (135...143))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (135...138))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (135...138) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (138...143) = "[bar]"
+        │   │   ├── opening_loc: (138...139) = "["
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (139...142))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ CallNode (location: (139...142))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (139...142) = "bar"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "bar"
+        │   │   ├── closing_loc: (142...143) = "]"
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "[]"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (143...148) = "[baz]"
+        │   ├── opening_loc: (143...144) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (144...147))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (144...147))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (144...147) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── closing_loc: (147...148) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ ArrayNode (location: (150...153))
+        │   ├── elements: (length: 0)
+        │   ├── opening_loc: (150...151) = "["
+        │   └── closing_loc: (152...153) = "]"
+        ├── @ CallNode (location: (155...168))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (155...158))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (155...158) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (158...168) = "[bar, baz]"
+        │   ├── opening_loc: (158...159) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (159...167))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (159...162))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (159...162) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       └── @ CallNode (location: (164...167))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (164...167) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── closing_loc: (167...168) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ CallNode (location: (170...189))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (170...173))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (170...173) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (173...183) = "[bar, baz]"
+        │   ├── opening_loc: (173...174) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (174...189))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ CallNode (location: (174...177))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (174...177) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       ├── @ CallNode (location: (179...182))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (179...182) = "baz"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "baz"
+        │   │       └── @ CallNode (location: (186...189))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (186...189) = "qux"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "qux"
+        │   ├── closing_loc: (182...183) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ MultiWriteNode (location: (191...212))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ CallNode (location: (191...197))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ CallNode (location: (191...194))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (191...194) = "foo"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "foo"
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (194...197) = "[0]"
+        │   │   │   ├── opening_loc: (194...195) = "["
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (195...196))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ IntegerNode (location: (195...196))
+        │   │   │   ├── closing_loc: (196...197) = "]"
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "[]="
+        │   │   └── @ CallNode (location: (199...205))
+        │   │       ├── receiver:
+        │   │       │   @ CallNode (location: (199...202))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (199...202) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       ├── call_operator_loc: ∅
+        │   │       ├── message_loc: (202...205) = "[0]"
+        │   │       ├── opening_loc: (202...203) = "["
+        │   │       ├── arguments:
+        │   │       │   @ ArgumentsNode (location: (203...204))
+        │   │       │   └── arguments: (length: 1)
+        │   │       │       └── @ IntegerNode (location: (203...204))
+        │   │       ├── closing_loc: (204...205) = "]"
+        │   │       ├── block: ∅
+        │   │       ├── flags: 
+        │   │       └── name: "[]="
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (206...207) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (208...212))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (208...209))
+        │       │   └── @ IntegerNode (location: (211...212))
+        │       ├── opening_loc: ∅
+        │       └── closing_loc: ∅
+        ├── @ CallNode (location: (214...233))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (214...217))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (214...217) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (217...233) = "[bar[baz] = qux]"
+        │   ├── opening_loc: (217...218) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (218...232))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (218...232))
+        │   │           ├── receiver:
+        │   │           │   @ CallNode (location: (218...221))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (218...221) = "bar"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "bar"
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (221...226) = "[baz]"
+        │   │           ├── opening_loc: (221...222) = "["
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (222...232))
+        │   │           │   └── arguments: (length: 2)
+        │   │           │       ├── @ CallNode (location: (222...225))
+        │   │           │       │   ├── receiver: ∅
+        │   │           │       │   ├── call_operator_loc: ∅
+        │   │           │       │   ├── message_loc: (222...225) = "baz"
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── arguments: ∅
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   ├── block: ∅
+        │   │           │       │   ├── flags: variable_call
+        │   │           │       │   └── name: "baz"
+        │   │           │       └── @ CallNode (location: (229...232))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (229...232) = "qux"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "qux"
+        │   │           ├── closing_loc: (225...226) = "]"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "[]="
+        │   ├── closing_loc: (232...233) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ CallNode (location: (235...243))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (235...238))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (235...238) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (238...243) = "[bar]"
+        │   ├── opening_loc: (238...239) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (239...242))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (239...242))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (239...242) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: (242...243) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ CallNode (location: (245...259))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (245...248))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (245...248) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (248...253) = "[bar]"
+        │   ├── opening_loc: (248...249) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (249...259))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (249...252))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (249...252) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       └── @ CallNode (location: (256...259))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (256...259) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── closing_loc: (252...253) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ ArrayNode (location: (261...267))
+        │   ├── elements: (length: 1)
+        │   │   └── @ KeywordHashNode (location: (262...266))
+        │   │       └── elements: (length: 1)
+        │   │           └── @ AssocSplatNode (location: (262...266))
+        │   │               ├── value:
+        │   │               │   @ HashNode (location: (264...266))
+        │   │               │   ├── opening_loc: (264...265) = "{"
+        │   │               │   ├── elements: (length: 0)
+        │   │               │   └── closing_loc: (265...266) = "}"
+        │   │               └── operator_loc: (262...264) = "**"
+        │   ├── opening_loc: (261...262) = "["
+        │   └── closing_loc: (266...267) = "]"
+        ├── @ ArrayNode (location: (269...275))
+        │   ├── elements: (length: 1)
+        │   │   └── @ KeywordHashNode (location: (270...274))
+        │   │       └── elements: (length: 1)
+        │   │           └── @ AssocSplatNode (location: (270...274))
+        │   │               ├── value:
+        │   │               │   @ CallNode (location: (272...274))
+        │   │               │   ├── receiver: ∅
+        │   │               │   ├── call_operator_loc: ∅
+        │   │               │   ├── message_loc: (272...274) = "kw"
+        │   │               │   ├── opening_loc: ∅
+        │   │               │   ├── arguments: ∅
+        │   │               │   ├── closing_loc: ∅
+        │   │               │   ├── block: ∅
+        │   │               │   ├── flags: variable_call
+        │   │               │   └── name: "kw"
+        │   │               └── operator_loc: (270...272) = "**"
+        │   ├── opening_loc: (269...270) = "["
+        │   └── closing_loc: (274...275) = "]"
+        ├── @ ArrayNode (location: (277...286))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ IntegerNode (location: (278...279))
+        │   │   └── @ KeywordHashNode (location: (281...285))
+        │   │       └── elements: (length: 1)
+        │   │           └── @ AssocSplatNode (location: (281...285))
+        │   │               ├── value:
+        │   │               │   @ CallNode (location: (283...285))
+        │   │               │   ├── receiver: ∅
+        │   │               │   ├── call_operator_loc: ∅
+        │   │               │   ├── message_loc: (283...285) = "kw"
+        │   │               │   ├── opening_loc: ∅
+        │   │               │   ├── arguments: ∅
+        │   │               │   ├── closing_loc: ∅
+        │   │               │   ├── block: ∅
+        │   │               │   ├── flags: variable_call
+        │   │               │   └── name: "kw"
+        │   │               └── operator_loc: (281...283) = "**"
+        │   ├── opening_loc: (277...278) = "["
+        │   └── closing_loc: (285...286) = "]"
+        ├── @ ArrayNode (location: (288...309))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ IntegerNode (location: (289...290))
+        │   │   └── @ KeywordHashNode (location: (292...308))
+        │   │       └── elements: (length: 3)
+        │   │           ├── @ AssocSplatNode (location: (292...296))
+        │   │           │   ├── value:
+        │   │           │   │   @ CallNode (location: (294...296))
+        │   │           │   │   ├── receiver: ∅
+        │   │           │   │   ├── call_operator_loc: ∅
+        │   │           │   │   ├── message_loc: (294...296) = "kw"
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── arguments: ∅
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   ├── block: ∅
+        │   │           │   │   ├── flags: variable_call
+        │   │           │   │   └── name: "kw"
+        │   │           │   └── operator_loc: (292...294) = "**"
+        │   │           ├── @ AssocSplatNode (location: (298...302))
+        │   │           │   ├── value:
+        │   │           │   │   @ HashNode (location: (300...302))
+        │   │           │   │   ├── opening_loc: (300...301) = "{"
+        │   │           │   │   ├── elements: (length: 0)
+        │   │           │   │   └── closing_loc: (301...302) = "}"
+        │   │           │   └── operator_loc: (298...300) = "**"
+        │   │           └── @ AssocSplatNode (location: (304...308))
+        │   │               ├── value:
+        │   │               │   @ CallNode (location: (306...308))
+        │   │               │   ├── receiver: ∅
+        │   │               │   ├── call_operator_loc: ∅
+        │   │               │   ├── message_loc: (306...308) = "kw"
+        │   │               │   ├── opening_loc: ∅
+        │   │               │   ├── arguments: ∅
+        │   │               │   ├── closing_loc: ∅
+        │   │               │   ├── block: ∅
+        │   │               │   ├── flags: variable_call
+        │   │               │   └── name: "kw"
+        │   │               └── operator_loc: (304...306) = "**"
+        │   ├── opening_loc: (288...289) = "["
+        │   └── closing_loc: (308...309) = "]"
+        ├── @ ArrayNode (location: (311...328))
+        │   ├── elements: (length: 1)
+        │   │   └── @ KeywordHashNode (location: (315...325))
+        │   │       └── elements: (length: 1)
+        │   │           └── @ AssocNode (location: (315...325))
+        │   │               ├── key:
+        │   │               │   @ CallNode (location: (315...318))
+        │   │               │   ├── receiver: ∅
+        │   │               │   ├── call_operator_loc: ∅
+        │   │               │   ├── message_loc: (315...318) = "foo"
+        │   │               │   ├── opening_loc: ∅
+        │   │               │   ├── arguments: ∅
+        │   │               │   ├── closing_loc: ∅
+        │   │               │   ├── block: ∅
+        │   │               │   ├── flags: variable_call
+        │   │               │   └── name: "foo"
+        │   │               ├── value:
+        │   │               │   @ CallNode (location: (322...325))
+        │   │               │   ├── receiver: ∅
+        │   │               │   ├── call_operator_loc: ∅
+        │   │               │   ├── message_loc: (322...325) = "bar"
+        │   │               │   ├── opening_loc: ∅
+        │   │               │   ├── arguments: ∅
+        │   │               │   ├── closing_loc: ∅
+        │   │               │   ├── block: ∅
+        │   │               │   ├── flags: variable_call
+        │   │               │   └── name: "bar"
+        │   │               └── operator_loc: (319...321) = "=>"
+        │   ├── opening_loc: (311...312) = "["
+        │   └── closing_loc: (327...328) = "]"
+        ├── @ ArrayNode (location: (331...348))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ SymbolNode (location: (334...337))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (334...337) = "one"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "one"
+        │   │   ├── @ SymbolNode (location: (338...341))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (338...341) = "two"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "two"
+        │   │   └── @ SymbolNode (location: (342...347))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (342...347) = "three"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "three"
+        │   ├── opening_loc: (331...334) = "%i#"
+        │   └── closing_loc: (347...348) = "#"
+        ├── @ ArrayNode (location: (350...367))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ StringNode (location: (353...356))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (353...356) = "one"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "one"
+        │   │   ├── @ StringNode (location: (357...360))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (357...360) = "two"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "two"
+        │   │   └── @ StringNode (location: (361...366))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (361...366) = "three"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "three"
+        │   ├── opening_loc: (350...353) = "%w#"
+        │   └── closing_loc: (366...367) = "#"
+        ├── @ XStringNode (location: (369...386))
+        │   ├── opening_loc: (369...372) = "%x#"
+        │   ├── content_loc: (372...385) = "one two three"
+        │   ├── closing_loc: (385...386) = "#"
+        │   └── unescaped: "one two three"
+        ├── @ ArrayNode (location: (389...406))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ SymbolNode (location: (392...395))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (392...395) = "one"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "one"
+        │   │   ├── @ SymbolNode (location: (396...399))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (396...399) = "two"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "two"
+        │   │   └── @ SymbolNode (location: (400...405))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (400...405) = "three"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "three"
+        │   ├── opening_loc: (389...392) = "%i@"
+        │   └── closing_loc: (405...406) = "@"
+        ├── @ ArrayNode (location: (408...425))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ StringNode (location: (411...414))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (411...414) = "one"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "one"
+        │   │   ├── @ StringNode (location: (415...418))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (415...418) = "two"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "two"
+        │   │   └── @ StringNode (location: (419...424))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (419...424) = "three"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "three"
+        │   ├── opening_loc: (408...411) = "%w@"
+        │   └── closing_loc: (424...425) = "@"
+        ├── @ XStringNode (location: (427...444))
+        │   ├── opening_loc: (427...430) = "%x@"
+        │   ├── content_loc: (430...443) = "one two three"
+        │   ├── closing_loc: (443...444) = "@"
+        │   └── unescaped: "one two three"
+        ├── @ ArrayNode (location: (447...464))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ SymbolNode (location: (450...453))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (450...453) = "one"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "one"
+        │   │   ├── @ SymbolNode (location: (454...457))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (454...457) = "two"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "two"
+        │   │   └── @ SymbolNode (location: (458...463))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (458...463) = "three"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "three"
+        │   ├── opening_loc: (447...450) = "%i{"
+        │   └── closing_loc: (463...464) = "}"
+        ├── @ ArrayNode (location: (466...483))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ StringNode (location: (469...472))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (469...472) = "one"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "one"
+        │   │   ├── @ StringNode (location: (473...476))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (473...476) = "two"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "two"
+        │   │   └── @ StringNode (location: (477...482))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (477...482) = "three"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "three"
+        │   ├── opening_loc: (466...469) = "%w{"
+        │   └── closing_loc: (482...483) = "}"
+        ├── @ XStringNode (location: (485...502))
+        │   ├── opening_loc: (485...488) = "%x{"
+        │   ├── content_loc: (488...501) = "one two three"
+        │   ├── closing_loc: (501...502) = "}"
+        │   └── unescaped: "one two three"
+        └── @ ArrayNode (location: (504...511))
+            ├── elements: (length: 1)
+            │   └── @ StringNode (location: (507...510))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (507...510) = "\\C:"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\\C:"
+            ├── opening_loc: (504...507) = "%w["
+            └── closing_loc: (510...511) = "]"
diff --git a/test/yarp/snapshots/begin_ensure.txt b/test/yarp/snapshots/begin_ensure.txt
index a842d8f07f..9be9b9ce47 100644
--- a/test/yarp/snapshots/begin_ensure.txt
+++ b/test/yarp/snapshots/begin_ensure.txt
@@ -1,164 +1,249 @@
-ProgramNode(0...211)(
-  [],
-  StatementsNode(0...211)(
-    [BeginNode(0...20)(
-       (0...5),
-       StatementsNode(6...7)(
-         [CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "a")]
-       ),
-       nil,
-       nil,
-       EnsureNode(8...20)(
-         (8...14),
-         StatementsNode(15...16)(
-           [CallNode(15...16)(nil, nil, (15...16), nil, nil, nil, nil, 2, "b")]
-         ),
-         (17...20)
-       ),
-       (17...20)
-     ),
-     BeginNode(22...46)(
-       (22...27),
-       StatementsNode(29...30)(
-         [CallNode(29...30)(nil, nil, (29...30), nil, nil, nil, nil, 2, "a")]
-       ),
-       nil,
-       nil,
-       EnsureNode(32...46)(
-         (32...38),
-         StatementsNode(40...41)(
-           [CallNode(40...41)(nil, nil, (40...41), nil, nil, nil, nil, 2, "b")]
-         ),
-         (43...46)
-       ),
-       (43...46)
-     ),
-     BeginNode(48...70)(
-       (48...53),
-       StatementsNode(54...55)(
-         [CallNode(54...55)(nil, nil, (54...55), nil, nil, nil, nil, 2, "a")]
-       ),
-       nil,
-       nil,
-       EnsureNode(57...70)(
-         (57...63),
-         StatementsNode(64...65)(
-           [CallNode(64...65)(nil, nil, (64...65), nil, nil, nil, nil, 2, "b")]
-         ),
-         (67...70)
-       ),
-       (67...70)
-     ),
-     BeginNode(72...94)(
-       (72...77),
-       StatementsNode(78...79)(
-         [CallNode(78...79)(nil, nil, (78...79), nil, nil, nil, nil, 2, "a")]
-       ),
-       nil,
-       nil,
-       EnsureNode(81...94)(
-         (81...87),
-         StatementsNode(88...89)(
-           [CallNode(88...89)(nil, nil, (88...89), nil, nil, nil, nil, 2, "b")]
-         ),
-         (91...94)
-       ),
-       (91...94)
-     ),
-     BeginNode(96...211)(
-       (96...101),
-       StatementsNode(102...207)(
-         [BeginNode(102...207)(
-            (102...107),
-            StatementsNode(107...203)(
-              [CallNode(107...203)(
-                 SymbolNode(107...109)((107...108), (108...109), nil, "s"),
-                 (109...110),
-                 (110...111),
-                 nil,
-                 ArgumentsNode(112...203)(
-                   [BeginNode(112...203)(
-                      (112...117),
-                      nil,
-                      nil,
-                      nil,
-                      EnsureNode(118...203)(
-                        (118...124),
-                        StatementsNode(125...199)(
-                          [CallNode(125...199)(
-                             ConstantReadNode(125...131)(:Module),
-                             (131...132),
-                             (132...135),
-                             nil,
-                             nil,
-                             nil,
-                             BlockNode(136...199)(
-                               [],
-                               nil,
-                               StatementsNode(141...195)(
-                                 [BeginNode(141...195)(
-                                    (141...146),
-                                    StatementsNode(151...156)(
-                                      [BreakNode(151...156)(nil, (151...156))]
-                                    ),
-                                    nil,
-                                    nil,
-                                    EnsureNode(161...195)(
-                                      (161...167),
-                                      StatementsNode(168...189)(
-                                        [CallNode(168...189)(
-                                           ConstantReadNode(168...174)(
-                                             :Module
-                                           ),
-                                           (174...175),
-                                           (175...178),
-                                           nil,
-                                           nil,
-                                           nil,
-                                           BlockNode(179...189)(
-                                             [],
-                                             nil,
-                                             nil,
-                                             (179...181),
-                                             (186...189)
-                                           ),
-                                           0,
-                                           "new"
-                                         )]
-                                      ),
-                                      (192...195)
-                                    ),
-                                    (192...195)
-                                  )]
-                               ),
-                               (136...138),
-                               (196...199)
-                             ),
-                             0,
-                             "new"
-                           )]
-                        ),
-                        (200...203)
-                      ),
-                      (200...203)
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "l"
-               )]
-            ),
-            nil,
-            nil,
-            nil,
-            (204...207)
-          )]
-       ),
-       nil,
-       nil,
-       nil,
-       (208...211)
-     )]
-  )
-)
+@ ProgramNode (location: (0...211))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...211))
+    └── body: (length: 5)
+        ├── @ BeginNode (location: (0...20))
+        │   ├── begin_keyword_loc: (0...5) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (6...7))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (6...7))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (6...7) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause:
+        │   │   @ EnsureNode (location: (8...20))
+        │   │   ├── ensure_keyword_loc: (8...14) = "ensure"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (15...16))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (15...16))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (15...16) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── end_keyword_loc: (17...20) = "end"
+        │   └── end_keyword_loc: (17...20) = "end"
+        ├── @ BeginNode (location: (22...46))
+        │   ├── begin_keyword_loc: (22...27) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (29...30))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (29...30))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (29...30) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause:
+        │   │   @ EnsureNode (location: (32...46))
+        │   │   ├── ensure_keyword_loc: (32...38) = "ensure"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (40...41))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (40...41))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (40...41) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── end_keyword_loc: (43...46) = "end"
+        │   └── end_keyword_loc: (43...46) = "end"
+        ├── @ BeginNode (location: (48...70))
+        │   ├── begin_keyword_loc: (48...53) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (54...55))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (54...55))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (54...55) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause:
+        │   │   @ EnsureNode (location: (57...70))
+        │   │   ├── ensure_keyword_loc: (57...63) = "ensure"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (64...65))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (64...65))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (64...65) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── end_keyword_loc: (67...70) = "end"
+        │   └── end_keyword_loc: (67...70) = "end"
+        ├── @ BeginNode (location: (72...94))
+        │   ├── begin_keyword_loc: (72...77) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (78...79))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (78...79))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (78...79) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause:
+        │   │   @ EnsureNode (location: (81...94))
+        │   │   ├── ensure_keyword_loc: (81...87) = "ensure"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (88...89))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (88...89))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (88...89) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── end_keyword_loc: (91...94) = "end"
+        │   └── end_keyword_loc: (91...94) = "end"
+        └── @ BeginNode (location: (96...211))
+            ├── begin_keyword_loc: (96...101) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (102...207))
+            │   └── body: (length: 1)
+            │       └── @ BeginNode (location: (102...207))
+            │           ├── begin_keyword_loc: (102...107) = "begin"
+            │           ├── statements:
+            │           │   @ StatementsNode (location: (107...203))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (107...203))
+            │           │           ├── receiver:
+            │           │           │   @ SymbolNode (location: (107...109))
+            │           │           │   ├── opening_loc: (107...108) = ":"
+            │           │           │   ├── value_loc: (108...109) = "s"
+            │           │           │   ├── closing_loc: ∅
+            │           │           │   └── unescaped: "s"
+            │           │           ├── call_operator_loc: (109...110) = "."
+            │           │           ├── message_loc: (110...111) = "l"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments:
+            │           │           │   @ ArgumentsNode (location: (112...203))
+            │           │           │   └── arguments: (length: 1)
+            │           │           │       └── @ BeginNode (location: (112...203))
+            │           │           │           ├── begin_keyword_loc: (112...117) = "begin"
+            │           │           │           ├── statements: ∅
+            │           │           │           ├── rescue_clause: ∅
+            │           │           │           ├── else_clause: ∅
+            │           │           │           ├── ensure_clause:
+            │           │           │           │   @ EnsureNode (location: (118...203))
+            │           │           │           │   ├── ensure_keyword_loc: (118...124) = "ensure"
+            │           │           │           │   ├── statements:
+            │           │           │           │   │   @ StatementsNode (location: (125...199))
+            │           │           │           │   │   └── body: (length: 1)
+            │           │           │           │   │       └── @ CallNode (location: (125...199))
+            │           │           │           │   │           ├── receiver:
+            │           │           │           │   │           │   @ ConstantReadNode (location: (125...131))
+            │           │           │           │   │           │   └── name: :Module
+            │           │           │           │   │           ├── call_operator_loc: (131...132) = "."
+            │           │           │           │   │           ├── message_loc: (132...135) = "new"
+            │           │           │           │   │           ├── opening_loc: ∅
+            │           │           │           │   │           ├── arguments: ∅
+            │           │           │           │   │           ├── closing_loc: ∅
+            │           │           │           │   │           ├── block:
+            │           │           │           │   │           │   @ BlockNode (location: (136...199))
+            │           │           │           │   │           │   ├── locals: []
+            │           │           │           │   │           │   ├── parameters: ∅
+            │           │           │           │   │           │   ├── body:
+            │           │           │           │   │           │   │   @ StatementsNode (location: (141...195))
+            │           │           │           │   │           │   │   └── body: (length: 1)
+            │           │           │           │   │           │   │       └── @ BeginNode (location: (141...195))
+            │           │           │           │   │           │   │           ├── begin_keyword_loc: (141...146) = "begin"
+            │           │           │           │   │           │   │           ├── statements:
+            │           │           │           │   │           │   │           │   @ StatementsNode (location: (151...156))
+            │           │           │           │   │           │   │           │   └── body: (length: 1)
+            │           │           │           │   │           │   │           │       └── @ BreakNode (location: (151...156))
+            │           │           │           │   │           │   │           │           ├── arguments: ∅
+            │           │           │           │   │           │   │           │           └── keyword_loc: (151...156) = "break"
+            │           │           │           │   │           │   │           ├── rescue_clause: ∅
+            │           │           │           │   │           │   │           ├── else_clause: ∅
+            │           │           │           │   │           │   │           ├── ensure_clause:
+            │           │           │           │   │           │   │           │   @ EnsureNode (location: (161...195))
+            │           │           │           │   │           │   │           │   ├── ensure_keyword_loc: (161...167) = "ensure"
+            │           │           │           │   │           │   │           │   ├── statements:
+            │           │           │           │   │           │   │           │   │   @ StatementsNode (location: (168...189))
+            │           │           │           │   │           │   │           │   │   └── body: (length: 1)
+            │           │           │           │   │           │   │           │   │       └── @ CallNode (location: (168...189))
+            │           │           │           │   │           │   │           │   │           ├── receiver:
+            │           │           │           │   │           │   │           │   │           │   @ ConstantReadNode (location: (168...174))
+            │           │           │           │   │           │   │           │   │           │   └── name: :Module
+            │           │           │           │   │           │   │           │   │           ├── call_operator_loc: (174...175) = "."
+            │           │           │           │   │           │   │           │   │           ├── message_loc: (175...178) = "new"
+            │           │           │           │   │           │   │           │   │           ├── opening_loc: ∅
+            │           │           │           │   │           │   │           │   │           ├── arguments: ∅
+            │           │           │           │   │           │   │           │   │           ├── closing_loc: ∅
+            │           │           │           │   │           │   │           │   │           ├── block:
+            │           │           │           │   │           │   │           │   │           │   @ BlockNode (location: (179...189))
+            │           │           │           │   │           │   │           │   │           │   ├── locals: []
+            │           │           │           │   │           │   │           │   │           │   ├── parameters: ∅
+            │           │           │           │   │           │   │           │   │           │   ├── body: ∅
+            │           │           │           │   │           │   │           │   │           │   ├── opening_loc: (179...181) = "do"
+            │           │           │           │   │           │   │           │   │           │   └── closing_loc: (186...189) = "end"
+            │           │           │           │   │           │   │           │   │           ├── flags: 
+            │           │           │           │   │           │   │           │   │           └── name: "new"
+            │           │           │           │   │           │   │           │   └── end_keyword_loc: (192...195) = "end"
+            │           │           │           │   │           │   │           └── end_keyword_loc: (192...195) = "end"
+            │           │           │           │   │           │   ├── opening_loc: (136...138) = "do"
+            │           │           │           │   │           │   └── closing_loc: (196...199) = "end"
+            │           │           │           │   │           ├── flags: 
+            │           │           │           │   │           └── name: "new"
+            │           │           │           │   └── end_keyword_loc: (200...203) = "end"
+            │           │           │           └── end_keyword_loc: (200...203) = "end"
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: 
+            │           │           └── name: "l"
+            │           ├── rescue_clause: ∅
+            │           ├── else_clause: ∅
+            │           ├── ensure_clause: ∅
+            │           └── end_keyword_loc: (204...207) = "end"
+            ├── rescue_clause: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (208...211) = "end"
diff --git a/test/yarp/snapshots/begin_rescue.txt b/test/yarp/snapshots/begin_rescue.txt
index ac0592054a..0a872b40cf 100644
--- a/test/yarp/snapshots/begin_rescue.txt
+++ b/test/yarp/snapshots/begin_rescue.txt
@@ -1,598 +1,698 @@
-ProgramNode(0...578)(
-  [:ex],
-  StatementsNode(0...578)(
-    [BeginNode(0...33)(
-       (0...5),
-       StatementsNode(7...8)(
-         [CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "a")]
-       ),
-       RescueNode(10...19)(
-         (10...16),
-         [],
-         nil,
-         nil,
-         StatementsNode(18...19)(
-           [CallNode(18...19)(nil, nil, (18...19), nil, nil, nil, nil, 2, "b")]
-         ),
-         nil
-       ),
-       ElseNode(21...33)(
-         (21...25),
-         StatementsNode(27...28)(
-           [CallNode(27...28)(nil, nil, (27...28), nil, nil, nil, nil, 2, "c")]
-         ),
-         (30...33)
-       ),
-       nil,
-       (30...33)
-     ),
-     BeginNode(35...79)(
-       (35...40),
-       StatementsNode(42...43)(
-         [CallNode(42...43)(nil, nil, (42...43), nil, nil, nil, nil, 2, "a")]
-       ),
-       RescueNode(45...54)(
-         (45...51),
-         [],
-         nil,
-         nil,
-         StatementsNode(53...54)(
-           [CallNode(53...54)(nil, nil, (53...54), nil, nil, nil, nil, 2, "b")]
-         ),
-         nil
-       ),
-       ElseNode(56...71)(
-         (56...60),
-         StatementsNode(62...63)(
-           [CallNode(62...63)(nil, nil, (62...63), nil, nil, nil, nil, 2, "c")]
-         ),
-         (65...71)
-       ),
-       EnsureNode(65...79)(
-         (65...71),
-         StatementsNode(73...74)(
-           [CallNode(73...74)(nil, nil, (73...74), nil, nil, nil, nil, 2, "d")]
-         ),
-         (76...79)
-       ),
-       (76...79)
-     ),
-     BeginNode(81...92)(
-       (81...86),
-       StatementsNode(87...88)(
-         [CallNode(87...88)(nil, nil, (87...88), nil, nil, nil, nil, 2, "a")]
-       ),
-       nil,
-       nil,
-       nil,
-       (89...92)
-     ),
-     BeginNode(94...107)(
-       (94...99),
-       StatementsNode(101...102)(
-         [CallNode(101...102)(
-            nil,
-            nil,
-            (101...102),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       nil,
-       nil,
-       nil,
-       (104...107)
-     ),
-     BeginNode(109...121)(
-       (109...114),
-       StatementsNode(115...116)(
-         [CallNode(115...116)(
-            nil,
-            nil,
-            (115...116),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       nil,
-       nil,
-       nil,
-       (118...121)
-     ),
-     BeginNode(123...135)(
-       (123...128),
-       StatementsNode(129...130)(
-         [CallNode(129...130)(
-            nil,
-            nil,
-            (129...130),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       nil,
-       nil,
-       nil,
-       (132...135)
-     ),
-     BeginNode(137...175)(
-       (137...142),
-       StatementsNode(143...144)(
-         [CallNode(143...144)(
-            nil,
-            nil,
-            (143...144),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(145...171)(
-         (145...151),
-         [],
-         nil,
-         nil,
-         StatementsNode(152...153)(
-           [CallNode(152...153)(
-              nil,
-              nil,
-              (152...153),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         RescueNode(154...171)(
-           (154...160),
-           [],
-           nil,
-           nil,
-           StatementsNode(161...162)(
-             [CallNode(161...162)(
-                nil,
-                nil,
-                (161...162),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "c"
-              )]
-           ),
-           RescueNode(163...171)(
-             (163...169),
-             [],
-             nil,
-             nil,
-             StatementsNode(170...171)(
-               [CallNode(170...171)(
-                  nil,
-                  nil,
-                  (170...171),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "d"
-                )]
-             ),
-             nil
-           )
-         )
-       ),
-       nil,
-       nil,
-       (172...175)
-     ),
-     BeginNode(177...269)(
-       (177...182),
-       StatementsNode(185...186)(
-         [CallNode(185...186)(
-            nil,
-            nil,
-            (185...186),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(187...265)(
-         (187...193),
-         [ConstantReadNode(194...203)(:Exception)],
-         (204...206),
-         LocalVariableTargetNode(207...209)(:ex, 0),
-         StatementsNode(212...213)(
-           [CallNode(212...213)(
-              nil,
-              nil,
-              (212...213),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         RescueNode(214...265)(
-           (214...220),
-           [ConstantReadNode(221...237)(:AnotherException),
-            ConstantReadNode(239...255)(:OneMoreException)],
-           (256...258),
-           LocalVariableTargetNode(259...261)(:ex, 0),
-           StatementsNode(264...265)(
-             [CallNode(264...265)(
-                nil,
-                nil,
-                (264...265),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "c"
-              )]
-           ),
-           nil
-         )
-       ),
-       nil,
-       nil,
-       (266...269)
-     ),
-     BeginNode(271...322)(
-       (271...276),
-       StatementsNode(279...280)(
-         [CallNode(279...280)(
-            nil,
-            nil,
-            (279...280),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(281...307)(
-         (281...287),
-         [ConstantReadNode(288...297)(:Exception)],
-         (298...300),
-         LocalVariableTargetNode(301...303)(:ex, 0),
-         StatementsNode(306...307)(
-           [CallNode(306...307)(
-              nil,
-              nil,
-              (306...307),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       EnsureNode(308...322)(
-         (308...314),
-         StatementsNode(317...318)(
-           [CallNode(317...318)(
-              nil,
-              nil,
-              (317...318),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         (319...322)
-       ),
-       (319...322)
-     ),
-     StringNode(324...330)((324...326), (326...329), (329...330), "abc"),
-     BeginNode(332...352)(
-       (332...337),
-       StatementsNode(338...339)(
-         [CallNode(338...339)(
-            nil,
-            nil,
-            (338...339),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(340...348)(
-         (340...346),
-         [],
-         nil,
-         nil,
-         StatementsNode(347...348)(
-           [CallNode(347...348)(
-              nil,
-              nil,
-              (347...348),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (349...352)
-     ),
-     BeginNode(354...374)(
-       (354...359),
-       StatementsNode(360...361)(
-         [CallNode(360...361)(
-            nil,
-            nil,
-            (360...361),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(362...370)(
-         (362...368),
-         [],
-         nil,
-         nil,
-         StatementsNode(369...370)(
-           [CallNode(369...370)(
-              nil,
-              nil,
-              (369...370),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (371...374)
-     ),
-     BeginNode(376...396)(
-       (376...381),
-       StatementsNode(382...383)(
-         [CallNode(382...383)(
-            nil,
-            nil,
-            (382...383),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(384...392)(
-         (384...390),
-         [],
-         nil,
-         nil,
-         StatementsNode(391...392)(
-           [CallNode(391...392)(
-              nil,
-              nil,
-              (391...392),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (393...396)
-     ),
-     BeginNode(398...428)(
-       (398...403),
-       StatementsNode(404...405)(
-         [CallNode(404...405)(
-            nil,
-            nil,
-            (404...405),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(406...424)(
-         (406...412),
-         [ConstantReadNode(413...422)(:Exception)],
-         nil,
-         nil,
-         StatementsNode(423...424)(
-           [CallNode(423...424)(
-              nil,
-              nil,
-              (423...424),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (425...428)
-     ),
-     BeginNode(430...477)(
-       (430...435),
-       StatementsNode(436...437)(
-         [CallNode(436...437)(
-            nil,
-            nil,
-            (436...437),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(438...473)(
-         (438...444),
-         [ConstantReadNode(445...454)(:Exception),
-          ConstantReadNode(456...471)(:CustomException)],
-         nil,
-         nil,
-         StatementsNode(472...473)(
-           [CallNode(472...473)(
-              nil,
-              nil,
-              (472...473),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (474...477)
-     ),
-     BeginNode(479...536)(
-       (479...484),
-       StatementsNode(487...488)(
-         [CallNode(487...488)(
-            nil,
-            nil,
-            (487...488),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(489...532)(
-         (489...495),
-         [ConstantReadNode(496...505)(:Exception),
-          ConstantReadNode(507...522)(:CustomException)],
-         (523...525),
-         LocalVariableTargetNode(526...528)(:ex, 0),
-         StatementsNode(531...532)(
-           [CallNode(531...532)(
-              nil,
-              nil,
-              (531...532),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (533...536)
-     ),
-     BeginNode(538...578)(
-       (538...543),
-       StatementsNode(546...547)(
-         [CallNode(546...547)(
-            nil,
-            nil,
-            (546...547),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(548...574)(
-         (548...554),
-         [ConstantReadNode(555...564)(:Exception)],
-         (565...567),
-         LocalVariableTargetNode(568...570)(:ex, 0),
-         StatementsNode(573...574)(
-           [CallNode(573...574)(
-              nil,
-              nil,
-              (573...574),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (575...578)
-     )]
-  )
-)
+@ ProgramNode (location: (0...578))
+├── locals: [:ex]
+└── statements:
+    @ StatementsNode (location: (0...578))
+    └── body: (length: 17)
+        ├── @ BeginNode (location: (0...33))
+        │   ├── begin_keyword_loc: (0...5) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (7...8))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (7...8))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (7...8) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (10...19))
+        │   │   ├── keyword_loc: (10...16) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (18...19))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (18...19))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (18...19) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause:
+        │   │   @ ElseNode (location: (21...33))
+        │   │   ├── else_keyword_loc: (21...25) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (27...28))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (27...28))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (27...28) = "c"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "c"
+        │   │   └── end_keyword_loc: (30...33) = "end"
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (30...33) = "end"
+        ├── @ BeginNode (location: (35...79))
+        │   ├── begin_keyword_loc: (35...40) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (42...43))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (42...43))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (42...43) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (45...54))
+        │   │   ├── keyword_loc: (45...51) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (53...54))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (53...54))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (53...54) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause:
+        │   │   @ ElseNode (location: (56...71))
+        │   │   ├── else_keyword_loc: (56...60) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (62...63))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (62...63))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (62...63) = "c"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "c"
+        │   │   └── end_keyword_loc: (65...71) = "ensure"
+        │   ├── ensure_clause:
+        │   │   @ EnsureNode (location: (65...79))
+        │   │   ├── ensure_keyword_loc: (65...71) = "ensure"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (73...74))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (73...74))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (73...74) = "d"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "d"
+        │   │   └── end_keyword_loc: (76...79) = "end"
+        │   └── end_keyword_loc: (76...79) = "end"
+        ├── @ BeginNode (location: (81...92))
+        │   ├── begin_keyword_loc: (81...86) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (87...88))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (87...88))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (87...88) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (89...92) = "end"
+        ├── @ BeginNode (location: (94...107))
+        │   ├── begin_keyword_loc: (94...99) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (101...102))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (101...102))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (101...102) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (104...107) = "end"
+        ├── @ BeginNode (location: (109...121))
+        │   ├── begin_keyword_loc: (109...114) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (115...116))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (115...116))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (115...116) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (118...121) = "end"
+        ├── @ BeginNode (location: (123...135))
+        │   ├── begin_keyword_loc: (123...128) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (129...130))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (129...130))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (129...130) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (132...135) = "end"
+        ├── @ BeginNode (location: (137...175))
+        │   ├── begin_keyword_loc: (137...142) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (143...144))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (143...144))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (143...144) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (145...171))
+        │   │   ├── keyword_loc: (145...151) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (152...153))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (152...153))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (152...153) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent:
+        │   │       @ RescueNode (location: (154...171))
+        │   │       ├── keyword_loc: (154...160) = "rescue"
+        │   │       ├── exceptions: (length: 0)
+        │   │       ├── operator_loc: ∅
+        │   │       ├── reference: ∅
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (161...162))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ CallNode (location: (161...162))
+        │   │       │           ├── receiver: ∅
+        │   │       │           ├── call_operator_loc: ∅
+        │   │       │           ├── message_loc: (161...162) = "c"
+        │   │       │           ├── opening_loc: ∅
+        │   │       │           ├── arguments: ∅
+        │   │       │           ├── closing_loc: ∅
+        │   │       │           ├── block: ∅
+        │   │       │           ├── flags: variable_call
+        │   │       │           └── name: "c"
+        │   │       └── consequent:
+        │   │           @ RescueNode (location: (163...171))
+        │   │           ├── keyword_loc: (163...169) = "rescue"
+        │   │           ├── exceptions: (length: 0)
+        │   │           ├── operator_loc: ∅
+        │   │           ├── reference: ∅
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (170...171))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (170...171))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (170...171) = "d"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "d"
+        │   │           └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (172...175) = "end"
+        ├── @ BeginNode (location: (177...269))
+        │   ├── begin_keyword_loc: (177...182) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (185...186))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (185...186))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (185...186) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (187...265))
+        │   │   ├── keyword_loc: (187...193) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ ConstantReadNode (location: (194...203))
+        │   │   │       └── name: :Exception
+        │   │   ├── operator_loc: (204...206) = "=>"
+        │   │   ├── reference:
+        │   │   │   @ LocalVariableTargetNode (location: (207...209))
+        │   │   │   ├── name: :ex
+        │   │   │   └── depth: 0
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (212...213))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (212...213))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (212...213) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent:
+        │   │       @ RescueNode (location: (214...265))
+        │   │       ├── keyword_loc: (214...220) = "rescue"
+        │   │       ├── exceptions: (length: 2)
+        │   │       │   ├── @ ConstantReadNode (location: (221...237))
+        │   │       │   │   └── name: :AnotherException
+        │   │       │   └── @ ConstantReadNode (location: (239...255))
+        │   │       │       └── name: :OneMoreException
+        │   │       ├── operator_loc: (256...258) = "=>"
+        │   │       ├── reference:
+        │   │       │   @ LocalVariableTargetNode (location: (259...261))
+        │   │       │   ├── name: :ex
+        │   │       │   └── depth: 0
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (264...265))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ CallNode (location: (264...265))
+        │   │       │           ├── receiver: ∅
+        │   │       │           ├── call_operator_loc: ∅
+        │   │       │           ├── message_loc: (264...265) = "c"
+        │   │       │           ├── opening_loc: ∅
+        │   │       │           ├── arguments: ∅
+        │   │       │           ├── closing_loc: ∅
+        │   │       │           ├── block: ∅
+        │   │       │           ├── flags: variable_call
+        │   │       │           └── name: "c"
+        │   │       └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (266...269) = "end"
+        ├── @ BeginNode (location: (271...322))
+        │   ├── begin_keyword_loc: (271...276) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (279...280))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (279...280))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (279...280) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (281...307))
+        │   │   ├── keyword_loc: (281...287) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ ConstantReadNode (location: (288...297))
+        │   │   │       └── name: :Exception
+        │   │   ├── operator_loc: (298...300) = "=>"
+        │   │   ├── reference:
+        │   │   │   @ LocalVariableTargetNode (location: (301...303))
+        │   │   │   ├── name: :ex
+        │   │   │   └── depth: 0
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (306...307))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (306...307))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (306...307) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause:
+        │   │   @ EnsureNode (location: (308...322))
+        │   │   ├── ensure_keyword_loc: (308...314) = "ensure"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (317...318))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (317...318))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (317...318) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── end_keyword_loc: (319...322) = "end"
+        │   └── end_keyword_loc: (319...322) = "end"
+        ├── @ StringNode (location: (324...330))
+        │   ├── opening_loc: (324...326) = "%!"
+        │   ├── content_loc: (326...329) = "abc"
+        │   ├── closing_loc: (329...330) = "!"
+        │   └── unescaped: "abc"
+        ├── @ BeginNode (location: (332...352))
+        │   ├── begin_keyword_loc: (332...337) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (338...339))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (338...339))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (338...339) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (340...348))
+        │   │   ├── keyword_loc: (340...346) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (347...348))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (347...348))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (347...348) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (349...352) = "end"
+        ├── @ BeginNode (location: (354...374))
+        │   ├── begin_keyword_loc: (354...359) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (360...361))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (360...361))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (360...361) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (362...370))
+        │   │   ├── keyword_loc: (362...368) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (369...370))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (369...370))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (369...370) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (371...374) = "end"
+        ├── @ BeginNode (location: (376...396))
+        │   ├── begin_keyword_loc: (376...381) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (382...383))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (382...383))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (382...383) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (384...392))
+        │   │   ├── keyword_loc: (384...390) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (391...392))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (391...392))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (391...392) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (393...396) = "end"
+        ├── @ BeginNode (location: (398...428))
+        │   ├── begin_keyword_loc: (398...403) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (404...405))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (404...405))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (404...405) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (406...424))
+        │   │   ├── keyword_loc: (406...412) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ ConstantReadNode (location: (413...422))
+        │   │   │       └── name: :Exception
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (423...424))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (423...424))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (423...424) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (425...428) = "end"
+        ├── @ BeginNode (location: (430...477))
+        │   ├── begin_keyword_loc: (430...435) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (436...437))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (436...437))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (436...437) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (438...473))
+        │   │   ├── keyword_loc: (438...444) = "rescue"
+        │   │   ├── exceptions: (length: 2)
+        │   │   │   ├── @ ConstantReadNode (location: (445...454))
+        │   │   │   │   └── name: :Exception
+        │   │   │   └── @ ConstantReadNode (location: (456...471))
+        │   │   │       └── name: :CustomException
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (472...473))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (472...473))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (472...473) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (474...477) = "end"
+        ├── @ BeginNode (location: (479...536))
+        │   ├── begin_keyword_loc: (479...484) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (487...488))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (487...488))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (487...488) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (489...532))
+        │   │   ├── keyword_loc: (489...495) = "rescue"
+        │   │   ├── exceptions: (length: 2)
+        │   │   │   ├── @ ConstantReadNode (location: (496...505))
+        │   │   │   │   └── name: :Exception
+        │   │   │   └── @ ConstantReadNode (location: (507...522))
+        │   │   │       └── name: :CustomException
+        │   │   ├── operator_loc: (523...525) = "=>"
+        │   │   ├── reference:
+        │   │   │   @ LocalVariableTargetNode (location: (526...528))
+        │   │   │   ├── name: :ex
+        │   │   │   └── depth: 0
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (531...532))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (531...532))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (531...532) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (533...536) = "end"
+        └── @ BeginNode (location: (538...578))
+            ├── begin_keyword_loc: (538...543) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (546...547))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (546...547))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (546...547) = "a"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "a"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (548...574))
+            │   ├── keyword_loc: (548...554) = "rescue"
+            │   ├── exceptions: (length: 1)
+            │   │   └── @ ConstantReadNode (location: (555...564))
+            │   │       └── name: :Exception
+            │   ├── operator_loc: (565...567) = "=>"
+            │   ├── reference:
+            │   │   @ LocalVariableTargetNode (location: (568...570))
+            │   │   ├── name: :ex
+            │   │   └── depth: 0
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (573...574))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (573...574))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (573...574) = "b"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "b"
+            │   └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (575...578) = "end"
diff --git a/test/yarp/snapshots/blocks.txt b/test/yarp/snapshots/blocks.txt
index b23965960a..11a46497d8 100644
--- a/test/yarp/snapshots/blocks.txt
+++ b/test/yarp/snapshots/blocks.txt
@@ -1,624 +1,744 @@
-ProgramNode(0...402)(
-  [:fork],
-  StatementsNode(0...402)(
-    [CallNode(0...16)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...8),
-       (3...4),
-       ArgumentsNode(4...7)(
-         [CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "bar")]
-       ),
-       (7...8),
-       BlockNode(9...16)(
-         [],
-         nil,
-         StatementsNode(11...14)(
-           [CallNode(11...14)(
-              nil,
-              nil,
-              (11...14),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         (9...10),
-         (15...16)
-       ),
-       0,
-       "[]"
-     ),
-     CallNode(18...37)(
-       CallNode(18...21)(nil, nil, (18...21), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (21...26),
-       (21...22),
-       ArgumentsNode(22...25)(
-         [CallNode(22...25)(nil, nil, (22...25), nil, nil, nil, nil, 2, "bar")]
-       ),
-       (25...26),
-       BlockNode(27...37)(
-         [],
-         nil,
-         StatementsNode(30...33)(
-           [CallNode(30...33)(
-              nil,
-              nil,
-              (30...33),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         (27...29),
-         (34...37)
-       ),
-       0,
-       "[]"
-     ),
-     CallNode(39...74)(
-       CallNode(39...40)(nil, nil, (39...40), nil, nil, nil, nil, 2, "x"),
-       (40...41),
-       (41...47),
-       (47...48),
-       ArgumentsNode(48...49)([IntegerNode(48...49)()]),
-       (49...50),
-       BlockNode(51...74)(
-         [:x, :memo],
-         BlockParametersNode(53...62)(
-           ParametersNode(54...61)(
-             [RequiredParameterNode(54...55)(:x),
-              RequiredParameterNode(57...61)(:memo)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (53...54),
-           (61...62)
-         ),
-         StatementsNode(63...72)(
-           [LocalVariableOperatorWriteNode(63...72)(
-              (63...67),
-              (68...70),
-              LocalVariableReadNode(71...72)(:x, 0),
-              :memo,
-              :+,
-              0
-            )]
-         ),
-         (51...52),
-         (73...74)
-       ),
-       0,
-       "reduce"
-     ),
-     CallNode(76...86)(
-       nil,
-       nil,
-       (76...79),
-       nil,
-       nil,
-       nil,
-       BlockNode(80...86)([], nil, nil, (80...82), (83...86)),
-       0,
-       "foo"
-     ),
-     CallNode(88...109)(
-       nil,
-       nil,
-       (88...91),
-       nil,
-       ArgumentsNode(92...109)(
-         [CallNode(92...95)(nil, nil, (92...95), nil, nil, nil, nil, 2, "bar"),
-          ParenthesesNode(97...109)(
-            StatementsNode(98...108)(
-              [CallNode(98...108)(
-                 nil,
-                 nil,
-                 (98...101),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(102...108)([], nil, nil, (102...104), (105...108)),
-                 0,
-                 "baz"
-               )]
-            ),
-            (97...98),
-            (108...109)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(111...125)(
-       nil,
-       nil,
-       (111...114),
-       nil,
-       ArgumentsNode(115...118)(
-         [CallNode(115...118)(
-            nil,
-            nil,
-            (115...118),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       nil,
-       BlockNode(119...125)([], nil, nil, (119...121), (122...125)),
-       0,
-       "foo"
-     ),
-     CallNode(127...145)(
-       nil,
-       nil,
-       (127...130),
-       nil,
-       ArgumentsNode(131...138)(
-         [CallNode(131...138)(
-            nil,
-            nil,
-            (131...134),
-            nil,
-            ArgumentsNode(135...138)(
-              [CallNode(135...138)(
-                 nil,
-                 nil,
-                 (135...138),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "baz"
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       nil,
-       BlockNode(139...145)([], nil, nil, (139...141), (142...145)),
-       0,
-       "foo"
-     ),
-     CallNode(147...168)(
-       nil,
-       nil,
-       (147...150),
-       nil,
-       nil,
-       nil,
-       BlockNode(151...168)(
-         [:a],
-         BlockParametersNode(154...164)(
-           ParametersNode(155...163)(
-             [],
-             [OptionalParameterNode(155...163)(
-                :a,
-                (155...156),
-                (157...158),
-                CallNode(159...163)(
-                  CallNode(159...160)(
-                    nil,
-                    nil,
-                    (159...160),
-                    nil,
-                    nil,
-                    nil,
-                    nil,
-                    2,
-                    "b"
-                  ),
-                  nil,
-                  (160...163),
-                  (160...161),
-                  ArgumentsNode(161...162)([IntegerNode(161...162)()]),
-                  (162...163),
-                  nil,
-                  0,
-                  "[]"
-                )
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (154...155),
-           (163...164)
-         ),
-         nil,
-         (151...153),
-         (165...168)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(170...187)(
-       nil,
-       nil,
-       (170...173),
-       nil,
-       nil,
-       nil,
-       BlockNode(174...187)(
-         [],
-         nil,
-         BeginNode(177...187)(
-           nil,
-           nil,
-           RescueNode(177...183)((177...183), [], nil, nil, nil, nil),
-           nil,
-           nil,
-           (184...187)
-         ),
-         (174...176),
-         (184...187)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(189...233)(
-       nil,
-       nil,
-       (189...192),
-       nil,
-       nil,
-       nil,
-       BlockNode(193...233)(
-         [],
-         nil,
-         StatementsNode(198...229)(
-           [CallNode(198...229)(
-              nil,
-              nil,
-              (198...201),
-              nil,
-              nil,
-              nil,
-              BlockNode(202...229)(
-                [],
-                nil,
-                StatementsNode(209...223)(
-                  [CallNode(209...223)(
-                     nil,
-                     nil,
-                     (209...212),
-                     nil,
-                     nil,
-                     nil,
-                     BlockNode(213...223)(
-                       [],
-                       nil,
-                       nil,
-                       (213...215),
-                       (220...223)
-                     ),
-                     0,
-                     "baz"
-                   )]
-                ),
-                (202...204),
-                (226...229)
-              ),
-              0,
-              "bar"
-            )]
-         ),
-         (193...195),
-         (230...233)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(235...251)(
-       CallNode(235...238)(
-         nil,
-         nil,
-         (235...238),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (238...243),
-       (238...239),
-       ArgumentsNode(239...242)(
-         [CallNode(239...242)(
-            nil,
-            nil,
-            (239...242),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       (242...243),
-       BlockNode(244...251)(
-         [],
-         nil,
-         StatementsNode(246...249)(
-           [CallNode(246...249)(
-              nil,
-              nil,
-              (246...249),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         (244...245),
-         (250...251)
-       ),
-       0,
-       "[]"
-     ),
-     CallNode(253...277)(
-       nil,
-       nil,
-       (253...256),
-       nil,
-       nil,
-       nil,
-       BlockNode(257...277)(
-         [:x, :y, :z],
-         BlockParametersNode(259...273)(
-           ParametersNode(260...272)(
-             [RequiredParameterNode(260...261)(:x)],
-             [OptionalParameterNode(263...268)(
-                :y,
-                (263...264),
-                (265...266),
-                IntegerNode(267...268)()
-              )],
-             [],
-             nil,
-             [KeywordParameterNode(270...272)(:z, (270...272), nil)],
-             nil,
-             nil
-           ),
-           [],
-           (259...260),
-           (272...273)
-         ),
-         StatementsNode(274...275)([LocalVariableReadNode(274...275)(:x, 0)]),
-         (257...258),
-         (276...277)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(279...290)(
-       nil,
-       nil,
-       (279...282),
-       nil,
-       nil,
-       nil,
-       BlockNode(283...290)(
-         [:x],
-         BlockParametersNode(285...288)(
-           ParametersNode(286...287)(
-             [RequiredParameterNode(286...287)(:x)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (285...286),
-           (287...288)
-         ),
-         nil,
-         (283...284),
-         (289...290)
-       ),
-       0,
-       "foo"
-     ),
-     LocalVariableWriteNode(292...300)(
-       :fork,
-       0,
-       (292...296),
-       IntegerNode(299...300)(),
-       (297...298)
-     ),
-     CallNode(301...316)(
-       nil,
-       nil,
-       (301...305),
-       nil,
-       nil,
-       nil,
-       BlockNode(306...316)(
-         [:a],
-         BlockParametersNode(309...312)(
-           ParametersNode(310...311)(
-             [RequiredParameterNode(310...311)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (309...310),
-           (311...312)
-         ),
-         nil,
-         (306...308),
-         (313...316)
-       ),
-       0,
-       "fork"
-     ),
-     CallNode(318...330)(
-       nil,
-       nil,
-       (318...322),
-       nil,
-       nil,
-       nil,
-       BlockNode(323...330)(
-         [:a],
-         BlockParametersNode(325...328)(
-           ParametersNode(326...327)(
-             [RequiredParameterNode(326...327)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (325...326),
-           (327...328)
-         ),
-         nil,
-         (323...324),
-         (329...330)
-       ),
-       0,
-       "fork"
-     ),
-     CallNode(332...340)(
-       nil,
-       nil,
-       (332...333),
-       nil,
-       nil,
-       nil,
-       BlockNode(334...340)([], nil, nil, (334...336), (337...340)),
-       0,
-       "C"
-     ),
-     CallNode(342...346)(
-       nil,
-       nil,
-       (342...343),
-       nil,
-       nil,
-       nil,
-       BlockNode(344...346)([], nil, nil, (344...345), (345...346)),
-       0,
-       "C"
-     ),
-     CallNode(348...383)(
-       nil,
-       nil,
-       (348...351),
-       nil,
-       ArgumentsNode(352...383)(
-         [CallNode(352...383)(
-            nil,
-            nil,
-            (352...358),
-            nil,
-            nil,
-            nil,
-            BlockNode(359...383)(
-              [:a, :b],
-              BlockParametersNode(361...381)(
-                ParametersNode(365...377)(
-                  [],
-                  [],
-                  [],
-                  nil,
-                  [KeywordParameterNode(365...369)(
-                     :a,
-                     (365...367),
-                     IntegerNode(368...369)()
-                   ),
-                   KeywordParameterNode(373...377)(
-                     :b,
-                     (373...375),
-                     IntegerNode(376...377)()
-                   )],
-                  nil,
-                  nil
-                ),
-                [],
-                (361...362),
-                (380...381)
-              ),
-              nil,
-              (359...360),
-              (382...383)
-            ),
-            0,
-            "lambda"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(385...402)(
-       nil,
-       nil,
-       (385...388),
-       nil,
-       nil,
-       nil,
-       BlockNode(389...402)(
-         [:bar],
-         BlockParametersNode(392...398)(
-           ParametersNode(393...397)(
-             [RequiredParameterNode(393...396)(:bar)],
-             [],
-             [],
-             RestParameterNode(396...397)(nil, nil, (396...397)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (392...393),
-           (397...398)
-         ),
-         nil,
-         (389...391),
-         (399...402)
-       ),
-       0,
-       "foo"
-     )]
-  )
-)
+@ ProgramNode (location: (0...402))
+├── locals: [:fork]
+└── statements:
+    @ StatementsNode (location: (0...402))
+    └── body: (length: 20)
+        ├── @ CallNode (location: (0...16))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (3...8) = "[bar]"
+        │   ├── opening_loc: (3...4) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...7))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (4...7))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (4...7) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: (7...8) = "]"
+        │   ├── block:
+        │   │   @ BlockNode (location: (9...16))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (11...14))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (11...14))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (11...14) = "baz"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "baz"
+        │   │   ├── opening_loc: (9...10) = "{"
+        │   │   └── closing_loc: (15...16) = "}"
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ CallNode (location: (18...37))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (18...21))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (18...21) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (21...26) = "[bar]"
+        │   ├── opening_loc: (21...22) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (22...25))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (22...25))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (22...25) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: (25...26) = "]"
+        │   ├── block:
+        │   │   @ BlockNode (location: (27...37))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (30...33))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (30...33))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (30...33) = "baz"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "baz"
+        │   │   ├── opening_loc: (27...29) = "do"
+        │   │   └── closing_loc: (34...37) = "end"
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ CallNode (location: (39...74))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (39...40))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (39...40) = "x"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "x"
+        │   ├── call_operator_loc: (40...41) = "."
+        │   ├── message_loc: (41...47) = "reduce"
+        │   ├── opening_loc: (47...48) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (48...49))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (48...49))
+        │   ├── closing_loc: (49...50) = ")"
+        │   ├── block:
+        │   │   @ BlockNode (location: (51...74))
+        │   │   ├── locals: [:x, :memo]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (53...62))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (54...61))
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ RequiredParameterNode (location: (54...55))
+        │   │   │   │   │   │   └── name: :x
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (57...61))
+        │   │   │   │   │       └── name: :memo
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (53...54) = "|"
+        │   │   │   └── closing_loc: (61...62) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (63...72))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableOperatorWriteNode (location: (63...72))
+        │   │   │           ├── name_loc: (63...67) = "memo"
+        │   │   │           ├── operator_loc: (68...70) = "+="
+        │   │   │           ├── value:
+        │   │   │           │   @ LocalVariableReadNode (location: (71...72))
+        │   │   │           │   ├── name: :x
+        │   │   │           │   └── depth: 0
+        │   │   │           ├── name: :memo
+        │   │   │           ├── operator: :+
+        │   │   │           └── depth: 0
+        │   │   ├── opening_loc: (51...52) = "{"
+        │   │   └── closing_loc: (73...74) = "}"
+        │   ├── flags: 
+        │   └── name: "reduce"
+        ├── @ CallNode (location: (76...86))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (76...79) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (80...86))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (80...82) = "do"
+        │   │   └── closing_loc: (83...86) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (88...109))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (88...91) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (92...109))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (92...95))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (92...95) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       └── @ ParenthesesNode (location: (97...109))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (98...108))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (98...108))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (98...101) = "baz"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block:
+        │   │           │           │   @ BlockNode (location: (102...108))
+        │   │           │           │   ├── locals: []
+        │   │           │           │   ├── parameters: ∅
+        │   │           │           │   ├── body: ∅
+        │   │           │           │   ├── opening_loc: (102...104) = "do"
+        │   │           │           │   └── closing_loc: (105...108) = "end"
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "baz"
+        │   │           ├── opening_loc: (97...98) = "("
+        │   │           └── closing_loc: (108...109) = ")"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (111...125))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (111...114) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (115...118))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (115...118))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (115...118) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (119...125))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (119...121) = "do"
+        │   │   └── closing_loc: (122...125) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (127...145))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (127...130) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (131...138))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (131...138))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (131...134) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (135...138))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ CallNode (location: (135...138))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (135...138) = "baz"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "baz"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (139...145))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (139...141) = "do"
+        │   │   └── closing_loc: (142...145) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (147...168))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (147...150) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (151...168))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (154...164))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (155...163))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (155...163))
+        │   │   │   │   │       ├── name: :a
+        │   │   │   │   │       ├── name_loc: (155...156) = "a"
+        │   │   │   │   │       ├── operator_loc: (157...158) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ CallNode (location: (159...163))
+        │   │   │   │   │           ├── receiver:
+        │   │   │   │   │           │   @ CallNode (location: (159...160))
+        │   │   │   │   │           │   ├── receiver: ∅
+        │   │   │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │   │   │           │   ├── message_loc: (159...160) = "b"
+        │   │   │   │   │           │   ├── opening_loc: ∅
+        │   │   │   │   │           │   ├── arguments: ∅
+        │   │   │   │   │           │   ├── closing_loc: ∅
+        │   │   │   │   │           │   ├── block: ∅
+        │   │   │   │   │           │   ├── flags: variable_call
+        │   │   │   │   │           │   └── name: "b"
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (160...163) = "[1]"
+        │   │   │   │   │           ├── opening_loc: (160...161) = "["
+        │   │   │   │   │           ├── arguments:
+        │   │   │   │   │           │   @ ArgumentsNode (location: (161...162))
+        │   │   │   │   │           │   └── arguments: (length: 1)
+        │   │   │   │   │           │       └── @ IntegerNode (location: (161...162))
+        │   │   │   │   │           ├── closing_loc: (162...163) = "]"
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: 
+        │   │   │   │   │           └── name: "[]"
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (154...155) = "|"
+        │   │   │   └── closing_loc: (163...164) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (151...153) = "do"
+        │   │   └── closing_loc: (165...168) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (170...187))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (170...173) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (174...187))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (177...187))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements: ∅
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (177...183))
+        │   │   │   │   ├── keyword_loc: (177...183) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 0)
+        │   │   │   │   ├── operator_loc: ∅
+        │   │   │   │   ├── reference: ∅
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (184...187) = "end"
+        │   │   ├── opening_loc: (174...176) = "do"
+        │   │   └── closing_loc: (184...187) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (189...233))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (189...192) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (193...233))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (198...229))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (198...229))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (198...201) = "bar"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block:
+        │   │   │           │   @ BlockNode (location: (202...229))
+        │   │   │           │   ├── locals: []
+        │   │   │           │   ├── parameters: ∅
+        │   │   │           │   ├── body:
+        │   │   │           │   │   @ StatementsNode (location: (209...223))
+        │   │   │           │   │   └── body: (length: 1)
+        │   │   │           │   │       └── @ CallNode (location: (209...223))
+        │   │   │           │   │           ├── receiver: ∅
+        │   │   │           │   │           ├── call_operator_loc: ∅
+        │   │   │           │   │           ├── message_loc: (209...212) = "baz"
+        │   │   │           │   │           ├── opening_loc: ∅
+        │   │   │           │   │           ├── arguments: ∅
+        │   │   │           │   │           ├── closing_loc: ∅
+        │   │   │           │   │           ├── block:
+        │   │   │           │   │           │   @ BlockNode (location: (213...223))
+        │   │   │           │   │           │   ├── locals: []
+        │   │   │           │   │           │   ├── parameters: ∅
+        │   │   │           │   │           │   ├── body: ∅
+        │   │   │           │   │           │   ├── opening_loc: (213...215) = "do"
+        │   │   │           │   │           │   └── closing_loc: (220...223) = "end"
+        │   │   │           │   │           ├── flags: 
+        │   │   │           │   │           └── name: "baz"
+        │   │   │           │   ├── opening_loc: (202...204) = "do"
+        │   │   │           │   └── closing_loc: (226...229) = "end"
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "bar"
+        │   │   ├── opening_loc: (193...195) = "do"
+        │   │   └── closing_loc: (230...233) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (235...251))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (235...238))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (235...238) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (238...243) = "[bar]"
+        │   ├── opening_loc: (238...239) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (239...242))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (239...242))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (239...242) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: (242...243) = "]"
+        │   ├── block:
+        │   │   @ BlockNode (location: (244...251))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (246...249))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (246...249))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (246...249) = "baz"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "baz"
+        │   │   ├── opening_loc: (244...245) = "{"
+        │   │   └── closing_loc: (250...251) = "}"
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ CallNode (location: (253...277))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (253...256) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (257...277))
+        │   │   ├── locals: [:x, :y, :z]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (259...273))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (260...272))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (260...261))
+        │   │   │   │   │       └── name: :x
+        │   │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (263...268))
+        │   │   │   │   │       ├── name: :y
+        │   │   │   │   │       ├── name_loc: (263...264) = "y"
+        │   │   │   │   │       ├── operator_loc: (265...266) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (267...268))
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 1)
+        │   │   │   │   │   └── @ KeywordParameterNode (location: (270...272))
+        │   │   │   │   │       ├── name: :z
+        │   │   │   │   │       ├── name_loc: (270...272) = "z:"
+        │   │   │   │   │       └── value: ∅
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (259...260) = "|"
+        │   │   │   └── closing_loc: (272...273) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (274...275))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableReadNode (location: (274...275))
+        │   │   │           ├── name: :x
+        │   │   │           └── depth: 0
+        │   │   ├── opening_loc: (257...258) = "{"
+        │   │   └── closing_loc: (276...277) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (279...290))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (279...282) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (283...290))
+        │   │   ├── locals: [:x]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (285...288))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (286...287))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (286...287))
+        │   │   │   │   │       └── name: :x
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (285...286) = "|"
+        │   │   │   └── closing_loc: (287...288) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (283...284) = "{"
+        │   │   └── closing_loc: (289...290) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ LocalVariableWriteNode (location: (292...300))
+        │   ├── name: :fork
+        │   ├── depth: 0
+        │   ├── name_loc: (292...296) = "fork"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (299...300))
+        │   └── operator_loc: (297...298) = "="
+        ├── @ CallNode (location: (301...316))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (301...305) = "fork"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (306...316))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (309...312))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (310...311))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (310...311))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (309...310) = "|"
+        │   │   │   └── closing_loc: (311...312) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (306...308) = "do"
+        │   │   └── closing_loc: (313...316) = "end"
+        │   ├── flags: 
+        │   └── name: "fork"
+        ├── @ CallNode (location: (318...330))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (318...322) = "fork"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (323...330))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (325...328))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (326...327))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (326...327))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (325...326) = "|"
+        │   │   │   └── closing_loc: (327...328) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (323...324) = "{"
+        │   │   └── closing_loc: (329...330) = "}"
+        │   ├── flags: 
+        │   └── name: "fork"
+        ├── @ CallNode (location: (332...340))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (332...333) = "C"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (334...340))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (334...336) = "do"
+        │   │   └── closing_loc: (337...340) = "end"
+        │   ├── flags: 
+        │   └── name: "C"
+        ├── @ CallNode (location: (342...346))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (342...343) = "C"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (344...346))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (344...345) = "{"
+        │   │   └── closing_loc: (345...346) = "}"
+        │   ├── flags: 
+        │   └── name: "C"
+        ├── @ CallNode (location: (348...383))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (348...351) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (352...383))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (352...383))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (352...358) = "lambda"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (359...383))
+        │   │           │   ├── locals: [:a, :b]
+        │   │           │   ├── parameters:
+        │   │           │   │   @ BlockParametersNode (location: (361...381))
+        │   │           │   │   ├── parameters:
+        │   │           │   │   │   @ ParametersNode (location: (365...377))
+        │   │           │   │   │   ├── requireds: (length: 0)
+        │   │           │   │   │   ├── optionals: (length: 0)
+        │   │           │   │   │   ├── posts: (length: 0)
+        │   │           │   │   │   ├── rest: ∅
+        │   │           │   │   │   ├── keywords: (length: 2)
+        │   │           │   │   │   │   ├── @ KeywordParameterNode (location: (365...369))
+        │   │           │   │   │   │   │   ├── name: :a
+        │   │           │   │   │   │   │   ├── name_loc: (365...367) = "a:"
+        │   │           │   │   │   │   │   └── value:
+        │   │           │   │   │   │   │       @ IntegerNode (location: (368...369))
+        │   │           │   │   │   │   └── @ KeywordParameterNode (location: (373...377))
+        │   │           │   │   │   │       ├── name: :b
+        │   │           │   │   │   │       ├── name_loc: (373...375) = "b:"
+        │   │           │   │   │   │       └── value:
+        │   │           │   │   │   │           @ IntegerNode (location: (376...377))
+        │   │           │   │   │   ├── keyword_rest: ∅
+        │   │           │   │   │   └── block: ∅
+        │   │           │   │   ├── locals: (length: 0)
+        │   │           │   │   ├── opening_loc: (361...362) = "|"
+        │   │           │   │   └── closing_loc: (380...381) = "|"
+        │   │           │   ├── body: ∅
+        │   │           │   ├── opening_loc: (359...360) = "{"
+        │   │           │   └── closing_loc: (382...383) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "lambda"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        └── @ CallNode (location: (385...402))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (385...388) = "foo"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (389...402))
+            │   ├── locals: [:bar]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (392...398))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (393...397))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (393...396))
+            │   │   │   │       └── name: :bar
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (396...397))
+            │   │   │   │   ├── name: nil
+            │   │   │   │   ├── name_loc: ∅
+            │   │   │   │   └── operator_loc: (396...397) = ","
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (392...393) = "|"
+            │   │   └── closing_loc: (397...398) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (389...391) = "do"
+            │   └── closing_loc: (399...402) = "end"
+            ├── flags: 
+            └── name: "foo"
diff --git a/test/yarp/snapshots/boolean_operators.txt b/test/yarp/snapshots/boolean_operators.txt
index f1fc5cd4b2..fcb3337a78 100644
--- a/test/yarp/snapshots/boolean_operators.txt
+++ b/test/yarp/snapshots/boolean_operators.txt
@@ -1,27 +1,54 @@
-ProgramNode(0...24)(
-  [:a],
-  StatementsNode(0...24)(
-    [LocalVariableAndWriteNode(0...7)(
-       (0...1),
-       (2...5),
-       CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b"),
-       :a,
-       0
-     ),
-     LocalVariableOperatorWriteNode(9...15)(
-       (9...10),
-       (11...13),
-       CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "b"),
-       :a,
-       :+,
-       0
-     ),
-     LocalVariableOrWriteNode(17...24)(
-       (17...18),
-       (19...22),
-       CallNode(23...24)(nil, nil, (23...24), nil, nil, nil, nil, 2, "b"),
-       :a,
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 3)
+        ├── @ LocalVariableAndWriteNode (location: (0...7))
+        │   ├── name_loc: (0...1) = "a"
+        │   ├── operator_loc: (2...5) = "&&="
+        │   ├── value:
+        │   │   @ CallNode (location: (6...7))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (6...7) = "b"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "b"
+        │   ├── name: :a
+        │   └── depth: 0
+        ├── @ LocalVariableOperatorWriteNode (location: (9...15))
+        │   ├── name_loc: (9...10) = "a"
+        │   ├── operator_loc: (11...13) = "+="
+        │   ├── value:
+        │   │   @ CallNode (location: (14...15))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (14...15) = "b"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "b"
+        │   ├── name: :a
+        │   ├── operator: :+
+        │   └── depth: 0
+        └── @ LocalVariableOrWriteNode (location: (17...24))
+            ├── name_loc: (17...18) = "a"
+            ├── operator_loc: (19...22) = "||="
+            ├── value:
+            │   @ CallNode (location: (23...24))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (23...24) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "b"
+            ├── name: :a
+            └── depth: 0
diff --git a/test/yarp/snapshots/booleans.txt b/test/yarp/snapshots/booleans.txt
index f4e609652c..a380121bee 100644
--- a/test/yarp/snapshots/booleans.txt
+++ b/test/yarp/snapshots/booleans.txt
@@ -1,4 +1,7 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)([FalseNode(0...5)(), TrueNode(7...11)()])
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 2)
+        ├── @ FalseNode (location: (0...5))
+        └── @ TrueNode (location: (7...11))
diff --git a/test/yarp/snapshots/break.txt b/test/yarp/snapshots/break.txt
index b8ae8ffe81..21a46081db 100644
--- a/test/yarp/snapshots/break.txt
+++ b/test/yarp/snapshots/break.txt
@@ -1,158 +1,188 @@
-ProgramNode(0...168)(
-  [],
-  StatementsNode(0...168)(
-    [BreakNode(0...5)(nil, (0...5)),
-     BreakNode(7...26)(
-       ArgumentsNode(13...26)(
-         [ParenthesesNode(13...16)(
-            StatementsNode(14...15)([IntegerNode(14...15)()]),
-            (13...14),
-            (15...16)
-          ),
-          ParenthesesNode(18...21)(
-            StatementsNode(19...20)([IntegerNode(19...20)()]),
-            (18...19),
-            (20...21)
-          ),
-          ParenthesesNode(23...26)(
-            StatementsNode(24...25)([IntegerNode(24...25)()]),
-            (23...24),
-            (25...26)
-          )]
-       ),
-       (7...12)
-     ),
-     BreakNode(28...35)(
-       ArgumentsNode(34...35)([IntegerNode(34...35)()]),
-       (28...33)
-     ),
-     BreakNode(37...50)(
-       ArgumentsNode(43...50)(
-         [IntegerNode(43...44)(),
-          IntegerNode(46...47)(),
-          IntegerNode(49...50)()]
-       ),
-       (37...42)
-     ),
-     BreakNode(52...65)(
-       ArgumentsNode(58...65)(
-         [IntegerNode(58...59)(),
-          IntegerNode(61...62)(),
-          IntegerNode(64...65)()]
-       ),
-       (52...57)
-     ),
-     BreakNode(67...82)(
-       ArgumentsNode(73...82)(
-         [ArrayNode(73...82)(
-            [IntegerNode(74...75)(),
-             IntegerNode(77...78)(),
-             IntegerNode(80...81)()],
-            (73...74),
-            (81...82)
-          )]
-       ),
-       (67...72)
-     ),
-     BreakNode(84...100)(
-       ArgumentsNode(89...100)(
-         [ParenthesesNode(89...100)(
-            StatementsNode(93...98)(
-              [IntegerNode(93...94)(), IntegerNode(97...98)()]
-            ),
-            (89...90),
-            (99...100)
-          )]
-       ),
-       (84...89)
-     ),
-     BreakNode(102...109)(
-       ArgumentsNode(107...109)(
-         [ParenthesesNode(107...109)(nil, (107...108), (108...109))]
-       ),
-       (102...107)
-     ),
-     BreakNode(111...119)(
-       ArgumentsNode(116...119)(
-         [ParenthesesNode(116...119)(
-            StatementsNode(117...118)([IntegerNode(117...118)()]),
-            (116...117),
-            (118...119)
-          )]
-       ),
-       (111...116)
-     ),
-     CallNode(121...143)(
-       CallNode(121...137)(
-         nil,
-         nil,
-         (121...124),
-         nil,
-         nil,
-         nil,
-         BlockNode(125...137)(
-           [],
-           nil,
-           StatementsNode(127...135)(
-             [BreakNode(127...135)(
-                ArgumentsNode(133...135)([IntegerNode(133...135)()]),
-                (127...132)
-              )]
-           ),
-           (125...126),
-           (136...137)
-         ),
-         0,
-         "foo"
-       ),
-       nil,
-       (138...140),
-       nil,
-       ArgumentsNode(141...143)([IntegerNode(141...143)()]),
-       nil,
-       nil,
-       0,
-       "=="
-     ),
-     CallNode(145...168)(
-       CallNode(145...162)(
-         nil,
-         nil,
-         (145...148),
-         nil,
-         nil,
-         nil,
-         BlockNode(149...162)(
-           [:a],
-           BlockParametersNode(151...154)(
-             ParametersNode(152...153)(
-               [RequiredParameterNode(152...153)(:a)],
-               [],
-               [],
-               nil,
-               [],
-               nil,
-               nil
-             ),
-             [],
-             (151...152),
-             (153...154)
-           ),
-           StatementsNode(155...160)([BreakNode(155...160)(nil, (155...160))]),
-           (149...150),
-           (161...162)
-         ),
-         0,
-         "foo"
-       ),
-       nil,
-       (163...165),
-       nil,
-       ArgumentsNode(166...168)([IntegerNode(166...168)()]),
-       nil,
-       nil,
-       0,
-       "=="
-     )]
-  )
-)
+@ ProgramNode (location: (0...168))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...168))
+    └── body: (length: 11)
+        ├── @ BreakNode (location: (0...5))
+        │   ├── arguments: ∅
+        │   └── keyword_loc: (0...5) = "break"
+        ├── @ BreakNode (location: (7...26))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (13...26))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ ParenthesesNode (location: (13...16))
+        │   │       │   ├── body:
+        │   │       │   │   @ StatementsNode (location: (14...15))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ IntegerNode (location: (14...15))
+        │   │       │   ├── opening_loc: (13...14) = "("
+        │   │       │   └── closing_loc: (15...16) = ")"
+        │   │       ├── @ ParenthesesNode (location: (18...21))
+        │   │       │   ├── body:
+        │   │       │   │   @ StatementsNode (location: (19...20))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ IntegerNode (location: (19...20))
+        │   │       │   ├── opening_loc: (18...19) = "("
+        │   │       │   └── closing_loc: (20...21) = ")"
+        │   │       └── @ ParenthesesNode (location: (23...26))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (24...25))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (24...25))
+        │   │           ├── opening_loc: (23...24) = "("
+        │   │           └── closing_loc: (25...26) = ")"
+        │   └── keyword_loc: (7...12) = "break"
+        ├── @ BreakNode (location: (28...35))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (34...35))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (34...35))
+        │   └── keyword_loc: (28...33) = "break"
+        ├── @ BreakNode (location: (37...50))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (43...50))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ IntegerNode (location: (43...44))
+        │   │       ├── @ IntegerNode (location: (46...47))
+        │   │       └── @ IntegerNode (location: (49...50))
+        │   └── keyword_loc: (37...42) = "break"
+        ├── @ BreakNode (location: (52...65))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (58...65))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ IntegerNode (location: (58...59))
+        │   │       ├── @ IntegerNode (location: (61...62))
+        │   │       └── @ IntegerNode (location: (64...65))
+        │   └── keyword_loc: (52...57) = "break"
+        ├── @ BreakNode (location: (67...82))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (73...82))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ArrayNode (location: (73...82))
+        │   │           ├── elements: (length: 3)
+        │   │           │   ├── @ IntegerNode (location: (74...75))
+        │   │           │   ├── @ IntegerNode (location: (77...78))
+        │   │           │   └── @ IntegerNode (location: (80...81))
+        │   │           ├── opening_loc: (73...74) = "["
+        │   │           └── closing_loc: (81...82) = "]"
+        │   └── keyword_loc: (67...72) = "break"
+        ├── @ BreakNode (location: (84...100))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (89...100))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (89...100))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (93...98))
+        │   │           │   └── body: (length: 2)
+        │   │           │       ├── @ IntegerNode (location: (93...94))
+        │   │           │       └── @ IntegerNode (location: (97...98))
+        │   │           ├── opening_loc: (89...90) = "("
+        │   │           └── closing_loc: (99...100) = ")"
+        │   └── keyword_loc: (84...89) = "break"
+        ├── @ BreakNode (location: (102...109))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (107...109))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (107...109))
+        │   │           ├── body: ∅
+        │   │           ├── opening_loc: (107...108) = "("
+        │   │           └── closing_loc: (108...109) = ")"
+        │   └── keyword_loc: (102...107) = "break"
+        ├── @ BreakNode (location: (111...119))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (116...119))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (116...119))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (117...118))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (117...118))
+        │   │           ├── opening_loc: (116...117) = "("
+        │   │           └── closing_loc: (118...119) = ")"
+        │   └── keyword_loc: (111...116) = "break"
+        ├── @ CallNode (location: (121...143))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (121...137))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (121...124) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (125...137))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body:
+        │   │   │   │   @ StatementsNode (location: (127...135))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ BreakNode (location: (127...135))
+        │   │   │   │           ├── arguments:
+        │   │   │   │           │   @ ArgumentsNode (location: (133...135))
+        │   │   │   │           │   └── arguments: (length: 1)
+        │   │   │   │           │       └── @ IntegerNode (location: (133...135))
+        │   │   │   │           └── keyword_loc: (127...132) = "break"
+        │   │   │   ├── opening_loc: (125...126) = "{"
+        │   │   │   └── closing_loc: (136...137) = "}"
+        │   │   ├── flags: 
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (138...140) = "=="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (141...143))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (141...143))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=="
+        └── @ CallNode (location: (145...168))
+            ├── receiver:
+            │   @ CallNode (location: (145...162))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (145...148) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (149...162))
+            │   │   ├── locals: [:a]
+            │   │   ├── parameters:
+            │   │   │   @ BlockParametersNode (location: (151...154))
+            │   │   │   ├── parameters:
+            │   │   │   │   @ ParametersNode (location: (152...153))
+            │   │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   │   └── @ RequiredParameterNode (location: (152...153))
+            │   │   │   │   │       └── name: :a
+            │   │   │   │   ├── optionals: (length: 0)
+            │   │   │   │   ├── posts: (length: 0)
+            │   │   │   │   ├── rest: ∅
+            │   │   │   │   ├── keywords: (length: 0)
+            │   │   │   │   ├── keyword_rest: ∅
+            │   │   │   │   └── block: ∅
+            │   │   │   ├── locals: (length: 0)
+            │   │   │   ├── opening_loc: (151...152) = "|"
+            │   │   │   └── closing_loc: (153...154) = "|"
+            │   │   ├── body:
+            │   │   │   @ StatementsNode (location: (155...160))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ BreakNode (location: (155...160))
+            │   │   │           ├── arguments: ∅
+            │   │   │           └── keyword_loc: (155...160) = "break"
+            │   │   ├── opening_loc: (149...150) = "{"
+            │   │   └── closing_loc: (161...162) = "}"
+            │   ├── flags: 
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (163...165) = "=="
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (166...168))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (166...168))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "=="
diff --git a/test/yarp/snapshots/case.txt b/test/yarp/snapshots/case.txt
index 346b466a5e..3aa6c131df 100644
--- a/test/yarp/snapshots/case.txt
+++ b/test/yarp/snapshots/case.txt
@@ -1,208 +1,253 @@
-ProgramNode(0...272)(
-  [],
-  StatementsNode(0...272)(
-    [CaseNode(0...21)(
-       SymbolNode(5...8)((5...6), (6...8), nil, "hi"),
-       [WhenNode(9...17)(
-          (9...13),
-          [SymbolNode(14...17)((14...15), (15...17), nil, "hi")],
-          nil
-        )],
-       nil,
-       (0...4),
-       (18...21)
-     ),
-     CaseNode(23...81)(
-       TrueNode(28...32)(),
-       [WhenNode(34...53)(
-          (34...38),
-          [TrueNode(39...43)()],
-          StatementsNode(45...53)(
-            [CallNode(45...53)(
-               nil,
-               nil,
-               (45...49),
-               nil,
-               ArgumentsNode(50...53)(
-                 [SymbolNode(50...53)((50...51), (51...53), nil, "hi")]
-               ),
-               nil,
-               nil,
-               0,
-               "puts"
-             )]
-          )
-        ),
-        WhenNode(55...76)(
-          (55...59),
-          [FalseNode(60...65)()],
-          StatementsNode(67...76)(
-            [CallNode(67...76)(
-               nil,
-               nil,
-               (67...71),
-               nil,
-               ArgumentsNode(72...76)(
-                 [SymbolNode(72...76)((72...73), (73...76), nil, "bye")]
-               ),
-               nil,
-               nil,
-               0,
-               "puts"
-             )]
-          )
-        )],
-       nil,
-       (23...27),
-       (78...81)
-     ),
-     CaseNode(83...103)(
-       nil,
-       [WhenNode(89...98)(
-          (89...93),
-          [SplatNode(94...98)(
-             (94...95),
-             CallNode(95...98)(
-               nil,
-               nil,
-               (95...98),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "foo"
-             )
-           )],
-          nil
-        )],
-       nil,
-       (83...87),
-       (100...103)
-     ),
-     CaseNode(105...134)(
-       SymbolNode(110...113)((110...111), (111...113), nil, "hi"),
-       [WhenNode(114...122)(
-          (114...118),
-          [SymbolNode(119...122)((119...120), (120...122), nil, "hi")],
-          nil
-        )],
-       ElseNode(123...134)(
-         (123...127),
-         StatementsNode(128...130)(
-           [SymbolNode(128...130)((128...129), (129...130), nil, "b")]
-         ),
-         (131...134)
-       ),
-       (105...109),
-       (131...134)
-     ),
-     CaseNode(136...172)(
-       CallNode(141...145)(
-         nil,
-         nil,
-         (141...145),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "this"
-       ),
-       [WhenNode(147...167)(
-          (147...151),
-          [ConstantReadNode(152...158)(:FooBar),
-           ConstantReadNode(160...167)(:BazBonk)],
-          nil
-        )],
-       nil,
-       (136...140),
-       (169...172)
-     ),
-     CaseNode(174...198)(
-       nil,
-       [WhenNode(179...194)(
-          (179...183),
-          [CallNode(184...194)(
-             CallNode(184...187)(
-               nil,
-               nil,
-               (184...187),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "foo"
-             ),
-             nil,
-             (188...190),
-             nil,
-             ArgumentsNode(191...194)(
-               [CallNode(191...194)(
-                  nil,
-                  nil,
-                  (191...194),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )]
-             ),
-             nil,
-             nil,
-             0,
-             "=="
-           )],
-          nil
-        )],
-       nil,
-       (174...178),
-       (195...198)
-     ),
-     CaseNode(200...230)(
-       nil,
-       [WhenNode(205...211)(
-          (205...209),
-          [CallNode(210...211)(
-             nil,
-             nil,
-             (210...211),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "a"
-           )],
-          nil
-        )],
-       ElseNode(212...230)((212...216), nil, (227...230)),
-       (200...204),
-       (227...230)
-     ),
-     CaseNode(232...272)(
-       CallNode(237...241)(
-         nil,
-         nil,
-         (237...241),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "type"
-       ),
-       [WhenNode(246...253)(
-          (246...250),
-          [SymbolNode(251...253)((251...252), (252...253), nil, "b")],
-          nil
-        )],
-       ElseNode(260...272)((260...264), nil, (269...272)),
-       (232...236),
-       (269...272)
-     )]
-  )
-)
+@ ProgramNode (location: (0...272))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...272))
+    └── body: (length: 8)
+        ├── @ CaseNode (location: (0...21))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (5...8))
+        │   │   ├── opening_loc: (5...6) = ":"
+        │   │   ├── value_loc: (6...8) = "hi"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "hi"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (9...17))
+        │   │       ├── keyword_loc: (9...13) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ SymbolNode (location: (14...17))
+        │   │       │       ├── opening_loc: (14...15) = ":"
+        │   │       │       ├── value_loc: (15...17) = "hi"
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       └── unescaped: "hi"
+        │   │       └── statements: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (0...4) = "case"
+        │   └── end_keyword_loc: (18...21) = "end"
+        ├── @ CaseNode (location: (23...81))
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (28...32))
+        │   ├── conditions: (length: 2)
+        │   │   ├── @ WhenNode (location: (34...53))
+        │   │   │   ├── keyword_loc: (34...38) = "when"
+        │   │   │   ├── conditions: (length: 1)
+        │   │   │   │   └── @ TrueNode (location: (39...43))
+        │   │   │   └── statements:
+        │   │   │       @ StatementsNode (location: (45...53))
+        │   │   │       └── body: (length: 1)
+        │   │   │           └── @ CallNode (location: (45...53))
+        │   │   │               ├── receiver: ∅
+        │   │   │               ├── call_operator_loc: ∅
+        │   │   │               ├── message_loc: (45...49) = "puts"
+        │   │   │               ├── opening_loc: ∅
+        │   │   │               ├── arguments:
+        │   │   │               │   @ ArgumentsNode (location: (50...53))
+        │   │   │               │   └── arguments: (length: 1)
+        │   │   │               │       └── @ SymbolNode (location: (50...53))
+        │   │   │               │           ├── opening_loc: (50...51) = ":"
+        │   │   │               │           ├── value_loc: (51...53) = "hi"
+        │   │   │               │           ├── closing_loc: ∅
+        │   │   │               │           └── unescaped: "hi"
+        │   │   │               ├── closing_loc: ∅
+        │   │   │               ├── block: ∅
+        │   │   │               ├── flags: 
+        │   │   │               └── name: "puts"
+        │   │   └── @ WhenNode (location: (55...76))
+        │   │       ├── keyword_loc: (55...59) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ FalseNode (location: (60...65))
+        │   │       └── statements:
+        │   │           @ StatementsNode (location: (67...76))
+        │   │           └── body: (length: 1)
+        │   │               └── @ CallNode (location: (67...76))
+        │   │                   ├── receiver: ∅
+        │   │                   ├── call_operator_loc: ∅
+        │   │                   ├── message_loc: (67...71) = "puts"
+        │   │                   ├── opening_loc: ∅
+        │   │                   ├── arguments:
+        │   │                   │   @ ArgumentsNode (location: (72...76))
+        │   │                   │   └── arguments: (length: 1)
+        │   │                   │       └── @ SymbolNode (location: (72...76))
+        │   │                   │           ├── opening_loc: (72...73) = ":"
+        │   │                   │           ├── value_loc: (73...76) = "bye"
+        │   │                   │           ├── closing_loc: ∅
+        │   │                   │           └── unescaped: "bye"
+        │   │                   ├── closing_loc: ∅
+        │   │                   ├── block: ∅
+        │   │                   ├── flags: 
+        │   │                   └── name: "puts"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (23...27) = "case"
+        │   └── end_keyword_loc: (78...81) = "end"
+        ├── @ CaseNode (location: (83...103))
+        │   ├── predicate: ∅
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (89...98))
+        │   │       ├── keyword_loc: (89...93) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ SplatNode (location: (94...98))
+        │   │       │       ├── operator_loc: (94...95) = "*"
+        │   │       │       └── expression:
+        │   │       │           @ CallNode (location: (95...98))
+        │   │       │           ├── receiver: ∅
+        │   │       │           ├── call_operator_loc: ∅
+        │   │       │           ├── message_loc: (95...98) = "foo"
+        │   │       │           ├── opening_loc: ∅
+        │   │       │           ├── arguments: ∅
+        │   │       │           ├── closing_loc: ∅
+        │   │       │           ├── block: ∅
+        │   │       │           ├── flags: variable_call
+        │   │       │           └── name: "foo"
+        │   │       └── statements: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (83...87) = "case"
+        │   └── end_keyword_loc: (100...103) = "end"
+        ├── @ CaseNode (location: (105...134))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (110...113))
+        │   │   ├── opening_loc: (110...111) = ":"
+        │   │   ├── value_loc: (111...113) = "hi"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "hi"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (114...122))
+        │   │       ├── keyword_loc: (114...118) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ SymbolNode (location: (119...122))
+        │   │       │       ├── opening_loc: (119...120) = ":"
+        │   │       │       ├── value_loc: (120...122) = "hi"
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       └── unescaped: "hi"
+        │   │       └── statements: ∅
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (123...134))
+        │   │   ├── else_keyword_loc: (123...127) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (128...130))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ SymbolNode (location: (128...130))
+        │   │   │           ├── opening_loc: (128...129) = ":"
+        │   │   │           ├── value_loc: (129...130) = "b"
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           └── unescaped: "b"
+        │   │   └── end_keyword_loc: (131...134) = "end"
+        │   ├── case_keyword_loc: (105...109) = "case"
+        │   └── end_keyword_loc: (131...134) = "end"
+        ├── @ CaseNode (location: (136...172))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (141...145))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (141...145) = "this"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "this"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (147...167))
+        │   │       ├── keyword_loc: (147...151) = "when"
+        │   │       ├── conditions: (length: 2)
+        │   │       │   ├── @ ConstantReadNode (location: (152...158))
+        │   │       │   │   └── name: :FooBar
+        │   │       │   └── @ ConstantReadNode (location: (160...167))
+        │   │       │       └── name: :BazBonk
+        │   │       └── statements: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (136...140) = "case"
+        │   └── end_keyword_loc: (169...172) = "end"
+        ├── @ CaseNode (location: (174...198))
+        │   ├── predicate: ∅
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (179...194))
+        │   │       ├── keyword_loc: (179...183) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ CallNode (location: (184...194))
+        │   │       │       ├── receiver:
+        │   │       │       │   @ CallNode (location: (184...187))
+        │   │       │       │   ├── receiver: ∅
+        │   │       │       │   ├── call_operator_loc: ∅
+        │   │       │       │   ├── message_loc: (184...187) = "foo"
+        │   │       │       │   ├── opening_loc: ∅
+        │   │       │       │   ├── arguments: ∅
+        │   │       │       │   ├── closing_loc: ∅
+        │   │       │       │   ├── block: ∅
+        │   │       │       │   ├── flags: variable_call
+        │   │       │       │   └── name: "foo"
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (188...190) = "=="
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments:
+        │   │       │       │   @ ArgumentsNode (location: (191...194))
+        │   │       │       │   └── arguments: (length: 1)
+        │   │       │       │       └── @ CallNode (location: (191...194))
+        │   │       │       │           ├── receiver: ∅
+        │   │       │       │           ├── call_operator_loc: ∅
+        │   │       │       │           ├── message_loc: (191...194) = "bar"
+        │   │       │       │           ├── opening_loc: ∅
+        │   │       │       │           ├── arguments: ∅
+        │   │       │       │           ├── closing_loc: ∅
+        │   │       │       │           ├── block: ∅
+        │   │       │       │           ├── flags: variable_call
+        │   │       │       │           └── name: "bar"
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: 
+        │   │       │       └── name: "=="
+        │   │       └── statements: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (174...178) = "case"
+        │   └── end_keyword_loc: (195...198) = "end"
+        ├── @ CaseNode (location: (200...230))
+        │   ├── predicate: ∅
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (205...211))
+        │   │       ├── keyword_loc: (205...209) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ CallNode (location: (210...211))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (210...211) = "a"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "a"
+        │   │       └── statements: ∅
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (212...230))
+        │   │   ├── else_keyword_loc: (212...216) = "else"
+        │   │   ├── statements: ∅
+        │   │   └── end_keyword_loc: (227...230) = "end"
+        │   ├── case_keyword_loc: (200...204) = "case"
+        │   └── end_keyword_loc: (227...230) = "end"
+        └── @ CaseNode (location: (232...272))
+            ├── predicate:
+            │   @ CallNode (location: (237...241))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (237...241) = "type"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "type"
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (246...253))
+            │       ├── keyword_loc: (246...250) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ SymbolNode (location: (251...253))
+            │       │       ├── opening_loc: (251...252) = ":"
+            │       │       ├── value_loc: (252...253) = "b"
+            │       │       ├── closing_loc: ∅
+            │       │       └── unescaped: "b"
+            │       └── statements: ∅
+            ├── consequent:
+            │   @ ElseNode (location: (260...272))
+            │   ├── else_keyword_loc: (260...264) = "else"
+            │   ├── statements: ∅
+            │   └── end_keyword_loc: (269...272) = "end"
+            ├── case_keyword_loc: (232...236) = "case"
+            └── end_keyword_loc: (269...272) = "end"
diff --git a/test/yarp/snapshots/classes.txt b/test/yarp/snapshots/classes.txt
index 0679fe957f..387190dbbc 100644
--- a/test/yarp/snapshots/classes.txt
+++ b/test/yarp/snapshots/classes.txt
@@ -1,287 +1,348 @@
-ProgramNode(0...370)(
-  [],
-  StatementsNode(0...370)(
-    [ClassNode(0...17)(
-       [:a],
-       (0...5),
-       ConstantReadNode(6...7)(:A),
-       nil,
-       nil,
-       StatementsNode(8...13)(
-         [LocalVariableWriteNode(8...13)(
-            :a,
-            0,
-            (8...9),
-            IntegerNode(12...13)(),
-            (10...11)
-          )]
-       ),
-       (14...17),
-       :A
-     ),
-     ClassNode(19...39)(
-       [],
-       (19...24),
-       ConstantReadNode(25...26)(:A),
-       nil,
-       nil,
-       BeginNode(28...39)(
-         nil,
-         nil,
-         nil,
-         nil,
-         EnsureNode(28...39)((28...34), nil, (36...39)),
-         (36...39)
-       ),
-       (36...39),
-       :A
-     ),
-     ClassNode(41...75)(
-       [],
-       (41...46),
-       ConstantReadNode(47...48)(:A),
-       nil,
-       nil,
-       BeginNode(50...75)(
-         nil,
-         nil,
-         RescueNode(50...56)((50...56), [], nil, nil, nil, nil),
-         ElseNode(58...70)((58...62), nil, (64...70)),
-         EnsureNode(64...75)((64...70), nil, (72...75)),
-         (72...75)
-       ),
-       (72...75),
-       :A
-     ),
-     ClassNode(77...98)(
-       [:a],
-       (77...82),
-       ConstantReadNode(83...84)(:A),
-       (85...86),
-       ConstantReadNode(87...88)(:B),
-       StatementsNode(89...94)(
-         [LocalVariableWriteNode(89...94)(
-            :a,
-            0,
-            (89...90),
-            IntegerNode(93...94)(),
-            (91...92)
-          )]
-       ),
-       (95...98),
-       :A
-     ),
-     SingletonClassNode(100...120)(
-       [],
-       (100...105),
-       (106...108),
-       CallNode(109...116)(
-         CallNode(113...116)(
-           nil,
-           nil,
-           (113...116),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         nil,
-         (109...112),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       nil,
-       (117...120)
-     ),
-     ClassNode(122...162)(
-       [],
-       (122...127),
-       ConstantReadNode(128...129)(:A),
-       nil,
-       nil,
-       StatementsNode(131...157)(
-         [SingletonClassNode(131...157)(
-            [],
-            (131...136),
-            (137...139),
-            SelfNode(140...144)(),
-            BeginNode(146...157)(
-              nil,
-              nil,
-              nil,
-              nil,
-              EnsureNode(146...157)((146...152), nil, (154...157)),
-              (154...157)
-            ),
-            (154...157)
-          )]
-       ),
-       (159...162),
-       :A
-     ),
-     ClassNode(164...218)(
-       [],
-       (164...169),
-       ConstantReadNode(170...171)(:A),
-       nil,
-       nil,
-       StatementsNode(173...213)(
-         [SingletonClassNode(173...213)(
-            [],
-            (173...178),
-            (179...181),
-            SelfNode(182...186)(),
-            BeginNode(188...213)(
-              nil,
-              nil,
-              RescueNode(188...194)((188...194), [], nil, nil, nil, nil),
-              ElseNode(196...208)((196...200), nil, (202...208)),
-              EnsureNode(202...213)((202...208), nil, (210...213)),
-              (210...213)
-            ),
-            (210...213)
-          )]
-       ),
-       (215...218),
-       :A
-     ),
-     SingletonClassNode(220...240)(
-       [],
-       (220...225),
-       (226...228),
-       CallNode(229...236)(
-         CallNode(229...232)(
-           nil,
-           nil,
-           (229...232),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         (232...233),
-         (233...236),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "bar"
-       ),
-       nil,
-       (237...240)
-     ),
-     SingletonClassNode(242...262)(
-       [],
-       (242...247),
-       (248...250),
-       CallNode(251...258)(
-         CallNode(251...254)(
-           nil,
-           nil,
-           (251...254),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         (254...255),
-         (255...258),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "bar"
-       ),
-       nil,
-       (259...262)
-     ),
-     SingletonClassNode(264...281)(
-       [],
-       (264...269),
-       (270...272),
-       SelfNode(273...277)(),
-       nil,
-       (278...281)
-     ),
-     SingletonClassNode(283...300)(
-       [],
-       (283...288),
-       (289...291),
-       SelfNode(292...296)(),
-       nil,
-       (297...300)
-     ),
-     SingletonClassNode(302...325)(
-       [],
-       (302...307),
-       (308...310),
-       SelfNode(311...315)(),
-       StatementsNode(316...321)(
-         [CallNode(316...321)(
-            IntegerNode(316...317)(),
-            nil,
-            (318...319),
-            nil,
-            ArgumentsNode(320...321)([IntegerNode(320...321)()]),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       ),
-       (322...325)
-     ),
-     SingletonClassNode(327...350)(
-       [],
-       (327...332),
-       (333...335),
-       SelfNode(336...340)(),
-       StatementsNode(341...346)(
-         [CallNode(341...346)(
-            IntegerNode(341...342)(),
-            nil,
-            (343...344),
-            nil,
-            ArgumentsNode(345...346)([IntegerNode(345...346)()]),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       ),
-       (347...350)
-     ),
-     ClassNode(352...370)(
-       [],
-       (352...357),
-       ConstantReadNode(358...359)(:A),
-       (360...361),
-       CallNode(362...366)(
-         ConstantReadNode(362...363)(:B),
-         nil,
-         (363...366),
-         (363...364),
-         ArgumentsNode(364...365)([IntegerNode(364...365)()]),
-         (365...366),
-         nil,
-         0,
-         "[]"
-       ),
-       nil,
-       (367...370),
-       :A
-     )]
-  )
-)
+@ ProgramNode (location: (0...370))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...370))
+    └── body: (length: 14)
+        ├── @ ClassNode (location: (0...17))
+        │   ├── locals: [:a]
+        │   ├── class_keyword_loc: (0...5) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (6...7))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (8...13))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableWriteNode (location: (8...13))
+        │   │           ├── name: :a
+        │   │           ├── depth: 0
+        │   │           ├── name_loc: (8...9) = "a"
+        │   │           ├── value:
+        │   │           │   @ IntegerNode (location: (12...13))
+        │   │           └── operator_loc: (10...11) = "="
+        │   ├── end_keyword_loc: (14...17) = "end"
+        │   └── name: :A
+        ├── @ ClassNode (location: (19...39))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (19...24) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (25...26))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (28...39))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements: ∅
+        │   │   ├── rescue_clause: ∅
+        │   │   ├── else_clause: ∅
+        │   │   ├── ensure_clause:
+        │   │   │   @ EnsureNode (location: (28...39))
+        │   │   │   ├── ensure_keyword_loc: (28...34) = "ensure"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── end_keyword_loc: (36...39) = "end"
+        │   │   └── end_keyword_loc: (36...39) = "end"
+        │   ├── end_keyword_loc: (36...39) = "end"
+        │   └── name: :A
+        ├── @ ClassNode (location: (41...75))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (41...46) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (47...48))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (50...75))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements: ∅
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (50...56))
+        │   │   │   ├── keyword_loc: (50...56) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements: ∅
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause:
+        │   │   │   @ ElseNode (location: (58...70))
+        │   │   │   ├── else_keyword_loc: (58...62) = "else"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── end_keyword_loc: (64...70) = "ensure"
+        │   │   ├── ensure_clause:
+        │   │   │   @ EnsureNode (location: (64...75))
+        │   │   │   ├── ensure_keyword_loc: (64...70) = "ensure"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── end_keyword_loc: (72...75) = "end"
+        │   │   └── end_keyword_loc: (72...75) = "end"
+        │   ├── end_keyword_loc: (72...75) = "end"
+        │   └── name: :A
+        ├── @ ClassNode (location: (77...98))
+        │   ├── locals: [:a]
+        │   ├── class_keyword_loc: (77...82) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (83...84))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: (85...86) = "<"
+        │   ├── superclass:
+        │   │   @ ConstantReadNode (location: (87...88))
+        │   │   └── name: :B
+        │   ├── body:
+        │   │   @ StatementsNode (location: (89...94))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableWriteNode (location: (89...94))
+        │   │           ├── name: :a
+        │   │           ├── depth: 0
+        │   │           ├── name_loc: (89...90) = "a"
+        │   │           ├── value:
+        │   │           │   @ IntegerNode (location: (93...94))
+        │   │           └── operator_loc: (91...92) = "="
+        │   ├── end_keyword_loc: (95...98) = "end"
+        │   └── name: :A
+        ├── @ SingletonClassNode (location: (100...120))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (100...105) = "class"
+        │   ├── operator_loc: (106...108) = "<<"
+        │   ├── expression:
+        │   │   @ CallNode (location: (109...116))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (113...116))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (113...116) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (109...112) = "not"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "!"
+        │   ├── body: ∅
+        │   └── end_keyword_loc: (117...120) = "end"
+        ├── @ ClassNode (location: (122...162))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (122...127) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (128...129))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (131...157))
+        │   │   └── body: (length: 1)
+        │   │       └── @ SingletonClassNode (location: (131...157))
+        │   │           ├── locals: []
+        │   │           ├── class_keyword_loc: (131...136) = "class"
+        │   │           ├── operator_loc: (137...139) = "<<"
+        │   │           ├── expression:
+        │   │           │   @ SelfNode (location: (140...144))
+        │   │           ├── body:
+        │   │           │   @ BeginNode (location: (146...157))
+        │   │           │   ├── begin_keyword_loc: ∅
+        │   │           │   ├── statements: ∅
+        │   │           │   ├── rescue_clause: ∅
+        │   │           │   ├── else_clause: ∅
+        │   │           │   ├── ensure_clause:
+        │   │           │   │   @ EnsureNode (location: (146...157))
+        │   │           │   │   ├── ensure_keyword_loc: (146...152) = "ensure"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── end_keyword_loc: (154...157) = "end"
+        │   │           │   └── end_keyword_loc: (154...157) = "end"
+        │   │           └── end_keyword_loc: (154...157) = "end"
+        │   ├── end_keyword_loc: (159...162) = "end"
+        │   └── name: :A
+        ├── @ ClassNode (location: (164...218))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (164...169) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (170...171))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (173...213))
+        │   │   └── body: (length: 1)
+        │   │       └── @ SingletonClassNode (location: (173...213))
+        │   │           ├── locals: []
+        │   │           ├── class_keyword_loc: (173...178) = "class"
+        │   │           ├── operator_loc: (179...181) = "<<"
+        │   │           ├── expression:
+        │   │           │   @ SelfNode (location: (182...186))
+        │   │           ├── body:
+        │   │           │   @ BeginNode (location: (188...213))
+        │   │           │   ├── begin_keyword_loc: ∅
+        │   │           │   ├── statements: ∅
+        │   │           │   ├── rescue_clause:
+        │   │           │   │   @ RescueNode (location: (188...194))
+        │   │           │   │   ├── keyword_loc: (188...194) = "rescue"
+        │   │           │   │   ├── exceptions: (length: 0)
+        │   │           │   │   ├── operator_loc: ∅
+        │   │           │   │   ├── reference: ∅
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── consequent: ∅
+        │   │           │   ├── else_clause:
+        │   │           │   │   @ ElseNode (location: (196...208))
+        │   │           │   │   ├── else_keyword_loc: (196...200) = "else"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── end_keyword_loc: (202...208) = "ensure"
+        │   │           │   ├── ensure_clause:
+        │   │           │   │   @ EnsureNode (location: (202...213))
+        │   │           │   │   ├── ensure_keyword_loc: (202...208) = "ensure"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── end_keyword_loc: (210...213) = "end"
+        │   │           │   └── end_keyword_loc: (210...213) = "end"
+        │   │           └── end_keyword_loc: (210...213) = "end"
+        │   ├── end_keyword_loc: (215...218) = "end"
+        │   └── name: :A
+        ├── @ SingletonClassNode (location: (220...240))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (220...225) = "class"
+        │   ├── operator_loc: (226...228) = "<<"
+        │   ├── expression:
+        │   │   @ CallNode (location: (229...236))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (229...232))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (229...232) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: (232...233) = "."
+        │   │   ├── message_loc: (233...236) = "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "bar"
+        │   ├── body: ∅
+        │   └── end_keyword_loc: (237...240) = "end"
+        ├── @ SingletonClassNode (location: (242...262))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (242...247) = "class"
+        │   ├── operator_loc: (248...250) = "<<"
+        │   ├── expression:
+        │   │   @ CallNode (location: (251...258))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (251...254))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (251...254) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: (254...255) = "."
+        │   │   ├── message_loc: (255...258) = "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "bar"
+        │   ├── body: ∅
+        │   └── end_keyword_loc: (259...262) = "end"
+        ├── @ SingletonClassNode (location: (264...281))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (264...269) = "class"
+        │   ├── operator_loc: (270...272) = "<<"
+        │   ├── expression:
+        │   │   @ SelfNode (location: (273...277))
+        │   ├── body: ∅
+        │   └── end_keyword_loc: (278...281) = "end"
+        ├── @ SingletonClassNode (location: (283...300))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (283...288) = "class"
+        │   ├── operator_loc: (289...291) = "<<"
+        │   ├── expression:
+        │   │   @ SelfNode (location: (292...296))
+        │   ├── body: ∅
+        │   └── end_keyword_loc: (297...300) = "end"
+        ├── @ SingletonClassNode (location: (302...325))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (302...307) = "class"
+        │   ├── operator_loc: (308...310) = "<<"
+        │   ├── expression:
+        │   │   @ SelfNode (location: (311...315))
+        │   ├── body:
+        │   │   @ StatementsNode (location: (316...321))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (316...321))
+        │   │           ├── receiver:
+        │   │           │   @ IntegerNode (location: (316...317))
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (318...319) = "+"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (320...321))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (320...321))
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "+"
+        │   └── end_keyword_loc: (322...325) = "end"
+        ├── @ SingletonClassNode (location: (327...350))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (327...332) = "class"
+        │   ├── operator_loc: (333...335) = "<<"
+        │   ├── expression:
+        │   │   @ SelfNode (location: (336...340))
+        │   ├── body:
+        │   │   @ StatementsNode (location: (341...346))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (341...346))
+        │   │           ├── receiver:
+        │   │           │   @ IntegerNode (location: (341...342))
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (343...344) = "+"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (345...346))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (345...346))
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "+"
+        │   └── end_keyword_loc: (347...350) = "end"
+        └── @ ClassNode (location: (352...370))
+            ├── locals: []
+            ├── class_keyword_loc: (352...357) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (358...359))
+            │   └── name: :A
+            ├── inheritance_operator_loc: (360...361) = "<"
+            ├── superclass:
+            │   @ CallNode (location: (362...366))
+            │   ├── receiver:
+            │   │   @ ConstantReadNode (location: (362...363))
+            │   │   └── name: :B
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (363...366) = "[1]"
+            │   ├── opening_loc: (363...364) = "["
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (364...365))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ IntegerNode (location: (364...365))
+            │   ├── closing_loc: (365...366) = "]"
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "[]"
+            ├── body: ∅
+            ├── end_keyword_loc: (367...370) = "end"
+            └── name: :A
diff --git a/test/yarp/snapshots/comments.txt b/test/yarp/snapshots/comments.txt
index e24df47bc8..8e4da07ac8 100644
--- a/test/yarp/snapshots/comments.txt
+++ b/test/yarp/snapshots/comments.txt
@@ -1,64 +1,145 @@
-ProgramNode(0...118)(
-  [],
-  StatementsNode(0...118)(
-    [CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-     CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "b"),
-     CallNode(16...17)(nil, nil, (16...17), nil, nil, nil, nil, 2, "c"),
-     CallNode(28...29)(nil, nil, (28...29), nil, nil, nil, nil, 2, "d"),
-     CallNode(31...47)(
-       CallNode(31...32)(nil, nil, (31...32), nil, nil, nil, nil, 2, "e"),
-       (45...46),
-       (46...47),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "f"
-     ),
-     CallNode(49...64)(
-       CallNode(49...50)(nil, nil, (49...50), nil, nil, nil, nil, 2, "g"),
-       (62...63),
-       (63...64),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "h"
-     ),
-     CallNode(66...80)(
-       CallNode(66...67)(nil, nil, (66...67), nil, nil, nil, nil, 2, "i"),
-       (78...79),
-       (79...80),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "j"
-     ),
-     CallNode(82...98)(
-       CallNode(82...83)(nil, nil, (82...83), nil, nil, nil, nil, 2, "k"),
-       (96...97),
-       (97...98),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "l"
-     ),
-     CallNode(100...118)(
-       CallNode(100...101)(nil, nil, (100...101), nil, nil, nil, nil, 2, "m"),
-       (115...117),
-       (117...118),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "n"
-     )]
-  )
-)
+@ ProgramNode (location: (0...118))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...118))
+    └── body: (length: 9)
+        ├── @ CallNode (location: (0...1))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "a"
+        ├── @ CallNode (location: (13...14))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (13...14) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "b"
+        ├── @ CallNode (location: (16...17))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (16...17) = "c"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "c"
+        ├── @ CallNode (location: (28...29))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (28...29) = "d"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "d"
+        ├── @ CallNode (location: (31...47))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (31...32))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (31...32) = "e"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "e"
+        │   ├── call_operator_loc: (45...46) = "."
+        │   ├── message_loc: (46...47) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (49...64))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (49...50))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (49...50) = "g"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "g"
+        │   ├── call_operator_loc: (62...63) = "."
+        │   ├── message_loc: (63...64) = "h"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "h"
+        ├── @ CallNode (location: (66...80))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (66...67))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (66...67) = "i"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "i"
+        │   ├── call_operator_loc: (78...79) = "."
+        │   ├── message_loc: (79...80) = "j"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "j"
+        ├── @ CallNode (location: (82...98))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (82...83))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (82...83) = "k"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "k"
+        │   ├── call_operator_loc: (96...97) = "."
+        │   ├── message_loc: (97...98) = "l"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "l"
+        └── @ CallNode (location: (100...118))
+            ├── receiver:
+            │   @ CallNode (location: (100...101))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (100...101) = "m"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "m"
+            ├── call_operator_loc: (115...117) = "&."
+            ├── message_loc: (117...118) = "n"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "n"
diff --git a/test/yarp/snapshots/constants.txt b/test/yarp/snapshots/constants.txt
index bf4564c46d..e5e28cf573 100644
--- a/test/yarp/snapshots/constants.txt
+++ b/test/yarp/snapshots/constants.txt
@@ -1,1095 +1,1224 @@
-ProgramNode(0...792)(
-  [],
-  StatementsNode(0...792)(
-    [ConstantPathNode(0...4)(
-       ConstantReadNode(0...1)(:A),
-       ConstantReadNode(3...4)(:B),
-       (1...3)
-     ),
-     ConstantPathNode(6...13)(
-       ConstantPathNode(6...10)(
-         ConstantReadNode(6...7)(:A),
-         ConstantReadNode(9...10)(:B),
-         (7...9)
-       ),
-       ConstantReadNode(12...13)(:C),
-       (10...12)
-     ),
-     ConstantPathNode(15...19)(
-       CallNode(15...16)(nil, nil, (15...16), nil, nil, nil, nil, 2, "a"),
-       ConstantReadNode(18...19)(:B),
-       (16...18)
-     ),
-     ConstantPathWriteNode(21...29)(
-       ConstantPathNode(21...25)(
-         ConstantReadNode(21...22)(:A),
-         ConstantReadNode(24...25)(:B),
-         (22...24)
-       ),
-       (26...27),
-       IntegerNode(28...29)()
-     ),
-     ConstantWriteNode(31...36)(
-       :A,
-       (31...32),
-       IntegerNode(35...36)(),
-       (33...34)
-     ),
-     ConstantReadNode(38...41)(:ABC),
-     CallNode(43...48)(
-       nil,
-       nil,
-       (43...46),
-       nil,
-       ArgumentsNode(47...48)([IntegerNode(47...48)()]),
-       nil,
-       nil,
-       0,
-       "Foo"
-     ),
-     CallNode(50...58)(
-       nil,
-       nil,
-       (50...53),
-       nil,
-       ArgumentsNode(54...58)(
-         [SplatNode(54...58)(
-            (54...55),
-            CallNode(55...58)(
-              nil,
-              nil,
-              (55...58),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "Foo"
-     ),
-     CallNode(60...69)(
-       nil,
-       nil,
-       (60...63),
-       nil,
-       ArgumentsNode(64...69)(
-         [KeywordHashNode(64...69)(
-            [AssocSplatNode(64...69)(
-               CallNode(66...69)(
-                 nil,
-                 nil,
-                 (66...69),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "bar"
-               ),
-               (64...66)
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "Foo"
-     ),
-     CallNode(71...79)(
-       nil,
-       nil,
-       (71...74),
-       nil,
-       ArgumentsNode(75...79)(
-         [BlockArgumentNode(75...79)(
-            CallNode(76...79)(
-              nil,
-              nil,
-              (76...79),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            ),
-            (75...76)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "Foo"
-     ),
-     CallNode(81...94)(
-       ConstantReadNode(81...84)(:Foo),
-       (84...86),
-       (86...89),
-       nil,
-       ArgumentsNode(90...94)(
-         [SplatNode(90...94)(
-            (90...91),
-            CallNode(91...94)(
-              nil,
-              nil,
-              (91...94),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "Bar"
-     ),
-     CallNode(96...110)(
-       ConstantReadNode(96...99)(:Foo),
-       (99...101),
-       (101...104),
-       nil,
-       ArgumentsNode(105...110)(
-         [KeywordHashNode(105...110)(
-            [AssocSplatNode(105...110)(
-               CallNode(107...110)(
-                 nil,
-                 nil,
-                 (107...110),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "baz"
-               ),
-               (105...107)
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "Bar"
-     ),
-     CallNode(112...125)(
-       ConstantReadNode(112...115)(:Foo),
-       (115...117),
-       (117...120),
-       nil,
-       ArgumentsNode(121...125)(
-         [BlockArgumentNode(121...125)(
-            CallNode(122...125)(
-              nil,
-              nil,
-              (122...125),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            ),
-            (121...122)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "Bar"
-     ),
-     CallNode(127...135)(
-       ConstantPathNode(127...130)(
-         nil,
-         ConstantReadNode(129...130)(:A),
-         (127...129)
-       ),
-       (130...132),
-       (132...135),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     ConstantPathWriteNode(137...144)(
-       ConstantPathNode(137...140)(
-         nil,
-         ConstantReadNode(139...140)(:A),
-         (137...139)
-       ),
-       (141...142),
-       IntegerNode(143...144)()
-     ),
-     ConstantPathWriteNode(146...156)(
-       ConstantPathNode(146...152)(
-         ConstantPathNode(146...149)(
-           nil,
-           ConstantReadNode(148...149)(:A),
-           (146...148)
-         ),
-         ConstantReadNode(151...152)(:B),
-         (149...151)
-       ),
-       (153...154),
-       IntegerNode(155...156)()
-     ),
-     ConstantPathNode(158...164)(
-       ConstantPathNode(158...161)(
-         nil,
-         ConstantReadNode(160...161)(:A),
-         (158...160)
-       ),
-       ConstantReadNode(163...164)(:B),
-       (161...163)
-     ),
-     ConstantPathNode(166...169)(
-       nil,
-       ConstantReadNode(168...169)(:A),
-       (166...168)
-     ),
-     CallNode(171...179)(
-       ConstantReadNode(171...172)(:A),
-       (172...174),
-       (174...179),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "false"
-     ),
-     CallNode(181...191)(
-       ConstantPathNode(181...185)(
-         ConstantReadNode(181...182)(:A),
-         ConstantReadNode(184...185)(:B),
-         (182...184)
-       ),
-       (185...187),
-       (187...191),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "true"
-     ),
-     CallNode(193...197)(
-       ConstantReadNode(193...194)(:A),
-       (194...196),
-       (196...197),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "&"
-     ),
-     CallNode(199...203)(
-       ConstantReadNode(199...200)(:A),
-       (200...202),
-       (202...203),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "`"
-     ),
-     CallNode(205...209)(
-       ConstantReadNode(205...206)(:A),
-       (206...208),
-       (208...209),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(211...216)(
-       ConstantReadNode(211...212)(:A),
-       (212...214),
-       (214...216),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!="
-     ),
-     CallNode(218...222)(
-       ConstantReadNode(218...219)(:A),
-       (219...221),
-       (221...222),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "^"
-     ),
-     CallNode(224...229)(
-       ConstantReadNode(224...225)(:A),
-       (225...227),
-       (227...229),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "=="
-     ),
-     CallNode(231...237)(
-       ConstantReadNode(231...232)(:A),
-       (232...234),
-       (234...237),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "==="
-     ),
-     CallNode(239...244)(
-       ConstantReadNode(239...240)(:A),
-       (240...242),
-       (242...244),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "=~"
-     ),
-     CallNode(246...250)(
-       ConstantReadNode(246...247)(:A),
-       (247...249),
-       (249...250),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       ">"
-     ),
-     CallNode(252...257)(
-       ConstantReadNode(252...253)(:A),
-       (253...255),
-       (255...257),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       ">="
-     ),
-     CallNode(259...264)(
-       ConstantReadNode(259...260)(:A),
-       (260...262),
-       (262...264),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       ">>"
-     ),
-     CallNode(266...271)(
-       ConstantReadNode(266...267)(:A),
-       (267...269),
-       (269...271),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "<<"
-     ),
-     ConstantPathNode(273...281)(
-       ConstantReadNode(273...274)(:A),
-       ConstantReadNode(280...281)(:C),
-       (274...276)
-     ),
-     CallNode(283...291)(
-       ConstantReadNode(283...284)(:A),
-       (284...286),
-       (286...291),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "alias"
-     ),
-     CallNode(293...299)(
-       ConstantReadNode(293...294)(:A),
-       (294...296),
-       (296...299),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "and"
-     ),
-     CallNode(301...309)(
-       ConstantReadNode(301...302)(:A),
-       (302...304),
-       (304...309),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "begin"
-     ),
-     ConstantPathNode(311...319)(
-       ConstantReadNode(311...312)(:A),
-       ConstantReadNode(314...319)(:BEGIN),
-       (312...314)
-     ),
-     CallNode(321...329)(
-       ConstantReadNode(321...322)(:A),
-       (322...324),
-       (324...329),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "break"
-     ),
-     CallNode(331...339)(
-       ConstantReadNode(331...332)(:A),
-       (332...334),
-       (334...339),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "class"
-     ),
-     CallNode(341...347)(
-       ConstantReadNode(341...342)(:A),
-       (342...344),
-       (344...347),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "def"
-     ),
-     CallNode(349...359)(
-       ConstantReadNode(349...350)(:A),
-       (350...352),
-       (352...359),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "defined"
-     ),
-     CallNode(361...366)(
-       ConstantReadNode(361...362)(:A),
-       (362...364),
-       (364...366),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "do"
-     ),
-     CallNode(368...375)(
-       ConstantReadNode(368...369)(:A),
-       (369...371),
-       (371...375),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "else"
-     ),
-     CallNode(377...385)(
-       ConstantReadNode(377...378)(:A),
-       (378...380),
-       (380...385),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "elsif"
-     ),
-     CallNode(387...393)(
-       ConstantReadNode(387...388)(:A),
-       (388...390),
-       (390...393),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "end"
-     ),
-     ConstantPathNode(395...401)(
-       ConstantReadNode(395...396)(:A),
-       ConstantReadNode(398...401)(:END),
-       (396...398)
-     ),
-     CallNode(403...412)(
-       ConstantReadNode(403...404)(:A),
-       (404...406),
-       (406...412),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "ensure"
-     ),
-     CallNode(414...422)(
-       ConstantReadNode(414...415)(:A),
-       (415...417),
-       (417...422),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "false"
-     ),
-     CallNode(424...430)(
-       ConstantReadNode(424...425)(:A),
-       (425...427),
-       (427...430),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "for"
-     ),
-     CallNode(432...437)(
-       ConstantReadNode(432...433)(:A),
-       (433...435),
-       (435...437),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "if"
-     ),
-     CallNode(439...444)(
-       ConstantReadNode(439...440)(:A),
-       (440...442),
-       (442...444),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "in"
-     ),
-     CallNode(446...453)(
-       ConstantReadNode(446...447)(:A),
-       (447...449),
-       (449...453),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "next"
-     ),
-     CallNode(455...461)(
-       ConstantReadNode(455...456)(:A),
-       (456...458),
-       (458...461),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "nil"
-     ),
-     CallNode(463...469)(
-       ConstantReadNode(463...464)(:A),
-       (464...466),
-       (466...469),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "not"
-     ),
-     CallNode(471...476)(
-       ConstantReadNode(471...472)(:A),
-       (472...474),
-       (474...476),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "or"
-     ),
-     CallNode(478...485)(
-       ConstantReadNode(478...479)(:A),
-       (479...481),
-       (481...485),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "redo"
-     ),
-     CallNode(487...496)(
-       ConstantReadNode(487...488)(:A),
-       (488...490),
-       (490...496),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "rescue"
-     ),
-     CallNode(498...506)(
-       ConstantReadNode(498...499)(:A),
-       (499...501),
-       (501...506),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "retry"
-     ),
-     CallNode(508...517)(
-       ConstantReadNode(508...509)(:A),
-       (509...511),
-       (511...517),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "return"
-     ),
-     CallNode(519...526)(
-       ConstantReadNode(519...520)(:A),
-       (520...522),
-       (522...526),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "self"
-     ),
-     CallNode(528...536)(
-       ConstantReadNode(528...529)(:A),
-       (529...531),
-       (531...536),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "super"
-     ),
-     CallNode(538...545)(
-       ConstantReadNode(538...539)(:A),
-       (539...541),
-       (541...545),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "then"
-     ),
-     CallNode(547...554)(
-       ConstantReadNode(547...548)(:A),
-       (548...550),
-       (550...554),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "true"
-     ),
-     CallNode(556...564)(
-       ConstantReadNode(556...557)(:A),
-       (557...559),
-       (559...564),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "undef"
-     ),
-     CallNode(566...575)(
-       ConstantReadNode(566...567)(:A),
-       (567...569),
-       (569...575),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "unless"
-     ),
-     CallNode(577...585)(
-       ConstantReadNode(577...578)(:A),
-       (578...580),
-       (580...585),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "until"
-     ),
-     CallNode(587...594)(
-       ConstantReadNode(587...588)(:A),
-       (588...590),
-       (590...594),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "when"
-     ),
-     CallNode(596...604)(
-       ConstantReadNode(596...597)(:A),
-       (597...599),
-       (599...604),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "while"
-     ),
-     CallNode(606...614)(
-       ConstantReadNode(606...607)(:A),
-       (607...609),
-       (609...614),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "yield"
-     ),
-     CallNode(616...631)(
-       ConstantReadNode(616...617)(:A),
-       (617...619),
-       (619...631),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "__ENCODING__"
-     ),
-     CallNode(633...644)(
-       ConstantReadNode(633...634)(:A),
-       (634...636),
-       (636...644),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "__FILE__"
-     ),
-     CallNode(646...657)(
-       ConstantReadNode(646...647)(:A),
-       (647...649),
-       (649...657),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "__LINE__"
-     ),
-     CallNode(659...663)(
-       ConstantReadNode(659...660)(:A),
-       (660...662),
-       (662...663),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "<"
-     ),
-     CallNode(665...671)(
-       ConstantReadNode(665...666)(:A),
-       (666...668),
-       (668...671),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "<=>"
-     ),
-     CallNode(673...678)(
-       ConstantReadNode(673...674)(:A),
-       (674...676),
-       (676...678),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "<<"
-     ),
-     CallNode(680...684)(
-       ConstantReadNode(680...681)(:A),
-       (681...683),
-       (683...684),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "-"
-     ),
-     CallNode(686...690)(
-       ConstantReadNode(686...687)(:A),
-       (687...689),
-       (689...690),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "%"
-     ),
-     CallNode(692...697)(
-       ConstantReadNode(692...693)(:A),
-       (693...695),
-       (695...696),
-       nil,
-       ArgumentsNode(696...697)(
-         [CallNode(696...697)(
-            nil,
-            nil,
-            (696...697),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "i"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "%"
-     ),
-     CallNode(699...704)(
-       ConstantReadNode(699...700)(:A),
-       (700...702),
-       (702...703),
-       nil,
-       ArgumentsNode(703...704)(
-         [CallNode(703...704)(
-            nil,
-            nil,
-            (703...704),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "w"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "%"
-     ),
-     CallNode(706...711)(
-       ConstantReadNode(706...707)(:A),
-       (707...709),
-       (709...710),
-       nil,
-       ArgumentsNode(710...711)(
-         [CallNode(710...711)(
-            nil,
-            nil,
-            (710...711),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "x"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "%"
-     ),
-     CallNode(713...718)(
-       ConstantReadNode(713...714)(:A),
-       (714...716),
-       (716...717),
-       nil,
-       ArgumentsNode(717...718)([ConstantReadNode(717...718)(:I)]),
-       nil,
-       nil,
-       0,
-       "%"
-     ),
-     CallNode(720...725)(
-       ConstantReadNode(720...721)(:A),
-       (721...723),
-       (723...724),
-       nil,
-       ArgumentsNode(724...725)([ConstantReadNode(724...725)(:W)]),
-       nil,
-       nil,
-       0,
-       "%"
-     ),
-     CallNode(727...731)(
-       ConstantReadNode(727...728)(:A),
-       (728...730),
-       (730...731),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "|"
-     ),
-     CallNode(733...737)(
-       ConstantReadNode(733...734)(:A),
-       (734...736),
-       (736...737),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     CallNode(739...743)(
-       ConstantReadNode(739...740)(:A),
-       (740...742),
-       (742...743),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "/"
-     ),
-     CallNode(745...749)(
-       ConstantReadNode(745...746)(:A),
-       (746...748),
-       (748...749),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "*"
-     ),
-     CallNode(751...756)(
-       ConstantReadNode(751...752)(:A),
-       (752...754),
-       (754...756),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "**"
-     ),
-     CallNode(758...762)(
-       ConstantReadNode(758...759)(:A),
-       (759...761),
-       (761...762),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "~"
-     ),
-     ConstantPathNode(764...772)(
-       CallNode(764...768)(
-         ConstantReadNode(764...765)(:A),
-         (765...767),
-         (767...768),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "_"
-       ),
-       ConstantReadNode(771...772)(:C),
-       (768...770)
-     ),
-     RangeNode(774...792)(
-       CallNode(774...778)(
-         ConstantReadNode(774...775)(:A),
-         (775...777),
-         (777...778),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "_"
-       ),
-       CallNode(782...792)(
-         ConstantReadNode(782...783)(:A),
-         (783...785),
-         (785...792),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "__END__"
-       ),
-       (778...780),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...792))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...792))
+    └── body: (length: 90)
+        ├── @ ConstantPathNode (location: (0...4))
+        │   ├── parent:
+        │   │   @ ConstantReadNode (location: (0...1))
+        │   │   └── name: :A
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (3...4))
+        │   │   └── name: :B
+        │   └── delimiter_loc: (1...3) = "::"
+        ├── @ ConstantPathNode (location: (6...13))
+        │   ├── parent:
+        │   │   @ ConstantPathNode (location: (6...10))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (6...7))
+        │   │   │   └── name: :A
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (9...10))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (7...9) = "::"
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (12...13))
+        │   │   └── name: :C
+        │   └── delimiter_loc: (10...12) = "::"
+        ├── @ ConstantPathNode (location: (15...19))
+        │   ├── parent:
+        │   │   @ CallNode (location: (15...16))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (15...16) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (18...19))
+        │   │   └── name: :B
+        │   └── delimiter_loc: (16...18) = "::"
+        ├── @ ConstantPathWriteNode (location: (21...29))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (21...25))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (21...22))
+        │   │   │   └── name: :A
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (24...25))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (22...24) = "::"
+        │   ├── operator_loc: (26...27) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (28...29))
+        ├── @ ConstantWriteNode (location: (31...36))
+        │   ├── name: :A
+        │   ├── name_loc: (31...32) = "A"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (35...36))
+        │   └── operator_loc: (33...34) = "="
+        ├── @ ConstantReadNode (location: (38...41))
+        │   └── name: :ABC
+        ├── @ CallNode (location: (43...48))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (43...46) = "Foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (47...48))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (47...48))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Foo"
+        ├── @ CallNode (location: (50...58))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (50...53) = "Foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (54...58))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SplatNode (location: (54...58))
+        │   │           ├── operator_loc: (54...55) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (55...58))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (55...58) = "bar"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Foo"
+        ├── @ CallNode (location: (60...69))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (60...63) = "Foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (64...69))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (64...69))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocSplatNode (location: (64...69))
+        │   │                   ├── value:
+        │   │                   │   @ CallNode (location: (66...69))
+        │   │                   │   ├── receiver: ∅
+        │   │                   │   ├── call_operator_loc: ∅
+        │   │                   │   ├── message_loc: (66...69) = "bar"
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── arguments: ∅
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   ├── block: ∅
+        │   │                   │   ├── flags: variable_call
+        │   │                   │   └── name: "bar"
+        │   │                   └── operator_loc: (64...66) = "**"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Foo"
+        ├── @ CallNode (location: (71...79))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (71...74) = "Foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (75...79))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ BlockArgumentNode (location: (75...79))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (76...79))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (76...79) = "bar"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "bar"
+        │   │           └── operator_loc: (75...76) = "&"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Foo"
+        ├── @ CallNode (location: (81...94))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (81...84))
+        │   │   └── name: :Foo
+        │   ├── call_operator_loc: (84...86) = "::"
+        │   ├── message_loc: (86...89) = "Bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (90...94))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SplatNode (location: (90...94))
+        │   │           ├── operator_loc: (90...91) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (91...94))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (91...94) = "baz"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "baz"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Bar"
+        ├── @ CallNode (location: (96...110))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (96...99))
+        │   │   └── name: :Foo
+        │   ├── call_operator_loc: (99...101) = "::"
+        │   ├── message_loc: (101...104) = "Bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (105...110))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (105...110))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocSplatNode (location: (105...110))
+        │   │                   ├── value:
+        │   │                   │   @ CallNode (location: (107...110))
+        │   │                   │   ├── receiver: ∅
+        │   │                   │   ├── call_operator_loc: ∅
+        │   │                   │   ├── message_loc: (107...110) = "baz"
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── arguments: ∅
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   ├── block: ∅
+        │   │                   │   ├── flags: variable_call
+        │   │                   │   └── name: "baz"
+        │   │                   └── operator_loc: (105...107) = "**"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Bar"
+        ├── @ CallNode (location: (112...125))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (112...115))
+        │   │   └── name: :Foo
+        │   ├── call_operator_loc: (115...117) = "::"
+        │   ├── message_loc: (117...120) = "Bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (121...125))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ BlockArgumentNode (location: (121...125))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (122...125))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (122...125) = "baz"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "baz"
+        │   │           └── operator_loc: (121...122) = "&"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Bar"
+        ├── @ CallNode (location: (127...135))
+        │   ├── receiver:
+        │   │   @ ConstantPathNode (location: (127...130))
+        │   │   ├── parent: ∅
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (129...130))
+        │   │   │   └── name: :A
+        │   │   └── delimiter_loc: (127...129) = "::"
+        │   ├── call_operator_loc: (130...132) = "::"
+        │   ├── message_loc: (132...135) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ ConstantPathWriteNode (location: (137...144))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (137...140))
+        │   │   ├── parent: ∅
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (139...140))
+        │   │   │   └── name: :A
+        │   │   └── delimiter_loc: (137...139) = "::"
+        │   ├── operator_loc: (141...142) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (143...144))
+        ├── @ ConstantPathWriteNode (location: (146...156))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (146...152))
+        │   │   ├── parent:
+        │   │   │   @ ConstantPathNode (location: (146...149))
+        │   │   │   ├── parent: ∅
+        │   │   │   ├── child:
+        │   │   │   │   @ ConstantReadNode (location: (148...149))
+        │   │   │   │   └── name: :A
+        │   │   │   └── delimiter_loc: (146...148) = "::"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (151...152))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (149...151) = "::"
+        │   ├── operator_loc: (153...154) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (155...156))
+        ├── @ ConstantPathNode (location: (158...164))
+        │   ├── parent:
+        │   │   @ ConstantPathNode (location: (158...161))
+        │   │   ├── parent: ∅
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (160...161))
+        │   │   │   └── name: :A
+        │   │   └── delimiter_loc: (158...160) = "::"
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (163...164))
+        │   │   └── name: :B
+        │   └── delimiter_loc: (161...163) = "::"
+        ├── @ ConstantPathNode (location: (166...169))
+        │   ├── parent: ∅
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (168...169))
+        │   │   └── name: :A
+        │   └── delimiter_loc: (166...168) = "::"
+        ├── @ CallNode (location: (171...179))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (171...172))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (172...174) = "::"
+        │   ├── message_loc: (174...179) = "false"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "false"
+        ├── @ CallNode (location: (181...191))
+        │   ├── receiver:
+        │   │   @ ConstantPathNode (location: (181...185))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (181...182))
+        │   │   │   └── name: :A
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (184...185))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (182...184) = "::"
+        │   ├── call_operator_loc: (185...187) = "::"
+        │   ├── message_loc: (187...191) = "true"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "true"
+        ├── @ CallNode (location: (193...197))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (193...194))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (194...196) = "::"
+        │   ├── message_loc: (196...197) = "&"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "&"
+        ├── @ CallNode (location: (199...203))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (199...200))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (200...202) = "::"
+        │   ├── message_loc: (202...203) = "`"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "`"
+        ├── @ CallNode (location: (205...209))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (205...206))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (206...208) = "::"
+        │   ├── message_loc: (208...209) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (211...216))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (211...212))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (212...214) = "::"
+        │   ├── message_loc: (214...216) = "!="
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!="
+        ├── @ CallNode (location: (218...222))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (218...219))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (219...221) = "::"
+        │   ├── message_loc: (221...222) = "^"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "^"
+        ├── @ CallNode (location: (224...229))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (224...225))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (225...227) = "::"
+        │   ├── message_loc: (227...229) = "=="
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=="
+        ├── @ CallNode (location: (231...237))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (231...232))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (232...234) = "::"
+        │   ├── message_loc: (234...237) = "==="
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "==="
+        ├── @ CallNode (location: (239...244))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (239...240))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (240...242) = "::"
+        │   ├── message_loc: (242...244) = "=~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=~"
+        ├── @ CallNode (location: (246...250))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (246...247))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (247...249) = "::"
+        │   ├── message_loc: (249...250) = ">"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: ">"
+        ├── @ CallNode (location: (252...257))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (252...253))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (253...255) = "::"
+        │   ├── message_loc: (255...257) = ">="
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: ">="
+        ├── @ CallNode (location: (259...264))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (259...260))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (260...262) = "::"
+        │   ├── message_loc: (262...264) = ">>"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: ">>"
+        ├── @ CallNode (location: (266...271))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (266...267))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (267...269) = "::"
+        │   ├── message_loc: (269...271) = "<<"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<<"
+        ├── @ ConstantPathNode (location: (273...281))
+        │   ├── parent:
+        │   │   @ ConstantReadNode (location: (273...274))
+        │   │   └── name: :A
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (280...281))
+        │   │   └── name: :C
+        │   └── delimiter_loc: (274...276) = "::"
+        ├── @ CallNode (location: (283...291))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (283...284))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (284...286) = "::"
+        │   ├── message_loc: (286...291) = "alias"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "alias"
+        ├── @ CallNode (location: (293...299))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (293...294))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (294...296) = "::"
+        │   ├── message_loc: (296...299) = "and"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "and"
+        ├── @ CallNode (location: (301...309))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (301...302))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (302...304) = "::"
+        │   ├── message_loc: (304...309) = "begin"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "begin"
+        ├── @ ConstantPathNode (location: (311...319))
+        │   ├── parent:
+        │   │   @ ConstantReadNode (location: (311...312))
+        │   │   └── name: :A
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (314...319))
+        │   │   └── name: :BEGIN
+        │   └── delimiter_loc: (312...314) = "::"
+        ├── @ CallNode (location: (321...329))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (321...322))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (322...324) = "::"
+        │   ├── message_loc: (324...329) = "break"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "break"
+        ├── @ CallNode (location: (331...339))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (331...332))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (332...334) = "::"
+        │   ├── message_loc: (334...339) = "class"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "class"
+        ├── @ CallNode (location: (341...347))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (341...342))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (342...344) = "::"
+        │   ├── message_loc: (344...347) = "def"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "def"
+        ├── @ CallNode (location: (349...359))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (349...350))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (350...352) = "::"
+        │   ├── message_loc: (352...359) = "defined"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "defined"
+        ├── @ CallNode (location: (361...366))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (361...362))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (362...364) = "::"
+        │   ├── message_loc: (364...366) = "do"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "do"
+        ├── @ CallNode (location: (368...375))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (368...369))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (369...371) = "::"
+        │   ├── message_loc: (371...375) = "else"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "else"
+        ├── @ CallNode (location: (377...385))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (377...378))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (378...380) = "::"
+        │   ├── message_loc: (380...385) = "elsif"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "elsif"
+        ├── @ CallNode (location: (387...393))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (387...388))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (388...390) = "::"
+        │   ├── message_loc: (390...393) = "end"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "end"
+        ├── @ ConstantPathNode (location: (395...401))
+        │   ├── parent:
+        │   │   @ ConstantReadNode (location: (395...396))
+        │   │   └── name: :A
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (398...401))
+        │   │   └── name: :END
+        │   └── delimiter_loc: (396...398) = "::"
+        ├── @ CallNode (location: (403...412))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (403...404))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (404...406) = "::"
+        │   ├── message_loc: (406...412) = "ensure"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "ensure"
+        ├── @ CallNode (location: (414...422))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (414...415))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (415...417) = "::"
+        │   ├── message_loc: (417...422) = "false"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "false"
+        ├── @ CallNode (location: (424...430))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (424...425))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (425...427) = "::"
+        │   ├── message_loc: (427...430) = "for"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "for"
+        ├── @ CallNode (location: (432...437))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (432...433))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (433...435) = "::"
+        │   ├── message_loc: (435...437) = "if"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "if"
+        ├── @ CallNode (location: (439...444))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (439...440))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (440...442) = "::"
+        │   ├── message_loc: (442...444) = "in"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "in"
+        ├── @ CallNode (location: (446...453))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (446...447))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (447...449) = "::"
+        │   ├── message_loc: (449...453) = "next"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "next"
+        ├── @ CallNode (location: (455...461))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (455...456))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (456...458) = "::"
+        │   ├── message_loc: (458...461) = "nil"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "nil"
+        ├── @ CallNode (location: (463...469))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (463...464))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (464...466) = "::"
+        │   ├── message_loc: (466...469) = "not"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "not"
+        ├── @ CallNode (location: (471...476))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (471...472))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (472...474) = "::"
+        │   ├── message_loc: (474...476) = "or"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "or"
+        ├── @ CallNode (location: (478...485))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (478...479))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (479...481) = "::"
+        │   ├── message_loc: (481...485) = "redo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "redo"
+        ├── @ CallNode (location: (487...496))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (487...488))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (488...490) = "::"
+        │   ├── message_loc: (490...496) = "rescue"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "rescue"
+        ├── @ CallNode (location: (498...506))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (498...499))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (499...501) = "::"
+        │   ├── message_loc: (501...506) = "retry"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "retry"
+        ├── @ CallNode (location: (508...517))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (508...509))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (509...511) = "::"
+        │   ├── message_loc: (511...517) = "return"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "return"
+        ├── @ CallNode (location: (519...526))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (519...520))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (520...522) = "::"
+        │   ├── message_loc: (522...526) = "self"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "self"
+        ├── @ CallNode (location: (528...536))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (528...529))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (529...531) = "::"
+        │   ├── message_loc: (531...536) = "super"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "super"
+        ├── @ CallNode (location: (538...545))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (538...539))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (539...541) = "::"
+        │   ├── message_loc: (541...545) = "then"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "then"
+        ├── @ CallNode (location: (547...554))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (547...548))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (548...550) = "::"
+        │   ├── message_loc: (550...554) = "true"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "true"
+        ├── @ CallNode (location: (556...564))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (556...557))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (557...559) = "::"
+        │   ├── message_loc: (559...564) = "undef"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "undef"
+        ├── @ CallNode (location: (566...575))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (566...567))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (567...569) = "::"
+        │   ├── message_loc: (569...575) = "unless"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "unless"
+        ├── @ CallNode (location: (577...585))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (577...578))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (578...580) = "::"
+        │   ├── message_loc: (580...585) = "until"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "until"
+        ├── @ CallNode (location: (587...594))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (587...588))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (588...590) = "::"
+        │   ├── message_loc: (590...594) = "when"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "when"
+        ├── @ CallNode (location: (596...604))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (596...597))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (597...599) = "::"
+        │   ├── message_loc: (599...604) = "while"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "while"
+        ├── @ CallNode (location: (606...614))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (606...607))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (607...609) = "::"
+        │   ├── message_loc: (609...614) = "yield"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "yield"
+        ├── @ CallNode (location: (616...631))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (616...617))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (617...619) = "::"
+        │   ├── message_loc: (619...631) = "__ENCODING__"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "__ENCODING__"
+        ├── @ CallNode (location: (633...644))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (633...634))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (634...636) = "::"
+        │   ├── message_loc: (636...644) = "__FILE__"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "__FILE__"
+        ├── @ CallNode (location: (646...657))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (646...647))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (647...649) = "::"
+        │   ├── message_loc: (649...657) = "__LINE__"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "__LINE__"
+        ├── @ CallNode (location: (659...663))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (659...660))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (660...662) = "::"
+        │   ├── message_loc: (662...663) = "<"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<"
+        ├── @ CallNode (location: (665...671))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (665...666))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (666...668) = "::"
+        │   ├── message_loc: (668...671) = "<=>"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<=>"
+        ├── @ CallNode (location: (673...678))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (673...674))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (674...676) = "::"
+        │   ├── message_loc: (676...678) = "<<"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<<"
+        ├── @ CallNode (location: (680...684))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (680...681))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (681...683) = "::"
+        │   ├── message_loc: (683...684) = "-"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "-"
+        ├── @ CallNode (location: (686...690))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (686...687))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (687...689) = "::"
+        │   ├── message_loc: (689...690) = "%"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "%"
+        ├── @ CallNode (location: (692...697))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (692...693))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (693...695) = "::"
+        │   ├── message_loc: (695...696) = "%"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (696...697))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (696...697))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (696...697) = "i"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "i"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "%"
+        ├── @ CallNode (location: (699...704))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (699...700))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (700...702) = "::"
+        │   ├── message_loc: (702...703) = "%"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (703...704))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (703...704))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (703...704) = "w"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "w"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "%"
+        ├── @ CallNode (location: (706...711))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (706...707))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (707...709) = "::"
+        │   ├── message_loc: (709...710) = "%"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (710...711))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (710...711))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (710...711) = "x"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "x"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "%"
+        ├── @ CallNode (location: (713...718))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (713...714))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (714...716) = "::"
+        │   ├── message_loc: (716...717) = "%"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (717...718))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ConstantReadNode (location: (717...718))
+        │   │           └── name: :I
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "%"
+        ├── @ CallNode (location: (720...725))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (720...721))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (721...723) = "::"
+        │   ├── message_loc: (723...724) = "%"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (724...725))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ConstantReadNode (location: (724...725))
+        │   │           └── name: :W
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "%"
+        ├── @ CallNode (location: (727...731))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (727...728))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (728...730) = "::"
+        │   ├── message_loc: (730...731) = "|"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "|"
+        ├── @ CallNode (location: (733...737))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (733...734))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (734...736) = "::"
+        │   ├── message_loc: (736...737) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        ├── @ CallNode (location: (739...743))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (739...740))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (740...742) = "::"
+        │   ├── message_loc: (742...743) = "/"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "/"
+        ├── @ CallNode (location: (745...749))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (745...746))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (746...748) = "::"
+        │   ├── message_loc: (748...749) = "*"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "*"
+        ├── @ CallNode (location: (751...756))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (751...752))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (752...754) = "::"
+        │   ├── message_loc: (754...756) = "**"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "**"
+        ├── @ CallNode (location: (758...762))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (758...759))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (759...761) = "::"
+        │   ├── message_loc: (761...762) = "~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "~"
+        ├── @ ConstantPathNode (location: (764...772))
+        │   ├── parent:
+        │   │   @ CallNode (location: (764...768))
+        │   │   ├── receiver:
+        │   │   │   @ ConstantReadNode (location: (764...765))
+        │   │   │   └── name: :A
+        │   │   ├── call_operator_loc: (765...767) = "::"
+        │   │   ├── message_loc: (767...768) = "_"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "_"
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (771...772))
+        │   │   └── name: :C
+        │   └── delimiter_loc: (768...770) = "::"
+        └── @ RangeNode (location: (774...792))
+            ├── left:
+            │   @ CallNode (location: (774...778))
+            │   ├── receiver:
+            │   │   @ ConstantReadNode (location: (774...775))
+            │   │   └── name: :A
+            │   ├── call_operator_loc: (775...777) = "::"
+            │   ├── message_loc: (777...778) = "_"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "_"
+            ├── right:
+            │   @ CallNode (location: (782...792))
+            │   ├── receiver:
+            │   │   @ ConstantReadNode (location: (782...783))
+            │   │   └── name: :A
+            │   ├── call_operator_loc: (783...785) = "::"
+            │   ├── message_loc: (785...792) = "__END__"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "__END__"
+            ├── operator_loc: (778...780) = ".."
+            └── flags: 
diff --git a/test/yarp/snapshots/dash_heredocs.txt b/test/yarp/snapshots/dash_heredocs.txt
index e2eea3c2a5..3016a3ae35 100644
--- a/test/yarp/snapshots/dash_heredocs.txt
+++ b/test/yarp/snapshots/dash_heredocs.txt
@@ -1,176 +1,263 @@
-ProgramNode(0...278)(
-  [],
-  StatementsNode(0...278)(
-    [InterpolatedStringNode(0...6)(
-       (0...6),
-       [StringNode(7...11)(nil, (7...11), nil, "  a\n")],
-       (11...15)
-     ),
-     CallNode(16...36)(
-       InterpolatedStringNode(16...24)(
-         (16...24),
-         [StringNode(37...41)(nil, (37...41), nil, "  a\n")],
-         (41...47)
-       ),
-       nil,
-       (25...26),
-       nil,
-       ArgumentsNode(27...36)(
-         [InterpolatedStringNode(27...36)(
-            (27...36),
-            [StringNode(47...51)(nil, (47...51), nil, "  b\n")],
-            (51...58)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     InterpolatedXStringNode(59...67)(
-       (59...67),
-       [StringNode(68...72)(nil, (68...72), nil, "  a\n"),
-        EmbeddedStatementsNode(72...76)(
-          (72...74),
-          StatementsNode(74...75)(
-            [CallNode(74...75)(
-               nil,
-               nil,
-               (74...75),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "b"
-             )]
-          ),
-          (75...76)
-        ),
-        StringNode(76...77)(nil, (76...77), nil, "\n")],
-       (77...81)
-     ),
-     InterpolatedStringNode(82...88)(
-       (82...88),
-       [StringNode(98...102)(nil, (98...102), nil, "  a\n")],
-       (102...106)
-     ),
-     InterpolatedStringNode(107...113)(
-       (107...113),
-       [StringNode(114...122)(nil, (114...122), nil, "  a\n" + "  b\n")],
-       (122...128)
-     ),
-     InterpolatedStringNode(129...137)(
-       (129...137),
-       [StringNode(138...142)(nil, (138...142), nil, "  a\n"),
-        EmbeddedStatementsNode(142...146)(
-          (142...144),
-          StatementsNode(144...145)(
-            [CallNode(144...145)(
-               nil,
-               nil,
-               (144...145),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "b"
-             )]
-          ),
-          (145...146)
-        ),
-        StringNode(146...147)(nil, (146...147), nil, "\n")],
-       (147...151)
-     ),
-     InterpolatedStringNode(152...158)(
-       (152...158),
-       [StringNode(159...163)(nil, (159...163), nil, "  a\n"),
-        EmbeddedStatementsNode(163...167)(
-          (163...165),
-          StatementsNode(165...166)(
-            [CallNode(165...166)(
-               nil,
-               nil,
-               (165...166),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "b"
-             )]
-          ),
-          (166...167)
-        ),
-        StringNode(167...168)(nil, (167...168), nil, "\n")],
-       (168...172)
-     ),
-     StringNode(173...179)((173...175), (175...178), (178...179), "abc"),
-     InterpolatedStringNode(181...187)(
-       (181...187),
-       [StringNode(188...196)(nil, (188...196), nil, "  a\n" + "  b\n")],
-       (196...200)
-     ),
-     InterpolatedStringNode(201...206)((201...206), [], (207...208)),
-     InterpolatedStringNode(209...217)(
-       (209...217),
-       [StringNode(218...227)(nil, (218...227), nil, "  a \#{1}\n")],
-       (227...231)
-     ),
-     CallNode(232...243)(
-       InterpolatedStringNode(232...236)(
-         (232...236),
-         [StringNode(244...248)(nil, (244...248), nil, "  a\n")],
-         (248...250)
-       ),
-       nil,
-       (237...238),
-       nil,
-       ArgumentsNode(239...243)(
-         [InterpolatedStringNode(239...243)(
-            (239...243),
-            [StringNode(250...256)(nil, (250...256), nil, "  b\n" + "  "),
-             EmbeddedStatementsNode(256...263)(
-               (256...258),
-               StatementsNode(258...259)([IntegerNode(258...259)()]),
-               (262...263)
-             ),
-             StringNode(263...264)(nil, (263...264), nil, "\n")],
-            (264...266)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     CallNode(267...278)(
-       InterpolatedStringNode(267...271)(
-         (267...271),
-         [StringNode(279...283)(nil, (279...283), nil, "  a\n")],
-         (283...285)
-       ),
-       nil,
-       (272...273),
-       nil,
-       ArgumentsNode(274...278)(
-         [InterpolatedStringNode(274...278)(
-            (274...278),
-            [StringNode(285...291)(nil, (285...291), nil, "  b\n" + "  "),
-             EmbeddedStatementsNode(291...298)(
-               (291...293),
-               StatementsNode(296...297)([IntegerNode(296...297)()]),
-               (297...298)
-             ),
-             StringNode(298...299)(nil, (298...299), nil, "\n")],
-            (299...301)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "+"
-     )]
-  )
-)
+@ ProgramNode (location: (0...278))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...278))
+    └── body: (length: 13)
+        ├── @ InterpolatedStringNode (location: (0...6))
+        │   ├── opening_loc: (0...6) = "<<-EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (7...11))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (7...11) = "  a\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "  a\n"
+        │   └── closing_loc: (11...15) = "EOF\n"
+        ├── @ CallNode (location: (16...36))
+        │   ├── receiver:
+        │   │   @ InterpolatedStringNode (location: (16...24))
+        │   │   ├── opening_loc: (16...24) = "<<-FIRST"
+        │   │   ├── parts: (length: 1)
+        │   │   │   └── @ StringNode (location: (37...41))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (37...41) = "  a\n"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "  a\n"
+        │   │   └── closing_loc: (41...47) = "FIRST\n"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (25...26) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (27...36))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (27...36))
+        │   │           ├── opening_loc: (27...36) = "<<-SECOND"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (47...51))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (47...51) = "  b\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "  b\n"
+        │   │           └── closing_loc: (51...58) = "SECOND\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        ├── @ InterpolatedXStringNode (location: (59...67))
+        │   ├── opening_loc: (59...67) = "<<-`EOF`"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (68...72))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (68...72) = "  a\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "  a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (72...76))
+        │   │   │   ├── opening_loc: (72...74) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (74...75))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (74...75))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (74...75) = "b"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "b"
+        │   │   │   └── closing_loc: (75...76) = "}"
+        │   │   └── @ StringNode (location: (76...77))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (76...77) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (77...81) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (82...88))
+        │   ├── opening_loc: (82...88) = "<<-EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (98...102))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (98...102) = "  a\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "  a\n"
+        │   └── closing_loc: (102...106) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (107...113))
+        │   ├── opening_loc: (107...113) = "<<-EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (114...122))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (114...122) = "  a\n  b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "  a\n  b\n"
+        │   └── closing_loc: (122...128) = "  EOF\n"
+        ├── @ InterpolatedStringNode (location: (129...137))
+        │   ├── opening_loc: (129...137) = "<<-\"EOF\""
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (138...142))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (138...142) = "  a\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "  a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (142...146))
+        │   │   │   ├── opening_loc: (142...144) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (144...145))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (144...145))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (144...145) = "b"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "b"
+        │   │   │   └── closing_loc: (145...146) = "}"
+        │   │   └── @ StringNode (location: (146...147))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (146...147) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (147...151) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (152...158))
+        │   ├── opening_loc: (152...158) = "<<-EOF"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (159...163))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (159...163) = "  a\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "  a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (163...167))
+        │   │   │   ├── opening_loc: (163...165) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (165...166))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (165...166))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (165...166) = "b"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "b"
+        │   │   │   └── closing_loc: (166...167) = "}"
+        │   │   └── @ StringNode (location: (167...168))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (167...168) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (168...172) = "EOF\n"
+        ├── @ StringNode (location: (173...179))
+        │   ├── opening_loc: (173...175) = "%#"
+        │   ├── content_loc: (175...178) = "abc"
+        │   ├── closing_loc: (178...179) = "#"
+        │   └── unescaped: "abc"
+        ├── @ InterpolatedStringNode (location: (181...187))
+        │   ├── opening_loc: (181...187) = "<<-EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (188...196))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (188...196) = "  a\n  b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "  a\n  b\n"
+        │   └── closing_loc: (196...200) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (201...206))
+        │   ├── opening_loc: (201...206) = "<<-''"
+        │   ├── parts: (length: 0)
+        │   └── closing_loc: (207...208) = "\n"
+        ├── @ InterpolatedStringNode (location: (209...217))
+        │   ├── opening_loc: (209...217) = "<<-'EOF'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (218...227))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (218...227) = "  a \#{1}\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "  a \#{1}\n"
+        │   └── closing_loc: (227...231) = "EOF\n"
+        ├── @ CallNode (location: (232...243))
+        │   ├── receiver:
+        │   │   @ InterpolatedStringNode (location: (232...236))
+        │   │   ├── opening_loc: (232...236) = "<<-A"
+        │   │   ├── parts: (length: 1)
+        │   │   │   └── @ StringNode (location: (244...248))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (244...248) = "  a\n"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "  a\n"
+        │   │   └── closing_loc: (248...250) = "A\n"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (237...238) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (239...243))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (239...243))
+        │   │           ├── opening_loc: (239...243) = "<<-B"
+        │   │           ├── parts: (length: 3)
+        │   │           │   ├── @ StringNode (location: (250...256))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (250...256) = "  b\n  "
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "  b\n  "
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (256...263))
+        │   │           │   │   ├── opening_loc: (256...258) = "\#{"
+        │   │           │   │   ├── statements:
+        │   │           │   │   │   @ StatementsNode (location: (258...259))
+        │   │           │   │   │   └── body: (length: 1)
+        │   │           │   │   │       └── @ IntegerNode (location: (258...259))
+        │   │           │   │   └── closing_loc: (262...263) = "}"
+        │   │           │   └── @ StringNode (location: (263...264))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (263...264) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (264...266) = "B\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        └── @ CallNode (location: (267...278))
+            ├── receiver:
+            │   @ InterpolatedStringNode (location: (267...271))
+            │   ├── opening_loc: (267...271) = "<<-A"
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (279...283))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (279...283) = "  a\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "  a\n"
+            │   └── closing_loc: (283...285) = "A\n"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (272...273) = "+"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (274...278))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedStringNode (location: (274...278))
+            │           ├── opening_loc: (274...278) = "<<-B"
+            │           ├── parts: (length: 3)
+            │           │   ├── @ StringNode (location: (285...291))
+            │           │   │   ├── opening_loc: ∅
+            │           │   │   ├── content_loc: (285...291) = "  b\n  "
+            │           │   │   ├── closing_loc: ∅
+            │           │   │   └── unescaped: "  b\n  "
+            │           │   ├── @ EmbeddedStatementsNode (location: (291...298))
+            │           │   │   ├── opening_loc: (291...293) = "\#{"
+            │           │   │   ├── statements:
+            │           │   │   │   @ StatementsNode (location: (296...297))
+            │           │   │   │   └── body: (length: 1)
+            │           │   │   │       └── @ IntegerNode (location: (296...297))
+            │           │   │   └── closing_loc: (297...298) = "}"
+            │           │   └── @ StringNode (location: (298...299))
+            │           │       ├── opening_loc: ∅
+            │           │       ├── content_loc: (298...299) = "\n"
+            │           │       ├── closing_loc: ∅
+            │           │       └── unescaped: "\n"
+            │           └── closing_loc: (299...301) = "B\n"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "+"
diff --git a/test/yarp/snapshots/defined.txt b/test/yarp/snapshots/defined.txt
index 1d4b5a5502..56f88ed100 100644
--- a/test/yarp/snapshots/defined.txt
+++ b/test/yarp/snapshots/defined.txt
@@ -1,34 +1,69 @@
-ProgramNode(0...78)(
-  [:x],
-  StatementsNode(0...78)(
-    [AndNode(0...25)(
-       DefinedNode(0...10)(nil, IntegerNode(9...10)(), nil, (0...8)),
-       DefinedNode(15...25)(nil, IntegerNode(24...25)(), nil, (15...23)),
-       (11...14)
-     ),
-     DefinedNode(27...43)(
-       (35...36),
-       LocalVariableOperatorWriteNode(36...42)(
-         (36...37),
-         (38...40),
-         IntegerNode(41...42)(),
-         :x,
-         :%,
-         0
-       ),
-       (42...43),
-       (27...35)
-     ),
-     DefinedNode(45...66)(
-       (53...54),
-       AndNode(54...65)(
-         CallNode(54...57)(nil, nil, (54...57), nil, nil, nil, nil, 2, "foo"),
-         CallNode(62...65)(nil, nil, (62...65), nil, nil, nil, nil, 2, "bar"),
-         (58...61)
-       ),
-       (65...66),
-       (45...53)
-     ),
-     DefinedNode(68...78)(nil, IntegerNode(77...78)(), nil, (68...76))]
-  )
-)
+@ ProgramNode (location: (0...78))
+├── locals: [:x]
+└── statements:
+    @ StatementsNode (location: (0...78))
+    └── body: (length: 4)
+        ├── @ AndNode (location: (0...25))
+        │   ├── left:
+        │   │   @ DefinedNode (location: (0...10))
+        │   │   ├── lparen_loc: ∅
+        │   │   ├── value:
+        │   │   │   @ IntegerNode (location: (9...10))
+        │   │   ├── rparen_loc: ∅
+        │   │   └── keyword_loc: (0...8) = "defined?"
+        │   ├── right:
+        │   │   @ DefinedNode (location: (15...25))
+        │   │   ├── lparen_loc: ∅
+        │   │   ├── value:
+        │   │   │   @ IntegerNode (location: (24...25))
+        │   │   ├── rparen_loc: ∅
+        │   │   └── keyword_loc: (15...23) = "defined?"
+        │   └── operator_loc: (11...14) = "and"
+        ├── @ DefinedNode (location: (27...43))
+        │   ├── lparen_loc: (35...36) = "("
+        │   ├── value:
+        │   │   @ LocalVariableOperatorWriteNode (location: (36...42))
+        │   │   ├── name_loc: (36...37) = "x"
+        │   │   ├── operator_loc: (38...40) = "%="
+        │   │   ├── value:
+        │   │   │   @ IntegerNode (location: (41...42))
+        │   │   ├── name: :x
+        │   │   ├── operator: :%
+        │   │   └── depth: 0
+        │   ├── rparen_loc: (42...43) = ")"
+        │   └── keyword_loc: (27...35) = "defined?"
+        ├── @ DefinedNode (location: (45...66))
+        │   ├── lparen_loc: (53...54) = "("
+        │   ├── value:
+        │   │   @ AndNode (location: (54...65))
+        │   │   ├── left:
+        │   │   │   @ CallNode (location: (54...57))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (54...57) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── right:
+        │   │   │   @ CallNode (location: (62...65))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (62...65) = "bar"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "bar"
+        │   │   └── operator_loc: (58...61) = "and"
+        │   ├── rparen_loc: (65...66) = ")"
+        │   └── keyword_loc: (45...53) = "defined?"
+        └── @ DefinedNode (location: (68...78))
+            ├── lparen_loc: ∅
+            ├── value:
+            │   @ IntegerNode (location: (77...78))
+            ├── rparen_loc: ∅
+            └── keyword_loc: (68...76) = "defined?"
diff --git a/test/yarp/snapshots/dos_endings.txt b/test/yarp/snapshots/dos_endings.txt
index 7048028b2a..5186b4ebfb 100644
--- a/test/yarp/snapshots/dos_endings.txt
+++ b/test/yarp/snapshots/dos_endings.txt
@@ -1,81 +1,96 @@
-ProgramNode(0...108)(
-  [:x, :a],
-  StatementsNode(0...108)(
-    [CallNode(0...24)(
-       nil,
-       nil,
-       (0...4),
-       nil,
-       ArgumentsNode(5...24)(
-         [StringConcatNode(5...24)(
-            StringNode(5...9)((5...6), (6...8), (8...9), "hi"),
-            StringNode(17...24)((17...18), (18...23), (23...24), "there")
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "puts"
-     ),
-     ArrayNode(28...37)(
-       [SymbolNode(31...36)(nil, (31...36), nil, "ab")],
-       (28...31),
-       (36...37)
-     ),
-     InterpolatedStringNode(41...45)(
-       (41...45),
-       [StringNode(47...70)(
-          nil,
-          (47...70),
-          nil,
-          "    1     2\r\n" + "    3\r\n"
-        )],
-       (70...73)
-     ),
-     LocalVariableWriteNode(75...84)(
-       :x,
-       0,
-       (75...76),
-       StringNode(79...84)((79...82), (82...82), (82...84), ""),
-       (77...78)
-     ),
-     LocalVariableWriteNode(88...108)(
-       :a,
-       0,
-       (88...89),
-       CallNode(92...108)(
-         nil,
-         nil,
-         (92...95),
-         (95...96),
-         ArgumentsNode(96...107)(
-           [CallNode(96...107)(
-              InterpolatedStringNode(96...102)(
-                (96...102),
-                [StringNode(110...121)(
-                   nil,
-                   (110...121),
-                   nil,
-                   "\n" + "baz\r\n"
-                 )],
-                (121...128)
-              ),
-              (102...103),
-              (103...107),
-              nil,
-              nil,
-              nil,
-              nil,
-              0,
-              "chop"
-            )]
-         ),
-         (107...108),
-         nil,
-         0,
-         "foo"
-       ),
-       (90...91)
-     )]
-  )
-)
+@ ProgramNode (location: (0...108))
+├── locals: [:x, :a]
+└── statements:
+    @ StatementsNode (location: (0...108))
+    └── body: (length: 5)
+        ├── @ CallNode (location: (0...24))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...4) = "puts"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (5...24))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringConcatNode (location: (5...24))
+        │   │           ├── left:
+        │   │           │   @ StringNode (location: (5...9))
+        │   │           │   ├── opening_loc: (5...6) = "\""
+        │   │           │   ├── content_loc: (6...8) = "hi"
+        │   │           │   ├── closing_loc: (8...9) = "\""
+        │   │           │   └── unescaped: "hi"
+        │   │           └── right:
+        │   │               @ StringNode (location: (17...24))
+        │   │               ├── opening_loc: (17...18) = "\""
+        │   │               ├── content_loc: (18...23) = "there"
+        │   │               ├── closing_loc: (23...24) = "\""
+        │   │               └── unescaped: "there"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "puts"
+        ├── @ ArrayNode (location: (28...37))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SymbolNode (location: (31...36))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (31...36) = "a\\\r\nb"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "ab"
+        │   ├── opening_loc: (28...31) = "%I{"
+        │   └── closing_loc: (36...37) = "}"
+        ├── @ InterpolatedStringNode (location: (41...45))
+        │   ├── opening_loc: (41...45) = "<<-E"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (47...70))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (47...70) = "    1 \\\r\n    2\r\n    3\r\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "    1     2\r\n    3\r\n"
+        │   └── closing_loc: (70...73) = "E\r\n"
+        ├── @ LocalVariableWriteNode (location: (75...84))
+        │   ├── name: :x
+        │   ├── depth: 0
+        │   ├── name_loc: (75...76) = "x"
+        │   ├── value:
+        │   │   @ StringNode (location: (79...84))
+        │   │   ├── opening_loc: (79...82) = "%\r\n"
+        │   │   ├── content_loc: (82...82) = ""
+        │   │   ├── closing_loc: (82...84) = "\r\n"
+        │   │   └── unescaped: ""
+        │   └── operator_loc: (77...78) = "="
+        └── @ LocalVariableWriteNode (location: (88...108))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (88...89) = "a"
+            ├── value:
+            │   @ CallNode (location: (92...108))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (92...95) = "foo"
+            │   ├── opening_loc: (95...96) = "("
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (96...107))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (96...107))
+            │   │           ├── receiver:
+            │   │           │   @ InterpolatedStringNode (location: (96...102))
+            │   │           │   ├── opening_loc: (96...102) = "<<~EOF"
+            │   │           │   ├── parts: (length: 1)
+            │   │           │   │   └── @ StringNode (location: (110...121))
+            │   │           │   │       ├── opening_loc: ∅
+            │   │           │   │       ├── content_loc: (110...121) = "\r\n    baz\r\n"
+            │   │           │   │       ├── closing_loc: ∅
+            │   │           │   │       └── unescaped: "\nbaz\r\n"
+            │   │           │   └── closing_loc: (121...128) = "  EOF\r\n"
+            │   │           ├── call_operator_loc: (102...103) = "."
+            │   │           ├── message_loc: (103...107) = "chop"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "chop"
+            │   ├── closing_loc: (107...108) = ")"
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "foo"
+            └── operator_loc: (90...91) = "="
diff --git a/test/yarp/snapshots/embdoc_no_newline_at_end.txt b/test/yarp/snapshots/embdoc_no_newline_at_end.txt
index bd3eaf5ff4..81b8a103ea 100644
--- a/test/yarp/snapshots/embdoc_no_newline_at_end.txt
+++ b/test/yarp/snapshots/embdoc_no_newline_at_end.txt
@@ -1 +1,5 @@
-ProgramNode(0...0)([], StatementsNode(0...0)([]))
+@ ProgramNode (location: (0...0))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...0))
+    └── body: (length: 0)
diff --git a/test/yarp/snapshots/endless_methods.txt b/test/yarp/snapshots/endless_methods.txt
index 61b7493847..556950fe3b 100644
--- a/test/yarp/snapshots/endless_methods.txt
+++ b/test/yarp/snapshots/endless_methods.txt
@@ -1,83 +1,95 @@
-ProgramNode(0...51)(
-  [],
-  StatementsNode(0...51)(
-    [DefNode(0...11)(
-       :foo,
-       (4...7),
-       nil,
-       nil,
-       StatementsNode(10...11)([IntegerNode(10...11)()]),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       (8...9),
-       nil
-     ),
-     DefNode(13...27)(
-       :bar,
-       (17...20),
-       nil,
-       nil,
-       StatementsNode(23...27)(
-         [CallNode(23...27)(
-            nil,
-            nil,
-            (23...24),
-            nil,
-            ArgumentsNode(25...27)(
-              [StringNode(25...27)((25...26), (26...26), (26...27), "")]
-            ),
-            nil,
-            nil,
-            0,
-            "A"
-          )]
-       ),
-       [],
-       (13...16),
-       nil,
-       nil,
-       nil,
-       (21...22),
-       nil
-     ),
-     DefNode(29...51)(
-       :method,
-       (33...39),
-       nil,
-       nil,
-       StatementsNode(42...51)(
-         [CallNode(42...51)(
-            CallNode(42...47)(
-              IntegerNode(42...43)(),
-              nil,
-              (44...45),
-              nil,
-              ArgumentsNode(46...47)([IntegerNode(46...47)()]),
-              nil,
-              nil,
-              0,
-              "+"
-            ),
-            nil,
-            (48...49),
-            nil,
-            ArgumentsNode(50...51)([IntegerNode(50...51)()]),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       ),
-       [],
-       (29...32),
-       nil,
-       nil,
-       nil,
-       (40...41),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...51))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...51))
+    └── body: (length: 3)
+        ├── @ DefNode (location: (0...11))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (10...11))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (10...11))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (8...9) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (13...27))
+        │   ├── name: :bar
+        │   ├── name_loc: (17...20) = "bar"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (23...27))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (23...27))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (23...24) = "A"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (25...27))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ StringNode (location: (25...27))
+        │   │           │           ├── opening_loc: (25...26) = "\""
+        │   │           │           ├── content_loc: (26...26) = ""
+        │   │           │           ├── closing_loc: (26...27) = "\""
+        │   │           │           └── unescaped: ""
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "A"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (13...16) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (21...22) = "="
+        │   └── end_keyword_loc: ∅
+        └── @ DefNode (location: (29...51))
+            ├── name: :method
+            ├── name_loc: (33...39) = "method"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (42...51))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (42...51))
+            │           ├── receiver:
+            │           │   @ CallNode (location: (42...47))
+            │           │   ├── receiver:
+            │           │   │   @ IntegerNode (location: (42...43))
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (44...45) = "+"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments:
+            │           │   │   @ ArgumentsNode (location: (46...47))
+            │           │   │   └── arguments: (length: 1)
+            │           │   │       └── @ IntegerNode (location: (46...47))
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: 
+            │           │   └── name: "+"
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (48...49) = "+"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (50...51))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ IntegerNode (location: (50...51))
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "+"
+            ├── locals: []
+            ├── def_keyword_loc: (29...32) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: (40...41) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/endless_range_in_conditional.txt b/test/yarp/snapshots/endless_range_in_conditional.txt
index 4360818e40..f719692438 100644
--- a/test/yarp/snapshots/endless_range_in_conditional.txt
+++ b/test/yarp/snapshots/endless_range_in_conditional.txt
@@ -1,31 +1,42 @@
-ProgramNode(0...39)(
-  [],
-  StatementsNode(0...39)(
-    [IfNode(0...13)(
-       (0...2),
-       FlipFlopNode(3...7)(
-         IntegerNode(3...4)(),
-         IntegerNode(6...7)(),
-         (4...6),
-         0
-       ),
-       nil,
-       nil,
-       (10...13)
-     ),
-     IfNode(14...26)(
-       (14...16),
-       FlipFlopNode(17...20)(nil, IntegerNode(19...20)(), (17...19), 0),
-       nil,
-       nil,
-       (23...26)
-     ),
-     IfNode(27...39)(
-       (27...29),
-       FlipFlopNode(30...33)(IntegerNode(30...31)(), nil, (31...33), 0),
-       nil,
-       nil,
-       (36...39)
-     )]
-  )
-)
+@ ProgramNode (location: (0...39))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...39))
+    └── body: (length: 3)
+        ├── @ IfNode (location: (0...13))
+        │   ├── if_keyword_loc: (0...2) = "if"
+        │   ├── predicate:
+        │   │   @ FlipFlopNode (location: (3...7))
+        │   │   ├── left:
+        │   │   │   @ IntegerNode (location: (3...4))
+        │   │   ├── right:
+        │   │   │   @ IntegerNode (location: (6...7))
+        │   │   ├── operator_loc: (4...6) = ".."
+        │   │   └── flags: 
+        │   ├── statements: ∅
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (10...13) = "end"
+        ├── @ IfNode (location: (14...26))
+        │   ├── if_keyword_loc: (14...16) = "if"
+        │   ├── predicate:
+        │   │   @ FlipFlopNode (location: (17...20))
+        │   │   ├── left: ∅
+        │   │   ├── right:
+        │   │   │   @ IntegerNode (location: (19...20))
+        │   │   ├── operator_loc: (17...19) = ".."
+        │   │   └── flags: 
+        │   ├── statements: ∅
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (23...26) = "end"
+        └── @ IfNode (location: (27...39))
+            ├── if_keyword_loc: (27...29) = "if"
+            ├── predicate:
+            │   @ FlipFlopNode (location: (30...33))
+            │   ├── left:
+            │   │   @ IntegerNode (location: (30...31))
+            │   ├── right: ∅
+            │   ├── operator_loc: (31...33) = ".."
+            │   └── flags: 
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (36...39) = "end"
diff --git a/test/yarp/snapshots/for.txt b/test/yarp/snapshots/for.txt
index 77f85312e3..d873101bec 100644
--- a/test/yarp/snapshots/for.txt
+++ b/test/yarp/snapshots/for.txt
@@ -1,116 +1,176 @@
-ProgramNode(0...143)(
-  [:i, :j, :k],
-  StatementsNode(0...143)(
-    [ForNode(0...20)(
-       MultiTargetNode(4...5)(
-         [LocalVariableTargetNode(4...5)(:i, 0)],
-         nil,
-         nil
-       ),
-       RangeNode(9...14)(
-         IntegerNode(9...10)(),
-         IntegerNode(12...14)(),
-         (10...12),
-         0
-       ),
-       StatementsNode(15...16)([LocalVariableReadNode(15...16)(:i, 0)]),
-       (0...3),
-       (6...8),
-       nil,
-       (17...20)
-     ),
-     ForNode(22...44)(
-       MultiTargetNode(26...27)(
-         [LocalVariableTargetNode(26...27)(:i, 0)],
-         nil,
-         nil
-       ),
-       RangeNode(31...36)(
-         IntegerNode(31...32)(),
-         IntegerNode(34...36)(),
-         (32...34),
-         0
-       ),
-       StatementsNode(38...39)([LocalVariableReadNode(38...39)(:i, 0)]),
-       (22...25),
-       (28...30),
-       nil,
-       (41...44)
-     ),
-     ForNode(46...68)(
-       MultiTargetNode(50...53)(
-         [LocalVariableTargetNode(50...51)(:i, 0),
-          LocalVariableTargetNode(52...53)(:j, 0)],
-         nil,
-         nil
-       ),
-       RangeNode(57...62)(
-         IntegerNode(57...58)(),
-         IntegerNode(60...62)(),
-         (58...60),
-         0
-       ),
-       StatementsNode(63...64)([LocalVariableReadNode(63...64)(:i, 0)]),
-       (46...49),
-       (54...56),
-       nil,
-       (65...68)
-     ),
-     ForNode(70...94)(
-       MultiTargetNode(74...79)(
-         [LocalVariableTargetNode(74...75)(:i, 0),
-          LocalVariableTargetNode(76...77)(:j, 0),
-          LocalVariableTargetNode(78...79)(:k, 0)],
-         nil,
-         nil
-       ),
-       RangeNode(83...88)(
-         IntegerNode(83...84)(),
-         IntegerNode(86...88)(),
-         (84...86),
-         0
-       ),
-       StatementsNode(89...90)([LocalVariableReadNode(89...90)(:i, 0)]),
-       (70...73),
-       (80...82),
-       nil,
-       (91...94)
-     ),
-     ForNode(96...119)(
-       MultiTargetNode(100...101)(
-         [LocalVariableTargetNode(100...101)(:i, 0)],
-         nil,
-         nil
-       ),
-       RangeNode(105...110)(
-         IntegerNode(105...106)(),
-         IntegerNode(108...110)(),
-         (106...108),
-         0
-       ),
-       StatementsNode(114...115)([LocalVariableReadNode(114...115)(:i, 0)]),
-       (96...99),
-       (102...104),
-       (111...113),
-       (116...119)
-     ),
-     ForNode(121...143)(
-       MultiTargetNode(125...126)(
-         [LocalVariableTargetNode(125...126)(:i, 0)],
-         nil,
-         nil
-       ),
-       RangeNode(130...135)(
-         IntegerNode(130...131)(),
-         IntegerNode(133...135)(),
-         (131...133),
-         0
-       ),
-       StatementsNode(137...138)([LocalVariableReadNode(137...138)(:i, 0)]),
-       (121...124),
-       (127...129),
-       nil,
-       (140...143)
-     )]
-  )
-)
+@ ProgramNode (location: (0...143))
+├── locals: [:i, :j, :k]
+└── statements:
+    @ StatementsNode (location: (0...143))
+    └── body: (length: 6)
+        ├── @ ForNode (location: (0...20))
+        │   ├── index:
+        │   │   @ MultiTargetNode (location: (4...5))
+        │   │   ├── targets: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (4...5))
+        │   │   │       ├── name: :i
+        │   │   │       └── depth: 0
+        │   │   ├── lparen_loc: ∅
+        │   │   └── rparen_loc: ∅
+        │   ├── collection:
+        │   │   @ RangeNode (location: (9...14))
+        │   │   ├── left:
+        │   │   │   @ IntegerNode (location: (9...10))
+        │   │   ├── right:
+        │   │   │   @ IntegerNode (location: (12...14))
+        │   │   ├── operator_loc: (10...12) = ".."
+        │   │   └── flags: 
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (15...16))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (15...16))
+        │   │           ├── name: :i
+        │   │           └── depth: 0
+        │   ├── for_keyword_loc: (0...3) = "for"
+        │   ├── in_keyword_loc: (6...8) = "in"
+        │   ├── do_keyword_loc: ∅
+        │   └── end_keyword_loc: (17...20) = "end"
+        ├── @ ForNode (location: (22...44))
+        │   ├── index:
+        │   │   @ MultiTargetNode (location: (26...27))
+        │   │   ├── targets: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (26...27))
+        │   │   │       ├── name: :i
+        │   │   │       └── depth: 0
+        │   │   ├── lparen_loc: ∅
+        │   │   └── rparen_loc: ∅
+        │   ├── collection:
+        │   │   @ RangeNode (location: (31...36))
+        │   │   ├── left:
+        │   │   │   @ IntegerNode (location: (31...32))
+        │   │   ├── right:
+        │   │   │   @ IntegerNode (location: (34...36))
+        │   │   ├── operator_loc: (32...34) = ".."
+        │   │   └── flags: 
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (38...39))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (38...39))
+        │   │           ├── name: :i
+        │   │           └── depth: 0
+        │   ├── for_keyword_loc: (22...25) = "for"
+        │   ├── in_keyword_loc: (28...30) = "in"
+        │   ├── do_keyword_loc: ∅
+        │   └── end_keyword_loc: (41...44) = "end"
+        ├── @ ForNode (location: (46...68))
+        │   ├── index:
+        │   │   @ MultiTargetNode (location: (50...53))
+        │   │   ├── targets: (length: 2)
+        │   │   │   ├── @ LocalVariableTargetNode (location: (50...51))
+        │   │   │   │   ├── name: :i
+        │   │   │   │   └── depth: 0
+        │   │   │   └── @ LocalVariableTargetNode (location: (52...53))
+        │   │   │       ├── name: :j
+        │   │   │       └── depth: 0
+        │   │   ├── lparen_loc: ∅
+        │   │   └── rparen_loc: ∅
+        │   ├── collection:
+        │   │   @ RangeNode (location: (57...62))
+        │   │   ├── left:
+        │   │   │   @ IntegerNode (location: (57...58))
+        │   │   ├── right:
+        │   │   │   @ IntegerNode (location: (60...62))
+        │   │   ├── operator_loc: (58...60) = ".."
+        │   │   └── flags: 
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (63...64))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (63...64))
+        │   │           ├── name: :i
+        │   │           └── depth: 0
+        │   ├── for_keyword_loc: (46...49) = "for"
+        │   ├── in_keyword_loc: (54...56) = "in"
+        │   ├── do_keyword_loc: ∅
+        │   └── end_keyword_loc: (65...68) = "end"
+        ├── @ ForNode (location: (70...94))
+        │   ├── index:
+        │   │   @ MultiTargetNode (location: (74...79))
+        │   │   ├── targets: (length: 3)
+        │   │   │   ├── @ LocalVariableTargetNode (location: (74...75))
+        │   │   │   │   ├── name: :i
+        │   │   │   │   └── depth: 0
+        │   │   │   ├── @ LocalVariableTargetNode (location: (76...77))
+        │   │   │   │   ├── name: :j
+        │   │   │   │   └── depth: 0
+        │   │   │   └── @ LocalVariableTargetNode (location: (78...79))
+        │   │   │       ├── name: :k
+        │   │   │       └── depth: 0
+        │   │   ├── lparen_loc: ∅
+        │   │   └── rparen_loc: ∅
+        │   ├── collection:
+        │   │   @ RangeNode (location: (83...88))
+        │   │   ├── left:
+        │   │   │   @ IntegerNode (location: (83...84))
+        │   │   ├── right:
+        │   │   │   @ IntegerNode (location: (86...88))
+        │   │   ├── operator_loc: (84...86) = ".."
+        │   │   └── flags: 
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (89...90))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (89...90))
+        │   │           ├── name: :i
+        │   │           └── depth: 0
+        │   ├── for_keyword_loc: (70...73) = "for"
+        │   ├── in_keyword_loc: (80...82) = "in"
+        │   ├── do_keyword_loc: ∅
+        │   └── end_keyword_loc: (91...94) = "end"
+        ├── @ ForNode (location: (96...119))
+        │   ├── index:
+        │   │   @ MultiTargetNode (location: (100...101))
+        │   │   ├── targets: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (100...101))
+        │   │   │       ├── name: :i
+        │   │   │       └── depth: 0
+        │   │   ├── lparen_loc: ∅
+        │   │   └── rparen_loc: ∅
+        │   ├── collection:
+        │   │   @ RangeNode (location: (105...110))
+        │   │   ├── left:
+        │   │   │   @ IntegerNode (location: (105...106))
+        │   │   ├── right:
+        │   │   │   @ IntegerNode (location: (108...110))
+        │   │   ├── operator_loc: (106...108) = ".."
+        │   │   └── flags: 
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (114...115))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (114...115))
+        │   │           ├── name: :i
+        │   │           └── depth: 0
+        │   ├── for_keyword_loc: (96...99) = "for"
+        │   ├── in_keyword_loc: (102...104) = "in"
+        │   ├── do_keyword_loc: (111...113) = "do"
+        │   └── end_keyword_loc: (116...119) = "end"
+        └── @ ForNode (location: (121...143))
+            ├── index:
+            │   @ MultiTargetNode (location: (125...126))
+            │   ├── targets: (length: 1)
+            │   │   └── @ LocalVariableTargetNode (location: (125...126))
+            │   │       ├── name: :i
+            │   │       └── depth: 0
+            │   ├── lparen_loc: ∅
+            │   └── rparen_loc: ∅
+            ├── collection:
+            │   @ RangeNode (location: (130...135))
+            │   ├── left:
+            │   │   @ IntegerNode (location: (130...131))
+            │   ├── right:
+            │   │   @ IntegerNode (location: (133...135))
+            │   ├── operator_loc: (131...133) = ".."
+            │   └── flags: 
+            ├── statements:
+            │   @ StatementsNode (location: (137...138))
+            │   └── body: (length: 1)
+            │       └── @ LocalVariableReadNode (location: (137...138))
+            │           ├── name: :i
+            │           └── depth: 0
+            ├── for_keyword_loc: (121...124) = "for"
+            ├── in_keyword_loc: (127...129) = "in"
+            ├── do_keyword_loc: ∅
+            └── end_keyword_loc: (140...143) = "end"
diff --git a/test/yarp/snapshots/global_variables.txt b/test/yarp/snapshots/global_variables.txt
index 578f02e9b8..4e1feffd58 100644
--- a/test/yarp/snapshots/global_variables.txt
+++ b/test/yarp/snapshots/global_variables.txt
@@ -1,52 +1,164 @@
-ProgramNode(0...349)(
-  [],
-  StatementsNode(0...349)(
-    [GlobalVariableReadNode(0...16)(:$global_variable),
-     GlobalVariableReadNode(18...20)(:$_),
-     GlobalVariableReadNode(22...25)(:$-w),
-     GlobalVariableReadNode(27...37)(:$LOAD_PATH),
-     GlobalVariableReadNode(39...45)(:$stdin),
-     GlobalVariableReadNode(47...54)(:$stdout),
-     GlobalVariableReadNode(56...63)(:$stderr),
-     GlobalVariableReadNode(65...67)(:$!),
-     GlobalVariableReadNode(69...71)(:$?),
-     GlobalVariableReadNode(73...75)(:$~),
-     BackReferenceReadNode(77...79)(),
-     BackReferenceReadNode(81...83)(),
-     BackReferenceReadNode(85...87)(),
-     BackReferenceReadNode(89...91)(),
-     GlobalVariableReadNode(93...95)(:$:),
-     GlobalVariableReadNode(97...99)(:$;),
-     GlobalVariableReadNode(101...103)(:$,),
-     GlobalVariableReadNode(105...111)(:$DEBUG),
-     GlobalVariableReadNode(113...122)(:$FILENAME),
-     GlobalVariableReadNode(124...126)(:$0),
-     GlobalVariableReadNode(128...131)(:$-0),
-     GlobalVariableReadNode(133...149)(:$LOADED_FEATURES),
-     GlobalVariableReadNode(151...159)(:$VERBOSE),
-     GlobalVariableReadNode(161...164)(:$-K),
-     SymbolNode(166...183)((166...167), (167...183), nil, "$global_variable"),
-     SymbolNode(185...188)((185...186), (186...188), nil, "$_"),
-     SymbolNode(190...194)((190...191), (191...194), nil, "$-w"),
-     SymbolNode(196...207)((196...197), (197...207), nil, "$LOAD_PATH"),
-     SymbolNode(209...216)((209...210), (210...216), nil, "$stdin"),
-     SymbolNode(218...226)((218...219), (219...226), nil, "$stdout"),
-     SymbolNode(228...236)((228...229), (229...236), nil, "$stderr"),
-     SymbolNode(238...241)((238...239), (239...241), nil, "$!"),
-     SymbolNode(243...246)((243...244), (244...246), nil, "$?"),
-     SymbolNode(248...251)((248...249), (249...251), nil, "$~"),
-     SymbolNode(253...256)((253...254), (254...256), nil, "$&"),
-     SymbolNode(258...261)((258...259), (259...261), nil, "$`"),
-     SymbolNode(263...266)((263...264), (264...266), nil, "$'"),
-     SymbolNode(268...271)((268...269), (269...271), nil, "$+"),
-     SymbolNode(273...276)((273...274), (274...276), nil, "$:"),
-     SymbolNode(278...281)((278...279), (279...281), nil, "$;"),
-     SymbolNode(283...290)((283...284), (284...290), nil, "$DEBUG"),
-     SymbolNode(292...302)((292...293), (293...302), nil, "$FILENAME"),
-     SymbolNode(304...307)((304...305), (305...307), nil, "$0"),
-     SymbolNode(309...313)((309...310), (310...313), nil, "$-0"),
-     SymbolNode(315...332)((315...316), (316...332), nil, "$LOADED_FEATURES"),
-     SymbolNode(334...343)((334...335), (335...343), nil, "$VERBOSE"),
-     SymbolNode(345...349)((345...346), (346...349), nil, "$-K")]
-  )
-)
+@ ProgramNode (location: (0...349))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...349))
+    └── body: (length: 47)
+        ├── @ GlobalVariableReadNode (location: (0...16))
+        │   └── name: :$global_variable
+        ├── @ GlobalVariableReadNode (location: (18...20))
+        │   └── name: :$_
+        ├── @ GlobalVariableReadNode (location: (22...25))
+        │   └── name: :$-w
+        ├── @ GlobalVariableReadNode (location: (27...37))
+        │   └── name: :$LOAD_PATH
+        ├── @ GlobalVariableReadNode (location: (39...45))
+        │   └── name: :$stdin
+        ├── @ GlobalVariableReadNode (location: (47...54))
+        │   └── name: :$stdout
+        ├── @ GlobalVariableReadNode (location: (56...63))
+        │   └── name: :$stderr
+        ├── @ GlobalVariableReadNode (location: (65...67))
+        │   └── name: :$!
+        ├── @ GlobalVariableReadNode (location: (69...71))
+        │   └── name: :$?
+        ├── @ GlobalVariableReadNode (location: (73...75))
+        │   └── name: :$~
+        ├── @ BackReferenceReadNode (location: (77...79))
+        ├── @ BackReferenceReadNode (location: (81...83))
+        ├── @ BackReferenceReadNode (location: (85...87))
+        ├── @ BackReferenceReadNode (location: (89...91))
+        ├── @ GlobalVariableReadNode (location: (93...95))
+        │   └── name: :$:
+        ├── @ GlobalVariableReadNode (location: (97...99))
+        │   └── name: :$;
+        ├── @ GlobalVariableReadNode (location: (101...103))
+        │   └── name: :$,
+        ├── @ GlobalVariableReadNode (location: (105...111))
+        │   └── name: :$DEBUG
+        ├── @ GlobalVariableReadNode (location: (113...122))
+        │   └── name: :$FILENAME
+        ├── @ GlobalVariableReadNode (location: (124...126))
+        │   └── name: :$0
+        ├── @ GlobalVariableReadNode (location: (128...131))
+        │   └── name: :$-0
+        ├── @ GlobalVariableReadNode (location: (133...149))
+        │   └── name: :$LOADED_FEATURES
+        ├── @ GlobalVariableReadNode (location: (151...159))
+        │   └── name: :$VERBOSE
+        ├── @ GlobalVariableReadNode (location: (161...164))
+        │   └── name: :$-K
+        ├── @ SymbolNode (location: (166...183))
+        │   ├── opening_loc: (166...167) = ":"
+        │   ├── value_loc: (167...183) = "$global_variable"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$global_variable"
+        ├── @ SymbolNode (location: (185...188))
+        │   ├── opening_loc: (185...186) = ":"
+        │   ├── value_loc: (186...188) = "$_"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$_"
+        ├── @ SymbolNode (location: (190...194))
+        │   ├── opening_loc: (190...191) = ":"
+        │   ├── value_loc: (191...194) = "$-w"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$-w"
+        ├── @ SymbolNode (location: (196...207))
+        │   ├── opening_loc: (196...197) = ":"
+        │   ├── value_loc: (197...207) = "$LOAD_PATH"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$LOAD_PATH"
+        ├── @ SymbolNode (location: (209...216))
+        │   ├── opening_loc: (209...210) = ":"
+        │   ├── value_loc: (210...216) = "$stdin"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$stdin"
+        ├── @ SymbolNode (location: (218...226))
+        │   ├── opening_loc: (218...219) = ":"
+        │   ├── value_loc: (219...226) = "$stdout"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$stdout"
+        ├── @ SymbolNode (location: (228...236))
+        │   ├── opening_loc: (228...229) = ":"
+        │   ├── value_loc: (229...236) = "$stderr"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$stderr"
+        ├── @ SymbolNode (location: (238...241))
+        │   ├── opening_loc: (238...239) = ":"
+        │   ├── value_loc: (239...241) = "$!"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$!"
+        ├── @ SymbolNode (location: (243...246))
+        │   ├── opening_loc: (243...244) = ":"
+        │   ├── value_loc: (244...246) = "$?"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$?"
+        ├── @ SymbolNode (location: (248...251))
+        │   ├── opening_loc: (248...249) = ":"
+        │   ├── value_loc: (249...251) = "$~"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$~"
+        ├── @ SymbolNode (location: (253...256))
+        │   ├── opening_loc: (253...254) = ":"
+        │   ├── value_loc: (254...256) = "$&"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$&"
+        ├── @ SymbolNode (location: (258...261))
+        │   ├── opening_loc: (258...259) = ":"
+        │   ├── value_loc: (259...261) = "$`"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$`"
+        ├── @ SymbolNode (location: (263...266))
+        │   ├── opening_loc: (263...264) = ":"
+        │   ├── value_loc: (264...266) = "$'"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$'"
+        ├── @ SymbolNode (location: (268...271))
+        │   ├── opening_loc: (268...269) = ":"
+        │   ├── value_loc: (269...271) = "$+"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$+"
+        ├── @ SymbolNode (location: (273...276))
+        │   ├── opening_loc: (273...274) = ":"
+        │   ├── value_loc: (274...276) = "$:"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$:"
+        ├── @ SymbolNode (location: (278...281))
+        │   ├── opening_loc: (278...279) = ":"
+        │   ├── value_loc: (279...281) = "$;"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$;"
+        ├── @ SymbolNode (location: (283...290))
+        │   ├── opening_loc: (283...284) = ":"
+        │   ├── value_loc: (284...290) = "$DEBUG"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$DEBUG"
+        ├── @ SymbolNode (location: (292...302))
+        │   ├── opening_loc: (292...293) = ":"
+        │   ├── value_loc: (293...302) = "$FILENAME"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$FILENAME"
+        ├── @ SymbolNode (location: (304...307))
+        │   ├── opening_loc: (304...305) = ":"
+        │   ├── value_loc: (305...307) = "$0"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$0"
+        ├── @ SymbolNode (location: (309...313))
+        │   ├── opening_loc: (309...310) = ":"
+        │   ├── value_loc: (310...313) = "$-0"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$-0"
+        ├── @ SymbolNode (location: (315...332))
+        │   ├── opening_loc: (315...316) = ":"
+        │   ├── value_loc: (316...332) = "$LOADED_FEATURES"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$LOADED_FEATURES"
+        ├── @ SymbolNode (location: (334...343))
+        │   ├── opening_loc: (334...335) = ":"
+        │   ├── value_loc: (335...343) = "$VERBOSE"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$VERBOSE"
+        └── @ SymbolNode (location: (345...349))
+            ├── opening_loc: (345...346) = ":"
+            ├── value_loc: (346...349) = "$-K"
+            ├── closing_loc: ∅
+            └── unescaped: "$-K"
diff --git a/test/yarp/snapshots/hashes.txt b/test/yarp/snapshots/hashes.txt
index cfd3e04f16..b19e988eb5 100644
--- a/test/yarp/snapshots/hashes.txt
+++ b/test/yarp/snapshots/hashes.txt
@@ -1,110 +1,255 @@
-ProgramNode(0...120)(
-  [],
-  StatementsNode(0...120)(
-    [HashNode(0...2)((0...1), [], (1...2)),
-     HashNode(4...7)((4...5), [], (6...7)),
-     HashNode(9...27)(
-       (9...10),
-       [AssocNode(11...17)(
-          CallNode(11...12)(nil, nil, (11...12), nil, nil, nil, nil, 2, "a"),
-          CallNode(16...17)(nil, nil, (16...17), nil, nil, nil, nil, 2, "b"),
-          (13...15)
-        ),
-        AssocNode(19...25)(
-          CallNode(19...20)(nil, nil, (19...20), nil, nil, nil, nil, 2, "c"),
-          CallNode(24...25)(nil, nil, (24...25), nil, nil, nil, nil, 2, "d"),
-          (21...23)
-        )],
-       (26...27)
-     ),
-     HashNode(29...44)(
-       (29...30),
-       [AssocNode(31...37)(
-          CallNode(31...32)(nil, nil, (31...32), nil, nil, nil, nil, 2, "a"),
-          CallNode(36...37)(nil, nil, (36...37), nil, nil, nil, nil, 2, "b"),
-          (33...35)
-        ),
-        AssocSplatNode(39...42)(
-          CallNode(41...42)(nil, nil, (41...42), nil, nil, nil, nil, 2, "c"),
-          (39...41)
-        )],
-       (43...44)
-     ),
-     HashNode(46...79)(
-       (46...47),
-       [AssocNode(54...58)(
-          SymbolNode(54...56)(nil, (54...55), (55...56), "a"),
-          CallNode(57...58)(nil, nil, (57...58), nil, nil, nil, nil, 2, "b"),
-          nil
-        ),
-        AssocNode(66...70)(
-          SymbolNode(66...68)(nil, (66...67), (67...68), "c"),
-          CallNode(69...70)(nil, nil, (69...70), nil, nil, nil, nil, 2, "d"),
-          nil
-        )],
-       (78...79)
-     ),
-     HashNode(81...106)(
-       (81...82),
-       [AssocNode(83...87)(
-          SymbolNode(83...85)(nil, (83...84), (84...85), "a"),
-          CallNode(86...87)(nil, nil, (86...87), nil, nil, nil, nil, 2, "b"),
-          nil
-        ),
-        AssocNode(89...93)(
-          SymbolNode(89...91)(nil, (89...90), (90...91), "c"),
-          CallNode(92...93)(nil, nil, (92...93), nil, nil, nil, nil, 2, "d"),
-          nil
-        ),
-        AssocSplatNode(95...98)(
-          CallNode(97...98)(nil, nil, (97...98), nil, nil, nil, nil, 2, "e"),
-          (95...97)
-        ),
-        AssocNode(100...104)(
-          SymbolNode(100...102)(nil, (100...101), (101...102), "f"),
-          CallNode(103...104)(
-            nil,
-            nil,
-            (103...104),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "g"
-          ),
-          nil
-        )],
-       (105...106)
-     ),
-     HashNode(108...120)(
-       (108...109),
-       [AssocNode(110...118)(
-          SymbolNode(110...114)((110...111), (111...112), (112...114), "a"),
-          CallNode(115...118)(
-            CallNode(116...118)(
-              nil,
-              nil,
-              (116...118),
-              nil,
-              nil,
-              nil,
-              nil,
-              0,
-              "b?"
-            ),
-            nil,
-            (115...116),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "!"
-          ),
-          nil
-        )],
-       (119...120)
-     )]
-  )
-)
+@ ProgramNode (location: (0...120))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...120))
+    └── body: (length: 7)
+        ├── @ HashNode (location: (0...2))
+        │   ├── opening_loc: (0...1) = "{"
+        │   ├── elements: (length: 0)
+        │   └── closing_loc: (1...2) = "}"
+        ├── @ HashNode (location: (4...7))
+        │   ├── opening_loc: (4...5) = "{"
+        │   ├── elements: (length: 0)
+        │   └── closing_loc: (6...7) = "}"
+        ├── @ HashNode (location: (9...27))
+        │   ├── opening_loc: (9...10) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (11...17))
+        │   │   │   ├── key:
+        │   │   │   │   @ CallNode (location: (11...12))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (11...12) = "a"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "a"
+        │   │   │   ├── value:
+        │   │   │   │   @ CallNode (location: (16...17))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (16...17) = "b"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "b"
+        │   │   │   └── operator_loc: (13...15) = "=>"
+        │   │   └── @ AssocNode (location: (19...25))
+        │   │       ├── key:
+        │   │       │   @ CallNode (location: (19...20))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (19...20) = "c"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "c"
+        │   │       ├── value:
+        │   │       │   @ CallNode (location: (24...25))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (24...25) = "d"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "d"
+        │   │       └── operator_loc: (21...23) = "=>"
+        │   └── closing_loc: (26...27) = "}"
+        ├── @ HashNode (location: (29...44))
+        │   ├── opening_loc: (29...30) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (31...37))
+        │   │   │   ├── key:
+        │   │   │   │   @ CallNode (location: (31...32))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (31...32) = "a"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "a"
+        │   │   │   ├── value:
+        │   │   │   │   @ CallNode (location: (36...37))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (36...37) = "b"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "b"
+        │   │   │   └── operator_loc: (33...35) = "=>"
+        │   │   └── @ AssocSplatNode (location: (39...42))
+        │   │       ├── value:
+        │   │       │   @ CallNode (location: (41...42))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (41...42) = "c"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "c"
+        │   │       └── operator_loc: (39...41) = "**"
+        │   └── closing_loc: (43...44) = "}"
+        ├── @ HashNode (location: (46...79))
+        │   ├── opening_loc: (46...47) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (54...58))
+        │   │   │   ├── key:
+        │   │   │   │   @ SymbolNode (location: (54...56))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── value_loc: (54...55) = "a"
+        │   │   │   │   ├── closing_loc: (55...56) = ":"
+        │   │   │   │   └── unescaped: "a"
+        │   │   │   ├── value:
+        │   │   │   │   @ CallNode (location: (57...58))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (57...58) = "b"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "b"
+        │   │   │   └── operator_loc: ∅
+        │   │   └── @ AssocNode (location: (66...70))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (66...68))
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── value_loc: (66...67) = "c"
+        │   │       │   ├── closing_loc: (67...68) = ":"
+        │   │       │   └── unescaped: "c"
+        │   │       ├── value:
+        │   │       │   @ CallNode (location: (69...70))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (69...70) = "d"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "d"
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (78...79) = "}"
+        ├── @ HashNode (location: (81...106))
+        │   ├── opening_loc: (81...82) = "{"
+        │   ├── elements: (length: 4)
+        │   │   ├── @ AssocNode (location: (83...87))
+        │   │   │   ├── key:
+        │   │   │   │   @ SymbolNode (location: (83...85))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── value_loc: (83...84) = "a"
+        │   │   │   │   ├── closing_loc: (84...85) = ":"
+        │   │   │   │   └── unescaped: "a"
+        │   │   │   ├── value:
+        │   │   │   │   @ CallNode (location: (86...87))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (86...87) = "b"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "b"
+        │   │   │   └── operator_loc: ∅
+        │   │   ├── @ AssocNode (location: (89...93))
+        │   │   │   ├── key:
+        │   │   │   │   @ SymbolNode (location: (89...91))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── value_loc: (89...90) = "c"
+        │   │   │   │   ├── closing_loc: (90...91) = ":"
+        │   │   │   │   └── unescaped: "c"
+        │   │   │   ├── value:
+        │   │   │   │   @ CallNode (location: (92...93))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (92...93) = "d"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "d"
+        │   │   │   └── operator_loc: ∅
+        │   │   ├── @ AssocSplatNode (location: (95...98))
+        │   │   │   ├── value:
+        │   │   │   │   @ CallNode (location: (97...98))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (97...98) = "e"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "e"
+        │   │   │   └── operator_loc: (95...97) = "**"
+        │   │   └── @ AssocNode (location: (100...104))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (100...102))
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── value_loc: (100...101) = "f"
+        │   │       │   ├── closing_loc: (101...102) = ":"
+        │   │       │   └── unescaped: "f"
+        │   │       ├── value:
+        │   │       │   @ CallNode (location: (103...104))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (103...104) = "g"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "g"
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (105...106) = "}"
+        └── @ HashNode (location: (108...120))
+            ├── opening_loc: (108...109) = "{"
+            ├── elements: (length: 1)
+            │   └── @ AssocNode (location: (110...118))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (110...114))
+            │       │   ├── opening_loc: (110...111) = "\""
+            │       │   ├── value_loc: (111...112) = "a"
+            │       │   ├── closing_loc: (112...114) = "\":"
+            │       │   └── unescaped: "a"
+            │       ├── value:
+            │       │   @ CallNode (location: (115...118))
+            │       │   ├── receiver:
+            │       │   │   @ CallNode (location: (116...118))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (116...118) = "b?"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: 
+            │       │   │   └── name: "b?"
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (115...116) = "!"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "!"
+            │       └── operator_loc: ∅
+            └── closing_loc: (119...120) = "}"
diff --git a/test/yarp/snapshots/heredoc_with_escaped_newline_at_start.txt b/test/yarp/snapshots/heredoc_with_escaped_newline_at_start.txt
index 43fa751526..ed2abc7f39 100644
--- a/test/yarp/snapshots/heredoc_with_escaped_newline_at_start.txt
+++ b/test/yarp/snapshots/heredoc_with_escaped_newline_at_start.txt
@@ -1,45 +1,59 @@
-ProgramNode(0...62)(
-  [],
-  StatementsNode(0...62)(
-    [CallNode(0...25)(
-       InterpolatedStringNode(0...9)((0...9), [], (27...34)),
-       (9...10),
-       (10...14),
-       nil,
-       ArgumentsNode(15...25)(
-         [RegularExpressionNode(15...21)(
-            (15...16),
-            (16...20),
-            (20...21),
-            "^ {",
-            0
-          ),
-          StringNode(23...25)((23...24), (24...24), (24...25), "")]
-       ),
-       nil,
-       nil,
-       0,
-       "gsub"
-     ),
-     CallNode(37...62)(
-       InterpolatedStringNode(37...46)((37...46), [], (65...73)),
-       (46...47),
-       (47...51),
-       nil,
-       ArgumentsNode(52...62)(
-         [RegularExpressionNode(52...58)(
-            (52...53),
-            (53...57),
-            (57...58),
-            "^ {",
-            0
-          ),
-          StringNode(60...62)((60...61), (61...61), (61...62), "")]
-       ),
-       nil,
-       nil,
-       0,
-       "gsub"
-     )]
-  )
-)
+@ ProgramNode (location: (0...62))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...62))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...25))
+        │   ├── receiver:
+        │   │   @ InterpolatedStringNode (location: (0...9))
+        │   │   ├── opening_loc: (0...9) = "<<-TARGET"
+        │   │   ├── parts: (length: 0)
+        │   │   └── closing_loc: (27...34) = "TARGET\n"
+        │   ├── call_operator_loc: (9...10) = "."
+        │   ├── message_loc: (10...14) = "gsub"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (15...25))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ RegularExpressionNode (location: (15...21))
+        │   │       │   ├── opening_loc: (15...16) = "/"
+        │   │       │   ├── content_loc: (16...20) = "^\\s{"
+        │   │       │   ├── closing_loc: (20...21) = "/"
+        │   │       │   ├── unescaped: "^ {"
+        │   │       │   └── flags: 
+        │   │       └── @ StringNode (location: (23...25))
+        │   │           ├── opening_loc: (23...24) = "'"
+        │   │           ├── content_loc: (24...24) = ""
+        │   │           ├── closing_loc: (24...25) = "'"
+        │   │           └── unescaped: ""
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "gsub"
+        └── @ CallNode (location: (37...62))
+            ├── receiver:
+            │   @ InterpolatedStringNode (location: (37...46))
+            │   ├── opening_loc: (37...46) = "<<-TARGET"
+            │   ├── parts: (length: 0)
+            │   └── closing_loc: (65...73) = "TARGET\r\n"
+            ├── call_operator_loc: (46...47) = "."
+            ├── message_loc: (47...51) = "gsub"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (52...62))
+            │   └── arguments: (length: 2)
+            │       ├── @ RegularExpressionNode (location: (52...58))
+            │       │   ├── opening_loc: (52...53) = "/"
+            │       │   ├── content_loc: (53...57) = "^\\s{"
+            │       │   ├── closing_loc: (57...58) = "/"
+            │       │   ├── unescaped: "^ {"
+            │       │   └── flags: 
+            │       └── @ StringNode (location: (60...62))
+            │           ├── opening_loc: (60...61) = "'"
+            │           ├── content_loc: (61...61) = ""
+            │           ├── closing_loc: (61...62) = "'"
+            │           └── unescaped: ""
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "gsub"
diff --git a/test/yarp/snapshots/heredoc_with_trailing_newline.txt b/test/yarp/snapshots/heredoc_with_trailing_newline.txt
index adaa524dda..cf80947b0c 100644
--- a/test/yarp/snapshots/heredoc_with_trailing_newline.txt
+++ b/test/yarp/snapshots/heredoc_with_trailing_newline.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)([InterpolatedStringNode(0...6)((0...6), [], (7...10))])
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...6))
+            ├── opening_loc: (0...6) = "<<-END"
+            ├── parts: (length: 0)
+            └── closing_loc: (7...10) = "END"
diff --git a/test/yarp/snapshots/heredocs_nested.txt b/test/yarp/snapshots/heredocs_nested.txt
index 750e5e4473..a35b0bf4d5 100644
--- a/test/yarp/snapshots/heredocs_nested.txt
+++ b/test/yarp/snapshots/heredocs_nested.txt
@@ -1,22 +1,34 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [InterpolatedStringNode(0...7)(
-       (0...7),
-       [StringNode(8...12)(nil, (8...12), nil, "pre\n"),
-        EmbeddedStatementsNode(12...36)(
-          (12...14),
-          StatementsNode(15...21)(
-            [InterpolatedStringNode(15...21)(
-               (15...21),
-               [StringNode(22...30)(nil, (22...30), nil, "  hello\n")],
-               (30...35)
-             )]
-          ),
-          (35...36)
-        ),
-        StringNode(36...42)(nil, (36...42), nil, "\n" + "post\n")],
-       (42...47)
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...7))
+            ├── opening_loc: (0...7) = "<<~RUBY"
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (8...12))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (8...12) = "pre\n"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "pre\n"
+            │   ├── @ EmbeddedStatementsNode (location: (12...36))
+            │   │   ├── opening_loc: (12...14) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (15...21))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ InterpolatedStringNode (location: (15...21))
+            │   │   │           ├── opening_loc: (15...21) = "<<RUBY"
+            │   │   │           ├── parts: (length: 1)
+            │   │   │           │   └── @ StringNode (location: (22...30))
+            │   │   │           │       ├── opening_loc: ∅
+            │   │   │           │       ├── content_loc: (22...30) = "  hello\n"
+            │   │   │           │       ├── closing_loc: ∅
+            │   │   │           │       └── unescaped: "  hello\n"
+            │   │   │           └── closing_loc: (30...35) = "RUBY\n"
+            │   │   └── closing_loc: (35...36) = "}"
+            │   └── @ StringNode (location: (36...42))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (36...42) = "\npost\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\npost\n"
+            └── closing_loc: (42...47) = "RUBY\n"
diff --git a/test/yarp/snapshots/heredocs_with_ignored_newlines.txt b/test/yarp/snapshots/heredocs_with_ignored_newlines.txt
index 3fd8c7accb..e8e6616219 100644
--- a/test/yarp/snapshots/heredocs_with_ignored_newlines.txt
+++ b/test/yarp/snapshots/heredocs_with_ignored_newlines.txt
@@ -1,23 +1,18 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [InterpolatedStringNode(0...7)((0...7), [], (9...14)),
-     InterpolatedStringNode(15...23)(
-       (15...23),
-       [StringNode(25...100)(
-          nil,
-          (25...100),
-          nil,
-          "way over\n" +
-          "<<HERE\n" +
-          "  not here\n" +
-          "HERE\n" +
-          "\n" +
-          "<<~BUT  but\n" +
-          "BUT\n" +
-          "  there\n"
-        )],
-       (100...106)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 2)
+        ├── @ InterpolatedStringNode (location: (0...7))
+        │   ├── opening_loc: (0...7) = "<<-HERE"
+        │   ├── parts: (length: 0)
+        │   └── closing_loc: (9...14) = "HERE\n"
+        └── @ InterpolatedStringNode (location: (15...23))
+            ├── opening_loc: (15...23) = "<<~THERE"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (25...100))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (25...100) = "  way over\n  <<HERE\n    not here\n  HERE\n\n  <<~BUT\\\n    but\n  BUT\n    there\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "way over\n<<HERE\n  not here\nHERE\n\n<<~BUT  but\nBUT\n  there\n"
+            └── closing_loc: (100...106) = "THERE\n"
diff --git a/test/yarp/snapshots/heredocs_with_ignored_newlines_and_non_empty.txt b/test/yarp/snapshots/heredocs_with_ignored_newlines_and_non_empty.txt
index 876c64a219..d5c0bf56b6 100644
--- a/test/yarp/snapshots/heredocs_with_ignored_newlines_and_non_empty.txt
+++ b/test/yarp/snapshots/heredocs_with_ignored_newlines_and_non_empty.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [InterpolatedStringNode(0...6)(
-       (0...6),
-       [StringNode(7...23)(nil, (7...23), nil, " some\n" + " heredocs\n")],
-       (23...26)
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...6))
+            ├── opening_loc: (0...6) = "<<-EOE"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (7...23))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (7...23) = " some\n heredocs\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: " some\n heredocs\n"
+            └── closing_loc: (23...26) = "EOE"
diff --git a/test/yarp/snapshots/if.txt b/test/yarp/snapshots/if.txt
index 07c8f714a3..1d4ba51517 100644
--- a/test/yarp/snapshots/if.txt
+++ b/test/yarp/snapshots/if.txt
@@ -1,340 +1,409 @@
-ProgramNode(0...382)(
-  [],
-  StatementsNode(0...382)(
-    [IfNode(0...15)(
-       (0...2),
-       TrueNode(3...7)(),
-       StatementsNode(9...10)([IntegerNode(9...10)()]),
-       nil,
-       (12...15)
-     ),
-     IfNode(17...37)(
-       (17...19),
-       TrueNode(20...24)(),
-       StatementsNode(25...26)([IntegerNode(25...26)()]),
-       ElseNode(27...37)(
-         (27...31),
-         StatementsNode(32...33)([IntegerNode(32...33)()]),
-         (34...37)
-       ),
-       (34...37)
-     ),
-     IfNode(39...112)(
-       (39...41),
-       TrueNode(42...46)(),
-       StatementsNode(52...56)([TrueNode(52...56)()]),
-       IfNode(57...112)(
-         (57...62),
-         FalseNode(63...68)(),
-         StatementsNode(74...79)([FalseNode(74...79)()]),
-         IfNode(80...112)(
-           (80...85),
-           NilNode(86...89)(),
-           StatementsNode(95...98)([NilNode(95...98)()]),
-           ElseNode(99...112)(
-             (99...103),
-             StatementsNode(104...108)([SelfNode(104...108)()]),
-             (109...112)
-           ),
-           (109...112)
-         ),
-         (109...112)
-       ),
-       (109...112)
-     ),
-     IfNode(114...123)(
-       (116...118),
-       TrueNode(119...123)(),
-       StatementsNode(114...115)([IntegerNode(114...115)()]),
-       nil,
-       nil
-     ),
-     IfNode(125...138)(
-       (131...133),
-       TrueNode(134...138)(),
-       StatementsNode(125...130)([BreakNode(125...130)(nil, (125...130))]),
-       nil,
-       nil
-     ),
-     IfNode(140...152)(
-       (145...147),
-       TrueNode(148...152)(),
-       StatementsNode(140...144)([NextNode(140...144)(nil, (140...144))]),
-       nil,
-       nil
-     ),
-     IfNode(154...168)(
-       (161...163),
-       TrueNode(164...168)(),
-       StatementsNode(154...160)([ReturnNode(154...160)((154...160), nil)]),
-       nil,
-       nil
-     ),
-     IfNode(170...200)(
-       (170...172),
-       CallNode(173...182)(
-         nil,
-         nil,
-         (173...182),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "exit_loop"
-       ),
-       StatementsNode(188...196)(
-         [BreakNode(188...196)(
-            ArgumentsNode(194...196)([IntegerNode(194...196)()]),
-            (188...193)
-          )]
-       ),
-       nil,
-       (197...200)
-     ),
-     IfNode(202...221)(
-       (202...204),
-       CallNode(205...208)(
-         nil,
-         nil,
-         (205...208),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       StatementsNode(214...217)(
-         [CallNode(214...217)(
-            nil,
-            nil,
-            (214...217),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       nil,
-       (218...221)
-     ),
-     IfNode(223...234)(
-       (230...232),
-       CallNode(233...234)(nil, nil, (233...234), nil, nil, nil, nil, 2, "c"),
-       StatementsNode(223...229)(
-         [IfNode(223...229)(
-            (225...227),
-            CallNode(228...229)(
-              nil,
-              nil,
-              (228...229),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            ),
-            StatementsNode(223...224)(
-              [CallNode(223...224)(
-                 nil,
-                 nil,
-                 (223...224),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "a"
-               )]
-            ),
-            nil,
-            nil
-          )]
-       ),
-       nil,
-       nil
-     ),
-     IfNode(236...259)(
-       (236...238),
-       TrueNode(239...243)(),
-       StatementsNode(246...250)(
-         [CallNode(246...250)(
-            nil,
-            nil,
-            (246...247),
-            nil,
-            ArgumentsNode(248...250)(
-              [KeywordHashNode(248...250)(
-                 [AssocNode(248...250)(
-                    SymbolNode(248...250)(nil, (248...249), (249...250), "b"),
-                    nil,
-                    nil
-                  )]
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "a"
-          )]
-       ),
-       ElseNode(251...259)((251...255), nil, (256...259)),
-       (256...259)
-     ),
-     IfNode(261...293)(
-       (261...263),
-       MatchPredicateNode(264...273)(
-         CallNode(264...268)(
-           nil,
-           nil,
-           (264...268),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "type"
-         ),
-         IntegerNode(272...273)(),
-         (269...271)
-       ),
-       nil,
-       IfNode(274...293)(
-         (274...279),
-         MatchPredicateNode(280...289)(
-           CallNode(280...284)(
-             nil,
-             nil,
-             (280...284),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "type"
-           ),
-           ConstantReadNode(288...289)(:B),
-           (285...287)
-         ),
-         nil,
-         nil,
-         (290...293)
-       ),
-       (290...293)
-     ),
-     IfNode(295...382)(
-       (295...297),
-       IntegerNode(298...299)(),
-       StatementsNode(302...321)(
-         [CallNode(302...321)(
-            nil,
-            nil,
-            (302...308),
-            nil,
-            nil,
-            nil,
-            BlockNode(309...321)(
-              [:_],
-              BlockParametersNode(312...315)(
-                ParametersNode(313...314)(
-                  [RequiredParameterNode(313...314)(:_)],
-                  [],
-                  [],
-                  nil,
-                  [],
-                  nil,
-                  nil
-                ),
-                [],
-                (312...313),
-                (314...315)
-              ),
-              nil,
-              (309...311),
-              (318...321)
-            ),
-            0,
-            "lambda"
-          )]
-       ),
-       IfNode(322...382)(
-         (322...327),
-         IntegerNode(328...329)(),
-         StatementsNode(332...351)(
-           [CallNode(332...351)(
-              nil,
-              nil,
-              (332...338),
-              nil,
-              nil,
-              nil,
-              BlockNode(339...351)(
-                [:_],
-                BlockParametersNode(342...345)(
-                  ParametersNode(343...344)(
-                    [RequiredParameterNode(343...344)(:_)],
-                    [],
-                    [],
-                    nil,
-                    [],
-                    nil,
-                    nil
-                  ),
-                  [],
-                  (342...343),
-                  (344...345)
-                ),
-                nil,
-                (339...341),
-                (348...351)
-              ),
-              0,
-              "lambda"
-            )]
-         ),
-         ElseNode(352...382)(
-           (352...356),
-           StatementsNode(359...378)(
-             [CallNode(359...378)(
-                nil,
-                nil,
-                (359...365),
-                nil,
-                nil,
-                nil,
-                BlockNode(366...378)(
-                  [:_],
-                  BlockParametersNode(369...372)(
-                    ParametersNode(370...371)(
-                      [RequiredParameterNode(370...371)(:_)],
-                      [],
-                      [],
-                      nil,
-                      [],
-                      nil,
-                      nil
-                    ),
-                    [],
-                    (369...370),
-                    (371...372)
-                  ),
-                  nil,
-                  (366...368),
-                  (375...378)
-                ),
-                0,
-                "lambda"
-              )]
-           ),
-           (379...382)
-         ),
-         (379...382)
-       ),
-       (379...382)
-     )]
-  )
-)
+@ ProgramNode (location: (0...382))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...382))
+    └── body: (length: 13)
+        ├── @ IfNode (location: (0...15))
+        │   ├── if_keyword_loc: (0...2) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (3...7))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (9...10))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (9...10))
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (12...15) = "end"
+        ├── @ IfNode (location: (17...37))
+        │   ├── if_keyword_loc: (17...19) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (20...24))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (25...26))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (25...26))
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (27...37))
+        │   │   ├── else_keyword_loc: (27...31) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (32...33))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (32...33))
+        │   │   └── end_keyword_loc: (34...37) = "end"
+        │   └── end_keyword_loc: (34...37) = "end"
+        ├── @ IfNode (location: (39...112))
+        │   ├── if_keyword_loc: (39...41) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (42...46))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (52...56))
+        │   │   └── body: (length: 1)
+        │   │       └── @ TrueNode (location: (52...56))
+        │   ├── consequent:
+        │   │   @ IfNode (location: (57...112))
+        │   │   ├── if_keyword_loc: (57...62) = "elsif"
+        │   │   ├── predicate:
+        │   │   │   @ FalseNode (location: (63...68))
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (74...79))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ FalseNode (location: (74...79))
+        │   │   ├── consequent:
+        │   │   │   @ IfNode (location: (80...112))
+        │   │   │   ├── if_keyword_loc: (80...85) = "elsif"
+        │   │   │   ├── predicate:
+        │   │   │   │   @ NilNode (location: (86...89))
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (95...98))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ NilNode (location: (95...98))
+        │   │   │   ├── consequent:
+        │   │   │   │   @ ElseNode (location: (99...112))
+        │   │   │   │   ├── else_keyword_loc: (99...103) = "else"
+        │   │   │   │   ├── statements:
+        │   │   │   │   │   @ StatementsNode (location: (104...108))
+        │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │       └── @ SelfNode (location: (104...108))
+        │   │   │   │   └── end_keyword_loc: (109...112) = "end"
+        │   │   │   └── end_keyword_loc: (109...112) = "end"
+        │   │   └── end_keyword_loc: (109...112) = "end"
+        │   └── end_keyword_loc: (109...112) = "end"
+        ├── @ IfNode (location: (114...123))
+        │   ├── if_keyword_loc: (116...118) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (119...123))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (114...115))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (114...115))
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (125...138))
+        │   ├── if_keyword_loc: (131...133) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (134...138))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (125...130))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (125...130))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (125...130) = "break"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (140...152))
+        │   ├── if_keyword_loc: (145...147) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (148...152))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (140...144))
+        │   │   └── body: (length: 1)
+        │   │       └── @ NextNode (location: (140...144))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (140...144) = "next"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (154...168))
+        │   ├── if_keyword_loc: (161...163) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (164...168))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (154...160))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ReturnNode (location: (154...160))
+        │   │           ├── keyword_loc: (154...160) = "return"
+        │   │           └── arguments: ∅
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (170...200))
+        │   ├── if_keyword_loc: (170...172) = "if"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (173...182))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (173...182) = "exit_loop"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "exit_loop"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (188...196))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (188...196))
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (194...196))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (194...196))
+        │   │           └── keyword_loc: (188...193) = "break"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (197...200) = "end"
+        ├── @ IfNode (location: (202...221))
+        │   ├── if_keyword_loc: (202...204) = "if"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (205...208))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (205...208) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (214...217))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (214...217))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (214...217) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (218...221) = "end"
+        ├── @ IfNode (location: (223...234))
+        │   ├── if_keyword_loc: (230...232) = "if"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (233...234))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (233...234) = "c"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "c"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (223...229))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IfNode (location: (223...229))
+        │   │           ├── if_keyword_loc: (225...227) = "if"
+        │   │           ├── predicate:
+        │   │           │   @ CallNode (location: (228...229))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (228...229) = "b"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "b"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (223...224))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (223...224))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (223...224) = "a"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "a"
+        │   │           ├── consequent: ∅
+        │   │           └── end_keyword_loc: ∅
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (236...259))
+        │   ├── if_keyword_loc: (236...238) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (239...243))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (246...250))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (246...250))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (246...247) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (248...250))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ KeywordHashNode (location: (248...250))
+        │   │           │           └── elements: (length: 1)
+        │   │           │               └── @ AssocNode (location: (248...250))
+        │   │           │                   ├── key:
+        │   │           │                   │   @ SymbolNode (location: (248...250))
+        │   │           │                   │   ├── opening_loc: ∅
+        │   │           │                   │   ├── value_loc: (248...249) = "b"
+        │   │           │                   │   ├── closing_loc: (249...250) = ":"
+        │   │           │                   │   └── unescaped: "b"
+        │   │           │                   ├── value: ∅
+        │   │           │                   └── operator_loc: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "a"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (251...259))
+        │   │   ├── else_keyword_loc: (251...255) = "else"
+        │   │   ├── statements: ∅
+        │   │   └── end_keyword_loc: (256...259) = "end"
+        │   └── end_keyword_loc: (256...259) = "end"
+        ├── @ IfNode (location: (261...293))
+        │   ├── if_keyword_loc: (261...263) = "if"
+        │   ├── predicate:
+        │   │   @ MatchPredicateNode (location: (264...273))
+        │   │   ├── value:
+        │   │   │   @ CallNode (location: (264...268))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (264...268) = "type"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "type"
+        │   │   ├── pattern:
+        │   │   │   @ IntegerNode (location: (272...273))
+        │   │   └── operator_loc: (269...271) = "in"
+        │   ├── statements: ∅
+        │   ├── consequent:
+        │   │   @ IfNode (location: (274...293))
+        │   │   ├── if_keyword_loc: (274...279) = "elsif"
+        │   │   ├── predicate:
+        │   │   │   @ MatchPredicateNode (location: (280...289))
+        │   │   │   ├── value:
+        │   │   │   │   @ CallNode (location: (280...284))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (280...284) = "type"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "type"
+        │   │   │   ├── pattern:
+        │   │   │   │   @ ConstantReadNode (location: (288...289))
+        │   │   │   │   └── name: :B
+        │   │   │   └── operator_loc: (285...287) = "in"
+        │   │   ├── statements: ∅
+        │   │   ├── consequent: ∅
+        │   │   └── end_keyword_loc: (290...293) = "end"
+        │   └── end_keyword_loc: (290...293) = "end"
+        └── @ IfNode (location: (295...382))
+            ├── if_keyword_loc: (295...297) = "if"
+            ├── predicate:
+            │   @ IntegerNode (location: (298...299))
+            ├── statements:
+            │   @ StatementsNode (location: (302...321))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (302...321))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (302...308) = "lambda"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block:
+            │           │   @ BlockNode (location: (309...321))
+            │           │   ├── locals: [:_]
+            │           │   ├── parameters:
+            │           │   │   @ BlockParametersNode (location: (312...315))
+            │           │   │   ├── parameters:
+            │           │   │   │   @ ParametersNode (location: (313...314))
+            │           │   │   │   ├── requireds: (length: 1)
+            │           │   │   │   │   └── @ RequiredParameterNode (location: (313...314))
+            │           │   │   │   │       └── name: :_
+            │           │   │   │   ├── optionals: (length: 0)
+            │           │   │   │   ├── posts: (length: 0)
+            │           │   │   │   ├── rest: ∅
+            │           │   │   │   ├── keywords: (length: 0)
+            │           │   │   │   ├── keyword_rest: ∅
+            │           │   │   │   └── block: ∅
+            │           │   │   ├── locals: (length: 0)
+            │           │   │   ├── opening_loc: (312...313) = "|"
+            │           │   │   └── closing_loc: (314...315) = "|"
+            │           │   ├── body: ∅
+            │           │   ├── opening_loc: (309...311) = "do"
+            │           │   └── closing_loc: (318...321) = "end"
+            │           ├── flags: 
+            │           └── name: "lambda"
+            ├── consequent:
+            │   @ IfNode (location: (322...382))
+            │   ├── if_keyword_loc: (322...327) = "elsif"
+            │   ├── predicate:
+            │   │   @ IntegerNode (location: (328...329))
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (332...351))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (332...351))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (332...338) = "lambda"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block:
+            │   │           │   @ BlockNode (location: (339...351))
+            │   │           │   ├── locals: [:_]
+            │   │           │   ├── parameters:
+            │   │           │   │   @ BlockParametersNode (location: (342...345))
+            │   │           │   │   ├── parameters:
+            │   │           │   │   │   @ ParametersNode (location: (343...344))
+            │   │           │   │   │   ├── requireds: (length: 1)
+            │   │           │   │   │   │   └── @ RequiredParameterNode (location: (343...344))
+            │   │           │   │   │   │       └── name: :_
+            │   │           │   │   │   ├── optionals: (length: 0)
+            │   │           │   │   │   ├── posts: (length: 0)
+            │   │           │   │   │   ├── rest: ∅
+            │   │           │   │   │   ├── keywords: (length: 0)
+            │   │           │   │   │   ├── keyword_rest: ∅
+            │   │           │   │   │   └── block: ∅
+            │   │           │   │   ├── locals: (length: 0)
+            │   │           │   │   ├── opening_loc: (342...343) = "|"
+            │   │           │   │   └── closing_loc: (344...345) = "|"
+            │   │           │   ├── body: ∅
+            │   │           │   ├── opening_loc: (339...341) = "do"
+            │   │           │   └── closing_loc: (348...351) = "end"
+            │   │           ├── flags: 
+            │   │           └── name: "lambda"
+            │   ├── consequent:
+            │   │   @ ElseNode (location: (352...382))
+            │   │   ├── else_keyword_loc: (352...356) = "else"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (359...378))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (359...378))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (359...365) = "lambda"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block:
+            │   │   │           │   @ BlockNode (location: (366...378))
+            │   │   │           │   ├── locals: [:_]
+            │   │   │           │   ├── parameters:
+            │   │   │           │   │   @ BlockParametersNode (location: (369...372))
+            │   │   │           │   │   ├── parameters:
+            │   │   │           │   │   │   @ ParametersNode (location: (370...371))
+            │   │   │           │   │   │   ├── requireds: (length: 1)
+            │   │   │           │   │   │   │   └── @ RequiredParameterNode (location: (370...371))
+            │   │   │           │   │   │   │       └── name: :_
+            │   │   │           │   │   │   ├── optionals: (length: 0)
+            │   │   │           │   │   │   ├── posts: (length: 0)
+            │   │   │           │   │   │   ├── rest: ∅
+            │   │   │           │   │   │   ├── keywords: (length: 0)
+            │   │   │           │   │   │   ├── keyword_rest: ∅
+            │   │   │           │   │   │   └── block: ∅
+            │   │   │           │   │   ├── locals: (length: 0)
+            │   │   │           │   │   ├── opening_loc: (369...370) = "|"
+            │   │   │           │   │   └── closing_loc: (371...372) = "|"
+            │   │   │           │   ├── body: ∅
+            │   │   │           │   ├── opening_loc: (366...368) = "do"
+            │   │   │           │   └── closing_loc: (375...378) = "end"
+            │   │   │           ├── flags: 
+            │   │   │           └── name: "lambda"
+            │   │   └── end_keyword_loc: (379...382) = "end"
+            │   └── end_keyword_loc: (379...382) = "end"
+            └── end_keyword_loc: (379...382) = "end"
diff --git a/test/yarp/snapshots/indented_file_end.txt b/test/yarp/snapshots/indented_file_end.txt
index bcdfba7302..ab9a2832c4 100644
--- a/test/yarp/snapshots/indented_file_end.txt
+++ b/test/yarp/snapshots/indented_file_end.txt
@@ -1,19 +1,18 @@
-ProgramNode(4...23)(
-  [],
-  StatementsNode(4...23)(
-    [DefNode(4...23)(
-       :hi,
-       (8...10),
-       nil,
-       nil,
-       nil,
-       [],
-       (4...7),
-       nil,
-       nil,
-       nil,
-       nil,
-       (20...23)
-     )]
-  )
-)
+@ ProgramNode (location: (4...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (4...23))
+    └── body: (length: 1)
+        └── @ DefNode (location: (4...23))
+            ├── name: :hi
+            ├── name_loc: (8...10) = "hi"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (4...7) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (20...23) = "end"
diff --git a/test/yarp/snapshots/integer_operations.txt b/test/yarp/snapshots/integer_operations.txt
index 5cade8a7d5..e446c1cdf1 100644
--- a/test/yarp/snapshots/integer_operations.txt
+++ b/test/yarp/snapshots/integer_operations.txt
@@ -1,383 +1,473 @@
-ProgramNode(0...247)(
-  [],
-  StatementsNode(0...247)(
-    [CallNode(0...2)(
-       IntegerNode(1...2)(),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(4...6)(
-       IntegerNode(5...6)(),
-       nil,
-       (4...5),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "~"
-     ),
-     CallNode(8...14)(
-       IntegerNode(8...9)(),
-       nil,
-       (10...12),
-       nil,
-       ArgumentsNode(13...14)([IntegerNode(13...14)()]),
-       nil,
-       nil,
-       0,
-       "!="
-     ),
-     CallNode(16...22)(
-       IntegerNode(16...17)(),
-       nil,
-       (18...20),
-       nil,
-       ArgumentsNode(21...22)([IntegerNode(21...22)()]),
-       nil,
-       nil,
-       0,
-       "!~"
-     ),
-     CallNode(24...29)(
-       IntegerNode(24...25)(),
-       nil,
-       (26...27),
-       nil,
-       ArgumentsNode(28...29)([IntegerNode(28...29)()]),
-       nil,
-       nil,
-       0,
-       "%"
-     ),
-     CallNode(31...36)(
-       IntegerNode(31...32)(),
-       nil,
-       (33...34),
-       nil,
-       ArgumentsNode(35...36)([IntegerNode(35...36)()]),
-       nil,
-       nil,
-       0,
-       "&"
-     ),
-     CallNode(38...43)(
-       IntegerNode(38...39)(),
-       nil,
-       (40...41),
-       nil,
-       ArgumentsNode(42...43)([IntegerNode(42...43)()]),
-       nil,
-       nil,
-       0,
-       "*"
-     ),
-     CallNode(45...49)(
-       IntegerNode(45...46)(),
-       nil,
-       (46...48),
-       nil,
-       ArgumentsNode(48...49)([IntegerNode(48...49)()]),
-       nil,
-       nil,
-       0,
-       "**"
-     ),
-     CallNode(51...56)(
-       IntegerNode(51...52)(),
-       nil,
-       (53...54),
-       nil,
-       ArgumentsNode(55...56)([IntegerNode(55...56)()]),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     CallNode(58...63)(
-       IntegerNode(58...59)(),
-       nil,
-       (60...61),
-       nil,
-       ArgumentsNode(62...63)([IntegerNode(62...63)()]),
-       nil,
-       nil,
-       0,
-       "-"
-     ),
-     CallNode(65...70)(
-       IntegerNode(65...66)(),
-       nil,
-       (67...68),
-       nil,
-       ArgumentsNode(69...70)([IntegerNode(69...70)()]),
-       nil,
-       nil,
-       0,
-       "/"
-     ),
-     CallNode(72...77)(
-       CallNode(72...75)(
-         IntegerNode(72...73)(),
-         nil,
-         (73...74),
-         nil,
-         ArgumentsNode(74...75)([IntegerNode(74...75)()]),
-         nil,
-         nil,
-         0,
-         "/"
-       ),
-       nil,
-       (75...76),
-       nil,
-       ArgumentsNode(76...77)([IntegerNode(76...77)()]),
-       nil,
-       nil,
-       0,
-       "/"
-     ),
-     CallNode(79...84)(
-       IntegerNode(79...80)(),
-       nil,
-       (81...82),
-       nil,
-       ArgumentsNode(83...84)([IntegerNode(83...84)()]),
-       nil,
-       nil,
-       0,
-       "<"
-     ),
-     CallNode(86...92)(
-       IntegerNode(86...87)(),
-       nil,
-       (88...90),
-       nil,
-       ArgumentsNode(91...92)([IntegerNode(91...92)()]),
-       nil,
-       nil,
-       0,
-       "<<"
-     ),
-     CallNode(94...100)(
-       IntegerNode(94...95)(),
-       nil,
-       (96...98),
-       nil,
-       ArgumentsNode(99...100)([IntegerNode(99...100)()]),
-       nil,
-       nil,
-       0,
-       "<="
-     ),
-     CallNode(102...109)(
-       IntegerNode(102...103)(),
-       nil,
-       (104...107),
-       nil,
-       ArgumentsNode(108...109)([IntegerNode(108...109)()]),
-       nil,
-       nil,
-       0,
-       "<=>"
-     ),
-     CallNode(111...117)(
-       IntegerNode(111...112)(),
-       nil,
-       (113...115),
-       nil,
-       ArgumentsNode(116...117)([IntegerNode(116...117)()]),
-       nil,
-       nil,
-       0,
-       "=="
-     ),
-     CallNode(119...126)(
-       IntegerNode(119...120)(),
-       nil,
-       (121...124),
-       nil,
-       ArgumentsNode(125...126)([IntegerNode(125...126)()]),
-       nil,
-       nil,
-       0,
-       "==="
-     ),
-     CallNode(128...134)(
-       IntegerNode(128...129)(),
-       nil,
-       (130...132),
-       nil,
-       ArgumentsNode(133...134)([IntegerNode(133...134)()]),
-       nil,
-       nil,
-       0,
-       "=~"
-     ),
-     CallNode(136...141)(
-       IntegerNode(136...137)(),
-       nil,
-       (138...139),
-       nil,
-       ArgumentsNode(140...141)([IntegerNode(140...141)()]),
-       nil,
-       nil,
-       0,
-       ">"
-     ),
-     CallNode(143...149)(
-       IntegerNode(143...144)(),
-       nil,
-       (145...147),
-       nil,
-       ArgumentsNode(148...149)([IntegerNode(148...149)()]),
-       nil,
-       nil,
-       0,
-       ">="
-     ),
-     CallNode(151...157)(
-       IntegerNode(151...152)(),
-       nil,
-       (153...155),
-       nil,
-       ArgumentsNode(156...157)([IntegerNode(156...157)()]),
-       nil,
-       nil,
-       0,
-       ">>"
-     ),
-     CallNode(159...164)(
-       IntegerNode(159...160)(),
-       nil,
-       (161...162),
-       nil,
-       ArgumentsNode(163...164)([IntegerNode(163...164)()]),
-       nil,
-       nil,
-       0,
-       "^"
-     ),
-     CallNode(166...171)(
-       IntegerNode(166...167)(),
-       nil,
-       (168...169),
-       nil,
-       ArgumentsNode(170...171)([IntegerNode(170...171)()]),
-       nil,
-       nil,
-       0,
-       "|"
-     ),
-     AndNode(173...179)(
-       IntegerNode(173...174)(),
-       IntegerNode(178...179)(),
-       (175...177)
-     ),
-     AndNode(181...188)(
-       IntegerNode(181...182)(),
-       IntegerNode(187...188)(),
-       (183...186)
-     ),
-     CallNode(190...200)(
-       IntegerNode(190...191)(),
-       nil,
-       (192...193),
-       nil,
-       ArgumentsNode(194...200)(
-         [CallNode(194...200)(
-            IntegerNode(194...195)(),
-            nil,
-            (196...198),
-            nil,
-            ArgumentsNode(199...200)([IntegerNode(199...200)()]),
-            nil,
-            nil,
-            0,
-            "**"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "*"
-     ),
-     CallNode(202...211)(
-       CallNode(202...207)(
-         IntegerNode(202...203)(),
-         nil,
-         (204...205),
-         nil,
-         ArgumentsNode(206...207)([IntegerNode(206...207)()]),
-         nil,
-         nil,
-         0,
-         "*"
-       ),
-       nil,
-       (208...209),
-       nil,
-       ArgumentsNode(210...211)([IntegerNode(210...211)()]),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     OrNode(213...219)(
-       IntegerNode(213...214)(),
-       IntegerNode(218...219)(),
-       (215...217)
-     ),
-     OrNode(221...227)(
-       IntegerNode(221...222)(),
-       IntegerNode(226...227)(),
-       (223...225)
-     ),
-     CallNode(229...238)(
-       IntegerNode(229...230)(),
-       nil,
-       (231...232),
-       nil,
-       ArgumentsNode(233...238)(
-         [CallNode(233...238)(
-            IntegerNode(233...234)(),
-            nil,
-            (235...236),
-            nil,
-            ArgumentsNode(237...238)([IntegerNode(237...238)()]),
-            nil,
-            nil,
-            0,
-            "*"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     ParenthesesNode(240...247)(
-       StatementsNode(241...246)(
-         [CallNode(241...246)(
-            IntegerNode(241...242)(),
-            nil,
-            (243...244),
-            nil,
-            ArgumentsNode(245...246)([IntegerNode(245...246)()]),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       ),
-       (240...241),
-       (246...247)
-     )]
-  )
-)
+@ ProgramNode (location: (0...247))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...247))
+    └── body: (length: 32)
+        ├── @ CallNode (location: (0...2))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (1...2))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (4...6))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (5...6))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (4...5) = "~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "~"
+        ├── @ CallNode (location: (8...14))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (8...9))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (10...12) = "!="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (13...14))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (13...14))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!="
+        ├── @ CallNode (location: (16...22))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (16...17))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (18...20) = "!~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (21...22))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (21...22))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!~"
+        ├── @ CallNode (location: (24...29))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (24...25))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (26...27) = "%"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (28...29))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (28...29))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "%"
+        ├── @ CallNode (location: (31...36))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (31...32))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (33...34) = "&"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (35...36))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (35...36))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "&"
+        ├── @ CallNode (location: (38...43))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (38...39))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (40...41) = "*"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (42...43))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (42...43))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "*"
+        ├── @ CallNode (location: (45...49))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (45...46))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (46...48) = "**"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (48...49))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (48...49))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "**"
+        ├── @ CallNode (location: (51...56))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (51...52))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (53...54) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (55...56))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (55...56))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        ├── @ CallNode (location: (58...63))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (58...59))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (60...61) = "-"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (62...63))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (62...63))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "-"
+        ├── @ CallNode (location: (65...70))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (65...66))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (67...68) = "/"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (69...70))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (69...70))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "/"
+        ├── @ CallNode (location: (72...77))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (72...75))
+        │   │   ├── receiver:
+        │   │   │   @ IntegerNode (location: (72...73))
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (73...74) = "/"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (74...75))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (74...75))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "/"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (75...76) = "/"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (76...77))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (76...77))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "/"
+        ├── @ CallNode (location: (79...84))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (79...80))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (81...82) = "<"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (83...84))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (83...84))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<"
+        ├── @ CallNode (location: (86...92))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (86...87))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (88...90) = "<<"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (91...92))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (91...92))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<<"
+        ├── @ CallNode (location: (94...100))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (94...95))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (96...98) = "<="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (99...100))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (99...100))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<="
+        ├── @ CallNode (location: (102...109))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (102...103))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (104...107) = "<=>"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (108...109))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (108...109))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<=>"
+        ├── @ CallNode (location: (111...117))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (111...112))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (113...115) = "=="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (116...117))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (116...117))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=="
+        ├── @ CallNode (location: (119...126))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (119...120))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (121...124) = "==="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (125...126))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (125...126))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "==="
+        ├── @ CallNode (location: (128...134))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (128...129))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (130...132) = "=~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (133...134))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (133...134))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=~"
+        ├── @ CallNode (location: (136...141))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (136...137))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (138...139) = ">"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (140...141))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (140...141))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: ">"
+        ├── @ CallNode (location: (143...149))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (143...144))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (145...147) = ">="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (148...149))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (148...149))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: ">="
+        ├── @ CallNode (location: (151...157))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (151...152))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (153...155) = ">>"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (156...157))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (156...157))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: ">>"
+        ├── @ CallNode (location: (159...164))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (159...160))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (161...162) = "^"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (163...164))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (163...164))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "^"
+        ├── @ CallNode (location: (166...171))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (166...167))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (168...169) = "|"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (170...171))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (170...171))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "|"
+        ├── @ AndNode (location: (173...179))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (173...174))
+        │   ├── right:
+        │   │   @ IntegerNode (location: (178...179))
+        │   └── operator_loc: (175...177) = "&&"
+        ├── @ AndNode (location: (181...188))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (181...182))
+        │   ├── right:
+        │   │   @ IntegerNode (location: (187...188))
+        │   └── operator_loc: (183...186) = "and"
+        ├── @ CallNode (location: (190...200))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (190...191))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (192...193) = "*"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (194...200))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (194...200))
+        │   │           ├── receiver:
+        │   │           │   @ IntegerNode (location: (194...195))
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (196...198) = "**"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (199...200))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (199...200))
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "**"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "*"
+        ├── @ CallNode (location: (202...211))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (202...207))
+        │   │   ├── receiver:
+        │   │   │   @ IntegerNode (location: (202...203))
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (204...205) = "*"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (206...207))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (206...207))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "*"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (208...209) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (210...211))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (210...211))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        ├── @ OrNode (location: (213...219))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (213...214))
+        │   ├── right:
+        │   │   @ IntegerNode (location: (218...219))
+        │   └── operator_loc: (215...217) = "or"
+        ├── @ OrNode (location: (221...227))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (221...222))
+        │   ├── right:
+        │   │   @ IntegerNode (location: (226...227))
+        │   └── operator_loc: (223...225) = "||"
+        ├── @ CallNode (location: (229...238))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (229...230))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (231...232) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (233...238))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (233...238))
+        │   │           ├── receiver:
+        │   │           │   @ IntegerNode (location: (233...234))
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (235...236) = "*"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (237...238))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (237...238))
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "*"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        └── @ ParenthesesNode (location: (240...247))
+            ├── body:
+            │   @ StatementsNode (location: (241...246))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (241...246))
+            │           ├── receiver:
+            │           │   @ IntegerNode (location: (241...242))
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (243...244) = "+"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (245...246))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ IntegerNode (location: (245...246))
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "+"
+            ├── opening_loc: (240...241) = "("
+            └── closing_loc: (246...247) = ")"
diff --git a/test/yarp/snapshots/keyword_method_names.txt b/test/yarp/snapshots/keyword_method_names.txt
index 293164bb1e..e3d8256658 100644
--- a/test/yarp/snapshots/keyword_method_names.txt
+++ b/test/yarp/snapshots/keyword_method_names.txt
@@ -1,151 +1,168 @@
-ProgramNode(0...185)(
-  [],
-  StatementsNode(0...185)(
-    [DefNode(0...11)(
-       :def,
-       (4...7),
-       nil,
-       nil,
-       nil,
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (8...11)
-     ),
-     DefNode(13...32)(
-       :ensure,
-       (22...28),
-       SelfNode(17...21)(),
-       nil,
-       nil,
-       [],
-       (13...16),
-       (21...22),
-       nil,
-       nil,
-       nil,
-       (29...32)
-     ),
-     CallNode(34...68)(
-       nil,
-       nil,
-       (34...41),
-       nil,
-       ArgumentsNode(42...68)(
-         [DefNode(42...68)(
-            :foo,
-            (46...49),
-            nil,
-            nil,
-            StatementsNode(52...64)(
-              [CallNode(52...64)(
-                 nil,
-                 nil,
-                 (52...55),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(56...64)([], nil, nil, (56...58), (61...64)),
-                 0,
-                 "bar"
-               )]
-            ),
-            [],
-            (42...45),
-            nil,
-            nil,
-            nil,
-            nil,
-            (65...68)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "private"
-     ),
-     DefNode(70...89)(
-       :m,
-       (74...75),
-       nil,
-       ParametersNode(76...84)(
-         [RequiredParameterNode(76...77)(:a)],
-         [],
-         [],
-         nil,
-         [],
-         NoKeywordsParameterNode(79...84)((79...81), (81...84)),
-         nil
-       ),
-       nil,
-       [:a],
-       (70...73),
-       nil,
-       (75...76),
-       (84...85),
-       nil,
-       (86...89)
-     ),
-     DefNode(91...113)(
-       :a,
-       (108...109),
-       SourceEncodingNode(95...107)(),
-       nil,
-       nil,
-       [],
-       (91...94),
-       (107...108),
-       nil,
-       nil,
-       nil,
-       (110...113)
-     ),
-     StringNode(115...121)((115...117), (117...120), (120...121), "abc"),
-     StringNode(123...129)((123...125), (125...128), (128...129), "abc"),
-     DefNode(131...149)(
-       :a,
-       (144...145),
-       SourceFileNode(135...143)("keyword_method_names.txt"),
-       nil,
-       nil,
-       [],
-       (131...134),
-       (143...144),
-       nil,
-       nil,
-       nil,
-       (146...149)
-     ),
-     DefNode(151...169)(
-       :a,
-       (164...165),
-       SourceLineNode(155...163)(),
-       nil,
-       nil,
-       [],
-       (151...154),
-       (163...164),
-       nil,
-       nil,
-       nil,
-       (166...169)
-     ),
-     DefNode(171...185)(
-       :a,
-       (180...181),
-       NilNode(175...178)(),
-       nil,
-       nil,
-       [],
-       (171...174),
-       (178...180),
-       nil,
-       nil,
-       nil,
-       (182...185)
-     )]
-  )
-)
+@ ProgramNode (location: (0...185))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...185))
+    └── body: (length: 10)
+        ├── @ DefNode (location: (0...11))
+        │   ├── name: :def
+        │   ├── name_loc: (4...7) = "def"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (8...11) = "end"
+        ├── @ DefNode (location: (13...32))
+        │   ├── name: :ensure
+        │   ├── name_loc: (22...28) = "ensure"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (17...21))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (13...16) = "def"
+        │   ├── operator_loc: (21...22) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (29...32) = "end"
+        ├── @ CallNode (location: (34...68))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (34...41) = "private"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (42...68))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ DefNode (location: (42...68))
+        │   │           ├── name: :foo
+        │   │           ├── name_loc: (46...49) = "foo"
+        │   │           ├── receiver: ∅
+        │   │           ├── parameters: ∅
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (52...64))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (52...64))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (52...55) = "bar"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block:
+        │   │           │           │   @ BlockNode (location: (56...64))
+        │   │           │           │   ├── locals: []
+        │   │           │           │   ├── parameters: ∅
+        │   │           │           │   ├── body: ∅
+        │   │           │           │   ├── opening_loc: (56...58) = "do"
+        │   │           │           │   └── closing_loc: (61...64) = "end"
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "bar"
+        │   │           ├── locals: []
+        │   │           ├── def_keyword_loc: (42...45) = "def"
+        │   │           ├── operator_loc: ∅
+        │   │           ├── lparen_loc: ∅
+        │   │           ├── rparen_loc: ∅
+        │   │           ├── equal_loc: ∅
+        │   │           └── end_keyword_loc: (65...68) = "end"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "private"
+        ├── @ DefNode (location: (70...89))
+        │   ├── name: :m
+        │   ├── name_loc: (74...75) = "m"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (76...84))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (76...77))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ NoKeywordsParameterNode (location: (79...84))
+        │   │   │   ├── operator_loc: (79...81) = "**"
+        │   │   │   └── keyword_loc: (81...84) = "nil"
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (70...73) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (75...76) = "("
+        │   ├── rparen_loc: (84...85) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (86...89) = "end"
+        ├── @ DefNode (location: (91...113))
+        │   ├── name: :a
+        │   ├── name_loc: (108...109) = "a"
+        │   ├── receiver:
+        │   │   @ SourceEncodingNode (location: (95...107))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (91...94) = "def"
+        │   ├── operator_loc: (107...108) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (110...113) = "end"
+        ├── @ StringNode (location: (115...121))
+        │   ├── opening_loc: (115...117) = "%{"
+        │   ├── content_loc: (117...120) = "abc"
+        │   ├── closing_loc: (120...121) = "}"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (123...129))
+        │   ├── opening_loc: (123...125) = "%\""
+        │   ├── content_loc: (125...128) = "abc"
+        │   ├── closing_loc: (128...129) = "\""
+        │   └── unescaped: "abc"
+        ├── @ DefNode (location: (131...149))
+        │   ├── name: :a
+        │   ├── name_loc: (144...145) = "a"
+        │   ├── receiver:
+        │   │   @ SourceFileNode (location: (135...143))
+        │   │   └── filepath: "keyword_method_names.txt"
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (131...134) = "def"
+        │   ├── operator_loc: (143...144) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (146...149) = "end"
+        ├── @ DefNode (location: (151...169))
+        │   ├── name: :a
+        │   ├── name_loc: (164...165) = "a"
+        │   ├── receiver:
+        │   │   @ SourceLineNode (location: (155...163))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (151...154) = "def"
+        │   ├── operator_loc: (163...164) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (166...169) = "end"
+        └── @ DefNode (location: (171...185))
+            ├── name: :a
+            ├── name_loc: (180...181) = "a"
+            ├── receiver:
+            │   @ NilNode (location: (175...178))
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (171...174) = "def"
+            ├── operator_loc: (178...180) = "::"
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (182...185) = "end"
diff --git a/test/yarp/snapshots/keywords.txt b/test/yarp/snapshots/keywords.txt
index c949b291aa..1e9e99ccca 100644
--- a/test/yarp/snapshots/keywords.txt
+++ b/test/yarp/snapshots/keywords.txt
@@ -1,11 +1,12 @@
-ProgramNode(0...51)(
-  [],
-  StatementsNode(0...51)(
-    [RedoNode(0...4)(),
-     RetryNode(6...11)(),
-     SelfNode(13...17)(),
-     SourceEncodingNode(19...31)(),
-     SourceFileNode(33...41)("keywords.txt"),
-     SourceLineNode(43...51)()]
-  )
-)
+@ ProgramNode (location: (0...51))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...51))
+    └── body: (length: 6)
+        ├── @ RedoNode (location: (0...4))
+        ├── @ RetryNode (location: (6...11))
+        ├── @ SelfNode (location: (13...17))
+        ├── @ SourceEncodingNode (location: (19...31))
+        ├── @ SourceFileNode (location: (33...41))
+        │   └── filepath: "keywords.txt"
+        └── @ SourceLineNode (location: (43...51))
diff --git a/test/yarp/snapshots/lambda.txt b/test/yarp/snapshots/lambda.txt
index 01846d7c14..e790c2ede0 100644
--- a/test/yarp/snapshots/lambda.txt
+++ b/test/yarp/snapshots/lambda.txt
@@ -1,188 +1,192 @@
-ProgramNode(0...92)(
-  [],
-  StatementsNode(0...92)(
-    [LambdaNode(0...14)(
-       [:foo],
-       (0...2),
-       (12...13),
-       (13...14),
-       BlockParametersNode(2...11)(
-         ParametersNode(6...9)(
-           [RequiredParameterNode(6...9)(:foo)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (2...3),
-         (10...11)
-       ),
-       nil
-     ),
-     LambdaNode(16...34)(
-       [:x],
-       (16...18),
-       (31...32),
-       (33...34),
-       BlockParametersNode(18...30)(
-         ParametersNode(19...29)(
-           [],
-           [],
-           [],
-           nil,
-           [KeywordParameterNode(19...29)(
-              :x,
-              (19...21),
-              InterpolatedStringNode(22...29)(
-                (22...23),
-                [StringNode(23...24)(nil, (23...24), nil, "b"),
-                 EmbeddedStatementsNode(24...28)(
-                   (24...26),
-                   StatementsNode(26...27)(
-                     [CallNode(26...27)(
-                        nil,
-                        nil,
-                        (26...27),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "a"
-                      )]
-                   ),
-                   (27...28)
-                 )],
-                (28...29)
-              )
-            )],
-           nil,
-           nil
-         ),
-         [],
-         (18...19),
-         (29...30)
-       ),
-       nil
-     ),
-     LambdaNode(36...51)(
-       [:a],
-       (36...38),
-       (49...50),
-       (50...51),
-       BlockParametersNode(38...48)(
-         ParametersNode(39...47)(
-           [],
-           [],
-           [],
-           nil,
-           [KeywordParameterNode(39...47)(
-              :a,
-              (39...41),
-              CallNode(42...47)(
-                CallNode(42...43)(
-                  nil,
-                  nil,
-                  (42...43),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "b"
-                ),
-                nil,
-                (44...45),
-                nil,
-                ArgumentsNode(46...47)([IntegerNode(46...47)()]),
-                nil,
-                nil,
-                0,
-                "*"
-              )
-            )],
-           nil,
-           nil
-         ),
-         [],
-         (38...39),
-         (47...48)
-       ),
-       nil
-     ),
-     LambdaNode(53...72)(
-       [:foo],
-       (53...55),
-       (66...68),
-       (69...72),
-       BlockParametersNode(56...65)(
-         ParametersNode(56...65)(
-           [],
-           [OptionalParameterNode(56...65)(
-              :foo,
-              (56...59),
-              (60...61),
-              CallNode(62...65)(
-                nil,
-                nil,
-                (62...65),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )
-            )],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         nil,
-         nil
-       ),
-       nil
-     ),
-     LambdaNode(74...92)(
-       [:foo],
-       (74...76),
-       (86...88),
-       (89...92),
-       BlockParametersNode(77...85)(
-         ParametersNode(77...85)(
-           [],
-           [],
-           [],
-           nil,
-           [KeywordParameterNode(77...85)(
-              :foo,
-              (77...81),
-              CallNode(82...85)(
-                nil,
-                nil,
-                (82...85),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )
-            )],
-           nil,
-           nil
-         ),
-         [],
-         nil,
-         nil
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...92))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...92))
+    └── body: (length: 5)
+        ├── @ LambdaNode (location: (0...14))
+        │   ├── locals: [:foo]
+        │   ├── operator_loc: (0...2) = "->"
+        │   ├── opening_loc: (12...13) = "{"
+        │   ├── closing_loc: (13...14) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (2...11))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (6...9))
+        │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   └── @ RequiredParameterNode (location: (6...9))
+        │   │   │   │       └── name: :foo
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (2...3) = "("
+        │   │   └── closing_loc: (10...11) = ")"
+        │   └── body: ∅
+        ├── @ LambdaNode (location: (16...34))
+        │   ├── locals: [:x]
+        │   ├── operator_loc: (16...18) = "->"
+        │   ├── opening_loc: (31...32) = "{"
+        │   ├── closing_loc: (33...34) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (18...30))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (19...29))
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 1)
+        │   │   │   │   └── @ KeywordParameterNode (location: (19...29))
+        │   │   │   │       ├── name: :x
+        │   │   │   │       ├── name_loc: (19...21) = "x:"
+        │   │   │   │       └── value:
+        │   │   │   │           @ InterpolatedStringNode (location: (22...29))
+        │   │   │   │           ├── opening_loc: (22...23) = "\""
+        │   │   │   │           ├── parts: (length: 2)
+        │   │   │   │           │   ├── @ StringNode (location: (23...24))
+        │   │   │   │           │   │   ├── opening_loc: ∅
+        │   │   │   │           │   │   ├── content_loc: (23...24) = "b"
+        │   │   │   │           │   │   ├── closing_loc: ∅
+        │   │   │   │           │   │   └── unescaped: "b"
+        │   │   │   │           │   └── @ EmbeddedStatementsNode (location: (24...28))
+        │   │   │   │           │       ├── opening_loc: (24...26) = "\#{"
+        │   │   │   │           │       ├── statements:
+        │   │   │   │           │       │   @ StatementsNode (location: (26...27))
+        │   │   │   │           │       │   └── body: (length: 1)
+        │   │   │   │           │       │       └── @ CallNode (location: (26...27))
+        │   │   │   │           │       │           ├── receiver: ∅
+        │   │   │   │           │       │           ├── call_operator_loc: ∅
+        │   │   │   │           │       │           ├── message_loc: (26...27) = "a"
+        │   │   │   │           │       │           ├── opening_loc: ∅
+        │   │   │   │           │       │           ├── arguments: ∅
+        │   │   │   │           │       │           ├── closing_loc: ∅
+        │   │   │   │           │       │           ├── block: ∅
+        │   │   │   │           │       │           ├── flags: variable_call
+        │   │   │   │           │       │           └── name: "a"
+        │   │   │   │           │       └── closing_loc: (27...28) = "}"
+        │   │   │   │           └── closing_loc: (28...29) = "\""
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (18...19) = "("
+        │   │   └── closing_loc: (29...30) = ")"
+        │   └── body: ∅
+        ├── @ LambdaNode (location: (36...51))
+        │   ├── locals: [:a]
+        │   ├── operator_loc: (36...38) = "->"
+        │   ├── opening_loc: (49...50) = "{"
+        │   ├── closing_loc: (50...51) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (38...48))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (39...47))
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 1)
+        │   │   │   │   └── @ KeywordParameterNode (location: (39...47))
+        │   │   │   │       ├── name: :a
+        │   │   │   │       ├── name_loc: (39...41) = "a:"
+        │   │   │   │       └── value:
+        │   │   │   │           @ CallNode (location: (42...47))
+        │   │   │   │           ├── receiver:
+        │   │   │   │           │   @ CallNode (location: (42...43))
+        │   │   │   │           │   ├── receiver: ∅
+        │   │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │   │           │   ├── message_loc: (42...43) = "b"
+        │   │   │   │           │   ├── opening_loc: ∅
+        │   │   │   │           │   ├── arguments: ∅
+        │   │   │   │           │   ├── closing_loc: ∅
+        │   │   │   │           │   ├── block: ∅
+        │   │   │   │           │   ├── flags: variable_call
+        │   │   │   │           │   └── name: "b"
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (44...45) = "*"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments:
+        │   │   │   │           │   @ ArgumentsNode (location: (46...47))
+        │   │   │   │           │   └── arguments: (length: 1)
+        │   │   │   │           │       └── @ IntegerNode (location: (46...47))
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: 
+        │   │   │   │           └── name: "*"
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (38...39) = "("
+        │   │   └── closing_loc: (47...48) = ")"
+        │   └── body: ∅
+        ├── @ LambdaNode (location: (53...72))
+        │   ├── locals: [:foo]
+        │   ├── operator_loc: (53...55) = "->"
+        │   ├── opening_loc: (66...68) = "do"
+        │   ├── closing_loc: (69...72) = "end"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (56...65))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (56...65))
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   └── @ OptionalParameterNode (location: (56...65))
+        │   │   │   │       ├── name: :foo
+        │   │   │   │       ├── name_loc: (56...59) = "foo"
+        │   │   │   │       ├── operator_loc: (60...61) = "="
+        │   │   │   │       └── value:
+        │   │   │   │           @ CallNode (location: (62...65))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (62...65) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── body: ∅
+        └── @ LambdaNode (location: (74...92))
+            ├── locals: [:foo]
+            ├── operator_loc: (74...76) = "->"
+            ├── opening_loc: (86...88) = "do"
+            ├── closing_loc: (89...92) = "end"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (77...85))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (77...85))
+            │   │   ├── requireds: (length: 0)
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 1)
+            │   │   │   └── @ KeywordParameterNode (location: (77...85))
+            │   │   │       ├── name: :foo
+            │   │   │       ├── name_loc: (77...81) = "foo:"
+            │   │   │       └── value:
+            │   │   │           @ CallNode (location: (82...85))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (82...85) = "bar"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "bar"
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: ∅
+            │   └── closing_loc: ∅
+            └── body: ∅
diff --git a/test/yarp/snapshots/method_calls.txt b/test/yarp/snapshots/method_calls.txt
index 37f03ef25f..86ffab5d2a 100644
--- a/test/yarp/snapshots/method_calls.txt
+++ b/test/yarp/snapshots/method_calls.txt
@@ -1,1656 +1,2159 @@
-ProgramNode(0...1237)(
-  [],
-  StatementsNode(0...1237)(
-    [CallNode(0...14)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       (4...7),
-       nil,
-       ArgumentsNode(8...14)(
-         [StringNode(8...14)((8...10), (10...13), (13...14), "baz")]
-       ),
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(16...25)(
-       CallNode(16...17)(nil, nil, (16...17), nil, nil, nil, nil, 2, "a"),
-       (17...18),
-       (18...19),
-       (19...20),
-       ArgumentsNode(20...24)(
-         [CallNode(20...21)(nil, nil, (20...21), nil, nil, nil, nil, 2, "c"),
-          CallNode(23...24)(nil, nil, (23...24), nil, nil, nil, nil, 2, "d")]
-       ),
-       (24...25),
-       nil,
-       0,
-       "b"
-     ),
-     CallNode(27...32)(
-       CallNode(27...28)(nil, nil, (27...28), nil, nil, nil, nil, 2, "a"),
-       (28...29),
-       (29...30),
-       (30...31),
-       nil,
-       (31...32),
-       nil,
-       0,
-       "b"
-     ),
-     CallNode(34...52)(
-       CallNode(34...44)(
-         CallNode(34...37)(nil, nil, (34...37), nil, nil, nil, nil, 2, "foo"),
-         (40...41),
-         (41...44),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "bar"
-       ),
-       (47...49),
-       (49...52),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "baz"
-     ),
-     CallNode(54...56)(nil, nil, (54...56), nil, nil, nil, nil, 0, "a!"),
-     CallNode(58...62)(
-       CallNode(58...59)(nil, nil, (58...59), nil, nil, nil, nil, 2, "a"),
-       (59...60),
-       nil,
-       (60...61),
-       nil,
-       (61...62),
-       nil,
-       0,
-       "call"
-     ),
-     CallNode(64...75)(
-       CallNode(64...65)(nil, nil, (64...65), nil, nil, nil, nil, 2, "a"),
-       (65...66),
-       nil,
-       (66...67),
-       ArgumentsNode(67...74)(
-         [IntegerNode(67...68)(),
-          IntegerNode(70...71)(),
-          IntegerNode(73...74)()]
-       ),
-       (74...75),
-       nil,
-       0,
-       "call"
-     ),
-     CallNode(77...81)(
-       CallNode(77...78)(nil, nil, (77...78), nil, nil, nil, nil, 2, "a"),
-       (78...80),
-       (80...81),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "b"
-     ),
-     CallNode(83...89)(
-       CallNode(83...84)(nil, nil, (83...84), nil, nil, nil, nil, 2, "a"),
-       (84...86),
-       (86...87),
-       nil,
-       ArgumentsNode(88...89)(
-         [CallNode(88...89)(nil, nil, (88...89), nil, nil, nil, nil, 2, "c")]
-       ),
-       nil,
-       nil,
-       0,
-       "b"
-     ),
-     CallNode(91...102)(
-       CallNode(91...94)(nil, nil, (91...94), nil, nil, nil, nil, 2, "foo"),
-       (94...95),
-       (95...98),
-       nil,
-       ArgumentsNode(101...102)([IntegerNode(101...102)()]),
-       nil,
-       nil,
-       0,
-       "bar="
-     ),
-     CallNode(104...106)(nil, nil, (104...106), nil, nil, nil, nil, 0, "a?"),
-     CallNode(108...117)(
-       nil,
-       nil,
-       (108...109),
-       (109...110),
-       ArgumentsNode(110...116)(
-         [BlockArgumentNode(110...116)(
-            CallNode(111...116)(
-              nil,
-              nil,
-              (111...116),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "block"
-            ),
-            (110...111)
-          )]
-       ),
-       (116...117),
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(119...130)(
-       nil,
-       nil,
-       (119...120),
-       (120...121),
-       ArgumentsNode(121...129)(
-         [KeywordHashNode(121...129)(
-            [AssocSplatNode(121...129)(
-               CallNode(123...129)(
-                 nil,
-                 nil,
-                 (123...129),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "kwargs"
-               ),
-               (121...123)
-             )]
-          )]
-       ),
-       (129...130),
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(132...137)(
-       CallNode(132...135)(
-         CallNode(132...133)(
-           nil,
-           nil,
-           (132...133),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "a"
-         ),
-         (133...134),
-         (134...135),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "b"
-       ),
-       (135...136),
-       (136...137),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "c"
-     ),
-     CallNode(139...146)(
-       nil,
-       nil,
-       (139...140),
-       (140...141),
-       ArgumentsNode(141...145)(
-         [CallNode(141...142)(
-            nil,
-            nil,
-            (141...142),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          ),
-          CallNode(144...145)(
-            nil,
-            nil,
-            (144...145),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "c"
-          )]
-       ),
-       (145...146),
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(148...151)(
-       nil,
-       nil,
-       (148...149),
-       (149...150),
-       nil,
-       (150...151),
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(153...161)(
-       nil,
-       nil,
-       (153...154),
-       (154...155),
-       ArgumentsNode(155...160)(
-         [SplatNode(155...160)(
-            (155...156),
-            CallNode(156...160)(
-              nil,
-              nil,
-              (156...160),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "args"
-            )
-          )]
-       ),
-       (160...161),
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(163...169)(
-       nil,
-       nil,
-       (163...164),
-       nil,
-       ArgumentsNode(165...169)(
-         [CallNode(165...166)(
-            nil,
-            nil,
-            (165...166),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          ),
-          CallNode(168...169)(
-            nil,
-            nil,
-            (168...169),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "c"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(171...179)(
-       CallNode(171...172)(nil, nil, (171...172), nil, nil, nil, nil, 2, "a"),
-       (172...173),
-       (173...174),
-       nil,
-       ArgumentsNode(175...179)(
-         [CallNode(175...176)(
-            nil,
-            nil,
-            (175...176),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "c"
-          ),
-          CallNode(178...179)(
-            nil,
-            nil,
-            (178...179),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "d"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "b"
-     ),
-     MultiWriteNode(181...204)(
-       [CallNode(181...188)(
-          CallNode(181...184)(
-            nil,
-            nil,
-            (181...184),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          ),
-          (184...185),
-          (185...188),
-          nil,
-          nil,
-          nil,
-          nil,
-          0,
-          "foo="
-        ),
-        CallNode(190...197)(
-          CallNode(190...193)(
-            nil,
-            nil,
-            (190...193),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          ),
-          (193...194),
-          (194...197),
-          nil,
-          nil,
-          nil,
-          nil,
-          0,
-          "bar="
-        )],
-       nil,
-       nil,
-       (198...199),
-       ArrayNode(200...204)(
-         [IntegerNode(200...201)(), IntegerNode(203...204)()],
-         nil,
-         nil
-       )
-     ),
-     CallNode(206...210)(
-       CallNode(206...207)(nil, nil, (206...207), nil, nil, nil, nil, 2, "a"),
-       (207...209),
-       (209...210),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "b"
-     ),
-     CallNode(212...217)(
-       CallNode(212...213)(nil, nil, (212...213), nil, nil, nil, nil, 2, "a"),
-       (213...215),
-       nil,
-       (215...216),
-       nil,
-       (216...217),
-       nil,
-       1,
-       "call"
-     ),
-     CallNode(219...226)(
-       CallNode(219...220)(nil, nil, (219...220), nil, nil, nil, nil, 2, "a"),
-       (220...222),
-       (222...223),
-       (223...224),
-       ArgumentsNode(224...225)(
-         [CallNode(224...225)(
-            nil,
-            nil,
-            (224...225),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "c"
-          )]
-       ),
-       (225...226),
-       nil,
-       1,
-       "b"
-     ),
-     CallNode(228...234)(
-       CallNode(228...229)(nil, nil, (228...229), nil, nil, nil, nil, 2, "a"),
-       (229...231),
-       (231...232),
-       (232...233),
-       nil,
-       (233...234),
-       nil,
-       1,
-       "b"
-     ),
-     IfNode(236...269)(
-       (247...249),
-       AndNode(250...269)(
-         OrNode(250...261)(
-           CallNode(250...254)(
-             nil,
-             nil,
-             (250...254),
-             nil,
-             nil,
-             nil,
-             nil,
-             0,
-             "bar?"
-           ),
-           CallNode(258...261)(
-             nil,
-             nil,
-             (258...261),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "baz"
-           ),
-           (255...257)
-         ),
-         CallNode(266...269)(
-           nil,
-           nil,
-           (266...269),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "qux"
-         ),
-         (262...265)
-       ),
-       StatementsNode(236...246)(
-         [CallNode(236...246)(
-            nil,
-            nil,
-            (236...239),
-            nil,
-            ArgumentsNode(240...246)(
-              [SymbolNode(240...242)((240...241), (241...242), nil, "a"),
-               SymbolNode(244...246)((244...245), (245...246), nil, "b")]
-            ),
-            nil,
-            nil,
-            0,
-            "foo"
-          )]
-       ),
-       nil,
-       nil
-     ),
-     CallNode(271...286)(
-       nil,
-       nil,
-       (271...274),
-       (274...275),
-       ArgumentsNode(275...284)(
-         [SymbolNode(275...277)((275...276), (276...277), nil, "a"),
-          SymbolNode(282...284)((282...283), (283...284), nil, "b")]
-       ),
-       (285...286),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(288...298)(
-       nil,
-       nil,
-       (288...291),
-       (291...292),
-       ArgumentsNode(292...297)(
-         [SplatNode(292...297)(
-            (292...293),
-            CallNode(293...297)(
-              nil,
-              nil,
-              (293...297),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "rest"
-            )
-          )]
-       ),
-       (297...298),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(300...340)(
-       nil,
-       nil,
-       (300...303),
-       (303...304),
-       ArgumentsNode(304...339)(
-         [SymbolNode(304...306)((304...305), (305...306), nil, "a"),
-          KeywordHashNode(308...332)(
-            [AssocNode(308...322)(
-               SymbolNode(308...310)((308...309), (309...310), nil, "h"),
-               ArrayNode(314...322)(
-                 [SymbolNode(315...317)((315...316), (316...317), nil, "x"),
-                  SymbolNode(319...321)((319...320), (320...321), nil, "y")],
-                 (314...315),
-                 (321...322)
-               ),
-               (311...313)
-             ),
-             AssocNode(324...332)(
-               SymbolNode(324...326)((324...325), (325...326), nil, "a"),
-               SymbolNode(330...332)((330...331), (331...332), nil, "b"),
-               (327...329)
-             )]
-          ),
-          BlockArgumentNode(334...339)(
-            SymbolNode(335...339)((335...336), (336...339), nil, "bar"),
-            (334...335)
-          )]
-       ),
-       (339...340),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(342...391)(
-       nil,
-       nil,
-       (342...344),
-       nil,
-       ArgumentsNode(345...391)(
-         [IntegerNode(345...348)(),
-          HashNode(350...391)(
-            (350...351),
-            [AssocNode(352...369)(
-               SymbolNode(352...358)((352...353), (353...358), nil, "there"),
-               SymbolNode(362...369)((362...363), (363...369), nil, "friend"),
-               (359...361)
-             ),
-             AssocSplatNode(371...375)(
-               HashNode(373...375)((373...374), [], (374...375)),
-               (371...373)
-             ),
-             AssocNode(377...389)(
-               SymbolNode(377...384)(nil, (377...383), (383...384), "whatup"),
-               SymbolNode(385...389)((385...386), (386...389), nil, "dog"),
-               nil
-             )],
-            (390...391)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "hi"
-     ),
-     CallNode(393...429)(
-       nil,
-       nil,
-       (393...396),
-       nil,
-       ArgumentsNode(397...408)(
-         [SymbolNode(397...399)((397...398), (398...399), nil, "a"),
-          KeywordHashNode(401...408)(
-            [AssocNode(401...408)(
-               SymbolNode(401...403)(nil, (401...402), (402...403), "b"),
-               TrueNode(404...408)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       BlockNode(409...429)(
-         [:a, :b],
-         BlockParametersNode(412...418)(
-           ParametersNode(413...417)(
-             [RequiredParameterNode(413...414)(:a),
-              RequiredParameterNode(416...417)(:b)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (412...413),
-           (417...418)
-         ),
-         StatementsNode(419...425)(
-           [CallNode(419...425)(
-              nil,
-              nil,
-              (419...423),
-              nil,
-              ArgumentsNode(424...425)(
-                [LocalVariableReadNode(424...425)(:a, 0)]
-              ),
-              nil,
-              nil,
-              0,
-              "puts"
-            )]
-         ),
-         (409...411),
-         (426...429)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(431...448)(
-       nil,
-       nil,
-       (431...433),
-       nil,
-       ArgumentsNode(434...448)(
-         [KeywordHashNode(434...448)(
-            [AssocNode(434...448)(
-               SymbolNode(434...440)(nil, (434...439), (439...440), "there"),
-               SymbolNode(441...448)((441...442), (442...448), nil, "friend"),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "hi"
-     ),
-     CallNode(450...490)(
-       nil,
-       nil,
-       (450...452),
-       nil,
-       ArgumentsNode(453...490)(
-         [KeywordHashNode(453...490)(
-            [AssocNode(453...470)(
-               SymbolNode(453...459)((453...454), (454...459), nil, "there"),
-               SymbolNode(463...470)((463...464), (464...470), nil, "friend"),
-               (460...462)
-             ),
-             AssocSplatNode(472...476)(
-               HashNode(474...476)((474...475), [], (475...476)),
-               (472...474)
-             ),
-             AssocNode(478...490)(
-               SymbolNode(478...485)(nil, (478...484), (484...485), "whatup"),
-               SymbolNode(486...490)((486...487), (487...490), nil, "dog"),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "hi"
-     ),
-     CallNode(492...533)(
-       nil,
-       nil,
-       (492...494),
-       (494...495),
-       ArgumentsNode(495...532)(
-         [KeywordHashNode(495...532)(
-            [AssocNode(495...512)(
-               SymbolNode(495...501)((495...496), (496...501), nil, "there"),
-               SymbolNode(505...512)((505...506), (506...512), nil, "friend"),
-               (502...504)
-             ),
-             AssocSplatNode(514...518)(
-               HashNode(516...518)((516...517), [], (517...518)),
-               (514...516)
-             ),
-             AssocNode(520...532)(
-               SymbolNode(520...527)(nil, (520...526), (526...527), "whatup"),
-               SymbolNode(528...532)((528...529), (529...532), nil, "dog"),
-               nil
-             )]
-          )]
-       ),
-       (532...533),
-       nil,
-       0,
-       "hi"
-     ),
-     CallNode(535...571)(
-       nil,
-       nil,
-       (535...538),
-       (538...539),
-       ArgumentsNode(539...570)(
-         [HashNode(539...561)(
-            (539...540),
-            [AssocNode(541...548)(
-               SymbolNode(541...543)(nil, (541...542), (542...543), "a"),
-               TrueNode(544...548)(),
-               nil
-             ),
-             AssocNode(550...558)(
-               SymbolNode(550...552)(nil, (550...551), (551...552), "b"),
-               FalseNode(553...558)(),
-               nil
-             )],
-            (560...561)
-          ),
-          BlockArgumentNode(563...570)(
-            SymbolNode(564...570)((564...565), (565...570), nil, "block"),
-            (563...564)
-          )]
-       ),
-       (570...571),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(573...593)(
-       nil,
-       nil,
-       (573...575),
-       nil,
-       ArgumentsNode(576...593)(
-         [KeywordHashNode(576...593)(
-            [AssocNode(576...593)(
-               SymbolNode(576...582)((576...577), (577...582), nil, "there"),
-               SymbolNode(586...593)((586...587), (587...593), nil, "friend"),
-               (583...585)
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "hi"
-     ),
-     CallNode(595...608)(
-       nil,
-       nil,
-       (595...598),
-       (598...599),
-       ArgumentsNode(599...605)(
-         [SymbolNode(599...601)((599...600), (600...601), nil, "a"),
-          SymbolNode(603...605)((603...604), (604...605), nil, "b")]
-       ),
-       (607...608),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(610...627)(
-       nil,
-       nil,
-       (610...613),
-       (613...614),
-       ArgumentsNode(615...624)(
-         [SymbolNode(615...617)((615...616), (616...617), nil, "a"),
-          KeywordHashNode(619...624)(
-            [AssocNode(619...624)(
-               SymbolNode(619...621)(nil, (619...620), (620...621), "b"),
-               SymbolNode(622...624)((622...623), (623...624), nil, "c"),
-               nil
-             )]
-          )]
-       ),
-       (626...627),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(629...640)(
-       nil,
-       nil,
-       (629...632),
-       nil,
-       ArgumentsNode(633...640)(
-         [BlockArgumentNode(633...640)(
-            SymbolNode(634...640)((634...635), (635...640), nil, "block"),
-            (633...634)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(642...672)(
-       nil,
-       nil,
-       (642...645),
-       nil,
-       ArgumentsNode(646...672)(
-         [KeywordHashNode(646...663)(
-            [AssocNode(646...653)(
-               SymbolNode(646...648)(nil, (646...647), (647...648), "a"),
-               TrueNode(649...653)(),
-               nil
-             ),
-             AssocNode(655...663)(
-               SymbolNode(655...657)(nil, (655...656), (656...657), "b"),
-               FalseNode(658...663)(),
-               nil
-             )]
-          ),
-          BlockArgumentNode(665...672)(
-            SymbolNode(666...672)((666...667), (667...672), nil, "block"),
-            (665...666)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(674...695)(
-       nil,
-       nil,
-       (674...683),
-       nil,
-       ArgumentsNode(684...695)(
-         [IntegerNode(684...685)(),
-          KeywordHashNode(687...695)(
-            [AssocNode(687...695)(
-               SymbolNode(687...693)(nil, (687...692), (692...693), "kwarg"),
-               IntegerNode(694...695)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "some_func"
-     ),
-     CallNode(697...715)(
-       ConstantReadNode(697...703)(:Kernel),
-       (703...704),
-       (704...711),
-       (711...712),
-       ArgumentsNode(712...714)([IntegerNode(712...714)()]),
-       (714...715),
-       nil,
-       0,
-       "Integer"
-     ),
-     CallNode(717...727)(
-       CallNode(717...718)(nil, nil, (717...718), nil, nil, nil, nil, 2, "x"),
-       (718...719),
-       (719...723),
-       nil,
-       nil,
-       nil,
-       BlockNode(724...727)([], nil, nil, (724...725), (726...727)),
-       0,
-       "each"
-     ),
-     CallNode(729...743)(
-       CallNode(729...732)(
-         nil,
-         nil,
-         (729...732),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (732...733),
-       (733...736),
-       nil,
-       nil,
-       nil,
-       BlockNode(737...743)(
-         [],
-         nil,
-         StatementsNode(739...741)([BackReferenceReadNode(739...741)()]),
-         (737...738),
-         (742...743)
-       ),
-       0,
-       "map"
-     ),
-     CallNode(745...757)(
-       ConstantPathNode(745...749)(
-         ConstantReadNode(745...746)(:A),
-         ConstantReadNode(748...749)(:B),
-         (746...748)
-       ),
-       (749...751),
-       (751...752),
-       nil,
-       ArgumentsNode(753...757)(
-         [SymbolNode(753...757)((753...754), (754...757), nil, "foo")]
-       ),
-       nil,
-       nil,
-       0,
-       "C"
-     ),
-     CallNode(759...772)(
-       ConstantPathNode(759...763)(
-         ConstantReadNode(759...760)(:A),
-         ConstantReadNode(762...763)(:B),
-         (760...762)
-       ),
-       (763...765),
-       (765...766),
-       (766...767),
-       ArgumentsNode(767...771)(
-         [SymbolNode(767...771)((767...768), (768...771), nil, "foo")]
-       ),
-       (771...772),
-       nil,
-       0,
-       "C"
-     ),
-     CallNode(774...791)(
-       ConstantPathNode(774...778)(
-         ConstantReadNode(774...775)(:A),
-         ConstantReadNode(777...778)(:B),
-         (775...777)
-       ),
-       (778...780),
-       (780...781),
-       (781...782),
-       ArgumentsNode(782...786)(
-         [SymbolNode(782...786)((782...783), (783...786), nil, "foo")]
-       ),
-       (786...787),
-       BlockNode(788...791)([], nil, nil, (788...789), (790...791)),
-       0,
-       "C"
-     ),
-     CallNode(793...805)(
-       nil,
-       nil,
-       (793...796),
-       (796...797),
-       ArgumentsNode(797...804)(
-         [KeywordHashNode(797...804)(
-            [AssocNode(797...804)(
-               SymbolNode(797...801)(
-                 (797...798),
-                 (798...799),
-                 (799...801),
-                 "a"
-               ),
-               IntegerNode(802...804)(),
-               nil
-             )]
-          )]
-       ),
-       (804...805),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(807...835)(
-       nil,
-       nil,
-       (807...810),
-       nil,
-       ArgumentsNode(811...835)(
-         [KeywordHashNode(811...835)(
-            [AssocNode(811...835)(
-               SymbolNode(811...815)(nil, (811...814), (814...815), "bar"),
-               HashNode(816...835)(
-                 (816...817),
-                 [AssocNode(818...833)(
-                    SymbolNode(818...822)(
-                      nil,
-                      (818...821),
-                      (821...822),
-                      "baz"
-                    ),
-                    CallNode(823...833)(
-                      nil,
-                      nil,
-                      (823...826),
-                      nil,
-                      nil,
-                      nil,
-                      BlockNode(827...833)(
-                        [],
-                        nil,
-                        nil,
-                        (827...829),
-                        (830...833)
-                      ),
-                      0,
-                      "qux"
-                    ),
-                    nil
-                  )],
-                 (834...835)
-               ),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(837...861)(
-       nil,
-       nil,
-       (837...840),
-       nil,
-       ArgumentsNode(841...861)(
-         [KeywordHashNode(841...861)(
-            [AssocNode(841...861)(
-               SymbolNode(841...845)(nil, (841...844), (844...845), "bar"),
-               HashNode(846...861)(
-                 (846...847),
-                 [AssocSplatNode(848...859)(
-                    CallNode(850...859)(
-                      nil,
-                      nil,
-                      (850...852),
-                      nil,
-                      nil,
-                      nil,
-                      BlockNode(853...859)(
-                        [],
-                        nil,
-                        nil,
-                        (853...855),
-                        (856...859)
-                      ),
-                      0,
-                      "kw"
-                    ),
-                    (848...850)
-                  )],
-                 (860...861)
-               ),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(863...899)(
-       nil,
-       nil,
-       (863...866),
-       nil,
-       ArgumentsNode(867...892)(
-         [InterpolatedStringNode(867...892)(
-            (867...868),
-            [EmbeddedStatementsNode(868...891)(
-               (868...870),
-               StatementsNode(870...890)(
-                 [CallNode(870...890)(
-                    CallNode(870...873)(
-                      nil,
-                      nil,
-                      (870...873),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "bar"
-                    ),
-                    (873...874),
-                    (874...877),
-                    nil,
-                    nil,
-                    nil,
-                    BlockNode(878...890)(
-                      [],
-                      nil,
-                      StatementsNode(881...886)(
-                        [StringNode(881...886)(
-                           (881...882),
-                           (882...885),
-                           (885...886),
-                           "baz"
-                         )]
-                      ),
-                      (878...880),
-                      (887...890)
-                    ),
-                    0,
-                    "map"
-                  )]
-               ),
-               (890...891)
-             )],
-            (891...892)
-          )]
-       ),
-       nil,
-       BlockNode(893...899)([], nil, nil, (893...895), (896...899)),
-       0,
-       "foo"
-     ),
-     CallNode(901...929)(
-       nil,
-       nil,
-       (901...904),
-       nil,
-       ArgumentsNode(905...929)(
-         [ClassNode(905...929)(
-            [],
-            (905...910),
-            ConstantReadNode(911...914)(:Bar),
-            nil,
-            nil,
-            StatementsNode(915...925)(
-              [CallNode(915...925)(
-                 nil,
-                 nil,
-                 (915...918),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(919...925)([], nil, nil, (919...921), (922...925)),
-                 0,
-                 "baz"
-               )]
-            ),
-            (926...929),
-            :Bar
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(931...960)(
-       nil,
-       nil,
-       (931...934),
-       nil,
-       ArgumentsNode(935...960)(
-         [ModuleNode(935...960)(
-            [],
-            (935...941),
-            ConstantReadNode(942...945)(:Bar),
-            StatementsNode(946...956)(
-              [CallNode(946...956)(
-                 nil,
-                 nil,
-                 (946...949),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(950...956)([], nil, nil, (950...952), (953...956)),
-                 0,
-                 "baz"
-               )]
-            ),
-            (957...960),
-            :Bar
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(962...978)(
-       nil,
-       nil,
-       (962...965),
-       nil,
-       ArgumentsNode(966...978)(
-         [ArrayNode(966...978)(
-            [CallNode(967...977)(
-               nil,
-               nil,
-               (967...970),
-               nil,
-               nil,
-               nil,
-               BlockNode(971...977)([], nil, nil, (971...973), (974...977)),
-               0,
-               "baz"
-             )],
-            (966...967),
-            (977...978)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(980...1008)(
-       nil,
-       nil,
-       (980...981),
-       nil,
-       ArgumentsNode(982...1008)(
-         [BeginNode(982...1008)(
-            (982...987),
-            StatementsNode(988...1004)(
-              [CallNode(988...1004)(
-                 IntegerNode(988...989)(),
-                 (989...990),
-                 (990...995),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(996...1004)(
-                   [],
-                   nil,
-                   StatementsNode(999...1000)([IntegerNode(999...1000)()]),
-                   (996...998),
-                   (1001...1004)
-                 ),
-                 0,
-                 "times"
-               )]
-            ),
-            nil,
-            nil,
-            nil,
-            (1005...1008)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(1010...1061)(
-       nil,
-       nil,
-       (1010...1013),
-       nil,
-       ArgumentsNode(1014...1061)(
-         [SymbolNode(1014...1016)((1014...1015), (1015...1016), nil, "a"),
-          IfNode(1020...1061)(
-            (1020...1022),
-            CallNode(1023...1024)(
-              nil,
-              nil,
-              (1023...1024),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "x"
-            ),
-            StatementsNode(1029...1055)(
-              [CallNode(1029...1055)(
-                 nil,
-                 nil,
-                 (1029...1032),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(1033...1055)(
-                   [:a],
-                   BlockParametersNode(1036...1039)(
-                     ParametersNode(1037...1038)(
-                       [RequiredParameterNode(1037...1038)(:a)],
-                       [],
-                       [],
-                       nil,
-                       [],
-                       nil,
-                       nil
-                     ),
-                     [],
-                     (1036...1037),
-                     (1038...1039)
-                   ),
-                   StatementsNode(1046...1047)(
-                     [LocalVariableReadNode(1046...1047)(:a, 0)]
-                   ),
-                   (1033...1035),
-                   (1052...1055)
-                 ),
-                 0,
-                 "bar"
-               )]
-            ),
-            nil,
-            (1058...1061)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(1063...1153)(
-       nil,
-       nil,
-       (1063...1066),
-       nil,
-       ArgumentsNode(1067...1153)(
-         [SymbolNode(1067...1069)((1067...1068), (1068...1069), nil, "a"),
-          WhileNode(1073...1117)(
-            (1073...1078),
-            (1114...1117),
-            CallNode(1079...1080)(
-              nil,
-              nil,
-              (1079...1080),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "x"
-            ),
-            StatementsNode(1085...1111)(
-              [CallNode(1085...1111)(
-                 nil,
-                 nil,
-                 (1085...1088),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(1089...1111)(
-                   [:a],
-                   BlockParametersNode(1092...1095)(
-                     ParametersNode(1093...1094)(
-                       [RequiredParameterNode(1093...1094)(:a)],
-                       [],
-                       [],
-                       nil,
-                       [],
-                       nil,
-                       nil
-                     ),
-                     [],
-                     (1092...1093),
-                     (1094...1095)
-                   ),
-                   StatementsNode(1102...1103)(
-                     [LocalVariableReadNode(1102...1103)(:a, 0)]
-                   ),
-                   (1089...1091),
-                   (1108...1111)
-                 ),
-                 0,
-                 "bar"
-               )]
-            ),
-            0
-          ),
-          UntilNode(1121...1153)(
-            (1121...1126),
-            (1150...1153),
-            CallNode(1127...1128)(
-              nil,
-              nil,
-              (1127...1128),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "x"
-            ),
-            StatementsNode(1133...1147)(
-              [CallNode(1133...1147)(
-                 nil,
-                 nil,
-                 (1133...1136),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(1137...1147)(
-                   [],
-                   nil,
-                   nil,
-                   (1137...1139),
-                   (1144...1147)
-                 ),
-                 0,
-                 "baz"
-               )]
-            ),
-            0
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(1155...1164)(
-       HashNode(1155...1157)((1155...1156), [], (1156...1157)),
-       nil,
-       (1158...1159),
-       nil,
-       ArgumentsNode(1160...1164)(
-         [CallNode(1160...1164)(
-            nil,
-            nil,
-            (1160...1161),
-            nil,
-            nil,
-            nil,
-            BlockNode(1162...1164)([], nil, nil, (1162...1163), (1163...1164)),
-            0,
-            "A"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     CallNode(1166...1182)(
-       HashNode(1166...1168)((1166...1167), [], (1167...1168)),
-       nil,
-       (1169...1170),
-       nil,
-       ArgumentsNode(1171...1182)(
-         [CallNode(1171...1182)(
-            nil,
-            nil,
-            (1171...1172),
-            nil,
-            nil,
-            nil,
-            BlockNode(1173...1182)(
-              [:a],
-              BlockParametersNode(1175...1178)(
-                ParametersNode(1176...1177)(
-                  [RequiredParameterNode(1176...1177)(:a)],
-                  [],
-                  [],
-                  nil,
-                  [],
-                  nil,
-                  nil
-                ),
-                [],
-                (1175...1176),
-                (1177...1178)
-              ),
-              StatementsNode(1179...1180)(
-                [LocalVariableReadNode(1179...1180)(:a, 0)]
-              ),
-              (1173...1174),
-              (1181...1182)
-            ),
-            0,
-            "A"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     CallNode(1184...1195)(
-       CallNode(1184...1188)(
-         nil,
-         nil,
-         (1184...1185),
-         nil,
-         nil,
-         nil,
-         BlockNode(1186...1188)([], nil, nil, (1186...1187), (1187...1188)),
-         0,
-         "A"
-       ),
-       nil,
-       (1189...1190),
-       nil,
-       ArgumentsNode(1191...1195)(
-         [CallNode(1191...1195)(
-            nil,
-            nil,
-            (1191...1192),
-            nil,
-            nil,
-            nil,
-            BlockNode(1193...1195)([], nil, nil, (1193...1194), (1194...1195)),
-            0,
-            "A"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     CallNode(1197...1208)(
-       CallNode(1197...1200)(
-         nil,
-         nil,
-         (1197...1200),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "lst"
-       ),
-       nil,
-       (1201...1203),
-       nil,
-       ArgumentsNode(1204...1208)(
-         [CallNode(1204...1208)(
-            nil,
-            nil,
-            (1204...1205),
-            nil,
-            nil,
-            nil,
-            BlockNode(1206...1208)([], nil, nil, (1206...1207), (1207...1208)),
-            0,
-            "A"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "<<"
-     ),
-     InterpolatedStringNode(1210...1227)(
-       (1210...1211),
-       [EmbeddedStatementsNode(1211...1226)(
-          (1211...1213),
-          StatementsNode(1214...1224)(
-            [CallNode(1214...1224)(
-               nil,
-               nil,
-               (1214...1218),
-               nil,
-               ArgumentsNode(1219...1224)(
-                 [ParenthesesNode(1219...1224)(
-                    StatementsNode(1220...1223)(
-                      [StringNode(1220...1223)(
-                         (1220...1221),
-                         (1221...1222),
-                         (1222...1223),
-                         " "
-                       )]
-                    ),
-                    (1219...1220),
-                    (1223...1224)
-                  )]
-               ),
-               nil,
-               nil,
-               0,
-               "join"
-             )]
-          ),
-          (1225...1226)
-        )],
-       (1226...1227)
-     ),
-     InterpolatedStringNode(1229...1237)(
-       (1229...1230),
-       [EmbeddedStatementsNode(1230...1236)(
-          (1230...1232),
-          StatementsNode(1232...1235)(
-            [ParenthesesNode(1232...1235)(
-               StatementsNode(1233...1234)(
-                 [CallNode(1233...1234)(
-                    nil,
-                    nil,
-                    (1233...1234),
-                    nil,
-                    nil,
-                    nil,
-                    nil,
-                    2,
-                    "v"
-                  )]
-               ),
-               (1232...1233),
-               (1234...1235)
-             )]
-          ),
-          (1235...1236)
-        )],
-       (1236...1237)
-     )]
-  )
-)
+@ ProgramNode (location: (0...1237))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...1237))
+    └── body: (length: 62)
+        ├── @ CallNode (location: (0...14))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: (4...7) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (8...14))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (8...14))
+        │   │           ├── opening_loc: (8...10) = "%{"
+        │   │           ├── content_loc: (10...13) = "baz"
+        │   │           ├── closing_loc: (13...14) = "}"
+        │   │           └── unescaped: "baz"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (16...25))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (16...17))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (16...17) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (17...18) = "."
+        │   ├── message_loc: (18...19) = "b"
+        │   ├── opening_loc: (19...20) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (20...24))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (20...21))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (20...21) = "c"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "c"
+        │   │       └── @ CallNode (location: (23...24))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (23...24) = "d"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "d"
+        │   ├── closing_loc: (24...25) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "b"
+        ├── @ CallNode (location: (27...32))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (27...28))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (27...28) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (28...29) = "."
+        │   ├── message_loc: (29...30) = "b"
+        │   ├── opening_loc: (30...31) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (31...32) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "b"
+        ├── @ CallNode (location: (34...52))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (34...44))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (34...37))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (34...37) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: (40...41) = "."
+        │   │   ├── message_loc: (41...44) = "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "bar"
+        │   ├── call_operator_loc: (47...49) = "&."
+        │   ├── message_loc: (49...52) = "baz"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: safe_navigation
+        │   └── name: "baz"
+        ├── @ CallNode (location: (54...56))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (54...56) = "a!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a!"
+        ├── @ CallNode (location: (58...62))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (58...59))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (58...59) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (59...60) = "."
+        │   ├── message_loc: ∅
+        │   ├── opening_loc: (60...61) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (61...62) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "call"
+        ├── @ CallNode (location: (64...75))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (64...65))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (64...65) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (65...66) = "."
+        │   ├── message_loc: ∅
+        │   ├── opening_loc: (66...67) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (67...74))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ IntegerNode (location: (67...68))
+        │   │       ├── @ IntegerNode (location: (70...71))
+        │   │       └── @ IntegerNode (location: (73...74))
+        │   ├── closing_loc: (74...75) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "call"
+        ├── @ CallNode (location: (77...81))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (77...78))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (77...78) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (78...80) = "::"
+        │   ├── message_loc: (80...81) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "b"
+        ├── @ CallNode (location: (83...89))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (83...84))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (83...84) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (84...86) = "::"
+        │   ├── message_loc: (86...87) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (88...89))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (88...89))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (88...89) = "c"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "c"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "b"
+        ├── @ CallNode (location: (91...102))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (91...94))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (91...94) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (94...95) = "."
+        │   ├── message_loc: (95...98) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (101...102))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (101...102))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar="
+        ├── @ CallNode (location: (104...106))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (104...106) = "a?"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a?"
+        ├── @ CallNode (location: (108...117))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (108...109) = "a"
+        │   ├── opening_loc: (109...110) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (110...116))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ BlockArgumentNode (location: (110...116))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (111...116))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (111...116) = "block"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "block"
+        │   │           └── operator_loc: (110...111) = "&"
+        │   ├── closing_loc: (116...117) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (119...130))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (119...120) = "a"
+        │   ├── opening_loc: (120...121) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (121...129))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (121...129))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocSplatNode (location: (121...129))
+        │   │                   ├── value:
+        │   │                   │   @ CallNode (location: (123...129))
+        │   │                   │   ├── receiver: ∅
+        │   │                   │   ├── call_operator_loc: ∅
+        │   │                   │   ├── message_loc: (123...129) = "kwargs"
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── arguments: ∅
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   ├── block: ∅
+        │   │                   │   ├── flags: variable_call
+        │   │                   │   └── name: "kwargs"
+        │   │                   └── operator_loc: (121...123) = "**"
+        │   ├── closing_loc: (129...130) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (132...137))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (132...135))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (132...133))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (132...133) = "a"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "a"
+        │   │   ├── call_operator_loc: (133...134) = "."
+        │   │   ├── message_loc: (134...135) = "b"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "b"
+        │   ├── call_operator_loc: (135...136) = "."
+        │   ├── message_loc: (136...137) = "c"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "c"
+        ├── @ CallNode (location: (139...146))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (139...140) = "a"
+        │   ├── opening_loc: (140...141) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (141...145))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (141...142))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (141...142) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "b"
+        │   │       └── @ CallNode (location: (144...145))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (144...145) = "c"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "c"
+        │   ├── closing_loc: (145...146) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (148...151))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (148...149) = "a"
+        │   ├── opening_loc: (149...150) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (150...151) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (153...161))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (153...154) = "a"
+        │   ├── opening_loc: (154...155) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (155...160))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SplatNode (location: (155...160))
+        │   │           ├── operator_loc: (155...156) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (156...160))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (156...160) = "args"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "args"
+        │   ├── closing_loc: (160...161) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (163...169))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (163...164) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (165...169))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (165...166))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (165...166) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "b"
+        │   │       └── @ CallNode (location: (168...169))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (168...169) = "c"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "c"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (171...179))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (171...172))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (171...172) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (172...173) = "."
+        │   ├── message_loc: (173...174) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (175...179))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (175...176))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (175...176) = "c"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "c"
+        │   │       └── @ CallNode (location: (178...179))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (178...179) = "d"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "d"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "b"
+        ├── @ MultiWriteNode (location: (181...204))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ CallNode (location: (181...188))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ CallNode (location: (181...184))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (181...184) = "foo"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "foo"
+        │   │   │   ├── call_operator_loc: (184...185) = "."
+        │   │   │   ├── message_loc: (185...188) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "foo="
+        │   │   └── @ CallNode (location: (190...197))
+        │   │       ├── receiver:
+        │   │       │   @ CallNode (location: (190...193))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (190...193) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       ├── call_operator_loc: (193...194) = "."
+        │   │       ├── message_loc: (194...197) = "bar"
+        │   │       ├── opening_loc: ∅
+        │   │       ├── arguments: ∅
+        │   │       ├── closing_loc: ∅
+        │   │       ├── block: ∅
+        │   │       ├── flags: 
+        │   │       └── name: "bar="
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (198...199) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (200...204))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (200...201))
+        │       │   └── @ IntegerNode (location: (203...204))
+        │       ├── opening_loc: ∅
+        │       └── closing_loc: ∅
+        ├── @ CallNode (location: (206...210))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (206...207))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (206...207) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (207...209) = "&."
+        │   ├── message_loc: (209...210) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: safe_navigation
+        │   └── name: "b"
+        ├── @ CallNode (location: (212...217))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (212...213))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (212...213) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (213...215) = "&."
+        │   ├── message_loc: ∅
+        │   ├── opening_loc: (215...216) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (216...217) = ")"
+        │   ├── block: ∅
+        │   ├── flags: safe_navigation
+        │   └── name: "call"
+        ├── @ CallNode (location: (219...226))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (219...220))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (219...220) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (220...222) = "&."
+        │   ├── message_loc: (222...223) = "b"
+        │   ├── opening_loc: (223...224) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (224...225))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (224...225))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (224...225) = "c"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "c"
+        │   ├── closing_loc: (225...226) = ")"
+        │   ├── block: ∅
+        │   ├── flags: safe_navigation
+        │   └── name: "b"
+        ├── @ CallNode (location: (228...234))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (228...229))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (228...229) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (229...231) = "&."
+        │   ├── message_loc: (231...232) = "b"
+        │   ├── opening_loc: (232...233) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (233...234) = ")"
+        │   ├── block: ∅
+        │   ├── flags: safe_navigation
+        │   └── name: "b"
+        ├── @ IfNode (location: (236...269))
+        │   ├── if_keyword_loc: (247...249) = "if"
+        │   ├── predicate:
+        │   │   @ AndNode (location: (250...269))
+        │   │   ├── left:
+        │   │   │   @ OrNode (location: (250...261))
+        │   │   │   ├── left:
+        │   │   │   │   @ CallNode (location: (250...254))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (250...254) = "bar?"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: 
+        │   │   │   │   └── name: "bar?"
+        │   │   │   ├── right:
+        │   │   │   │   @ CallNode (location: (258...261))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (258...261) = "baz"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "baz"
+        │   │   │   └── operator_loc: (255...257) = "or"
+        │   │   ├── right:
+        │   │   │   @ CallNode (location: (266...269))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (266...269) = "qux"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "qux"
+        │   │   └── operator_loc: (262...265) = "and"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (236...246))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (236...246))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (236...239) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (240...246))
+        │   │           │   └── arguments: (length: 2)
+        │   │           │       ├── @ SymbolNode (location: (240...242))
+        │   │           │       │   ├── opening_loc: (240...241) = ":"
+        │   │           │       │   ├── value_loc: (241...242) = "a"
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   └── unescaped: "a"
+        │   │           │       └── @ SymbolNode (location: (244...246))
+        │   │           │           ├── opening_loc: (244...245) = ":"
+        │   │           │           ├── value_loc: (245...246) = "b"
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           └── unescaped: "b"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "foo"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ CallNode (location: (271...286))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (271...274) = "foo"
+        │   ├── opening_loc: (274...275) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (275...284))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (275...277))
+        │   │       │   ├── opening_loc: (275...276) = ":"
+        │   │       │   ├── value_loc: (276...277) = "a"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "a"
+        │   │       └── @ SymbolNode (location: (282...284))
+        │   │           ├── opening_loc: (282...283) = ":"
+        │   │           ├── value_loc: (283...284) = "b"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "b"
+        │   ├── closing_loc: (285...286) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (288...298))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (288...291) = "foo"
+        │   ├── opening_loc: (291...292) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (292...297))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SplatNode (location: (292...297))
+        │   │           ├── operator_loc: (292...293) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (293...297))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (293...297) = "rest"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "rest"
+        │   ├── closing_loc: (297...298) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (300...340))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (300...303) = "foo"
+        │   ├── opening_loc: (303...304) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (304...339))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ SymbolNode (location: (304...306))
+        │   │       │   ├── opening_loc: (304...305) = ":"
+        │   │       │   ├── value_loc: (305...306) = "a"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "a"
+        │   │       ├── @ KeywordHashNode (location: (308...332))
+        │   │       │   └── elements: (length: 2)
+        │   │       │       ├── @ AssocNode (location: (308...322))
+        │   │       │       │   ├── key:
+        │   │       │       │   │   @ SymbolNode (location: (308...310))
+        │   │       │       │   │   ├── opening_loc: (308...309) = ":"
+        │   │       │       │   │   ├── value_loc: (309...310) = "h"
+        │   │       │       │   │   ├── closing_loc: ∅
+        │   │       │       │   │   └── unescaped: "h"
+        │   │       │       │   ├── value:
+        │   │       │       │   │   @ ArrayNode (location: (314...322))
+        │   │       │       │   │   ├── elements: (length: 2)
+        │   │       │       │   │   │   ├── @ SymbolNode (location: (315...317))
+        │   │       │       │   │   │   │   ├── opening_loc: (315...316) = ":"
+        │   │       │       │   │   │   │   ├── value_loc: (316...317) = "x"
+        │   │       │       │   │   │   │   ├── closing_loc: ∅
+        │   │       │       │   │   │   │   └── unescaped: "x"
+        │   │       │       │   │   │   └── @ SymbolNode (location: (319...321))
+        │   │       │       │   │   │       ├── opening_loc: (319...320) = ":"
+        │   │       │       │   │   │       ├── value_loc: (320...321) = "y"
+        │   │       │       │   │   │       ├── closing_loc: ∅
+        │   │       │       │   │   │       └── unescaped: "y"
+        │   │       │       │   │   ├── opening_loc: (314...315) = "["
+        │   │       │       │   │   └── closing_loc: (321...322) = "]"
+        │   │       │       │   └── operator_loc: (311...313) = "=>"
+        │   │       │       └── @ AssocNode (location: (324...332))
+        │   │       │           ├── key:
+        │   │       │           │   @ SymbolNode (location: (324...326))
+        │   │       │           │   ├── opening_loc: (324...325) = ":"
+        │   │       │           │   ├── value_loc: (325...326) = "a"
+        │   │       │           │   ├── closing_loc: ∅
+        │   │       │           │   └── unescaped: "a"
+        │   │       │           ├── value:
+        │   │       │           │   @ SymbolNode (location: (330...332))
+        │   │       │           │   ├── opening_loc: (330...331) = ":"
+        │   │       │           │   ├── value_loc: (331...332) = "b"
+        │   │       │           │   ├── closing_loc: ∅
+        │   │       │           │   └── unescaped: "b"
+        │   │       │           └── operator_loc: (327...329) = "=>"
+        │   │       └── @ BlockArgumentNode (location: (334...339))
+        │   │           ├── expression:
+        │   │           │   @ SymbolNode (location: (335...339))
+        │   │           │   ├── opening_loc: (335...336) = ":"
+        │   │           │   ├── value_loc: (336...339) = "bar"
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   └── unescaped: "bar"
+        │   │           └── operator_loc: (334...335) = "&"
+        │   ├── closing_loc: (339...340) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (342...391))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (342...344) = "hi"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (345...391))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ IntegerNode (location: (345...348))
+        │   │       └── @ HashNode (location: (350...391))
+        │   │           ├── opening_loc: (350...351) = "{"
+        │   │           ├── elements: (length: 3)
+        │   │           │   ├── @ AssocNode (location: (352...369))
+        │   │           │   │   ├── key:
+        │   │           │   │   │   @ SymbolNode (location: (352...358))
+        │   │           │   │   │   ├── opening_loc: (352...353) = ":"
+        │   │           │   │   │   ├── value_loc: (353...358) = "there"
+        │   │           │   │   │   ├── closing_loc: ∅
+        │   │           │   │   │   └── unescaped: "there"
+        │   │           │   │   ├── value:
+        │   │           │   │   │   @ SymbolNode (location: (362...369))
+        │   │           │   │   │   ├── opening_loc: (362...363) = ":"
+        │   │           │   │   │   ├── value_loc: (363...369) = "friend"
+        │   │           │   │   │   ├── closing_loc: ∅
+        │   │           │   │   │   └── unescaped: "friend"
+        │   │           │   │   └── operator_loc: (359...361) = "=>"
+        │   │           │   ├── @ AssocSplatNode (location: (371...375))
+        │   │           │   │   ├── value:
+        │   │           │   │   │   @ HashNode (location: (373...375))
+        │   │           │   │   │   ├── opening_loc: (373...374) = "{"
+        │   │           │   │   │   ├── elements: (length: 0)
+        │   │           │   │   │   └── closing_loc: (374...375) = "}"
+        │   │           │   │   └── operator_loc: (371...373) = "**"
+        │   │           │   └── @ AssocNode (location: (377...389))
+        │   │           │       ├── key:
+        │   │           │       │   @ SymbolNode (location: (377...384))
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── value_loc: (377...383) = "whatup"
+        │   │           │       │   ├── closing_loc: (383...384) = ":"
+        │   │           │       │   └── unescaped: "whatup"
+        │   │           │       ├── value:
+        │   │           │       │   @ SymbolNode (location: (385...389))
+        │   │           │       │   ├── opening_loc: (385...386) = ":"
+        │   │           │       │   ├── value_loc: (386...389) = "dog"
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   └── unescaped: "dog"
+        │   │           │       └── operator_loc: ∅
+        │   │           └── closing_loc: (390...391) = "}"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "hi"
+        ├── @ CallNode (location: (393...429))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (393...396) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (397...408))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (397...399))
+        │   │       │   ├── opening_loc: (397...398) = ":"
+        │   │       │   ├── value_loc: (398...399) = "a"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "a"
+        │   │       └── @ KeywordHashNode (location: (401...408))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (401...408))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (401...403))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (401...402) = "b"
+        │   │                   │   ├── closing_loc: (402...403) = ":"
+        │   │                   │   └── unescaped: "b"
+        │   │                   ├── value:
+        │   │                   │   @ TrueNode (location: (404...408))
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (409...429))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (412...418))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (413...417))
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ RequiredParameterNode (location: (413...414))
+        │   │   │   │   │   │   └── name: :a
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (416...417))
+        │   │   │   │   │       └── name: :b
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (412...413) = "|"
+        │   │   │   └── closing_loc: (417...418) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (419...425))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (419...425))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (419...423) = "puts"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (424...425))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ LocalVariableReadNode (location: (424...425))
+        │   │   │           │           ├── name: :a
+        │   │   │           │           └── depth: 0
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "puts"
+        │   │   ├── opening_loc: (409...411) = "do"
+        │   │   └── closing_loc: (426...429) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (431...448))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (431...433) = "hi"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (434...448))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (434...448))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (434...448))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (434...440))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (434...439) = "there"
+        │   │                   │   ├── closing_loc: (439...440) = ":"
+        │   │                   │   └── unescaped: "there"
+        │   │                   ├── value:
+        │   │                   │   @ SymbolNode (location: (441...448))
+        │   │                   │   ├── opening_loc: (441...442) = ":"
+        │   │                   │   ├── value_loc: (442...448) = "friend"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "friend"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "hi"
+        ├── @ CallNode (location: (450...490))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (450...452) = "hi"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (453...490))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (453...490))
+        │   │           └── elements: (length: 3)
+        │   │               ├── @ AssocNode (location: (453...470))
+        │   │               │   ├── key:
+        │   │               │   │   @ SymbolNode (location: (453...459))
+        │   │               │   │   ├── opening_loc: (453...454) = ":"
+        │   │               │   │   ├── value_loc: (454...459) = "there"
+        │   │               │   │   ├── closing_loc: ∅
+        │   │               │   │   └── unescaped: "there"
+        │   │               │   ├── value:
+        │   │               │   │   @ SymbolNode (location: (463...470))
+        │   │               │   │   ├── opening_loc: (463...464) = ":"
+        │   │               │   │   ├── value_loc: (464...470) = "friend"
+        │   │               │   │   ├── closing_loc: ∅
+        │   │               │   │   └── unescaped: "friend"
+        │   │               │   └── operator_loc: (460...462) = "=>"
+        │   │               ├── @ AssocSplatNode (location: (472...476))
+        │   │               │   ├── value:
+        │   │               │   │   @ HashNode (location: (474...476))
+        │   │               │   │   ├── opening_loc: (474...475) = "{"
+        │   │               │   │   ├── elements: (length: 0)
+        │   │               │   │   └── closing_loc: (475...476) = "}"
+        │   │               │   └── operator_loc: (472...474) = "**"
+        │   │               └── @ AssocNode (location: (478...490))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (478...485))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (478...484) = "whatup"
+        │   │                   │   ├── closing_loc: (484...485) = ":"
+        │   │                   │   └── unescaped: "whatup"
+        │   │                   ├── value:
+        │   │                   │   @ SymbolNode (location: (486...490))
+        │   │                   │   ├── opening_loc: (486...487) = ":"
+        │   │                   │   ├── value_loc: (487...490) = "dog"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "dog"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "hi"
+        ├── @ CallNode (location: (492...533))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (492...494) = "hi"
+        │   ├── opening_loc: (494...495) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (495...532))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (495...532))
+        │   │           └── elements: (length: 3)
+        │   │               ├── @ AssocNode (location: (495...512))
+        │   │               │   ├── key:
+        │   │               │   │   @ SymbolNode (location: (495...501))
+        │   │               │   │   ├── opening_loc: (495...496) = ":"
+        │   │               │   │   ├── value_loc: (496...501) = "there"
+        │   │               │   │   ├── closing_loc: ∅
+        │   │               │   │   └── unescaped: "there"
+        │   │               │   ├── value:
+        │   │               │   │   @ SymbolNode (location: (505...512))
+        │   │               │   │   ├── opening_loc: (505...506) = ":"
+        │   │               │   │   ├── value_loc: (506...512) = "friend"
+        │   │               │   │   ├── closing_loc: ∅
+        │   │               │   │   └── unescaped: "friend"
+        │   │               │   └── operator_loc: (502...504) = "=>"
+        │   │               ├── @ AssocSplatNode (location: (514...518))
+        │   │               │   ├── value:
+        │   │               │   │   @ HashNode (location: (516...518))
+        │   │               │   │   ├── opening_loc: (516...517) = "{"
+        │   │               │   │   ├── elements: (length: 0)
+        │   │               │   │   └── closing_loc: (517...518) = "}"
+        │   │               │   └── operator_loc: (514...516) = "**"
+        │   │               └── @ AssocNode (location: (520...532))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (520...527))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (520...526) = "whatup"
+        │   │                   │   ├── closing_loc: (526...527) = ":"
+        │   │                   │   └── unescaped: "whatup"
+        │   │                   ├── value:
+        │   │                   │   @ SymbolNode (location: (528...532))
+        │   │                   │   ├── opening_loc: (528...529) = ":"
+        │   │                   │   ├── value_loc: (529...532) = "dog"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "dog"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: (532...533) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "hi"
+        ├── @ CallNode (location: (535...571))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (535...538) = "foo"
+        │   ├── opening_loc: (538...539) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (539...570))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ HashNode (location: (539...561))
+        │   │       │   ├── opening_loc: (539...540) = "{"
+        │   │       │   ├── elements: (length: 2)
+        │   │       │   │   ├── @ AssocNode (location: (541...548))
+        │   │       │   │   │   ├── key:
+        │   │       │   │   │   │   @ SymbolNode (location: (541...543))
+        │   │       │   │   │   │   ├── opening_loc: ∅
+        │   │       │   │   │   │   ├── value_loc: (541...542) = "a"
+        │   │       │   │   │   │   ├── closing_loc: (542...543) = ":"
+        │   │       │   │   │   │   └── unescaped: "a"
+        │   │       │   │   │   ├── value:
+        │   │       │   │   │   │   @ TrueNode (location: (544...548))
+        │   │       │   │   │   └── operator_loc: ∅
+        │   │       │   │   └── @ AssocNode (location: (550...558))
+        │   │       │   │       ├── key:
+        │   │       │   │       │   @ SymbolNode (location: (550...552))
+        │   │       │   │       │   ├── opening_loc: ∅
+        │   │       │   │       │   ├── value_loc: (550...551) = "b"
+        │   │       │   │       │   ├── closing_loc: (551...552) = ":"
+        │   │       │   │       │   └── unescaped: "b"
+        │   │       │   │       ├── value:
+        │   │       │   │       │   @ FalseNode (location: (553...558))
+        │   │       │   │       └── operator_loc: ∅
+        │   │       │   └── closing_loc: (560...561) = "}"
+        │   │       └── @ BlockArgumentNode (location: (563...570))
+        │   │           ├── expression:
+        │   │           │   @ SymbolNode (location: (564...570))
+        │   │           │   ├── opening_loc: (564...565) = ":"
+        │   │           │   ├── value_loc: (565...570) = "block"
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   └── unescaped: "block"
+        │   │           └── operator_loc: (563...564) = "&"
+        │   ├── closing_loc: (570...571) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (573...593))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (573...575) = "hi"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (576...593))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (576...593))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (576...593))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (576...582))
+        │   │                   │   ├── opening_loc: (576...577) = ":"
+        │   │                   │   ├── value_loc: (577...582) = "there"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "there"
+        │   │                   ├── value:
+        │   │                   │   @ SymbolNode (location: (586...593))
+        │   │                   │   ├── opening_loc: (586...587) = ":"
+        │   │                   │   ├── value_loc: (587...593) = "friend"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "friend"
+        │   │                   └── operator_loc: (583...585) = "=>"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "hi"
+        ├── @ CallNode (location: (595...608))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (595...598) = "foo"
+        │   ├── opening_loc: (598...599) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (599...605))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (599...601))
+        │   │       │   ├── opening_loc: (599...600) = ":"
+        │   │       │   ├── value_loc: (600...601) = "a"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "a"
+        │   │       └── @ SymbolNode (location: (603...605))
+        │   │           ├── opening_loc: (603...604) = ":"
+        │   │           ├── value_loc: (604...605) = "b"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "b"
+        │   ├── closing_loc: (607...608) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (610...627))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (610...613) = "foo"
+        │   ├── opening_loc: (613...614) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (615...624))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (615...617))
+        │   │       │   ├── opening_loc: (615...616) = ":"
+        │   │       │   ├── value_loc: (616...617) = "a"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "a"
+        │   │       └── @ KeywordHashNode (location: (619...624))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (619...624))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (619...621))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (619...620) = "b"
+        │   │                   │   ├── closing_loc: (620...621) = ":"
+        │   │                   │   └── unescaped: "b"
+        │   │                   ├── value:
+        │   │                   │   @ SymbolNode (location: (622...624))
+        │   │                   │   ├── opening_loc: (622...623) = ":"
+        │   │                   │   ├── value_loc: (623...624) = "c"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "c"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: (626...627) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (629...640))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (629...632) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (633...640))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ BlockArgumentNode (location: (633...640))
+        │   │           ├── expression:
+        │   │           │   @ SymbolNode (location: (634...640))
+        │   │           │   ├── opening_loc: (634...635) = ":"
+        │   │           │   ├── value_loc: (635...640) = "block"
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   └── unescaped: "block"
+        │   │           └── operator_loc: (633...634) = "&"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (642...672))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (642...645) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (646...672))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ KeywordHashNode (location: (646...663))
+        │   │       │   └── elements: (length: 2)
+        │   │       │       ├── @ AssocNode (location: (646...653))
+        │   │       │       │   ├── key:
+        │   │       │       │   │   @ SymbolNode (location: (646...648))
+        │   │       │       │   │   ├── opening_loc: ∅
+        │   │       │       │   │   ├── value_loc: (646...647) = "a"
+        │   │       │       │   │   ├── closing_loc: (647...648) = ":"
+        │   │       │       │   │   └── unescaped: "a"
+        │   │       │       │   ├── value:
+        │   │       │       │   │   @ TrueNode (location: (649...653))
+        │   │       │       │   └── operator_loc: ∅
+        │   │       │       └── @ AssocNode (location: (655...663))
+        │   │       │           ├── key:
+        │   │       │           │   @ SymbolNode (location: (655...657))
+        │   │       │           │   ├── opening_loc: ∅
+        │   │       │           │   ├── value_loc: (655...656) = "b"
+        │   │       │           │   ├── closing_loc: (656...657) = ":"
+        │   │       │           │   └── unescaped: "b"
+        │   │       │           ├── value:
+        │   │       │           │   @ FalseNode (location: (658...663))
+        │   │       │           └── operator_loc: ∅
+        │   │       └── @ BlockArgumentNode (location: (665...672))
+        │   │           ├── expression:
+        │   │           │   @ SymbolNode (location: (666...672))
+        │   │           │   ├── opening_loc: (666...667) = ":"
+        │   │           │   ├── value_loc: (667...672) = "block"
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   └── unescaped: "block"
+        │   │           └── operator_loc: (665...666) = "&"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (674...695))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (674...683) = "some_func"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (684...695))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ IntegerNode (location: (684...685))
+        │   │       └── @ KeywordHashNode (location: (687...695))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (687...695))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (687...693))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (687...692) = "kwarg"
+        │   │                   │   ├── closing_loc: (692...693) = ":"
+        │   │                   │   └── unescaped: "kwarg"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (694...695))
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "some_func"
+        ├── @ CallNode (location: (697...715))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (697...703))
+        │   │   └── name: :Kernel
+        │   ├── call_operator_loc: (703...704) = "."
+        │   ├── message_loc: (704...711) = "Integer"
+        │   ├── opening_loc: (711...712) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (712...714))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (712...714))
+        │   ├── closing_loc: (714...715) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Integer"
+        ├── @ CallNode (location: (717...727))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (717...718))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (717...718) = "x"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "x"
+        │   ├── call_operator_loc: (718...719) = "."
+        │   ├── message_loc: (719...723) = "each"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (724...727))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (724...725) = "{"
+        │   │   └── closing_loc: (726...727) = "}"
+        │   ├── flags: 
+        │   └── name: "each"
+        ├── @ CallNode (location: (729...743))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (729...732))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (729...732) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (732...733) = "."
+        │   ├── message_loc: (733...736) = "map"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (737...743))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (739...741))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ BackReferenceReadNode (location: (739...741))
+        │   │   ├── opening_loc: (737...738) = "{"
+        │   │   └── closing_loc: (742...743) = "}"
+        │   ├── flags: 
+        │   └── name: "map"
+        ├── @ CallNode (location: (745...757))
+        │   ├── receiver:
+        │   │   @ ConstantPathNode (location: (745...749))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (745...746))
+        │   │   │   └── name: :A
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (748...749))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (746...748) = "::"
+        │   ├── call_operator_loc: (749...751) = "::"
+        │   ├── message_loc: (751...752) = "C"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (753...757))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SymbolNode (location: (753...757))
+        │   │           ├── opening_loc: (753...754) = ":"
+        │   │           ├── value_loc: (754...757) = "foo"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "foo"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "C"
+        ├── @ CallNode (location: (759...772))
+        │   ├── receiver:
+        │   │   @ ConstantPathNode (location: (759...763))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (759...760))
+        │   │   │   └── name: :A
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (762...763))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (760...762) = "::"
+        │   ├── call_operator_loc: (763...765) = "::"
+        │   ├── message_loc: (765...766) = "C"
+        │   ├── opening_loc: (766...767) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (767...771))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SymbolNode (location: (767...771))
+        │   │           ├── opening_loc: (767...768) = ":"
+        │   │           ├── value_loc: (768...771) = "foo"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "foo"
+        │   ├── closing_loc: (771...772) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "C"
+        ├── @ CallNode (location: (774...791))
+        │   ├── receiver:
+        │   │   @ ConstantPathNode (location: (774...778))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (774...775))
+        │   │   │   └── name: :A
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (777...778))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (775...777) = "::"
+        │   ├── call_operator_loc: (778...780) = "::"
+        │   ├── message_loc: (780...781) = "C"
+        │   ├── opening_loc: (781...782) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (782...786))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SymbolNode (location: (782...786))
+        │   │           ├── opening_loc: (782...783) = ":"
+        │   │           ├── value_loc: (783...786) = "foo"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "foo"
+        │   ├── closing_loc: (786...787) = ")"
+        │   ├── block:
+        │   │   @ BlockNode (location: (788...791))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (788...789) = "{"
+        │   │   └── closing_loc: (790...791) = "}"
+        │   ├── flags: 
+        │   └── name: "C"
+        ├── @ CallNode (location: (793...805))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (793...796) = "foo"
+        │   ├── opening_loc: (796...797) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (797...804))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (797...804))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (797...804))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (797...801))
+        │   │                   │   ├── opening_loc: (797...798) = "\""
+        │   │                   │   ├── value_loc: (798...799) = "a"
+        │   │                   │   ├── closing_loc: (799...801) = "\":"
+        │   │                   │   └── unescaped: "a"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (802...804))
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: (804...805) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (807...835))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (807...810) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (811...835))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (811...835))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (811...835))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (811...815))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (811...814) = "bar"
+        │   │                   │   ├── closing_loc: (814...815) = ":"
+        │   │                   │   └── unescaped: "bar"
+        │   │                   ├── value:
+        │   │                   │   @ HashNode (location: (816...835))
+        │   │                   │   ├── opening_loc: (816...817) = "{"
+        │   │                   │   ├── elements: (length: 1)
+        │   │                   │   │   └── @ AssocNode (location: (818...833))
+        │   │                   │   │       ├── key:
+        │   │                   │   │       │   @ SymbolNode (location: (818...822))
+        │   │                   │   │       │   ├── opening_loc: ∅
+        │   │                   │   │       │   ├── value_loc: (818...821) = "baz"
+        │   │                   │   │       │   ├── closing_loc: (821...822) = ":"
+        │   │                   │   │       │   └── unescaped: "baz"
+        │   │                   │   │       ├── value:
+        │   │                   │   │       │   @ CallNode (location: (823...833))
+        │   │                   │   │       │   ├── receiver: ∅
+        │   │                   │   │       │   ├── call_operator_loc: ∅
+        │   │                   │   │       │   ├── message_loc: (823...826) = "qux"
+        │   │                   │   │       │   ├── opening_loc: ∅
+        │   │                   │   │       │   ├── arguments: ∅
+        │   │                   │   │       │   ├── closing_loc: ∅
+        │   │                   │   │       │   ├── block:
+        │   │                   │   │       │   │   @ BlockNode (location: (827...833))
+        │   │                   │   │       │   │   ├── locals: []
+        │   │                   │   │       │   │   ├── parameters: ∅
+        │   │                   │   │       │   │   ├── body: ∅
+        │   │                   │   │       │   │   ├── opening_loc: (827...829) = "do"
+        │   │                   │   │       │   │   └── closing_loc: (830...833) = "end"
+        │   │                   │   │       │   ├── flags: 
+        │   │                   │   │       │   └── name: "qux"
+        │   │                   │   │       └── operator_loc: ∅
+        │   │                   │   └── closing_loc: (834...835) = "}"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (837...861))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (837...840) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (841...861))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (841...861))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (841...861))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (841...845))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (841...844) = "bar"
+        │   │                   │   ├── closing_loc: (844...845) = ":"
+        │   │                   │   └── unescaped: "bar"
+        │   │                   ├── value:
+        │   │                   │   @ HashNode (location: (846...861))
+        │   │                   │   ├── opening_loc: (846...847) = "{"
+        │   │                   │   ├── elements: (length: 1)
+        │   │                   │   │   └── @ AssocSplatNode (location: (848...859))
+        │   │                   │   │       ├── value:
+        │   │                   │   │       │   @ CallNode (location: (850...859))
+        │   │                   │   │       │   ├── receiver: ∅
+        │   │                   │   │       │   ├── call_operator_loc: ∅
+        │   │                   │   │       │   ├── message_loc: (850...852) = "kw"
+        │   │                   │   │       │   ├── opening_loc: ∅
+        │   │                   │   │       │   ├── arguments: ∅
+        │   │                   │   │       │   ├── closing_loc: ∅
+        │   │                   │   │       │   ├── block:
+        │   │                   │   │       │   │   @ BlockNode (location: (853...859))
+        │   │                   │   │       │   │   ├── locals: []
+        │   │                   │   │       │   │   ├── parameters: ∅
+        │   │                   │   │       │   │   ├── body: ∅
+        │   │                   │   │       │   │   ├── opening_loc: (853...855) = "do"
+        │   │                   │   │       │   │   └── closing_loc: (856...859) = "end"
+        │   │                   │   │       │   ├── flags: 
+        │   │                   │   │       │   └── name: "kw"
+        │   │                   │   │       └── operator_loc: (848...850) = "**"
+        │   │                   │   └── closing_loc: (860...861) = "}"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (863...899))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (863...866) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (867...892))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (867...892))
+        │   │           ├── opening_loc: (867...868) = "\""
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ EmbeddedStatementsNode (location: (868...891))
+        │   │           │       ├── opening_loc: (868...870) = "\#{"
+        │   │           │       ├── statements:
+        │   │           │       │   @ StatementsNode (location: (870...890))
+        │   │           │       │   └── body: (length: 1)
+        │   │           │       │       └── @ CallNode (location: (870...890))
+        │   │           │       │           ├── receiver:
+        │   │           │       │           │   @ CallNode (location: (870...873))
+        │   │           │       │           │   ├── receiver: ∅
+        │   │           │       │           │   ├── call_operator_loc: ∅
+        │   │           │       │           │   ├── message_loc: (870...873) = "bar"
+        │   │           │       │           │   ├── opening_loc: ∅
+        │   │           │       │           │   ├── arguments: ∅
+        │   │           │       │           │   ├── closing_loc: ∅
+        │   │           │       │           │   ├── block: ∅
+        │   │           │       │           │   ├── flags: variable_call
+        │   │           │       │           │   └── name: "bar"
+        │   │           │       │           ├── call_operator_loc: (873...874) = "."
+        │   │           │       │           ├── message_loc: (874...877) = "map"
+        │   │           │       │           ├── opening_loc: ∅
+        │   │           │       │           ├── arguments: ∅
+        │   │           │       │           ├── closing_loc: ∅
+        │   │           │       │           ├── block:
+        │   │           │       │           │   @ BlockNode (location: (878...890))
+        │   │           │       │           │   ├── locals: []
+        │   │           │       │           │   ├── parameters: ∅
+        │   │           │       │           │   ├── body:
+        │   │           │       │           │   │   @ StatementsNode (location: (881...886))
+        │   │           │       │           │   │   └── body: (length: 1)
+        │   │           │       │           │   │       └── @ StringNode (location: (881...886))
+        │   │           │       │           │   │           ├── opening_loc: (881...882) = "\""
+        │   │           │       │           │   │           ├── content_loc: (882...885) = "baz"
+        │   │           │       │           │   │           ├── closing_loc: (885...886) = "\""
+        │   │           │       │           │   │           └── unescaped: "baz"
+        │   │           │       │           │   ├── opening_loc: (878...880) = "do"
+        │   │           │       │           │   └── closing_loc: (887...890) = "end"
+        │   │           │       │           ├── flags: 
+        │   │           │       │           └── name: "map"
+        │   │           │       └── closing_loc: (890...891) = "}"
+        │   │           └── closing_loc: (891...892) = "\""
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (893...899))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (893...895) = "do"
+        │   │   └── closing_loc: (896...899) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (901...929))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (901...904) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (905...929))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ClassNode (location: (905...929))
+        │   │           ├── locals: []
+        │   │           ├── class_keyword_loc: (905...910) = "class"
+        │   │           ├── constant_path:
+        │   │           │   @ ConstantReadNode (location: (911...914))
+        │   │           │   └── name: :Bar
+        │   │           ├── inheritance_operator_loc: ∅
+        │   │           ├── superclass: ∅
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (915...925))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (915...925))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (915...918) = "baz"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block:
+        │   │           │           │   @ BlockNode (location: (919...925))
+        │   │           │           │   ├── locals: []
+        │   │           │           │   ├── parameters: ∅
+        │   │           │           │   ├── body: ∅
+        │   │           │           │   ├── opening_loc: (919...921) = "do"
+        │   │           │           │   └── closing_loc: (922...925) = "end"
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "baz"
+        │   │           ├── end_keyword_loc: (926...929) = "end"
+        │   │           └── name: :Bar
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (931...960))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (931...934) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (935...960))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ModuleNode (location: (935...960))
+        │   │           ├── locals: []
+        │   │           ├── module_keyword_loc: (935...941) = "module"
+        │   │           ├── constant_path:
+        │   │           │   @ ConstantReadNode (location: (942...945))
+        │   │           │   └── name: :Bar
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (946...956))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (946...956))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (946...949) = "baz"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block:
+        │   │           │           │   @ BlockNode (location: (950...956))
+        │   │           │           │   ├── locals: []
+        │   │           │           │   ├── parameters: ∅
+        │   │           │           │   ├── body: ∅
+        │   │           │           │   ├── opening_loc: (950...952) = "do"
+        │   │           │           │   └── closing_loc: (953...956) = "end"
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "baz"
+        │   │           ├── end_keyword_loc: (957...960) = "end"
+        │   │           └── name: :Bar
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (962...978))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (962...965) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (966...978))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ArrayNode (location: (966...978))
+        │   │           ├── elements: (length: 1)
+        │   │           │   └── @ CallNode (location: (967...977))
+        │   │           │       ├── receiver: ∅
+        │   │           │       ├── call_operator_loc: ∅
+        │   │           │       ├── message_loc: (967...970) = "baz"
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── arguments: ∅
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       ├── block:
+        │   │           │       │   @ BlockNode (location: (971...977))
+        │   │           │       │   ├── locals: []
+        │   │           │       │   ├── parameters: ∅
+        │   │           │       │   ├── body: ∅
+        │   │           │       │   ├── opening_loc: (971...973) = "do"
+        │   │           │       │   └── closing_loc: (974...977) = "end"
+        │   │           │       ├── flags: 
+        │   │           │       └── name: "baz"
+        │   │           ├── opening_loc: (966...967) = "["
+        │   │           └── closing_loc: (977...978) = "]"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (980...1008))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (980...981) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (982...1008))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ BeginNode (location: (982...1008))
+        │   │           ├── begin_keyword_loc: (982...987) = "begin"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (988...1004))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (988...1004))
+        │   │           │           ├── receiver:
+        │   │           │           │   @ IntegerNode (location: (988...989))
+        │   │           │           ├── call_operator_loc: (989...990) = "."
+        │   │           │           ├── message_loc: (990...995) = "times"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block:
+        │   │           │           │   @ BlockNode (location: (996...1004))
+        │   │           │           │   ├── locals: []
+        │   │           │           │   ├── parameters: ∅
+        │   │           │           │   ├── body:
+        │   │           │           │   │   @ StatementsNode (location: (999...1000))
+        │   │           │           │   │   └── body: (length: 1)
+        │   │           │           │   │       └── @ IntegerNode (location: (999...1000))
+        │   │           │           │   ├── opening_loc: (996...998) = "do"
+        │   │           │           │   └── closing_loc: (1001...1004) = "end"
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "times"
+        │   │           ├── rescue_clause: ∅
+        │   │           ├── else_clause: ∅
+        │   │           ├── ensure_clause: ∅
+        │   │           └── end_keyword_loc: (1005...1008) = "end"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (1010...1061))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (1010...1013) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (1014...1061))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (1014...1016))
+        │   │       │   ├── opening_loc: (1014...1015) = ":"
+        │   │       │   ├── value_loc: (1015...1016) = "a"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "a"
+        │   │       └── @ IfNode (location: (1020...1061))
+        │   │           ├── if_keyword_loc: (1020...1022) = "if"
+        │   │           ├── predicate:
+        │   │           │   @ CallNode (location: (1023...1024))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (1023...1024) = "x"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "x"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (1029...1055))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (1029...1055))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (1029...1032) = "bar"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block:
+        │   │           │           │   @ BlockNode (location: (1033...1055))
+        │   │           │           │   ├── locals: [:a]
+        │   │           │           │   ├── parameters:
+        │   │           │           │   │   @ BlockParametersNode (location: (1036...1039))
+        │   │           │           │   │   ├── parameters:
+        │   │           │           │   │   │   @ ParametersNode (location: (1037...1038))
+        │   │           │           │   │   │   ├── requireds: (length: 1)
+        │   │           │           │   │   │   │   └── @ RequiredParameterNode (location: (1037...1038))
+        │   │           │           │   │   │   │       └── name: :a
+        │   │           │           │   │   │   ├── optionals: (length: 0)
+        │   │           │           │   │   │   ├── posts: (length: 0)
+        │   │           │           │   │   │   ├── rest: ∅
+        │   │           │           │   │   │   ├── keywords: (length: 0)
+        │   │           │           │   │   │   ├── keyword_rest: ∅
+        │   │           │           │   │   │   └── block: ∅
+        │   │           │           │   │   ├── locals: (length: 0)
+        │   │           │           │   │   ├── opening_loc: (1036...1037) = "|"
+        │   │           │           │   │   └── closing_loc: (1038...1039) = "|"
+        │   │           │           │   ├── body:
+        │   │           │           │   │   @ StatementsNode (location: (1046...1047))
+        │   │           │           │   │   └── body: (length: 1)
+        │   │           │           │   │       └── @ LocalVariableReadNode (location: (1046...1047))
+        │   │           │           │   │           ├── name: :a
+        │   │           │           │   │           └── depth: 0
+        │   │           │           │   ├── opening_loc: (1033...1035) = "do"
+        │   │           │           │   └── closing_loc: (1052...1055) = "end"
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "bar"
+        │   │           ├── consequent: ∅
+        │   │           └── end_keyword_loc: (1058...1061) = "end"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (1063...1153))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (1063...1066) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (1067...1153))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ SymbolNode (location: (1067...1069))
+        │   │       │   ├── opening_loc: (1067...1068) = ":"
+        │   │       │   ├── value_loc: (1068...1069) = "a"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "a"
+        │   │       ├── @ WhileNode (location: (1073...1117))
+        │   │       │   ├── keyword_loc: (1073...1078) = "while"
+        │   │       │   ├── closing_loc: (1114...1117) = "end"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ CallNode (location: (1079...1080))
+        │   │       │   │   ├── receiver: ∅
+        │   │       │   │   ├── call_operator_loc: ∅
+        │   │       │   │   ├── message_loc: (1079...1080) = "x"
+        │   │       │   │   ├── opening_loc: ∅
+        │   │       │   │   ├── arguments: ∅
+        │   │       │   │   ├── closing_loc: ∅
+        │   │       │   │   ├── block: ∅
+        │   │       │   │   ├── flags: variable_call
+        │   │       │   │   └── name: "x"
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (1085...1111))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (1085...1111))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (1085...1088) = "bar"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments: ∅
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block:
+        │   │       │   │           │   @ BlockNode (location: (1089...1111))
+        │   │       │   │           │   ├── locals: [:a]
+        │   │       │   │           │   ├── parameters:
+        │   │       │   │           │   │   @ BlockParametersNode (location: (1092...1095))
+        │   │       │   │           │   │   ├── parameters:
+        │   │       │   │           │   │   │   @ ParametersNode (location: (1093...1094))
+        │   │       │   │           │   │   │   ├── requireds: (length: 1)
+        │   │       │   │           │   │   │   │   └── @ RequiredParameterNode (location: (1093...1094))
+        │   │       │   │           │   │   │   │       └── name: :a
+        │   │       │   │           │   │   │   ├── optionals: (length: 0)
+        │   │       │   │           │   │   │   ├── posts: (length: 0)
+        │   │       │   │           │   │   │   ├── rest: ∅
+        │   │       │   │           │   │   │   ├── keywords: (length: 0)
+        │   │       │   │           │   │   │   ├── keyword_rest: ∅
+        │   │       │   │           │   │   │   └── block: ∅
+        │   │       │   │           │   │   ├── locals: (length: 0)
+        │   │       │   │           │   │   ├── opening_loc: (1092...1093) = "|"
+        │   │       │   │           │   │   └── closing_loc: (1094...1095) = "|"
+        │   │       │   │           │   ├── body:
+        │   │       │   │           │   │   @ StatementsNode (location: (1102...1103))
+        │   │       │   │           │   │   └── body: (length: 1)
+        │   │       │   │           │   │       └── @ LocalVariableReadNode (location: (1102...1103))
+        │   │       │   │           │   │           ├── name: :a
+        │   │       │   │           │   │           └── depth: 0
+        │   │       │   │           │   ├── opening_loc: (1089...1091) = "do"
+        │   │       │   │           │   └── closing_loc: (1108...1111) = "end"
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "bar"
+        │   │       │   └── flags: 
+        │   │       └── @ UntilNode (location: (1121...1153))
+        │   │           ├── keyword_loc: (1121...1126) = "until"
+        │   │           ├── closing_loc: (1150...1153) = "end"
+        │   │           ├── predicate:
+        │   │           │   @ CallNode (location: (1127...1128))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (1127...1128) = "x"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "x"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (1133...1147))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (1133...1147))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (1133...1136) = "baz"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block:
+        │   │           │           │   @ BlockNode (location: (1137...1147))
+        │   │           │           │   ├── locals: []
+        │   │           │           │   ├── parameters: ∅
+        │   │           │           │   ├── body: ∅
+        │   │           │           │   ├── opening_loc: (1137...1139) = "do"
+        │   │           │           │   └── closing_loc: (1144...1147) = "end"
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "baz"
+        │   │           └── flags: 
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (1155...1164))
+        │   ├── receiver:
+        │   │   @ HashNode (location: (1155...1157))
+        │   │   ├── opening_loc: (1155...1156) = "{"
+        │   │   ├── elements: (length: 0)
+        │   │   └── closing_loc: (1156...1157) = "}"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (1158...1159) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (1160...1164))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (1160...1164))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (1160...1161) = "A"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (1162...1164))
+        │   │           │   ├── locals: []
+        │   │           │   ├── parameters: ∅
+        │   │           │   ├── body: ∅
+        │   │           │   ├── opening_loc: (1162...1163) = "{"
+        │   │           │   └── closing_loc: (1163...1164) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "A"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        ├── @ CallNode (location: (1166...1182))
+        │   ├── receiver:
+        │   │   @ HashNode (location: (1166...1168))
+        │   │   ├── opening_loc: (1166...1167) = "{"
+        │   │   ├── elements: (length: 0)
+        │   │   └── closing_loc: (1167...1168) = "}"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (1169...1170) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (1171...1182))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (1171...1182))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (1171...1172) = "A"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (1173...1182))
+        │   │           │   ├── locals: [:a]
+        │   │           │   ├── parameters:
+        │   │           │   │   @ BlockParametersNode (location: (1175...1178))
+        │   │           │   │   ├── parameters:
+        │   │           │   │   │   @ ParametersNode (location: (1176...1177))
+        │   │           │   │   │   ├── requireds: (length: 1)
+        │   │           │   │   │   │   └── @ RequiredParameterNode (location: (1176...1177))
+        │   │           │   │   │   │       └── name: :a
+        │   │           │   │   │   ├── optionals: (length: 0)
+        │   │           │   │   │   ├── posts: (length: 0)
+        │   │           │   │   │   ├── rest: ∅
+        │   │           │   │   │   ├── keywords: (length: 0)
+        │   │           │   │   │   ├── keyword_rest: ∅
+        │   │           │   │   │   └── block: ∅
+        │   │           │   │   ├── locals: (length: 0)
+        │   │           │   │   ├── opening_loc: (1175...1176) = "|"
+        │   │           │   │   └── closing_loc: (1177...1178) = "|"
+        │   │           │   ├── body:
+        │   │           │   │   @ StatementsNode (location: (1179...1180))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ LocalVariableReadNode (location: (1179...1180))
+        │   │           │   │           ├── name: :a
+        │   │           │   │           └── depth: 0
+        │   │           │   ├── opening_loc: (1173...1174) = "{"
+        │   │           │   └── closing_loc: (1181...1182) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "A"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        ├── @ CallNode (location: (1184...1195))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (1184...1188))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1184...1185) = "A"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (1186...1188))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (1186...1187) = "{"
+        │   │   │   └── closing_loc: (1187...1188) = "}"
+        │   │   ├── flags: 
+        │   │   └── name: "A"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (1189...1190) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (1191...1195))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (1191...1195))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (1191...1192) = "A"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (1193...1195))
+        │   │           │   ├── locals: []
+        │   │           │   ├── parameters: ∅
+        │   │           │   ├── body: ∅
+        │   │           │   ├── opening_loc: (1193...1194) = "{"
+        │   │           │   └── closing_loc: (1194...1195) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "A"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        ├── @ CallNode (location: (1197...1208))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (1197...1200))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1197...1200) = "lst"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "lst"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (1201...1203) = "<<"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (1204...1208))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (1204...1208))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (1204...1205) = "A"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (1206...1208))
+        │   │           │   ├── locals: []
+        │   │           │   ├── parameters: ∅
+        │   │           │   ├── body: ∅
+        │   │           │   ├── opening_loc: (1206...1207) = "{"
+        │   │           │   └── closing_loc: (1207...1208) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "A"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<<"
+        ├── @ InterpolatedStringNode (location: (1210...1227))
+        │   ├── opening_loc: (1210...1211) = "\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedStatementsNode (location: (1211...1226))
+        │   │       ├── opening_loc: (1211...1213) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (1214...1224))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ CallNode (location: (1214...1224))
+        │   │       │           ├── receiver: ∅
+        │   │       │           ├── call_operator_loc: ∅
+        │   │       │           ├── message_loc: (1214...1218) = "join"
+        │   │       │           ├── opening_loc: ∅
+        │   │       │           ├── arguments:
+        │   │       │           │   @ ArgumentsNode (location: (1219...1224))
+        │   │       │           │   └── arguments: (length: 1)
+        │   │       │           │       └── @ ParenthesesNode (location: (1219...1224))
+        │   │       │           │           ├── body:
+        │   │       │           │           │   @ StatementsNode (location: (1220...1223))
+        │   │       │           │           │   └── body: (length: 1)
+        │   │       │           │           │       └── @ StringNode (location: (1220...1223))
+        │   │       │           │           │           ├── opening_loc: (1220...1221) = "\""
+        │   │       │           │           │           ├── content_loc: (1221...1222) = " "
+        │   │       │           │           │           ├── closing_loc: (1222...1223) = "\""
+        │   │       │           │           │           └── unescaped: " "
+        │   │       │           │           ├── opening_loc: (1219...1220) = "("
+        │   │       │           │           └── closing_loc: (1223...1224) = ")"
+        │   │       │           ├── closing_loc: ∅
+        │   │       │           ├── block: ∅
+        │   │       │           ├── flags: 
+        │   │       │           └── name: "join"
+        │   │       └── closing_loc: (1225...1226) = "}"
+        │   └── closing_loc: (1226...1227) = "\""
+        └── @ InterpolatedStringNode (location: (1229...1237))
+            ├── opening_loc: (1229...1230) = "\""
+            ├── parts: (length: 1)
+            │   └── @ EmbeddedStatementsNode (location: (1230...1236))
+            │       ├── opening_loc: (1230...1232) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (1232...1235))
+            │       │   └── body: (length: 1)
+            │       │       └── @ ParenthesesNode (location: (1232...1235))
+            │       │           ├── body:
+            │       │           │   @ StatementsNode (location: (1233...1234))
+            │       │           │   └── body: (length: 1)
+            │       │           │       └── @ CallNode (location: (1233...1234))
+            │       │           │           ├── receiver: ∅
+            │       │           │           ├── call_operator_loc: ∅
+            │       │           │           ├── message_loc: (1233...1234) = "v"
+            │       │           │           ├── opening_loc: ∅
+            │       │           │           ├── arguments: ∅
+            │       │           │           ├── closing_loc: ∅
+            │       │           │           ├── block: ∅
+            │       │           │           ├── flags: variable_call
+            │       │           │           └── name: "v"
+            │       │           ├── opening_loc: (1232...1233) = "("
+            │       │           └── closing_loc: (1234...1235) = ")"
+            │       └── closing_loc: (1235...1236) = "}"
+            └── closing_loc: (1236...1237) = "\""
diff --git a/test/yarp/snapshots/methods.txt b/test/yarp/snapshots/methods.txt
index 3b0b5ca299..bcc6176a82 100644
--- a/test/yarp/snapshots/methods.txt
+++ b/test/yarp/snapshots/methods.txt
@@ -1,1469 +1,1591 @@
-ProgramNode(0...1194)(
-  [:a, :c],
-  StatementsNode(0...1194)(
-    [DefNode(0...23)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...18)(
-         [RequiredDestructuredParameterNode(8...18)(
-            [RequiredParameterNode(9...12)(:bar),
-             RequiredParameterNode(14...17)(:baz)],
-            (8...9),
-            (17...18)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:bar, :baz],
-       (0...3),
-       nil,
-       (7...8),
-       (18...19),
-       nil,
-       (20...23)
-     ),
-     DefNode(25...74)(
-       :foo,
-       (29...32),
-       nil,
-       ParametersNode(33...69)(
-         [RequiredDestructuredParameterNode(33...43)(
-            [RequiredParameterNode(34...37)(:bar),
-             RequiredParameterNode(39...42)(:baz)],
-            (33...34),
-            (42...43)
-          )],
-         [OptionalParameterNode(45...57)(
-            :optional,
-            (45...53),
-            (54...55),
-            IntegerNode(56...57)()
-          )],
-         [RequiredDestructuredParameterNode(59...69)(
-            [RequiredParameterNode(60...63)(:bin),
-             RequiredParameterNode(65...68)(:bag)],
-            (59...60),
-            (68...69)
-          )],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:bar, :baz, :optional, :bin, :bag],
-       (25...28),
-       nil,
-       (32...33),
-       (69...70),
-       nil,
-       (71...74)
-     ),
-     DefNode(77...95)(
-       :a,
-       (81...82),
-       nil,
-       nil,
-       BeginNode(84...95)(
-         nil,
-         nil,
-         nil,
-         nil,
-         EnsureNode(84...95)((84...90), nil, (92...95)),
-         (92...95)
-       ),
-       [],
-       (77...80),
-       nil,
-       nil,
-       nil,
-       nil,
-       (92...95)
-     ),
-     DefNode(97...110)(
-       :a,
-       (105...106),
-       ParenthesesNode(101...104)(
-         CallNode(102...103)(
-           nil,
-           nil,
-           (102...103),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "b"
-         ),
-         (101...102),
-         (103...104)
-       ),
-       nil,
-       nil,
-       [],
-       (97...100),
-       (104...105),
-       nil,
-       nil,
-       nil,
-       (107...110)
-     ),
-     DefNode(112...126)(
-       :b,
-       (121...122),
-       ParenthesesNode(116...119)(
-         CallNode(117...118)(
-           nil,
-           nil,
-           (117...118),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "a"
-         ),
-         (116...117),
-         (118...119)
-       ),
-       nil,
-       nil,
-       [],
-       (112...115),
-       (119...121),
-       nil,
-       nil,
-       nil,
-       (123...126)
-     ),
-     DefNode(128...143)(
-       :a,
-       (138...139),
-       FalseNode(132...137)(),
-       nil,
-       nil,
-       [],
-       (128...131),
-       (137...138),
-       nil,
-       nil,
-       nil,
-       (140...143)
-     ),
-     DefNode(145...159)(
-       :a,
-       (149...150),
-       nil,
-       ParametersNode(151...154)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(151...154)(),
-         nil
-       ),
-       nil,
-       [:"..."],
-       (145...148),
-       nil,
-       (150...151),
-       (154...155),
-       nil,
-       (156...159)
-     ),
-     DefNode(161...175)(
-       :a,
-       (170...171),
-       GlobalVariableReadNode(165...169)(:$var),
-       nil,
-       nil,
-       [],
-       (161...164),
-       (169...170),
-       nil,
-       nil,
-       nil,
-       (172...175)
-     ),
-     DefNode(177...188)(
-       :b,
-       (183...184),
-       CallNode(181...182)(nil, nil, (181...182), nil, nil, nil, nil, 2, "a"),
-       nil,
-       nil,
-       [],
-       (177...180),
-       (182...183),
-       nil,
-       nil,
-       nil,
-       (185...188)
-     ),
-     DefNode(190...204)(
-       :a,
-       (199...200),
-       InstanceVariableReadNode(194...198)(:@var),
-       nil,
-       nil,
-       [],
-       (190...193),
-       (198...199),
-       nil,
-       nil,
-       nil,
-       (201...204)
-     ),
-     DefNode(206...219)(
-       :a,
-       (210...211),
-       nil,
-       ParametersNode(212...214)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(212...214)(:b, (212...214), nil)],
-         nil,
-         nil
-       ),
-       nil,
-       [:b],
-       (206...209),
-       nil,
-       nil,
-       nil,
-       nil,
-       (216...219)
-     ),
-     StringNode(221...227)((221...223), (223...226), (226...227), "abc"),
-     DefNode(229...242)(
-       :a,
-       (233...234),
-       nil,
-       ParametersNode(235...237)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(235...237)(:b, (235...237), nil)],
-         nil,
-         nil
-       ),
-       nil,
-       [:b],
-       (229...232),
-       nil,
-       (234...235),
-       (237...238),
-       nil,
-       (239...242)
-     ),
-     DefNode(244...258)(
-       :a,
-       (248...249),
-       nil,
-       ParametersNode(250...253)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(250...253)(:b, (252...253), (250...252)),
-         nil
-       ),
-       nil,
-       [:b],
-       (244...247),
-       nil,
-       (249...250),
-       (253...254),
-       nil,
-       (255...258)
-     ),
-     DefNode(260...273)(
-       :a,
-       (264...265),
-       nil,
-       ParametersNode(266...268)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(266...268)(nil, nil, (266...268)),
-         nil
-       ),
-       nil,
-       [:**],
-       (260...263),
-       nil,
-       (265...266),
-       (268...269),
-       nil,
-       (270...273)
-     ),
-     LocalVariableWriteNode(275...280)(
-       :a,
-       0,
-       (275...276),
-       IntegerNode(279...280)(),
-       (277...278)
-     ),
-     DefNode(282...291)(
-       :a,
-       (286...287),
-       nil,
-       nil,
-       nil,
-       [],
-       (282...285),
-       nil,
-       nil,
-       nil,
-       nil,
-       (288...291)
-     ),
-     DefNode(293...310)(
-       :a,
-       (297...298),
-       nil,
-       ParametersNode(299...306)(
-         [RequiredParameterNode(299...300)(:b),
-          RequiredParameterNode(302...303)(:c),
-          RequiredParameterNode(305...306)(:d)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:b, :c, :d],
-       (293...296),
-       nil,
-       nil,
-       nil,
-       nil,
-       (307...310)
-     ),
-     DefNode(312...325)(
-       :a,
-       (320...321),
-       NilNode(316...319)(),
-       nil,
-       nil,
-       [],
-       (312...315),
-       (319...320),
-       nil,
-       nil,
-       nil,
-       (322...325)
-     ),
-     DefNode(327...345)(
-       :a,
-       (331...332),
-       nil,
-       ParametersNode(333...341)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(333...335)(:b, (333...335), nil),
-          KeywordParameterNode(337...341)(
-            :c,
-            (337...339),
-            IntegerNode(340...341)()
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:b, :c],
-       (327...330),
-       nil,
-       nil,
-       nil,
-       nil,
-       (342...345)
-     ),
-     DefNode(347...366)(
-       :a,
-       (351...352),
-       nil,
-       ParametersNode(353...361)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(353...355)(:b, (353...355), nil),
-          KeywordParameterNode(357...361)(
-            :c,
-            (357...359),
-            IntegerNode(360...361)()
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:b, :c],
-       (347...350),
-       nil,
-       (352...353),
-       (361...362),
-       nil,
-       (363...366)
-     ),
-     DefNode(368...389)(
-       :a,
-       (372...373),
-       nil,
-       ParametersNode(374...384)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(374...380)(
-            :b,
-            (374...376),
-            IntegerNode(379...380)()
-          ),
-          KeywordParameterNode(382...384)(:c, (382...384), nil)],
-         nil,
-         nil
-       ),
-       nil,
-       [:b, :c],
-       (368...371),
-       nil,
-       (373...374),
-       (384...385),
-       nil,
-       (386...389)
-     ),
-     StringNode(391...397)((391...393), (393...396), (396...397), "abc"),
-     DefNode(399...421)(
-       :a,
-       (403...404),
-       nil,
-       ParametersNode(405...417)(
-         [],
-         [OptionalParameterNode(405...410)(
-            :b,
-            (405...406),
-            (407...408),
-            IntegerNode(409...410)()
-          ),
-          OptionalParameterNode(412...417)(
-            :c,
-            (412...413),
-            (414...415),
-            IntegerNode(416...417)()
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:b, :c],
-       (399...402),
-       nil,
-       nil,
-       nil,
-       nil,
-       (418...421)
-     ),
-     DefNode(423...434)(
-       :a,
-       (427...428),
-       nil,
-       nil,
-       nil,
-       [],
-       (423...426),
-       nil,
-       (428...429),
-       (429...430),
-       nil,
-       (431...434)
-     ),
-     DefNode(436...454)(
-       :a,
-       (440...441),
-       nil,
-       ParametersNode(442...450)(
-         [RequiredParameterNode(442...443)(:b)],
-         [OptionalParameterNode(445...450)(
-            :c,
-            (445...446),
-            (447...448),
-            IntegerNode(449...450)()
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:b, :c],
-       (436...439),
-       nil,
-       nil,
-       nil,
-       nil,
-       (451...454)
-     ),
-     DefNode(456...467)(
-       :a,
-       (460...461),
-       nil,
-       ParametersNode(462...463)(
-         [RequiredParameterNode(462...463)(:b)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:b],
-       (456...459),
-       nil,
-       nil,
-       nil,
-       nil,
-       (464...467)
-     ),
-     DefNode(469...501)(
-       :a,
-       (473...474),
-       nil,
-       nil,
-       BeginNode(476...501)(
-         nil,
-         nil,
-         RescueNode(476...482)((476...482), [], nil, nil, nil, nil),
-         ElseNode(484...496)((484...488), nil, (490...496)),
-         EnsureNode(490...501)((490...496), nil, (498...501)),
-         (498...501)
-       ),
-       [],
-       (469...472),
-       nil,
-       nil,
-       nil,
-       nil,
-       (498...501)
-     ),
-     DefNode(503...515)(
-       :a,
-       (507...508),
-       nil,
-       ParametersNode(509...511)(
-         [],
-         [],
-         [],
-         RestParameterNode(509...511)(:b, (510...511), (509...510)),
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:b],
-       (503...506),
-       nil,
-       nil,
-       nil,
-       nil,
-       (512...515)
-     ),
-     DefNode(517...529)(
-       :a,
-       (521...522),
-       nil,
-       ParametersNode(523...524)(
-         [],
-         [],
-         [],
-         RestParameterNode(523...524)(nil, nil, (523...524)),
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:*],
-       (517...520),
-       nil,
-       (522...523),
-       (524...525),
-       nil,
-       (526...529)
-     ),
-     DefNode(531...546)(
-       :a,
-       (535...536),
-       nil,
-       nil,
-       StatementsNode(537...542)(
-         [LocalVariableWriteNode(537...542)(
-            :b,
-            0,
-            (537...538),
-            IntegerNode(541...542)(),
-            (539...540)
-          )]
-       ),
-       [:b],
-       (531...534),
-       nil,
-       nil,
-       nil,
-       nil,
-       (543...546)
-     ),
-     DefNode(548...562)(
-       :a,
-       (557...558),
-       SelfNode(552...556)(),
-       nil,
-       nil,
-       [],
-       (548...551),
-       (556...557),
-       nil,
-       nil,
-       nil,
-       (559...562)
-     ),
-     DefNode(564...578)(
-       :a,
-       (573...574),
-       TrueNode(568...572)(),
-       nil,
-       nil,
-       [],
-       (564...567),
-       (572...573),
-       nil,
-       nil,
-       nil,
-       (575...578)
-     ),
-     DefNode(580...589)(
-       :a,
-       (584...585),
-       nil,
-       nil,
-       nil,
-       [],
-       (580...583),
-       nil,
-       nil,
-       nil,
-       nil,
-       (586...589)
-     ),
-     DefNode(591...625)(
-       :hi,
-       (595...597),
-       nil,
-       nil,
-       StatementsNode(598...621)(
-         [IfNode(598...616)(
-            (609...611),
-            TrueNode(612...616)(),
-            StatementsNode(598...608)(
-              [ReturnNode(598...608)(
-                 (598...604),
-                 ArgumentsNode(605...608)(
-                   [SymbolNode(605...608)((605...606), (606...608), nil, "hi")]
-                 )
-               )]
-            ),
-            nil,
-            nil
-          ),
-          SymbolNode(617...621)((617...618), (618...621), nil, "bye")]
-       ),
-       [],
-       (591...594),
-       nil,
-       nil,
-       nil,
-       nil,
-       (622...625)
-     ),
-     DefNode(627...638)(
-       :foo,
-       (631...634),
-       nil,
-       nil,
-       StatementsNode(637...638)([IntegerNode(637...638)()]),
-       [],
-       (627...630),
-       nil,
-       nil,
-       nil,
-       (635...636),
-       nil
-     ),
-     DefNode(639...650)(
-       :bar,
-       (643...646),
-       nil,
-       nil,
-       StatementsNode(649...650)([IntegerNode(649...650)()]),
-       [],
-       (639...642),
-       nil,
-       nil,
-       nil,
-       (647...648),
-       nil
-     ),
-     DefNode(652...670)(
-       :foo,
-       (656...659),
-       nil,
-       ParametersNode(660...663)(
-         [RequiredParameterNode(660...663)(:bar)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(667...670)([IntegerNode(667...670)()]),
-       [:bar],
-       (652...655),
-       nil,
-       (659...660),
-       (663...664),
-       (665...666),
-       nil
-     ),
-     DefNode(672...685)(
-       :foo,
-       (676...679),
-       nil,
-       nil,
-       StatementsNode(682...685)([IntegerNode(682...685)()]),
-       [],
-       (672...675),
-       nil,
-       nil,
-       nil,
-       (680...681),
-       nil
-     ),
-     DefNode(687...706)(
-       :a,
-       (691...692),
-       nil,
-       ParametersNode(693...694)(
-         [],
-         [],
-         [],
-         RestParameterNode(693...694)(nil, nil, (693...694)),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(697...701)(
-         [CallNode(697...701)(
-            nil,
-            nil,
-            (697...698),
-            (698...699),
-            ArgumentsNode(699...700)([SplatNode(699...700)((699...700), nil)]),
-            (700...701),
-            nil,
-            0,
-            "b"
-          )]
-       ),
-       [:*],
-       (687...690),
-       nil,
-       (692...693),
-       (694...695),
-       nil,
-       (703...706)
-     ),
-     DefNode(708...731)(
-       :a,
-       (712...713),
-       nil,
-       ParametersNode(714...717)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(714...717)(),
-         nil
-       ),
-       StatementsNode(720...726)(
-         [CallNode(720...726)(
-            nil,
-            nil,
-            (720...721),
-            (721...722),
-            ArgumentsNode(722...725)([ForwardingArgumentsNode(722...725)()]),
-            (725...726),
-            nil,
-            0,
-            "b"
-          )]
-       ),
-       [:"..."],
-       (708...711),
-       nil,
-       (713...714),
-       (717...718),
-       nil,
-       (728...731)
-     ),
-     DefNode(733...762)(
-       :a,
-       (737...738),
-       nil,
-       ParametersNode(739...742)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(739...742)(),
-         nil
-       ),
-       StatementsNode(745...757)(
-         [CallNode(745...757)(
-            nil,
-            nil,
-            (745...746),
-            (746...747),
-            ArgumentsNode(747...756)(
-              [IntegerNode(747...748)(),
-               IntegerNode(750...751)(),
-               ForwardingArgumentsNode(753...756)()]
-            ),
-            (756...757),
-            nil,
-            0,
-            "b"
-          )]
-       ),
-       [:"..."],
-       (733...736),
-       nil,
-       (738...739),
-       (742...743),
-       nil,
-       (759...762)
-     ),
-     DefNode(764...781)(
-       :a,
-       (776...777),
-       ParenthesesNode(768...775)(
-         LocalVariableWriteNode(769...774)(
-           :c,
-           0,
-           (769...770),
-           CallNode(773...774)(
-             nil,
-             nil,
-             (773...774),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "b"
-           ),
-           (771...772)
-         ),
-         (768...769),
-         (774...775)
-       ),
-       nil,
-       nil,
-       [],
-       (764...767),
-       (775...776),
-       nil,
-       nil,
-       nil,
-       (778...781)
-     ),
-     DefNode(783...795)(
-       :a,
-       (787...788),
-       nil,
-       ParametersNode(789...791)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(789...791)(:b, (790...791), (789...790))
-       ),
-       nil,
-       [:b],
-       (783...786),
-       nil,
-       nil,
-       nil,
-       nil,
-       (792...795)
-     ),
-     DefNode(797...809)(
-       :a,
-       (801...802),
-       nil,
-       ParametersNode(803...804)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(803...804)(nil, nil, (803...804))
-       ),
-       nil,
-       [:&],
-       (797...800),
-       nil,
-       (802...803),
-       (804...805),
-       nil,
-       (806...809)
-     ),
-     DefNode(811...826)(
-       :a,
-       (821...822),
-       ClassVariableReadNode(815...820)(:@@var),
-       nil,
-       nil,
-       [],
-       (811...814),
-       (820...821),
-       nil,
-       nil,
-       nil,
-       (823...826)
-     ),
-     DefNode(828...845)(
-       :C,
-       (840...841),
-       ParenthesesNode(832...839)(
-         LocalVariableWriteNode(833...838)(
-           :a,
-           0,
-           (833...834),
-           CallNode(837...838)(
-             nil,
-             nil,
-             (837...838),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "b"
-           ),
-           (835...836)
-         ),
-         (832...833),
-         (838...839)
-       ),
-       nil,
-       nil,
-       [],
-       (828...831),
-       (839...840),
-       nil,
-       nil,
-       nil,
-       (842...845)
-     ),
-     DefNode(847...875)(
-       :Array_function,
-       (856...870),
-       SelfNode(851...855)(),
-       nil,
-       nil,
-       [],
-       (847...850),
-       (855...856),
-       nil,
-       nil,
-       nil,
-       (872...875)
-     ),
-     ConstantWriteNode(877...886)(
-       :Const,
-       (877...882),
-       IntegerNode(885...886)(),
-       (883...884)
-     ),
-     DefNode(888...903)(
-       :a,
-       (898...899),
-       ConstantReadNode(892...897)(:Const),
-       nil,
-       nil,
-       [],
-       (888...891),
-       (897...898),
-       nil,
-       nil,
-       nil,
-       (900...903)
-     ),
-     DefNode(905...936)(
-       :a,
-       (909...910),
-       nil,
-       ParametersNode(911...914)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(911...914)(),
-         nil
-       ),
-       StatementsNode(917...931)(
-         [InterpolatedStringNode(917...931)(
-            (917...918),
-            [StringNode(918...921)(nil, (918...921), nil, "foo"),
-             EmbeddedStatementsNode(921...930)(
-               (921...923),
-               StatementsNode(923...929)(
-                 [CallNode(923...929)(
-                    nil,
-                    nil,
-                    (923...924),
-                    (924...925),
-                    ArgumentsNode(925...928)(
-                      [ForwardingArgumentsNode(925...928)()]
-                    ),
-                    (928...929),
-                    nil,
-                    0,
-                    "b"
-                  )]
-               ),
-               (929...930)
-             )],
-            (930...931)
-          )]
-       ),
-       [:"..."],
-       (905...908),
-       nil,
-       (910...911),
-       (914...915),
-       nil,
-       (933...936)
-     ),
-     DefNode(938...980)(
-       :foo,
-       (942...945),
-       nil,
-       nil,
-       StatementsNode(948...976)(
-         [CallNode(948...976)(
-            HashNode(948...950)((948...949), [], (949...950)),
-            (950...951),
-            (951...956),
-            nil,
-            ArgumentsNode(957...976)(
-              [KeywordHashNode(957...976)(
-                 [AssocSplatNode(957...962)(
-                    CallNode(959...962)(
-                      nil,
-                      nil,
-                      (959...962),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "bar"
-                    ),
-                    (957...959)
-                  ),
-                  AssocSplatNode(964...969)(
-                    CallNode(966...969)(
-                      nil,
-                      nil,
-                      (966...969),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "baz"
-                    ),
-                    (964...966)
-                  ),
-                  AssocSplatNode(971...976)(
-                    CallNode(973...976)(
-                      nil,
-                      nil,
-                      (973...976),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "qux"
-                    ),
-                    (971...973)
-                  )]
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "merge"
-          )]
-       ),
-       [],
-       (938...941),
-       nil,
-       nil,
-       nil,
-       nil,
-       (977...980)
-     ),
-     DefNode(982...1006)(
-       :bar,
-       (986...989),
-       nil,
-       ParametersNode(990...1001)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(990...1001)(
-            :a,
-            (990...992),
-            ParenthesesNode(993...1001)(
-              StatementsNode(994...1000)(
-                [RangeNode(994...1000)(
-                   IntegerNode(994...995)(),
-                   IntegerNode(998...1000)(),
-                   (995...998),
-                   1
-                 )]
-              ),
-              (993...994),
-              (1000...1001)
-            )
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (982...985),
-       nil,
-       (989...990),
-       (1001...1002),
-       nil,
-       (1003...1006)
-     ),
-     DefNode(1008...1031)(
-       :bar,
-       (1012...1015),
-       nil,
-       ParametersNode(1016...1026)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(1016...1026)(
-            :a,
-            (1016...1018),
-            ParenthesesNode(1019...1026)(
-              StatementsNode(1020...1025)(
-                [RangeNode(1020...1025)(
-                   nil,
-                   IntegerNode(1023...1025)(),
-                   (1020...1023),
-                   1
-                 )]
-              ),
-              (1019...1020),
-              (1025...1026)
-            )
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (1008...1011),
-       nil,
-       (1015...1016),
-       (1026...1027),
-       nil,
-       (1028...1031)
-     ),
-     DefNode(1033...1055)(
-       :bar,
-       (1037...1040),
-       nil,
-       ParametersNode(1041...1050)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(1041...1050)(
-            :a,
-            (1041...1043),
-            ParenthesesNode(1044...1050)(
-              StatementsNode(1045...1049)(
-                [RangeNode(1045...1049)(
-                   IntegerNode(1045...1046)(),
-                   nil,
-                   (1046...1049),
-                   1
-                 )]
-              ),
-              (1044...1045),
-              (1049...1050)
-            )
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (1033...1036),
-       nil,
-       (1040...1041),
-       (1050...1051),
-       nil,
-       (1052...1055)
-     ),
-     DefNode(1057...1082)(
-       :bar,
-       (1061...1064),
-       nil,
-       ParametersNode(1065...1077)(
-         [],
-         [OptionalParameterNode(1065...1077)(
-            :a,
-            (1065...1066),
-            (1067...1068),
-            ParenthesesNode(1069...1077)(
-              StatementsNode(1070...1076)(
-                [RangeNode(1070...1076)(
-                   IntegerNode(1070...1071)(),
-                   IntegerNode(1074...1076)(),
-                   (1071...1074),
-                   1
-                 )]
-              ),
-              (1069...1070),
-              (1076...1077)
-            )
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (1057...1060),
-       nil,
-       (1064...1065),
-       (1077...1078),
-       nil,
-       (1079...1082)
-     ),
-     DefNode(1084...1108)(
-       :bar,
-       (1088...1091),
-       nil,
-       ParametersNode(1092...1103)(
-         [],
-         [OptionalParameterNode(1092...1103)(
-            :a,
-            (1092...1093),
-            (1094...1095),
-            ParenthesesNode(1096...1103)(
-              StatementsNode(1097...1102)(
-                [RangeNode(1097...1102)(
-                   nil,
-                   IntegerNode(1100...1102)(),
-                   (1097...1100),
-                   1
-                 )]
-              ),
-              (1096...1097),
-              (1102...1103)
-            )
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (1084...1087),
-       nil,
-       (1091...1092),
-       (1103...1104),
-       nil,
-       (1105...1108)
-     ),
-     DefNode(1110...1133)(
-       :bar,
-       (1114...1117),
-       nil,
-       ParametersNode(1118...1128)(
-         [],
-         [OptionalParameterNode(1118...1128)(
-            :a,
-            (1118...1119),
-            (1120...1121),
-            ParenthesesNode(1122...1128)(
-              StatementsNode(1123...1127)(
-                [RangeNode(1123...1127)(
-                   IntegerNode(1123...1124)(),
-                   nil,
-                   (1124...1127),
-                   1
-                 )]
-              ),
-              (1122...1123),
-              (1127...1128)
-            )
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (1110...1113),
-       nil,
-       (1117...1118),
-       (1128...1129),
-       nil,
-       (1130...1133)
-     ),
-     DefNode(1135...1167)(
-       :method,
-       (1139...1145),
-       nil,
-       ParametersNode(1146...1147)(
-         [RequiredParameterNode(1146...1147)(:a)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(1151...1163)(
-         [CallNode(1151...1163)(
-            CallNode(1151...1155)(
-              nil,
-              nil,
-              (1151...1155),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "item"
-            ),
-            nil,
-            (1156...1158),
-            nil,
-            ArgumentsNode(1159...1163)(
-              [CallNode(1159...1163)(
-                 nil,
-                 nil,
-                 (1159...1160),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(1161...1163)(
-                   [],
-                   nil,
-                   nil,
-                   (1161...1162),
-                   (1162...1163)
-                 ),
-                 0,
-                 "a"
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            ">>"
-          )]
-       ),
-       [:a],
-       (1135...1138),
-       nil,
-       (1145...1146),
-       (1147...1148),
-       nil,
-       (1164...1167)
-     ),
-     DefNode(1169...1194)(
-       :foo,
-       (1173...1176),
-       nil,
-       ParametersNode(1177...1189)(
-         [RequiredParameterNode(1177...1179)(:_a),
-          RequiredParameterNode(1181...1183)(:_a),
-          RequiredParameterNode(1185...1186)(:b),
-          RequiredParameterNode(1188...1189)(:c)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:_a, :b, :c],
-       (1169...1172),
-       nil,
-       (1176...1177),
-       (1189...1190),
-       nil,
-       (1191...1194)
-     )]
-  )
-)
+@ ProgramNode (location: (0...1194))
+├── locals: [:a, :c]
+└── statements:
+    @ StatementsNode (location: (0...1194))
+    └── body: (length: 60)
+        ├── @ DefNode (location: (0...23))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (8...18))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...18))
+        │   │   │       ├── parameters: (length: 2)
+        │   │   │       │   ├── @ RequiredParameterNode (location: (9...12))
+        │   │   │       │   │   └── name: :bar
+        │   │   │       │   └── @ RequiredParameterNode (location: (14...17))
+        │   │   │       │       └── name: :baz
+        │   │   │       ├── opening_loc: (8...9) = "("
+        │   │   │       └── closing_loc: (17...18) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:bar, :baz]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (7...8) = "("
+        │   ├── rparen_loc: (18...19) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (20...23) = "end"
+        ├── @ DefNode (location: (25...74))
+        │   ├── name: :foo
+        │   ├── name_loc: (29...32) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (33...69))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (33...43))
+        │   │   │       ├── parameters: (length: 2)
+        │   │   │       │   ├── @ RequiredParameterNode (location: (34...37))
+        │   │   │       │   │   └── name: :bar
+        │   │   │       │   └── @ RequiredParameterNode (location: (39...42))
+        │   │   │       │       └── name: :baz
+        │   │   │       ├── opening_loc: (33...34) = "("
+        │   │   │       └── closing_loc: (42...43) = ")"
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (45...57))
+        │   │   │       ├── name: :optional
+        │   │   │       ├── name_loc: (45...53) = "optional"
+        │   │   │       ├── operator_loc: (54...55) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (56...57))
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (59...69))
+        │   │   │       ├── parameters: (length: 2)
+        │   │   │       │   ├── @ RequiredParameterNode (location: (60...63))
+        │   │   │       │   │   └── name: :bin
+        │   │   │       │   └── @ RequiredParameterNode (location: (65...68))
+        │   │   │       │       └── name: :bag
+        │   │   │       ├── opening_loc: (59...60) = "("
+        │   │   │       └── closing_loc: (68...69) = ")"
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:bar, :baz, :optional, :bin, :bag]
+        │   ├── def_keyword_loc: (25...28) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (32...33) = "("
+        │   ├── rparen_loc: (69...70) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (71...74) = "end"
+        ├── @ DefNode (location: (77...95))
+        │   ├── name: :a
+        │   ├── name_loc: (81...82) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (84...95))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements: ∅
+        │   │   ├── rescue_clause: ∅
+        │   │   ├── else_clause: ∅
+        │   │   ├── ensure_clause:
+        │   │   │   @ EnsureNode (location: (84...95))
+        │   │   │   ├── ensure_keyword_loc: (84...90) = "ensure"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── end_keyword_loc: (92...95) = "end"
+        │   │   └── end_keyword_loc: (92...95) = "end"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (77...80) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (92...95) = "end"
+        ├── @ DefNode (location: (97...110))
+        │   ├── name: :a
+        │   ├── name_loc: (105...106) = "a"
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (101...104))
+        │   │   ├── body:
+        │   │   │   @ CallNode (location: (102...103))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (102...103) = "b"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "b"
+        │   │   ├── opening_loc: (101...102) = "("
+        │   │   └── closing_loc: (103...104) = ")"
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (97...100) = "def"
+        │   ├── operator_loc: (104...105) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (107...110) = "end"
+        ├── @ DefNode (location: (112...126))
+        │   ├── name: :b
+        │   ├── name_loc: (121...122) = "b"
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (116...119))
+        │   │   ├── body:
+        │   │   │   @ CallNode (location: (117...118))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (117...118) = "a"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "a"
+        │   │   ├── opening_loc: (116...117) = "("
+        │   │   └── closing_loc: (118...119) = ")"
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (112...115) = "def"
+        │   ├── operator_loc: (119...121) = "::"
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (123...126) = "end"
+        ├── @ DefNode (location: (128...143))
+        │   ├── name: :a
+        │   ├── name_loc: (138...139) = "a"
+        │   ├── receiver:
+        │   │   @ FalseNode (location: (132...137))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (128...131) = "def"
+        │   ├── operator_loc: (137...138) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (140...143) = "end"
+        ├── @ DefNode (location: (145...159))
+        │   ├── name: :a
+        │   ├── name_loc: (149...150) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (151...154))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (151...154))
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:"..."]
+        │   ├── def_keyword_loc: (145...148) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (150...151) = "("
+        │   ├── rparen_loc: (154...155) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (156...159) = "end"
+        ├── @ DefNode (location: (161...175))
+        │   ├── name: :a
+        │   ├── name_loc: (170...171) = "a"
+        │   ├── receiver:
+        │   │   @ GlobalVariableReadNode (location: (165...169))
+        │   │   └── name: :$var
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (161...164) = "def"
+        │   ├── operator_loc: (169...170) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (172...175) = "end"
+        ├── @ DefNode (location: (177...188))
+        │   ├── name: :b
+        │   ├── name_loc: (183...184) = "b"
+        │   ├── receiver:
+        │   │   @ CallNode (location: (181...182))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (181...182) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (177...180) = "def"
+        │   ├── operator_loc: (182...183) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (185...188) = "end"
+        ├── @ DefNode (location: (190...204))
+        │   ├── name: :a
+        │   ├── name_loc: (199...200) = "a"
+        │   ├── receiver:
+        │   │   @ InstanceVariableReadNode (location: (194...198))
+        │   │   └── name: :@var
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (190...193) = "def"
+        │   ├── operator_loc: (198...199) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (201...204) = "end"
+        ├── @ DefNode (location: (206...219))
+        │   ├── name: :a
+        │   ├── name_loc: (210...211) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (212...214))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (212...214))
+        │   │   │       ├── name: :b
+        │   │   │       ├── name_loc: (212...214) = "b:"
+        │   │   │       └── value: ∅
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (206...209) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (216...219) = "end"
+        ├── @ StringNode (location: (221...227))
+        │   ├── opening_loc: (221...223) = "%,"
+        │   ├── content_loc: (223...226) = "abc"
+        │   ├── closing_loc: (226...227) = ","
+        │   └── unescaped: "abc"
+        ├── @ DefNode (location: (229...242))
+        │   ├── name: :a
+        │   ├── name_loc: (233...234) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (235...237))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (235...237))
+        │   │   │       ├── name: :b
+        │   │   │       ├── name_loc: (235...237) = "b:"
+        │   │   │       └── value: ∅
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (229...232) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (234...235) = "("
+        │   ├── rparen_loc: (237...238) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (239...242) = "end"
+        ├── @ DefNode (location: (244...258))
+        │   ├── name: :a
+        │   ├── name_loc: (248...249) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (250...253))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ KeywordRestParameterNode (location: (250...253))
+        │   │   │   ├── name: :b
+        │   │   │   ├── name_loc: (252...253) = "b"
+        │   │   │   └── operator_loc: (250...252) = "**"
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (244...247) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (249...250) = "("
+        │   ├── rparen_loc: (253...254) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (255...258) = "end"
+        ├── @ DefNode (location: (260...273))
+        │   ├── name: :a
+        │   ├── name_loc: (264...265) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (266...268))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ KeywordRestParameterNode (location: (266...268))
+        │   │   │   ├── name: nil
+        │   │   │   ├── name_loc: ∅
+        │   │   │   └── operator_loc: (266...268) = "**"
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:**]
+        │   ├── def_keyword_loc: (260...263) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (265...266) = "("
+        │   ├── rparen_loc: (268...269) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (270...273) = "end"
+        ├── @ LocalVariableWriteNode (location: (275...280))
+        │   ├── name: :a
+        │   ├── depth: 0
+        │   ├── name_loc: (275...276) = "a"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (279...280))
+        │   └── operator_loc: (277...278) = "="
+        ├── @ DefNode (location: (282...291))
+        │   ├── name: :a
+        │   ├── name_loc: (286...287) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (282...285) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (288...291) = "end"
+        ├── @ DefNode (location: (293...310))
+        │   ├── name: :a
+        │   ├── name_loc: (297...298) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (299...306))
+        │   │   ├── requireds: (length: 3)
+        │   │   │   ├── @ RequiredParameterNode (location: (299...300))
+        │   │   │   │   └── name: :b
+        │   │   │   ├── @ RequiredParameterNode (location: (302...303))
+        │   │   │   │   └── name: :c
+        │   │   │   └── @ RequiredParameterNode (location: (305...306))
+        │   │   │       └── name: :d
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b, :c, :d]
+        │   ├── def_keyword_loc: (293...296) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (307...310) = "end"
+        ├── @ DefNode (location: (312...325))
+        │   ├── name: :a
+        │   ├── name_loc: (320...321) = "a"
+        │   ├── receiver:
+        │   │   @ NilNode (location: (316...319))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (312...315) = "def"
+        │   ├── operator_loc: (319...320) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (322...325) = "end"
+        ├── @ DefNode (location: (327...345))
+        │   ├── name: :a
+        │   ├── name_loc: (331...332) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (333...341))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 2)
+        │   │   │   ├── @ KeywordParameterNode (location: (333...335))
+        │   │   │   │   ├── name: :b
+        │   │   │   │   ├── name_loc: (333...335) = "b:"
+        │   │   │   │   └── value: ∅
+        │   │   │   └── @ KeywordParameterNode (location: (337...341))
+        │   │   │       ├── name: :c
+        │   │   │       ├── name_loc: (337...339) = "c:"
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (340...341))
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b, :c]
+        │   ├── def_keyword_loc: (327...330) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (342...345) = "end"
+        ├── @ DefNode (location: (347...366))
+        │   ├── name: :a
+        │   ├── name_loc: (351...352) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (353...361))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 2)
+        │   │   │   ├── @ KeywordParameterNode (location: (353...355))
+        │   │   │   │   ├── name: :b
+        │   │   │   │   ├── name_loc: (353...355) = "b:"
+        │   │   │   │   └── value: ∅
+        │   │   │   └── @ KeywordParameterNode (location: (357...361))
+        │   │   │       ├── name: :c
+        │   │   │       ├── name_loc: (357...359) = "c:"
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (360...361))
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b, :c]
+        │   ├── def_keyword_loc: (347...350) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (352...353) = "("
+        │   ├── rparen_loc: (361...362) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (363...366) = "end"
+        ├── @ DefNode (location: (368...389))
+        │   ├── name: :a
+        │   ├── name_loc: (372...373) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (374...384))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 2)
+        │   │   │   ├── @ KeywordParameterNode (location: (374...380))
+        │   │   │   │   ├── name: :b
+        │   │   │   │   ├── name_loc: (374...376) = "b:"
+        │   │   │   │   └── value:
+        │   │   │   │       @ IntegerNode (location: (379...380))
+        │   │   │   └── @ KeywordParameterNode (location: (382...384))
+        │   │   │       ├── name: :c
+        │   │   │       ├── name_loc: (382...384) = "c:"
+        │   │   │       └── value: ∅
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b, :c]
+        │   ├── def_keyword_loc: (368...371) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (373...374) = "("
+        │   ├── rparen_loc: (384...385) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (386...389) = "end"
+        ├── @ StringNode (location: (391...397))
+        │   ├── opening_loc: (391...393) = "%."
+        │   ├── content_loc: (393...396) = "abc"
+        │   ├── closing_loc: (396...397) = "."
+        │   └── unescaped: "abc"
+        ├── @ DefNode (location: (399...421))
+        │   ├── name: :a
+        │   ├── name_loc: (403...404) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (405...417))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 2)
+        │   │   │   ├── @ OptionalParameterNode (location: (405...410))
+        │   │   │   │   ├── name: :b
+        │   │   │   │   ├── name_loc: (405...406) = "b"
+        │   │   │   │   ├── operator_loc: (407...408) = "="
+        │   │   │   │   └── value:
+        │   │   │   │       @ IntegerNode (location: (409...410))
+        │   │   │   └── @ OptionalParameterNode (location: (412...417))
+        │   │   │       ├── name: :c
+        │   │   │       ├── name_loc: (412...413) = "c"
+        │   │   │       ├── operator_loc: (414...415) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (416...417))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b, :c]
+        │   ├── def_keyword_loc: (399...402) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (418...421) = "end"
+        ├── @ DefNode (location: (423...434))
+        │   ├── name: :a
+        │   ├── name_loc: (427...428) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (423...426) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (428...429) = "("
+        │   ├── rparen_loc: (429...430) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (431...434) = "end"
+        ├── @ DefNode (location: (436...454))
+        │   ├── name: :a
+        │   ├── name_loc: (440...441) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (442...450))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (442...443))
+        │   │   │       └── name: :b
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (445...450))
+        │   │   │       ├── name: :c
+        │   │   │       ├── name_loc: (445...446) = "c"
+        │   │   │       ├── operator_loc: (447...448) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (449...450))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b, :c]
+        │   ├── def_keyword_loc: (436...439) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (451...454) = "end"
+        ├── @ DefNode (location: (456...467))
+        │   ├── name: :a
+        │   ├── name_loc: (460...461) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (462...463))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (462...463))
+        │   │   │       └── name: :b
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (456...459) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (464...467) = "end"
+        ├── @ DefNode (location: (469...501))
+        │   ├── name: :a
+        │   ├── name_loc: (473...474) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (476...501))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements: ∅
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (476...482))
+        │   │   │   ├── keyword_loc: (476...482) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements: ∅
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause:
+        │   │   │   @ ElseNode (location: (484...496))
+        │   │   │   ├── else_keyword_loc: (484...488) = "else"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── end_keyword_loc: (490...496) = "ensure"
+        │   │   ├── ensure_clause:
+        │   │   │   @ EnsureNode (location: (490...501))
+        │   │   │   ├── ensure_keyword_loc: (490...496) = "ensure"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── end_keyword_loc: (498...501) = "end"
+        │   │   └── end_keyword_loc: (498...501) = "end"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (469...472) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (498...501) = "end"
+        ├── @ DefNode (location: (503...515))
+        │   ├── name: :a
+        │   ├── name_loc: (507...508) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (509...511))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (509...511))
+        │   │   │   ├── name: :b
+        │   │   │   ├── name_loc: (510...511) = "b"
+        │   │   │   └── operator_loc: (509...510) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (503...506) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (512...515) = "end"
+        ├── @ DefNode (location: (517...529))
+        │   ├── name: :a
+        │   ├── name_loc: (521...522) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (523...524))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (523...524))
+        │   │   │   ├── name: nil
+        │   │   │   ├── name_loc: ∅
+        │   │   │   └── operator_loc: (523...524) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:*]
+        │   ├── def_keyword_loc: (517...520) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (522...523) = "("
+        │   ├── rparen_loc: (524...525) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (526...529) = "end"
+        ├── @ DefNode (location: (531...546))
+        │   ├── name: :a
+        │   ├── name_loc: (535...536) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (537...542))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableWriteNode (location: (537...542))
+        │   │           ├── name: :b
+        │   │           ├── depth: 0
+        │   │           ├── name_loc: (537...538) = "b"
+        │   │           ├── value:
+        │   │           │   @ IntegerNode (location: (541...542))
+        │   │           └── operator_loc: (539...540) = "="
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (531...534) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (543...546) = "end"
+        ├── @ DefNode (location: (548...562))
+        │   ├── name: :a
+        │   ├── name_loc: (557...558) = "a"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (552...556))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (548...551) = "def"
+        │   ├── operator_loc: (556...557) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (559...562) = "end"
+        ├── @ DefNode (location: (564...578))
+        │   ├── name: :a
+        │   ├── name_loc: (573...574) = "a"
+        │   ├── receiver:
+        │   │   @ TrueNode (location: (568...572))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (564...567) = "def"
+        │   ├── operator_loc: (572...573) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (575...578) = "end"
+        ├── @ DefNode (location: (580...589))
+        │   ├── name: :a
+        │   ├── name_loc: (584...585) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (580...583) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (586...589) = "end"
+        ├── @ DefNode (location: (591...625))
+        │   ├── name: :hi
+        │   ├── name_loc: (595...597) = "hi"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (598...621))
+        │   │   └── body: (length: 2)
+        │   │       ├── @ IfNode (location: (598...616))
+        │   │       │   ├── if_keyword_loc: (609...611) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ TrueNode (location: (612...616))
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (598...608))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ ReturnNode (location: (598...608))
+        │   │       │   │           ├── keyword_loc: (598...604) = "return"
+        │   │       │   │           └── arguments:
+        │   │       │   │               @ ArgumentsNode (location: (605...608))
+        │   │       │   │               └── arguments: (length: 1)
+        │   │       │   │                   └── @ SymbolNode (location: (605...608))
+        │   │       │   │                       ├── opening_loc: (605...606) = ":"
+        │   │       │   │                       ├── value_loc: (606...608) = "hi"
+        │   │       │   │                       ├── closing_loc: ∅
+        │   │       │   │                       └── unescaped: "hi"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       └── @ SymbolNode (location: (617...621))
+        │   │           ├── opening_loc: (617...618) = ":"
+        │   │           ├── value_loc: (618...621) = "bye"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "bye"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (591...594) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (622...625) = "end"
+        ├── @ DefNode (location: (627...638))
+        │   ├── name: :foo
+        │   ├── name_loc: (631...634) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (637...638))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (637...638))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (627...630) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (635...636) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (639...650))
+        │   ├── name: :bar
+        │   ├── name_loc: (643...646) = "bar"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (649...650))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (649...650))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (639...642) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (647...648) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (652...670))
+        │   ├── name: :foo
+        │   ├── name_loc: (656...659) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (660...663))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (660...663))
+        │   │   │       └── name: :bar
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (667...670))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (667...670))
+        │   ├── locals: [:bar]
+        │   ├── def_keyword_loc: (652...655) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (659...660) = "("
+        │   ├── rparen_loc: (663...664) = ")"
+        │   ├── equal_loc: (665...666) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (672...685))
+        │   ├── name: :foo
+        │   ├── name_loc: (676...679) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (682...685))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (682...685))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (672...675) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (680...681) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (687...706))
+        │   ├── name: :a
+        │   ├── name_loc: (691...692) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (693...694))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (693...694))
+        │   │   │   ├── name: nil
+        │   │   │   ├── name_loc: ∅
+        │   │   │   └── operator_loc: (693...694) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (697...701))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (697...701))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (697...698) = "b"
+        │   │           ├── opening_loc: (698...699) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (699...700))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ SplatNode (location: (699...700))
+        │   │           │           ├── operator_loc: (699...700) = "*"
+        │   │           │           └── expression: ∅
+        │   │           ├── closing_loc: (700...701) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "b"
+        │   ├── locals: [:*]
+        │   ├── def_keyword_loc: (687...690) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (692...693) = "("
+        │   ├── rparen_loc: (694...695) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (703...706) = "end"
+        ├── @ DefNode (location: (708...731))
+        │   ├── name: :a
+        │   ├── name_loc: (712...713) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (714...717))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (714...717))
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (720...726))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (720...726))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (720...721) = "b"
+        │   │           ├── opening_loc: (721...722) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (722...725))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ ForwardingArgumentsNode (location: (722...725))
+        │   │           ├── closing_loc: (725...726) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "b"
+        │   ├── locals: [:"..."]
+        │   ├── def_keyword_loc: (708...711) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (713...714) = "("
+        │   ├── rparen_loc: (717...718) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (728...731) = "end"
+        ├── @ DefNode (location: (733...762))
+        │   ├── name: :a
+        │   ├── name_loc: (737...738) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (739...742))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (739...742))
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (745...757))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (745...757))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (745...746) = "b"
+        │   │           ├── opening_loc: (746...747) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (747...756))
+        │   │           │   └── arguments: (length: 3)
+        │   │           │       ├── @ IntegerNode (location: (747...748))
+        │   │           │       ├── @ IntegerNode (location: (750...751))
+        │   │           │       └── @ ForwardingArgumentsNode (location: (753...756))
+        │   │           ├── closing_loc: (756...757) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "b"
+        │   ├── locals: [:"..."]
+        │   ├── def_keyword_loc: (733...736) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (738...739) = "("
+        │   ├── rparen_loc: (742...743) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (759...762) = "end"
+        ├── @ DefNode (location: (764...781))
+        │   ├── name: :a
+        │   ├── name_loc: (776...777) = "a"
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (768...775))
+        │   │   ├── body:
+        │   │   │   @ LocalVariableWriteNode (location: (769...774))
+        │   │   │   ├── name: :c
+        │   │   │   ├── depth: 0
+        │   │   │   ├── name_loc: (769...770) = "c"
+        │   │   │   ├── value:
+        │   │   │   │   @ CallNode (location: (773...774))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (773...774) = "b"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "b"
+        │   │   │   └── operator_loc: (771...772) = "="
+        │   │   ├── opening_loc: (768...769) = "("
+        │   │   └── closing_loc: (774...775) = ")"
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (764...767) = "def"
+        │   ├── operator_loc: (775...776) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (778...781) = "end"
+        ├── @ DefNode (location: (783...795))
+        │   ├── name: :a
+        │   ├── name_loc: (787...788) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (789...791))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (789...791))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (790...791) = "b"
+        │   │       └── operator_loc: (789...790) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (783...786) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (792...795) = "end"
+        ├── @ DefNode (location: (797...809))
+        │   ├── name: :a
+        │   ├── name_loc: (801...802) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (803...804))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (803...804))
+        │   │       ├── name: nil
+        │   │       ├── name_loc: ∅
+        │   │       └── operator_loc: (803...804) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:&]
+        │   ├── def_keyword_loc: (797...800) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (802...803) = "("
+        │   ├── rparen_loc: (804...805) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (806...809) = "end"
+        ├── @ DefNode (location: (811...826))
+        │   ├── name: :a
+        │   ├── name_loc: (821...822) = "a"
+        │   ├── receiver:
+        │   │   @ ClassVariableReadNode (location: (815...820))
+        │   │   └── name: :@@var
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (811...814) = "def"
+        │   ├── operator_loc: (820...821) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (823...826) = "end"
+        ├── @ DefNode (location: (828...845))
+        │   ├── name: :C
+        │   ├── name_loc: (840...841) = "C"
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (832...839))
+        │   │   ├── body:
+        │   │   │   @ LocalVariableWriteNode (location: (833...838))
+        │   │   │   ├── name: :a
+        │   │   │   ├── depth: 0
+        │   │   │   ├── name_loc: (833...834) = "a"
+        │   │   │   ├── value:
+        │   │   │   │   @ CallNode (location: (837...838))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (837...838) = "b"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "b"
+        │   │   │   └── operator_loc: (835...836) = "="
+        │   │   ├── opening_loc: (832...833) = "("
+        │   │   └── closing_loc: (838...839) = ")"
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (828...831) = "def"
+        │   ├── operator_loc: (839...840) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (842...845) = "end"
+        ├── @ DefNode (location: (847...875))
+        │   ├── name: :Array_function
+        │   ├── name_loc: (856...870) = "Array_function"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (851...855))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (847...850) = "def"
+        │   ├── operator_loc: (855...856) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (872...875) = "end"
+        ├── @ ConstantWriteNode (location: (877...886))
+        │   ├── name: :Const
+        │   ├── name_loc: (877...882) = "Const"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (885...886))
+        │   └── operator_loc: (883...884) = "="
+        ├── @ DefNode (location: (888...903))
+        │   ├── name: :a
+        │   ├── name_loc: (898...899) = "a"
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (892...897))
+        │   │   └── name: :Const
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (888...891) = "def"
+        │   ├── operator_loc: (897...898) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (900...903) = "end"
+        ├── @ DefNode (location: (905...936))
+        │   ├── name: :a
+        │   ├── name_loc: (909...910) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (911...914))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (911...914))
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (917...931))
+        │   │   └── body: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (917...931))
+        │   │           ├── opening_loc: (917...918) = "\""
+        │   │           ├── parts: (length: 2)
+        │   │           │   ├── @ StringNode (location: (918...921))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (918...921) = "foo"
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "foo"
+        │   │           │   └── @ EmbeddedStatementsNode (location: (921...930))
+        │   │           │       ├── opening_loc: (921...923) = "\#{"
+        │   │           │       ├── statements:
+        │   │           │       │   @ StatementsNode (location: (923...929))
+        │   │           │       │   └── body: (length: 1)
+        │   │           │       │       └── @ CallNode (location: (923...929))
+        │   │           │       │           ├── receiver: ∅
+        │   │           │       │           ├── call_operator_loc: ∅
+        │   │           │       │           ├── message_loc: (923...924) = "b"
+        │   │           │       │           ├── opening_loc: (924...925) = "("
+        │   │           │       │           ├── arguments:
+        │   │           │       │           │   @ ArgumentsNode (location: (925...928))
+        │   │           │       │           │   └── arguments: (length: 1)
+        │   │           │       │           │       └── @ ForwardingArgumentsNode (location: (925...928))
+        │   │           │       │           ├── closing_loc: (928...929) = ")"
+        │   │           │       │           ├── block: ∅
+        │   │           │       │           ├── flags: 
+        │   │           │       │           └── name: "b"
+        │   │           │       └── closing_loc: (929...930) = "}"
+        │   │           └── closing_loc: (930...931) = "\""
+        │   ├── locals: [:"..."]
+        │   ├── def_keyword_loc: (905...908) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (910...911) = "("
+        │   ├── rparen_loc: (914...915) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (933...936) = "end"
+        ├── @ DefNode (location: (938...980))
+        │   ├── name: :foo
+        │   ├── name_loc: (942...945) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (948...976))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (948...976))
+        │   │           ├── receiver:
+        │   │           │   @ HashNode (location: (948...950))
+        │   │           │   ├── opening_loc: (948...949) = "{"
+        │   │           │   ├── elements: (length: 0)
+        │   │           │   └── closing_loc: (949...950) = "}"
+        │   │           ├── call_operator_loc: (950...951) = "."
+        │   │           ├── message_loc: (951...956) = "merge"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (957...976))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ KeywordHashNode (location: (957...976))
+        │   │           │           └── elements: (length: 3)
+        │   │           │               ├── @ AssocSplatNode (location: (957...962))
+        │   │           │               │   ├── value:
+        │   │           │               │   │   @ CallNode (location: (959...962))
+        │   │           │               │   │   ├── receiver: ∅
+        │   │           │               │   │   ├── call_operator_loc: ∅
+        │   │           │               │   │   ├── message_loc: (959...962) = "bar"
+        │   │           │               │   │   ├── opening_loc: ∅
+        │   │           │               │   │   ├── arguments: ∅
+        │   │           │               │   │   ├── closing_loc: ∅
+        │   │           │               │   │   ├── block: ∅
+        │   │           │               │   │   ├── flags: variable_call
+        │   │           │               │   │   └── name: "bar"
+        │   │           │               │   └── operator_loc: (957...959) = "**"
+        │   │           │               ├── @ AssocSplatNode (location: (964...969))
+        │   │           │               │   ├── value:
+        │   │           │               │   │   @ CallNode (location: (966...969))
+        │   │           │               │   │   ├── receiver: ∅
+        │   │           │               │   │   ├── call_operator_loc: ∅
+        │   │           │               │   │   ├── message_loc: (966...969) = "baz"
+        │   │           │               │   │   ├── opening_loc: ∅
+        │   │           │               │   │   ├── arguments: ∅
+        │   │           │               │   │   ├── closing_loc: ∅
+        │   │           │               │   │   ├── block: ∅
+        │   │           │               │   │   ├── flags: variable_call
+        │   │           │               │   │   └── name: "baz"
+        │   │           │               │   └── operator_loc: (964...966) = "**"
+        │   │           │               └── @ AssocSplatNode (location: (971...976))
+        │   │           │                   ├── value:
+        │   │           │                   │   @ CallNode (location: (973...976))
+        │   │           │                   │   ├── receiver: ∅
+        │   │           │                   │   ├── call_operator_loc: ∅
+        │   │           │                   │   ├── message_loc: (973...976) = "qux"
+        │   │           │                   │   ├── opening_loc: ∅
+        │   │           │                   │   ├── arguments: ∅
+        │   │           │                   │   ├── closing_loc: ∅
+        │   │           │                   │   ├── block: ∅
+        │   │           │                   │   ├── flags: variable_call
+        │   │           │                   │   └── name: "qux"
+        │   │           │                   └── operator_loc: (971...973) = "**"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "merge"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (938...941) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (977...980) = "end"
+        ├── @ DefNode (location: (982...1006))
+        │   ├── name: :bar
+        │   ├── name_loc: (986...989) = "bar"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (990...1001))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (990...1001))
+        │   │   │       ├── name: :a
+        │   │   │       ├── name_loc: (990...992) = "a:"
+        │   │   │       └── value:
+        │   │   │           @ ParenthesesNode (location: (993...1001))
+        │   │   │           ├── body:
+        │   │   │           │   @ StatementsNode (location: (994...1000))
+        │   │   │           │   └── body: (length: 1)
+        │   │   │           │       └── @ RangeNode (location: (994...1000))
+        │   │   │           │           ├── left:
+        │   │   │           │           │   @ IntegerNode (location: (994...995))
+        │   │   │           │           ├── right:
+        │   │   │           │           │   @ IntegerNode (location: (998...1000))
+        │   │   │           │           ├── operator_loc: (995...998) = "..."
+        │   │   │           │           └── flags: exclude_end
+        │   │   │           ├── opening_loc: (993...994) = "("
+        │   │   │           └── closing_loc: (1000...1001) = ")"
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (982...985) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (989...990) = "("
+        │   ├── rparen_loc: (1001...1002) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (1003...1006) = "end"
+        ├── @ DefNode (location: (1008...1031))
+        │   ├── name: :bar
+        │   ├── name_loc: (1012...1015) = "bar"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (1016...1026))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (1016...1026))
+        │   │   │       ├── name: :a
+        │   │   │       ├── name_loc: (1016...1018) = "a:"
+        │   │   │       └── value:
+        │   │   │           @ ParenthesesNode (location: (1019...1026))
+        │   │   │           ├── body:
+        │   │   │           │   @ StatementsNode (location: (1020...1025))
+        │   │   │           │   └── body: (length: 1)
+        │   │   │           │       └── @ RangeNode (location: (1020...1025))
+        │   │   │           │           ├── left: ∅
+        │   │   │           │           ├── right:
+        │   │   │           │           │   @ IntegerNode (location: (1023...1025))
+        │   │   │           │           ├── operator_loc: (1020...1023) = "..."
+        │   │   │           │           └── flags: exclude_end
+        │   │   │           ├── opening_loc: (1019...1020) = "("
+        │   │   │           └── closing_loc: (1025...1026) = ")"
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (1008...1011) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (1015...1016) = "("
+        │   ├── rparen_loc: (1026...1027) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (1028...1031) = "end"
+        ├── @ DefNode (location: (1033...1055))
+        │   ├── name: :bar
+        │   ├── name_loc: (1037...1040) = "bar"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (1041...1050))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (1041...1050))
+        │   │   │       ├── name: :a
+        │   │   │       ├── name_loc: (1041...1043) = "a:"
+        │   │   │       └── value:
+        │   │   │           @ ParenthesesNode (location: (1044...1050))
+        │   │   │           ├── body:
+        │   │   │           │   @ StatementsNode (location: (1045...1049))
+        │   │   │           │   └── body: (length: 1)
+        │   │   │           │       └── @ RangeNode (location: (1045...1049))
+        │   │   │           │           ├── left:
+        │   │   │           │           │   @ IntegerNode (location: (1045...1046))
+        │   │   │           │           ├── right: ∅
+        │   │   │           │           ├── operator_loc: (1046...1049) = "..."
+        │   │   │           │           └── flags: exclude_end
+        │   │   │           ├── opening_loc: (1044...1045) = "("
+        │   │   │           └── closing_loc: (1049...1050) = ")"
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (1033...1036) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (1040...1041) = "("
+        │   ├── rparen_loc: (1050...1051) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (1052...1055) = "end"
+        ├── @ DefNode (location: (1057...1082))
+        │   ├── name: :bar
+        │   ├── name_loc: (1061...1064) = "bar"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (1065...1077))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (1065...1077))
+        │   │   │       ├── name: :a
+        │   │   │       ├── name_loc: (1065...1066) = "a"
+        │   │   │       ├── operator_loc: (1067...1068) = "="
+        │   │   │       └── value:
+        │   │   │           @ ParenthesesNode (location: (1069...1077))
+        │   │   │           ├── body:
+        │   │   │           │   @ StatementsNode (location: (1070...1076))
+        │   │   │           │   └── body: (length: 1)
+        │   │   │           │       └── @ RangeNode (location: (1070...1076))
+        │   │   │           │           ├── left:
+        │   │   │           │           │   @ IntegerNode (location: (1070...1071))
+        │   │   │           │           ├── right:
+        │   │   │           │           │   @ IntegerNode (location: (1074...1076))
+        │   │   │           │           ├── operator_loc: (1071...1074) = "..."
+        │   │   │           │           └── flags: exclude_end
+        │   │   │           ├── opening_loc: (1069...1070) = "("
+        │   │   │           └── closing_loc: (1076...1077) = ")"
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (1057...1060) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (1064...1065) = "("
+        │   ├── rparen_loc: (1077...1078) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (1079...1082) = "end"
+        ├── @ DefNode (location: (1084...1108))
+        │   ├── name: :bar
+        │   ├── name_loc: (1088...1091) = "bar"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (1092...1103))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (1092...1103))
+        │   │   │       ├── name: :a
+        │   │   │       ├── name_loc: (1092...1093) = "a"
+        │   │   │       ├── operator_loc: (1094...1095) = "="
+        │   │   │       └── value:
+        │   │   │           @ ParenthesesNode (location: (1096...1103))
+        │   │   │           ├── body:
+        │   │   │           │   @ StatementsNode (location: (1097...1102))
+        │   │   │           │   └── body: (length: 1)
+        │   │   │           │       └── @ RangeNode (location: (1097...1102))
+        │   │   │           │           ├── left: ∅
+        │   │   │           │           ├── right:
+        │   │   │           │           │   @ IntegerNode (location: (1100...1102))
+        │   │   │           │           ├── operator_loc: (1097...1100) = "..."
+        │   │   │           │           └── flags: exclude_end
+        │   │   │           ├── opening_loc: (1096...1097) = "("
+        │   │   │           └── closing_loc: (1102...1103) = ")"
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (1084...1087) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (1091...1092) = "("
+        │   ├── rparen_loc: (1103...1104) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (1105...1108) = "end"
+        ├── @ DefNode (location: (1110...1133))
+        │   ├── name: :bar
+        │   ├── name_loc: (1114...1117) = "bar"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (1118...1128))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (1118...1128))
+        │   │   │       ├── name: :a
+        │   │   │       ├── name_loc: (1118...1119) = "a"
+        │   │   │       ├── operator_loc: (1120...1121) = "="
+        │   │   │       └── value:
+        │   │   │           @ ParenthesesNode (location: (1122...1128))
+        │   │   │           ├── body:
+        │   │   │           │   @ StatementsNode (location: (1123...1127))
+        │   │   │           │   └── body: (length: 1)
+        │   │   │           │       └── @ RangeNode (location: (1123...1127))
+        │   │   │           │           ├── left:
+        │   │   │           │           │   @ IntegerNode (location: (1123...1124))
+        │   │   │           │           ├── right: ∅
+        │   │   │           │           ├── operator_loc: (1124...1127) = "..."
+        │   │   │           │           └── flags: exclude_end
+        │   │   │           ├── opening_loc: (1122...1123) = "("
+        │   │   │           └── closing_loc: (1127...1128) = ")"
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (1110...1113) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (1117...1118) = "("
+        │   ├── rparen_loc: (1128...1129) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (1130...1133) = "end"
+        ├── @ DefNode (location: (1135...1167))
+        │   ├── name: :method
+        │   ├── name_loc: (1139...1145) = "method"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (1146...1147))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (1146...1147))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (1151...1163))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (1151...1163))
+        │   │           ├── receiver:
+        │   │           │   @ CallNode (location: (1151...1155))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (1151...1155) = "item"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "item"
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (1156...1158) = ">>"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (1159...1163))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ CallNode (location: (1159...1163))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (1159...1160) = "a"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block:
+        │   │           │           │   @ BlockNode (location: (1161...1163))
+        │   │           │           │   ├── locals: []
+        │   │           │           │   ├── parameters: ∅
+        │   │           │           │   ├── body: ∅
+        │   │           │           │   ├── opening_loc: (1161...1162) = "{"
+        │   │           │           │   └── closing_loc: (1162...1163) = "}"
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "a"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: ">>"
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (1135...1138) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (1145...1146) = "("
+        │   ├── rparen_loc: (1147...1148) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (1164...1167) = "end"
+        └── @ DefNode (location: (1169...1194))
+            ├── name: :foo
+            ├── name_loc: (1173...1176) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (1177...1189))
+            │   ├── requireds: (length: 4)
+            │   │   ├── @ RequiredParameterNode (location: (1177...1179))
+            │   │   │   └── name: :_a
+            │   │   ├── @ RequiredParameterNode (location: (1181...1183))
+            │   │   │   └── name: :_a
+            │   │   ├── @ RequiredParameterNode (location: (1185...1186))
+            │   │   │   └── name: :b
+            │   │   └── @ RequiredParameterNode (location: (1188...1189))
+            │   │       └── name: :c
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:_a, :b, :c]
+            ├── def_keyword_loc: (1169...1172) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (1176...1177) = "("
+            ├── rparen_loc: (1189...1190) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (1191...1194) = "end"
diff --git a/test/yarp/snapshots/modules.txt b/test/yarp/snapshots/modules.txt
index 741c3c8420..1fce495263 100644
--- a/test/yarp/snapshots/modules.txt
+++ b/test/yarp/snapshots/modules.txt
@@ -1,135 +1,174 @@
-ProgramNode(0...140)(
-  [],
-  StatementsNode(0...140)(
-    [ModuleNode(0...18)(
-       [:a],
-       (0...6),
-       ConstantReadNode(7...8)(:A),
-       StatementsNode(9...14)(
-         [LocalVariableWriteNode(9...14)(
-            :a,
-            0,
-            (9...10),
-            IntegerNode(13...14)(),
-            (11...12)
-          )]
-       ),
-       (15...18),
-       :A
-     ),
-     InterpolatedStringNode(20...38)(
-       (20...23),
-       [StringNode(23...27)(nil, (23...27), nil, "aaa "),
-        EmbeddedStatementsNode(27...33)(
-          (27...29),
-          StatementsNode(29...32)(
-            [CallNode(29...32)(
-               nil,
-               nil,
-               (29...32),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bbb"
-             )]
-          ),
-          (32...33)
-        ),
-        StringNode(33...37)(nil, (33...37), nil, " ccc")],
-       (37...38)
-     ),
-     ModuleNode(40...55)(
-       [],
-       (40...46),
-       ConstantPathNode(47...51)(
-         CallNode(47...48)(nil, nil, (47...48), nil, nil, nil, nil, 2, "m"),
-         ConstantReadNode(50...51)(:M),
-         (48...50)
-       ),
-       nil,
-       (52...55),
-       :M
-     ),
-     ModuleNode(57...85)(
-       [:x],
-       (57...63),
-       ConstantReadNode(64...65)(:A),
-       BeginNode(67...85)(
-         nil,
-         StatementsNode(67...72)(
-           [LocalVariableWriteNode(67...72)(
-              :x,
-              0,
-              (67...68),
-              IntegerNode(71...72)(),
-              (69...70)
-            )]
-         ),
-         RescueNode(74...80)((74...80), [], nil, nil, nil, nil),
-         nil,
-         nil,
-         (82...85)
-       ),
-       (82...85),
-       :A
-     ),
-     ModuleNode(87...101)(
-       [],
-       (87...93),
-       ConstantPathNode(94...97)(
-         nil,
-         ConstantReadNode(96...97)(:A),
-         (94...96)
-       ),
-       nil,
-       (98...101),
-       :A
-     ),
-     ModuleNode(103...120)(
-       [],
-       (103...109),
-       ConstantPathNode(110...116)(
-         CallNode(110...113)(
-           ConstantReadNode(110...111)(:A),
-           nil,
-           (111...113),
-           (111...112),
-           nil,
-           (112...113),
-           nil,
-           0,
-           "[]"
-         ),
-         ConstantReadNode(115...116)(:B),
-         (113...115)
-       ),
-       nil,
-       (117...120),
-       :B
-     ),
-     ModuleNode(122...140)(
-       [],
-       (122...128),
-       ConstantPathNode(129...136)(
-         CallNode(129...133)(
-           ConstantReadNode(129...130)(:A),
-           nil,
-           (130...133),
-           (130...131),
-           ArgumentsNode(131...132)([IntegerNode(131...132)()]),
-           (132...133),
-           nil,
-           0,
-           "[]"
-         ),
-         ConstantReadNode(135...136)(:B),
-         (133...135)
-       ),
-       nil,
-       (137...140),
-       :B
-     )]
-  )
-)
+@ ProgramNode (location: (0...140))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...140))
+    └── body: (length: 7)
+        ├── @ ModuleNode (location: (0...18))
+        │   ├── locals: [:a]
+        │   ├── module_keyword_loc: (0...6) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (7...8))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (9...14))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableWriteNode (location: (9...14))
+        │   │           ├── name: :a
+        │   │           ├── depth: 0
+        │   │           ├── name_loc: (9...10) = "a"
+        │   │           ├── value:
+        │   │           │   @ IntegerNode (location: (13...14))
+        │   │           └── operator_loc: (11...12) = "="
+        │   ├── end_keyword_loc: (15...18) = "end"
+        │   └── name: :A
+        ├── @ InterpolatedStringNode (location: (20...38))
+        │   ├── opening_loc: (20...23) = "%Q{"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (23...27))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (23...27) = "aaa "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "aaa "
+        │   │   ├── @ EmbeddedStatementsNode (location: (27...33))
+        │   │   │   ├── opening_loc: (27...29) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (29...32))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (29...32))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (29...32) = "bbb"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bbb"
+        │   │   │   └── closing_loc: (32...33) = "}"
+        │   │   └── @ StringNode (location: (33...37))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (33...37) = " ccc"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: " ccc"
+        │   └── closing_loc: (37...38) = "}"
+        ├── @ ModuleNode (location: (40...55))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (40...46) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (47...51))
+        │   │   ├── parent:
+        │   │   │   @ CallNode (location: (47...48))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (47...48) = "m"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "m"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (50...51))
+        │   │   │   └── name: :M
+        │   │   └── delimiter_loc: (48...50) = "::"
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (52...55) = "end"
+        │   └── name: :M
+        ├── @ ModuleNode (location: (57...85))
+        │   ├── locals: [:x]
+        │   ├── module_keyword_loc: (57...63) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (64...65))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ BeginNode (location: (67...85))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (67...72))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableWriteNode (location: (67...72))
+        │   │   │           ├── name: :x
+        │   │   │           ├── depth: 0
+        │   │   │           ├── name_loc: (67...68) = "x"
+        │   │   │           ├── value:
+        │   │   │           │   @ IntegerNode (location: (71...72))
+        │   │   │           └── operator_loc: (69...70) = "="
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (74...80))
+        │   │   │   ├── keyword_loc: (74...80) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements: ∅
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause: ∅
+        │   │   ├── ensure_clause: ∅
+        │   │   └── end_keyword_loc: (82...85) = "end"
+        │   ├── end_keyword_loc: (82...85) = "end"
+        │   └── name: :A
+        ├── @ ModuleNode (location: (87...101))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (87...93) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (94...97))
+        │   │   ├── parent: ∅
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (96...97))
+        │   │   │   └── name: :A
+        │   │   └── delimiter_loc: (94...96) = "::"
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (98...101) = "end"
+        │   └── name: :A
+        ├── @ ModuleNode (location: (103...120))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (103...109) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (110...116))
+        │   │   ├── parent:
+        │   │   │   @ CallNode (location: (110...113))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ ConstantReadNode (location: (110...111))
+        │   │   │   │   └── name: :A
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (111...113) = "[]"
+        │   │   │   ├── opening_loc: (111...112) = "["
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: (112...113) = "]"
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "[]"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (115...116))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (113...115) = "::"
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (117...120) = "end"
+        │   └── name: :B
+        └── @ ModuleNode (location: (122...140))
+            ├── locals: []
+            ├── module_keyword_loc: (122...128) = "module"
+            ├── constant_path:
+            │   @ ConstantPathNode (location: (129...136))
+            │   ├── parent:
+            │   │   @ CallNode (location: (129...133))
+            │   │   ├── receiver:
+            │   │   │   @ ConstantReadNode (location: (129...130))
+            │   │   │   └── name: :A
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (130...133) = "[1]"
+            │   │   ├── opening_loc: (130...131) = "["
+            │   │   ├── arguments:
+            │   │   │   @ ArgumentsNode (location: (131...132))
+            │   │   │   └── arguments: (length: 1)
+            │   │   │       └── @ IntegerNode (location: (131...132))
+            │   │   ├── closing_loc: (132...133) = "]"
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "[]"
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (135...136))
+            │   │   └── name: :B
+            │   └── delimiter_loc: (133...135) = "::"
+            ├── body: ∅
+            ├── end_keyword_loc: (137...140) = "end"
+            └── name: :B
diff --git a/test/yarp/snapshots/newline_terminated.txt b/test/yarp/snapshots/newline_terminated.txt
index 06ad6a989e..0e5072a913 100644
--- a/test/yarp/snapshots/newline_terminated.txt
+++ b/test/yarp/snapshots/newline_terminated.txt
@@ -1,28 +1,91 @@
-ProgramNode(76...212)(
-  [],
-  StatementsNode(76...212)(
-    [StringNode(76...82)((76...78), (78...81), (81...82), "abc"),
-     StringNode(84...90)((84...86), (86...89), (89...90), "abc"),
-     StringNode(92...98)((92...94), (94...97), (97...98), "abc"),
-     StringNode(100...106)((100...102), (102...105), (105...106), "abc"),
-     StringNode(108...114)((108...110), (110...113), (113...114), "abc"),
-     StringNode(116...122)((116...118), (118...121), (121...122), "abc"),
-     StringNode(124...130)((124...126), (126...129), (129...130), "abc"),
-     StringNode(132...139)((132...134), (134...138), (138...139), "\rabc"),
-     StringNode(142...149)((142...144), (144...148), (148...149), "\rabc"),
-     StringNode(151...157)((151...153), (153...156), (156...157), "abc"),
-     StringNode(159...165)((159...161), (161...164), (164...165), "abc"),
-     StringNode(167...173)((167...169), (169...172), (172...173), "abc"),
-     StringNode(175...181)((175...177), (177...180), (180...181), "abc"),
-     StringNode(182...188)((182...184), (184...187), (187...188), "foo"),
-     StringNode(189...196)((189...192), (192...195), (195...196), "foo"),
-     StringNode(197...204)((197...200), (200...203), (203...204), "foo"),
-     RegularExpressionNode(205...212)(
-       (205...208),
-       (208...211),
-       (211...212),
-       "foo",
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (76...212))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (76...212))
+    └── body: (length: 17)
+        ├── @ StringNode (location: (76...82))
+        │   ├── opening_loc: (76...78) = "% "
+        │   ├── content_loc: (78...81) = "abc"
+        │   ├── closing_loc: (81...82) = " "
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (84...90))
+        │   ├── opening_loc: (84...86) = "%\t"
+        │   ├── content_loc: (86...89) = "abc"
+        │   ├── closing_loc: (89...90) = "\t"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (92...98))
+        │   ├── opening_loc: (92...94) = "%\v"
+        │   ├── content_loc: (94...97) = "abc"
+        │   ├── closing_loc: (97...98) = "\v"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (100...106))
+        │   ├── opening_loc: (100...102) = "%\r"
+        │   ├── content_loc: (102...105) = "abc"
+        │   ├── closing_loc: (105...106) = "\r"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (108...114))
+        │   ├── opening_loc: (108...110) = "%\n"
+        │   ├── content_loc: (110...113) = "abc"
+        │   ├── closing_loc: (113...114) = "\n"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (116...122))
+        │   ├── opening_loc: (116...118) = "%\u0000"
+        │   ├── content_loc: (118...121) = "abc"
+        │   ├── closing_loc: (121...122) = "\u0000"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (124...130))
+        │   ├── opening_loc: (124...126) = "%\n"
+        │   ├── content_loc: (126...129) = "abc"
+        │   ├── closing_loc: (129...130) = "\n"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (132...139))
+        │   ├── opening_loc: (132...134) = "%\n"
+        │   ├── content_loc: (134...138) = "\rabc"
+        │   ├── closing_loc: (138...139) = "\n"
+        │   └── unescaped: "\rabc"
+        ├── @ StringNode (location: (142...149))
+        │   ├── opening_loc: (142...144) = "%\n"
+        │   ├── content_loc: (144...148) = "\rabc"
+        │   ├── closing_loc: (148...149) = "\n"
+        │   └── unescaped: "\rabc"
+        ├── @ StringNode (location: (151...157))
+        │   ├── opening_loc: (151...153) = "%\n"
+        │   ├── content_loc: (153...156) = "abc"
+        │   ├── closing_loc: (156...157) = "\n"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (159...165))
+        │   ├── opening_loc: (159...161) = "%\r"
+        │   ├── content_loc: (161...164) = "abc"
+        │   ├── closing_loc: (164...165) = "\r"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (167...173))
+        │   ├── opening_loc: (167...169) = "%\n"
+        │   ├── content_loc: (169...172) = "abc"
+        │   ├── closing_loc: (172...173) = "\n"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (175...181))
+        │   ├── opening_loc: (175...177) = "%\n"
+        │   ├── content_loc: (177...180) = "abc"
+        │   ├── closing_loc: (180...181) = "\n"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (182...188))
+        │   ├── opening_loc: (182...184) = "%\n"
+        │   ├── content_loc: (184...187) = "foo"
+        │   ├── closing_loc: (187...188) = "\n"
+        │   └── unescaped: "foo"
+        ├── @ StringNode (location: (189...196))
+        │   ├── opening_loc: (189...192) = "%q\n"
+        │   ├── content_loc: (192...195) = "foo"
+        │   ├── closing_loc: (195...196) = "\n"
+        │   └── unescaped: "foo"
+        ├── @ StringNode (location: (197...204))
+        │   ├── opening_loc: (197...200) = "%Q\n"
+        │   ├── content_loc: (200...203) = "foo"
+        │   ├── closing_loc: (203...204) = "\n"
+        │   └── unescaped: "foo"
+        └── @ RegularExpressionNode (location: (205...212))
+            ├── opening_loc: (205...208) = "%r\n"
+            ├── content_loc: (208...211) = "foo"
+            ├── closing_loc: (211...212) = "\n"
+            ├── unescaped: "foo"
+            └── flags: 
diff --git a/test/yarp/snapshots/next.txt b/test/yarp/snapshots/next.txt
index 533cf33bb8..d5b587c24d 100644
--- a/test/yarp/snapshots/next.txt
+++ b/test/yarp/snapshots/next.txt
@@ -1,88 +1,106 @@
-ProgramNode(0...118)(
-  [],
-  StatementsNode(0...118)(
-    [NextNode(0...4)(nil, (0...4)),
-     NextNode(6...24)(
-       ArgumentsNode(11...24)(
-         [ParenthesesNode(11...14)(
-            StatementsNode(12...13)([IntegerNode(12...13)()]),
-            (11...12),
-            (13...14)
-          ),
-          ParenthesesNode(16...19)(
-            StatementsNode(17...18)([IntegerNode(17...18)()]),
-            (16...17),
-            (18...19)
-          ),
-          ParenthesesNode(21...24)(
-            StatementsNode(22...23)([IntegerNode(22...23)()]),
-            (21...22),
-            (23...24)
-          )]
-       ),
-       (6...10)
-     ),
-     NextNode(26...32)(
-       ArgumentsNode(31...32)([IntegerNode(31...32)()]),
-       (26...30)
-     ),
-     NextNode(34...46)(
-       ArgumentsNode(39...46)(
-         [IntegerNode(39...40)(),
-          IntegerNode(42...43)(),
-          IntegerNode(45...46)()]
-       ),
-       (34...38)
-     ),
-     NextNode(48...60)(
-       ArgumentsNode(53...60)(
-         [IntegerNode(53...54)(),
-          IntegerNode(56...57)(),
-          IntegerNode(59...60)()]
-       ),
-       (48...52)
-     ),
-     NextNode(62...76)(
-       ArgumentsNode(67...76)(
-         [ArrayNode(67...76)(
-            [IntegerNode(68...69)(),
-             IntegerNode(71...72)(),
-             IntegerNode(74...75)()],
-            (67...68),
-            (75...76)
-          )]
-       ),
-       (62...66)
-     ),
-     NextNode(78...93)(
-       ArgumentsNode(82...93)(
-         [ParenthesesNode(82...93)(
-            StatementsNode(86...91)(
-              [IntegerNode(86...87)(), IntegerNode(90...91)()]
-            ),
-            (82...83),
-            (92...93)
-          )]
-       ),
-       (78...82)
-     ),
-     NextNode(95...99)(nil, (95...99)),
-     IntegerNode(100...101)(),
-     NextNode(103...109)(
-       ArgumentsNode(107...109)(
-         [ParenthesesNode(107...109)(nil, (107...108), (108...109))]
-       ),
-       (103...107)
-     ),
-     NextNode(111...118)(
-       ArgumentsNode(115...118)(
-         [ParenthesesNode(115...118)(
-            StatementsNode(116...117)([IntegerNode(116...117)()]),
-            (115...116),
-            (117...118)
-          )]
-       ),
-       (111...115)
-     )]
-  )
-)
+@ ProgramNode (location: (0...118))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...118))
+    └── body: (length: 11)
+        ├── @ NextNode (location: (0...4))
+        │   ├── arguments: ∅
+        │   └── keyword_loc: (0...4) = "next"
+        ├── @ NextNode (location: (6...24))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (11...24))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ ParenthesesNode (location: (11...14))
+        │   │       │   ├── body:
+        │   │       │   │   @ StatementsNode (location: (12...13))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ IntegerNode (location: (12...13))
+        │   │       │   ├── opening_loc: (11...12) = "("
+        │   │       │   └── closing_loc: (13...14) = ")"
+        │   │       ├── @ ParenthesesNode (location: (16...19))
+        │   │       │   ├── body:
+        │   │       │   │   @ StatementsNode (location: (17...18))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ IntegerNode (location: (17...18))
+        │   │       │   ├── opening_loc: (16...17) = "("
+        │   │       │   └── closing_loc: (18...19) = ")"
+        │   │       └── @ ParenthesesNode (location: (21...24))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (22...23))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (22...23))
+        │   │           ├── opening_loc: (21...22) = "("
+        │   │           └── closing_loc: (23...24) = ")"
+        │   └── keyword_loc: (6...10) = "next"
+        ├── @ NextNode (location: (26...32))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (31...32))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (31...32))
+        │   └── keyword_loc: (26...30) = "next"
+        ├── @ NextNode (location: (34...46))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (39...46))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ IntegerNode (location: (39...40))
+        │   │       ├── @ IntegerNode (location: (42...43))
+        │   │       └── @ IntegerNode (location: (45...46))
+        │   └── keyword_loc: (34...38) = "next"
+        ├── @ NextNode (location: (48...60))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (53...60))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ IntegerNode (location: (53...54))
+        │   │       ├── @ IntegerNode (location: (56...57))
+        │   │       └── @ IntegerNode (location: (59...60))
+        │   └── keyword_loc: (48...52) = "next"
+        ├── @ NextNode (location: (62...76))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (67...76))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ArrayNode (location: (67...76))
+        │   │           ├── elements: (length: 3)
+        │   │           │   ├── @ IntegerNode (location: (68...69))
+        │   │           │   ├── @ IntegerNode (location: (71...72))
+        │   │           │   └── @ IntegerNode (location: (74...75))
+        │   │           ├── opening_loc: (67...68) = "["
+        │   │           └── closing_loc: (75...76) = "]"
+        │   └── keyword_loc: (62...66) = "next"
+        ├── @ NextNode (location: (78...93))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (82...93))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (82...93))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (86...91))
+        │   │           │   └── body: (length: 2)
+        │   │           │       ├── @ IntegerNode (location: (86...87))
+        │   │           │       └── @ IntegerNode (location: (90...91))
+        │   │           ├── opening_loc: (82...83) = "("
+        │   │           └── closing_loc: (92...93) = ")"
+        │   └── keyword_loc: (78...82) = "next"
+        ├── @ NextNode (location: (95...99))
+        │   ├── arguments: ∅
+        │   └── keyword_loc: (95...99) = "next"
+        ├── @ IntegerNode (location: (100...101))
+        ├── @ NextNode (location: (103...109))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (107...109))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (107...109))
+        │   │           ├── body: ∅
+        │   │           ├── opening_loc: (107...108) = "("
+        │   │           └── closing_loc: (108...109) = ")"
+        │   └── keyword_loc: (103...107) = "next"
+        └── @ NextNode (location: (111...118))
+            ├── arguments:
+            │   @ ArgumentsNode (location: (115...118))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (115...118))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (116...117))
+            │           │   └── body: (length: 1)
+            │           │       └── @ IntegerNode (location: (116...117))
+            │           ├── opening_loc: (115...116) = "("
+            │           └── closing_loc: (117...118) = ")"
+            └── keyword_loc: (111...115) = "next"
diff --git a/test/yarp/snapshots/nils.txt b/test/yarp/snapshots/nils.txt
index daf9168e7e..8a709ca0be 100644
--- a/test/yarp/snapshots/nils.txt
+++ b/test/yarp/snapshots/nils.txt
@@ -1,20 +1,30 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [NilNode(0...3)(),
-     ParenthesesNode(5...7)(nil, (5...6), (6...7)),
-     ParenthesesNode(9...16)(nil, (9...10), (15...16)),
-     PostExecutionNode(18...27)(
-       StatementsNode(24...25)([IntegerNode(24...25)()]),
-       (18...21),
-       (22...23),
-       (26...27)
-     ),
-     PreExecutionNode(29...40)(
-       StatementsNode(37...38)([IntegerNode(37...38)()]),
-       (29...34),
-       (35...36),
-       (39...40)
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 5)
+        ├── @ NilNode (location: (0...3))
+        ├── @ ParenthesesNode (location: (5...7))
+        │   ├── body: ∅
+        │   ├── opening_loc: (5...6) = "("
+        │   └── closing_loc: (6...7) = ")"
+        ├── @ ParenthesesNode (location: (9...16))
+        │   ├── body: ∅
+        │   ├── opening_loc: (9...10) = "("
+        │   └── closing_loc: (15...16) = ")"
+        ├── @ PostExecutionNode (location: (18...27))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (24...25))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (24...25))
+        │   ├── keyword_loc: (18...21) = "END"
+        │   ├── opening_loc: (22...23) = "{"
+        │   └── closing_loc: (26...27) = "}"
+        └── @ PreExecutionNode (location: (29...40))
+            ├── statements:
+            │   @ StatementsNode (location: (37...38))
+            │   └── body: (length: 1)
+            │       └── @ IntegerNode (location: (37...38))
+            ├── keyword_loc: (29...34) = "BEGIN"
+            ├── opening_loc: (35...36) = "{"
+            └── closing_loc: (39...40) = "}"
diff --git a/test/yarp/snapshots/non_alphanumeric_methods.txt b/test/yarp/snapshots/non_alphanumeric_methods.txt
index a4cc39b6d3..5d07e19838 100644
--- a/test/yarp/snapshots/non_alphanumeric_methods.txt
+++ b/test/yarp/snapshots/non_alphanumeric_methods.txt
@@ -1,512 +1,500 @@
-ProgramNode(0...434)(
-  [],
-  StatementsNode(0...434)(
-    [DefNode(0...9)(
-       :!,
-       (4...5),
-       nil,
-       nil,
-       nil,
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (6...9)
-     ),
-     DefNode(11...21)(
-       :!=,
-       (15...17),
-       nil,
-       nil,
-       nil,
-       [],
-       (11...14),
-       nil,
-       nil,
-       nil,
-       nil,
-       (18...21)
-     ),
-     DefNode(23...33)(
-       :!~,
-       (27...29),
-       nil,
-       nil,
-       nil,
-       [],
-       (23...26),
-       nil,
-       nil,
-       nil,
-       nil,
-       (30...33)
-     ),
-     DefNode(35...44)(
-       :%,
-       (39...40),
-       nil,
-       nil,
-       nil,
-       [],
-       (35...38),
-       nil,
-       nil,
-       nil,
-       nil,
-       (41...44)
-     ),
-     DefNode(46...60)(
-       :+,
-       (55...56),
-       SelfNode(50...54)(),
-       nil,
-       nil,
-       [],
-       (46...49),
-       (54...55),
-       nil,
-       nil,
-       nil,
-       (57...60)
-     ),
-     DefNode(62...71)(
-       :&,
-       (66...67),
-       nil,
-       nil,
-       nil,
-       [],
-       (62...65),
-       nil,
-       nil,
-       nil,
-       nil,
-       (68...71)
-     ),
-     DefNode(73...82)(
-       :*,
-       (77...78),
-       nil,
-       nil,
-       nil,
-       [],
-       (73...76),
-       nil,
-       nil,
-       nil,
-       nil,
-       (79...82)
-     ),
-     DefNode(84...94)(
-       :**,
-       (88...90),
-       nil,
-       nil,
-       nil,
-       [],
-       (84...87),
-       nil,
-       nil,
-       nil,
-       nil,
-       (91...94)
-     ),
-     StringNode(96...102)((96...98), (98...101), (101...102), "abc"),
-     DefNode(104...117)(
-       :+,
-       (108...109),
-       nil,
-       ParametersNode(110...113)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(110...113)(:b, (112...113), (110...112)),
-         nil
-       ),
-       nil,
-       [:b],
-       (104...107),
-       nil,
-       nil,
-       nil,
-       nil,
-       (114...117)
-     ),
-     DefNode(119...130)(
-       :+,
-       (123...124),
-       nil,
-       nil,
-       nil,
-       [],
-       (119...122),
-       nil,
-       (124...125),
-       (125...126),
-       nil,
-       (127...130)
-     ),
-     DefNode(132...143)(
-       :+,
-       (136...137),
-       nil,
-       ParametersNode(138...139)(
-         [RequiredParameterNode(138...139)(:b)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:b],
-       (132...135),
-       nil,
-       nil,
-       nil,
-       nil,
-       (140...143)
-     ),
-     DefNode(145...159)(
-       :+,
-       (154...155),
-       SelfNode(149...153)(),
-       nil,
-       nil,
-       [],
-       (145...148),
-       (153...154),
-       nil,
-       nil,
-       nil,
-       (156...159)
-     ),
-     DefNode(161...170)(
-       :+,
-       (165...166),
-       nil,
-       nil,
-       nil,
-       [],
-       (161...164),
-       nil,
-       nil,
-       nil,
-       nil,
-       (167...170)
-     ),
-     DefNode(172...182)(
-       :+@,
-       (176...178),
-       nil,
-       nil,
-       nil,
-       [],
-       (172...175),
-       nil,
-       nil,
-       nil,
-       nil,
-       (179...182)
-     ),
-     DefNode(184...193)(
-       :-,
-       (188...189),
-       nil,
-       nil,
-       nil,
-       [],
-       (184...187),
-       nil,
-       nil,
-       nil,
-       nil,
-       (190...193)
-     ),
-     DefNode(195...206)(
-       :-,
-       (201...202),
-       CallNode(199...200)(nil, nil, (199...200), nil, nil, nil, nil, 2, "a"),
-       nil,
-       nil,
-       [],
-       (195...198),
-       (200...201),
-       nil,
-       nil,
-       nil,
-       (203...206)
-     ),
-     DefNode(208...218)(
-       :-@,
-       (212...214),
-       nil,
-       nil,
-       nil,
-       [],
-       (208...211),
-       nil,
-       nil,
-       nil,
-       nil,
-       (215...218)
-     ),
-     DefNode(220...229)(
-       :/,
-       (224...225),
-       nil,
-       nil,
-       nil,
-       [],
-       (220...223),
-       nil,
-       nil,
-       nil,
-       nil,
-       (226...229)
-     ),
-     DefNode(231...240)(
-       :<,
-       (235...236),
-       nil,
-       nil,
-       nil,
-       [],
-       (231...234),
-       nil,
-       nil,
-       nil,
-       nil,
-       (237...240)
-     ),
-     DefNode(242...252)(
-       :<<,
-       (246...248),
-       nil,
-       nil,
-       nil,
-       [],
-       (242...245),
-       nil,
-       nil,
-       nil,
-       nil,
-       (249...252)
-     ),
-     DefNode(254...264)(
-       :<=,
-       (258...260),
-       nil,
-       nil,
-       nil,
-       [],
-       (254...257),
-       nil,
-       nil,
-       nil,
-       nil,
-       (261...264)
-     ),
-     DefNode(266...277)(
-       :<=>,
-       (270...273),
-       nil,
-       nil,
-       nil,
-       [],
-       (266...269),
-       nil,
-       nil,
-       nil,
-       nil,
-       (274...277)
-     ),
-     DefNode(279...289)(
-       :==,
-       (283...285),
-       nil,
-       nil,
-       nil,
-       [],
-       (279...282),
-       nil,
-       nil,
-       nil,
-       nil,
-       (286...289)
-     ),
-     DefNode(291...302)(
-       :===,
-       (295...298),
-       nil,
-       nil,
-       nil,
-       [],
-       (291...294),
-       nil,
-       nil,
-       nil,
-       nil,
-       (299...302)
-     ),
-     DefNode(304...314)(
-       :=~,
-       (308...310),
-       nil,
-       nil,
-       nil,
-       [],
-       (304...307),
-       nil,
-       nil,
-       nil,
-       nil,
-       (311...314)
-     ),
-     DefNode(316...325)(
-       :>,
-       (320...321),
-       nil,
-       nil,
-       nil,
-       [],
-       (316...319),
-       nil,
-       nil,
-       nil,
-       nil,
-       (322...325)
-     ),
-     DefNode(327...337)(
-       :>=,
-       (331...333),
-       nil,
-       nil,
-       nil,
-       [],
-       (327...330),
-       nil,
-       nil,
-       nil,
-       nil,
-       (334...337)
-     ),
-     DefNode(339...349)(
-       :>>,
-       (343...345),
-       nil,
-       nil,
-       nil,
-       [],
-       (339...342),
-       nil,
-       nil,
-       nil,
-       nil,
-       (346...349)
-     ),
-     DefNode(351...361)(
-       :[],
-       (355...357),
-       nil,
-       nil,
-       nil,
-       [],
-       (351...354),
-       nil,
-       nil,
-       nil,
-       nil,
-       (358...361)
-     ),
-     DefNode(363...374)(
-       :[]=,
-       (367...370),
-       nil,
-       nil,
-       nil,
-       [],
-       (363...366),
-       nil,
-       nil,
-       nil,
-       nil,
-       (371...374)
-     ),
-     DefNode(376...385)(
-       :^,
-       (380...381),
-       nil,
-       nil,
-       nil,
-       [],
-       (376...379),
-       nil,
-       nil,
-       nil,
-       nil,
-       (382...385)
-     ),
-     DefNode(387...396)(
-       :`,
-       (391...392),
-       nil,
-       nil,
-       nil,
-       [],
-       (387...390),
-       nil,
-       nil,
-       nil,
-       nil,
-       (393...396)
-     ),
-     DefNode(398...412)(
-       :`,
-       (407...408),
-       SelfNode(402...406)(),
-       nil,
-       nil,
-       [],
-       (398...401),
-       (406...407),
-       nil,
-       nil,
-       nil,
-       (409...412)
-     ),
-     DefNode(414...423)(
-       :|,
-       (418...419),
-       nil,
-       nil,
-       nil,
-       [],
-       (414...417),
-       nil,
-       nil,
-       nil,
-       nil,
-       (420...423)
-     ),
-     DefNode(425...434)(
-       :~,
-       (429...430),
-       nil,
-       nil,
-       nil,
-       [],
-       (425...428),
-       nil,
-       nil,
-       nil,
-       nil,
-       (431...434)
-     )]
-  )
-)
+@ ProgramNode (location: (0...434))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...434))
+    └── body: (length: 36)
+        ├── @ DefNode (location: (0...9))
+        │   ├── name: :!
+        │   ├── name_loc: (4...5) = "!"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (6...9) = "end"
+        ├── @ DefNode (location: (11...21))
+        │   ├── name: :!=
+        │   ├── name_loc: (15...17) = "!="
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (11...14) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (18...21) = "end"
+        ├── @ DefNode (location: (23...33))
+        │   ├── name: :!~
+        │   ├── name_loc: (27...29) = "!~"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (23...26) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (30...33) = "end"
+        ├── @ DefNode (location: (35...44))
+        │   ├── name: :%
+        │   ├── name_loc: (39...40) = "%"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (35...38) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (41...44) = "end"
+        ├── @ DefNode (location: (46...60))
+        │   ├── name: :+
+        │   ├── name_loc: (55...56) = "+"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (50...54))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (46...49) = "def"
+        │   ├── operator_loc: (54...55) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (57...60) = "end"
+        ├── @ DefNode (location: (62...71))
+        │   ├── name: :&
+        │   ├── name_loc: (66...67) = "&"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (62...65) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (68...71) = "end"
+        ├── @ DefNode (location: (73...82))
+        │   ├── name: :*
+        │   ├── name_loc: (77...78) = "*"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (73...76) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (79...82) = "end"
+        ├── @ DefNode (location: (84...94))
+        │   ├── name: :**
+        │   ├── name_loc: (88...90) = "**"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (84...87) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (91...94) = "end"
+        ├── @ StringNode (location: (96...102))
+        │   ├── opening_loc: (96...98) = "%|"
+        │   ├── content_loc: (98...101) = "abc"
+        │   ├── closing_loc: (101...102) = "|"
+        │   └── unescaped: "abc"
+        ├── @ DefNode (location: (104...117))
+        │   ├── name: :+
+        │   ├── name_loc: (108...109) = "+"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (110...113))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ KeywordRestParameterNode (location: (110...113))
+        │   │   │   ├── name: :b
+        │   │   │   ├── name_loc: (112...113) = "b"
+        │   │   │   └── operator_loc: (110...112) = "**"
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (104...107) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (114...117) = "end"
+        ├── @ DefNode (location: (119...130))
+        │   ├── name: :+
+        │   ├── name_loc: (123...124) = "+"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (119...122) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (124...125) = "("
+        │   ├── rparen_loc: (125...126) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (127...130) = "end"
+        ├── @ DefNode (location: (132...143))
+        │   ├── name: :+
+        │   ├── name_loc: (136...137) = "+"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (138...139))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (138...139))
+        │   │   │       └── name: :b
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (132...135) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (140...143) = "end"
+        ├── @ DefNode (location: (145...159))
+        │   ├── name: :+
+        │   ├── name_loc: (154...155) = "+"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (149...153))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (145...148) = "def"
+        │   ├── operator_loc: (153...154) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (156...159) = "end"
+        ├── @ DefNode (location: (161...170))
+        │   ├── name: :+
+        │   ├── name_loc: (165...166) = "+"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (161...164) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (167...170) = "end"
+        ├── @ DefNode (location: (172...182))
+        │   ├── name: :+@
+        │   ├── name_loc: (176...178) = "+@"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (172...175) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (179...182) = "end"
+        ├── @ DefNode (location: (184...193))
+        │   ├── name: :-
+        │   ├── name_loc: (188...189) = "-"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (184...187) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (190...193) = "end"
+        ├── @ DefNode (location: (195...206))
+        │   ├── name: :-
+        │   ├── name_loc: (201...202) = "-"
+        │   ├── receiver:
+        │   │   @ CallNode (location: (199...200))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (199...200) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (195...198) = "def"
+        │   ├── operator_loc: (200...201) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (203...206) = "end"
+        ├── @ DefNode (location: (208...218))
+        │   ├── name: :-@
+        │   ├── name_loc: (212...214) = "-@"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (208...211) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (215...218) = "end"
+        ├── @ DefNode (location: (220...229))
+        │   ├── name: :/
+        │   ├── name_loc: (224...225) = "/"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (220...223) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (226...229) = "end"
+        ├── @ DefNode (location: (231...240))
+        │   ├── name: :<
+        │   ├── name_loc: (235...236) = "<"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (231...234) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (237...240) = "end"
+        ├── @ DefNode (location: (242...252))
+        │   ├── name: :<<
+        │   ├── name_loc: (246...248) = "<<"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (242...245) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (249...252) = "end"
+        ├── @ DefNode (location: (254...264))
+        │   ├── name: :<=
+        │   ├── name_loc: (258...260) = "<="
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (254...257) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (261...264) = "end"
+        ├── @ DefNode (location: (266...277))
+        │   ├── name: :<=>
+        │   ├── name_loc: (270...273) = "<=>"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (266...269) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (274...277) = "end"
+        ├── @ DefNode (location: (279...289))
+        │   ├── name: :==
+        │   ├── name_loc: (283...285) = "=="
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (279...282) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (286...289) = "end"
+        ├── @ DefNode (location: (291...302))
+        │   ├── name: :===
+        │   ├── name_loc: (295...298) = "==="
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (291...294) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (299...302) = "end"
+        ├── @ DefNode (location: (304...314))
+        │   ├── name: :=~
+        │   ├── name_loc: (308...310) = "=~"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (304...307) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (311...314) = "end"
+        ├── @ DefNode (location: (316...325))
+        │   ├── name: :>
+        │   ├── name_loc: (320...321) = ">"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (316...319) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (322...325) = "end"
+        ├── @ DefNode (location: (327...337))
+        │   ├── name: :>=
+        │   ├── name_loc: (331...333) = ">="
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (327...330) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (334...337) = "end"
+        ├── @ DefNode (location: (339...349))
+        │   ├── name: :>>
+        │   ├── name_loc: (343...345) = ">>"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (339...342) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (346...349) = "end"
+        ├── @ DefNode (location: (351...361))
+        │   ├── name: :[]
+        │   ├── name_loc: (355...357) = "[]"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (351...354) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (358...361) = "end"
+        ├── @ DefNode (location: (363...374))
+        │   ├── name: :[]=
+        │   ├── name_loc: (367...370) = "[]="
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (363...366) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (371...374) = "end"
+        ├── @ DefNode (location: (376...385))
+        │   ├── name: :^
+        │   ├── name_loc: (380...381) = "^"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (376...379) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (382...385) = "end"
+        ├── @ DefNode (location: (387...396))
+        │   ├── name: :`
+        │   ├── name_loc: (391...392) = "`"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (387...390) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (393...396) = "end"
+        ├── @ DefNode (location: (398...412))
+        │   ├── name: :`
+        │   ├── name_loc: (407...408) = "`"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (402...406))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (398...401) = "def"
+        │   ├── operator_loc: (406...407) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (409...412) = "end"
+        ├── @ DefNode (location: (414...423))
+        │   ├── name: :|
+        │   ├── name_loc: (418...419) = "|"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (414...417) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (420...423) = "end"
+        └── @ DefNode (location: (425...434))
+            ├── name: :~
+            ├── name_loc: (429...430) = "~"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (425...428) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (431...434) = "end"
diff --git a/test/yarp/snapshots/not.txt b/test/yarp/snapshots/not.txt
index 5a9889bf6a..65dd34bdfd 100644
--- a/test/yarp/snapshots/not.txt
+++ b/test/yarp/snapshots/not.txt
@@ -1,271 +1,351 @@
-ProgramNode(0...190)(
-  [],
-  StatementsNode(0...190)(
-    [AndNode(0...19)(
-       CallNode(0...7)(
-         CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "foo"),
-         nil,
-         (0...3),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       CallNode(12...19)(
-         CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "bar"),
-         nil,
-         (12...15),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       (8...11)
-     ),
-     CallNode(21...37)(
-       AndNode(25...36)(
-         CallNode(25...28)(nil, nil, (25...28), nil, nil, nil, nil, 2, "foo"),
-         CallNode(33...36)(nil, nil, (33...36), nil, nil, nil, nil, 2, "bar"),
-         (29...32)
-       ),
-       nil,
-       (21...24),
-       (24...25),
-       nil,
-       (36...37),
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(39...46)(
-       CallNode(43...46)(nil, nil, (43...46), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (39...42),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     AndNode(48...69)(
-       CallNode(48...55)(
-         CallNode(52...55)(nil, nil, (52...55), nil, nil, nil, nil, 2, "foo"),
-         nil,
-         (48...51),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       CallNode(60...69)(
-         CallNode(66...69)(nil, nil, (66...69), nil, nil, nil, nil, 2, "bar"),
-         nil,
-         (60...63),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       (56...59)
-     ),
-     AndNode(72...97)(
-       CallNode(72...79)(
-         CallNode(76...79)(nil, nil, (76...79), nil, nil, nil, nil, 2, "foo"),
-         nil,
-         (72...75),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       CallNode(88...97)(
-         CallNode(94...97)(nil, nil, (94...97), nil, nil, nil, nil, 2, "bar"),
-         nil,
-         (88...91),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       (80...83)
-     ),
-     AndNode(100...125)(
-       CallNode(100...107)(
-         CallNode(104...107)(
-           nil,
-           nil,
-           (104...107),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         nil,
-         (100...103),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       CallNode(114...125)(
-         CallNode(122...125)(
-           nil,
-           nil,
-           (122...125),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "bar"
-         ),
-         nil,
-         (114...117),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       (108...111)
-     ),
-     CallNode(127...138)(
-       CallNode(131...134)(
-         nil,
-         nil,
-         (131...134),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (127...130),
-       (130...131),
-       nil,
-       (137...138),
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(140...156)(
-       CallNode(147...150)(
-         nil,
-         nil,
-         (147...150),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (140...143),
-       (143...144),
-       nil,
-       (155...156),
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(158...172)(
-       FlipFlopNode(162...172)(
-         CallNode(162...165)(
-           nil,
-           nil,
-           (162...165),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         CallNode(169...172)(
-           nil,
-           nil,
-           (169...172),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "bar"
-         ),
-         (166...168),
-         0
-       ),
-       nil,
-       (158...161),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(174...190)(
-       ParenthesesNode(178...190)(
-         StatementsNode(179...189)(
-           [FlipFlopNode(179...189)(
-              CallNode(179...182)(
-                nil,
-                nil,
-                (179...182),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "foo"
-              ),
-              CallNode(186...189)(
-                nil,
-                nil,
-                (186...189),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (183...185),
-              0
-            )]
-         ),
-         (178...179),
-         (189...190)
-       ),
-       nil,
-       (174...177),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...190))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...190))
+    └── body: (length: 10)
+        ├── @ AndNode (location: (0...19))
+        │   ├── left:
+        │   │   @ CallNode (location: (0...7))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (4...7))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (4...7) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "not"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "!"
+        │   ├── right:
+        │   │   @ CallNode (location: (12...19))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (16...19))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (16...19) = "bar"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "bar"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (12...15) = "not"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "!"
+        │   └── operator_loc: (8...11) = "and"
+        ├── @ CallNode (location: (21...37))
+        │   ├── receiver:
+        │   │   @ AndNode (location: (25...36))
+        │   │   ├── left:
+        │   │   │   @ CallNode (location: (25...28))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (25...28) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── right:
+        │   │   │   @ CallNode (location: (33...36))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (33...36) = "bar"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "bar"
+        │   │   └── operator_loc: (29...32) = "and"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (21...24) = "not"
+        │   ├── opening_loc: (24...25) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (36...37) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (39...46))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (43...46))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (43...46) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (39...42) = "not"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ AndNode (location: (48...69))
+        │   ├── left:
+        │   │   @ CallNode (location: (48...55))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (52...55))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (52...55) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (48...51) = "not"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "!"
+        │   ├── right:
+        │   │   @ CallNode (location: (60...69))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (66...69))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (66...69) = "bar"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "bar"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (60...63) = "not"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "!"
+        │   └── operator_loc: (56...59) = "and"
+        ├── @ AndNode (location: (72...97))
+        │   ├── left:
+        │   │   @ CallNode (location: (72...79))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (76...79))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (76...79) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (72...75) = "not"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "!"
+        │   ├── right:
+        │   │   @ CallNode (location: (88...97))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (94...97))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (94...97) = "bar"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "bar"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (88...91) = "not"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "!"
+        │   └── operator_loc: (80...83) = "and"
+        ├── @ AndNode (location: (100...125))
+        │   ├── left:
+        │   │   @ CallNode (location: (100...107))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (104...107))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (104...107) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (100...103) = "not"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "!"
+        │   ├── right:
+        │   │   @ CallNode (location: (114...125))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (122...125))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (122...125) = "bar"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "bar"
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (114...117) = "not"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "!"
+        │   └── operator_loc: (108...111) = "and"
+        ├── @ CallNode (location: (127...138))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (131...134))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (131...134) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (127...130) = "not"
+        │   ├── opening_loc: (130...131) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (137...138) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (140...156))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (147...150))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (147...150) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (140...143) = "not"
+        │   ├── opening_loc: (143...144) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (155...156) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (158...172))
+        │   ├── receiver:
+        │   │   @ FlipFlopNode (location: (162...172))
+        │   │   ├── left:
+        │   │   │   @ CallNode (location: (162...165))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (162...165) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── right:
+        │   │   │   @ CallNode (location: (169...172))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (169...172) = "bar"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "bar"
+        │   │   ├── operator_loc: (166...168) = ".."
+        │   │   └── flags: 
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (158...161) = "not"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        └── @ CallNode (location: (174...190))
+            ├── receiver:
+            │   @ ParenthesesNode (location: (178...190))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (179...189))
+            │   │   └── body: (length: 1)
+            │   │       └── @ FlipFlopNode (location: (179...189))
+            │   │           ├── left:
+            │   │           │   @ CallNode (location: (179...182))
+            │   │           │   ├── receiver: ∅
+            │   │           │   ├── call_operator_loc: ∅
+            │   │           │   ├── message_loc: (179...182) = "foo"
+            │   │           │   ├── opening_loc: ∅
+            │   │           │   ├── arguments: ∅
+            │   │           │   ├── closing_loc: ∅
+            │   │           │   ├── block: ∅
+            │   │           │   ├── flags: variable_call
+            │   │           │   └── name: "foo"
+            │   │           ├── right:
+            │   │           │   @ CallNode (location: (186...189))
+            │   │           │   ├── receiver: ∅
+            │   │           │   ├── call_operator_loc: ∅
+            │   │           │   ├── message_loc: (186...189) = "bar"
+            │   │           │   ├── opening_loc: ∅
+            │   │           │   ├── arguments: ∅
+            │   │           │   ├── closing_loc: ∅
+            │   │           │   ├── block: ∅
+            │   │           │   ├── flags: variable_call
+            │   │           │   └── name: "bar"
+            │   │           ├── operator_loc: (183...185) = ".."
+            │   │           └── flags: 
+            │   ├── opening_loc: (178...179) = "("
+            │   └── closing_loc: (189...190) = ")"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (174...177) = "not"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/numbers.txt b/test/yarp/snapshots/numbers.txt
index 72fb895125..4242f6332c 100644
--- a/test/yarp/snapshots/numbers.txt
+++ b/test/yarp/snapshots/numbers.txt
@@ -1,43 +1,73 @@
-ProgramNode(0...161)(
-  [],
-  StatementsNode(0...161)(
-    [IntegerNode(0...1)(),
-     IntegerNode(3...4)(),
-     FloatNode(6...9)(),
-     IntegerNode(11...12)(),
-     IntegerNode(14...17)(),
-     IntegerNode(19...22)(),
-     IntegerNode(24...28)(),
-     IntegerNode(30...33)(),
-     IntegerNode(35...38)(),
-     IntegerNode(40...43)(),
-     IntegerNode(45...47)(),
-     IntegerNode(49...51)(),
-     IntegerNode(53...55)(),
-     IntegerNode(57...60)(),
-     IntegerNode(62...65)(),
-     IntegerNode(67...70)(),
-     IntegerNode(72...75)(),
-     IntegerNode(77...80)(),
-     IntegerNode(82...85)(),
-     ImaginaryNode(87...89)(IntegerNode(87...88)()),
-     RationalNode(91...93)(IntegerNode(91...92)()),
-     IntegerNode(95...97)(),
-     ImaginaryNode(99...102)(RationalNode(99...101)(IntegerNode(99...100)())),
-     ImaginaryNode(104...109)(RationalNode(104...108)(FloatNode(104...107)())),
-     ImaginaryNode(111...115)(
-       RationalNode(111...114)(IntegerNode(111...113)())
-     ),
-     ImaginaryNode(117...123)(RationalNode(117...122)(FloatNode(117...121)())),
-     RationalNode(125...129)(IntegerNode(125...128)()),
-     ImaginaryNode(131...135)(IntegerNode(131...134)()),
-     ImaginaryNode(137...142)(
-       RationalNode(137...141)(IntegerNode(137...140)())
-     ),
-     RationalNode(144...148)(IntegerNode(144...147)()),
-     ImaginaryNode(150...154)(IntegerNode(150...153)()),
-     ImaginaryNode(156...161)(
-       RationalNode(156...160)(IntegerNode(156...159)())
-     )]
-  )
-)
+@ ProgramNode (location: (0...161))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...161))
+    └── body: (length: 32)
+        ├── @ IntegerNode (location: (0...1))
+        ├── @ IntegerNode (location: (3...4))
+        ├── @ FloatNode (location: (6...9))
+        ├── @ IntegerNode (location: (11...12))
+        ├── @ IntegerNode (location: (14...17))
+        ├── @ IntegerNode (location: (19...22))
+        ├── @ IntegerNode (location: (24...28))
+        ├── @ IntegerNode (location: (30...33))
+        ├── @ IntegerNode (location: (35...38))
+        ├── @ IntegerNode (location: (40...43))
+        ├── @ IntegerNode (location: (45...47))
+        ├── @ IntegerNode (location: (49...51))
+        ├── @ IntegerNode (location: (53...55))
+        ├── @ IntegerNode (location: (57...60))
+        ├── @ IntegerNode (location: (62...65))
+        ├── @ IntegerNode (location: (67...70))
+        ├── @ IntegerNode (location: (72...75))
+        ├── @ IntegerNode (location: (77...80))
+        ├── @ IntegerNode (location: (82...85))
+        ├── @ ImaginaryNode (location: (87...89))
+        │   └── numeric:
+        │       @ IntegerNode (location: (87...88))
+        ├── @ RationalNode (location: (91...93))
+        │   └── numeric:
+        │       @ IntegerNode (location: (91...92))
+        ├── @ IntegerNode (location: (95...97))
+        ├── @ ImaginaryNode (location: (99...102))
+        │   └── numeric:
+        │       @ RationalNode (location: (99...101))
+        │       └── numeric:
+        │           @ IntegerNode (location: (99...100))
+        ├── @ ImaginaryNode (location: (104...109))
+        │   └── numeric:
+        │       @ RationalNode (location: (104...108))
+        │       └── numeric:
+        │           @ FloatNode (location: (104...107))
+        ├── @ ImaginaryNode (location: (111...115))
+        │   └── numeric:
+        │       @ RationalNode (location: (111...114))
+        │       └── numeric:
+        │           @ IntegerNode (location: (111...113))
+        ├── @ ImaginaryNode (location: (117...123))
+        │   └── numeric:
+        │       @ RationalNode (location: (117...122))
+        │       └── numeric:
+        │           @ FloatNode (location: (117...121))
+        ├── @ RationalNode (location: (125...129))
+        │   └── numeric:
+        │       @ IntegerNode (location: (125...128))
+        ├── @ ImaginaryNode (location: (131...135))
+        │   └── numeric:
+        │       @ IntegerNode (location: (131...134))
+        ├── @ ImaginaryNode (location: (137...142))
+        │   └── numeric:
+        │       @ RationalNode (location: (137...141))
+        │       └── numeric:
+        │           @ IntegerNode (location: (137...140))
+        ├── @ RationalNode (location: (144...148))
+        │   └── numeric:
+        │       @ IntegerNode (location: (144...147))
+        ├── @ ImaginaryNode (location: (150...154))
+        │   └── numeric:
+        │       @ IntegerNode (location: (150...153))
+        └── @ ImaginaryNode (location: (156...161))
+            └── numeric:
+                @ RationalNode (location: (156...160))
+                └── numeric:
+                    @ IntegerNode (location: (156...159))
diff --git a/test/yarp/snapshots/patterns.txt b/test/yarp/snapshots/patterns.txt
index b2f03f6b68..b875f70e95 100644
--- a/test/yarp/snapshots/patterns.txt
+++ b/test/yarp/snapshots/patterns.txt
@@ -1,3850 +1,4442 @@
-ProgramNode(0...3743)(
-  [:bar, :baz, :qux, :b, :a],
-  StatementsNode(0...3743)(
-    [MatchRequiredNode(0...10)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       LocalVariableTargetNode(7...10)(:bar, 0),
-       (4...6)
-     ),
-     MatchRequiredNode(11...19)(
-       CallNode(11...14)(nil, nil, (11...14), nil, nil, nil, nil, 2, "foo"),
-       IntegerNode(18...19)(),
-       (15...17)
-     ),
-     MatchRequiredNode(20...30)(
-       CallNode(20...23)(nil, nil, (20...23), nil, nil, nil, nil, 2, "foo"),
-       FloatNode(27...30)(),
-       (24...26)
-     ),
-     MatchRequiredNode(31...40)(
-       CallNode(31...34)(nil, nil, (31...34), nil, nil, nil, nil, 2, "foo"),
-       ImaginaryNode(38...40)(IntegerNode(38...39)()),
-       (35...37)
-     ),
-     MatchRequiredNode(41...50)(
-       CallNode(41...44)(nil, nil, (41...44), nil, nil, nil, nil, 2, "foo"),
-       RationalNode(48...50)(IntegerNode(48...49)()),
-       (45...47)
-     ),
-     MatchRequiredNode(51...62)(
-       CallNode(51...54)(nil, nil, (51...54), nil, nil, nil, nil, 2, "foo"),
-       SymbolNode(58...62)((58...59), (59...62), nil, "foo"),
-       (55...57)
-     ),
-     MatchRequiredNode(63...77)(
-       CallNode(63...66)(nil, nil, (63...66), nil, nil, nil, nil, 2, "foo"),
-       SymbolNode(70...77)((70...73), (73...76), (76...77), "foo"),
-       (67...69)
-     ),
-     MatchRequiredNode(78...91)(
-       CallNode(78...81)(nil, nil, (78...81), nil, nil, nil, nil, 2, "foo"),
-       SymbolNode(85...91)((85...87), (87...90), (90...91), "foo"),
-       (82...84)
-     ),
-     MatchRequiredNode(92...104)(
-       CallNode(92...95)(nil, nil, (92...95), nil, nil, nil, nil, 2, "foo"),
-       RegularExpressionNode(99...104)(
-         (99...100),
-         (100...103),
-         (103...104),
-         "foo",
-         0
-       ),
-       (96...98)
-     ),
-     MatchRequiredNode(105...117)(
-       CallNode(105...108)(
-         nil,
-         nil,
-         (105...108),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       XStringNode(112...117)((112...113), (113...116), (116...117), "foo"),
-       (109...111)
-     ),
-     MatchRequiredNode(118...132)(
-       CallNode(118...121)(
-         nil,
-         nil,
-         (118...121),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       XStringNode(125...132)((125...128), (128...131), (131...132), "foo"),
-       (122...124)
-     ),
-     MatchRequiredNode(133...147)(
-       CallNode(133...136)(
-         nil,
-         nil,
-         (133...136),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayNode(140...147)(
-         [SymbolNode(143...146)(nil, (143...146), nil, "foo")],
-         (140...143),
-         (146...147)
-       ),
-       (137...139)
-     ),
-     MatchRequiredNode(148...162)(
-       CallNode(148...151)(
-         nil,
-         nil,
-         (148...151),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayNode(155...162)(
-         [SymbolNode(158...161)(nil, (158...161), nil, "foo")],
-         (155...158),
-         (161...162)
-       ),
-       (152...154)
-     ),
-     MatchRequiredNode(163...177)(
-       CallNode(163...166)(
-         nil,
-         nil,
-         (163...166),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayNode(170...177)(
-         [StringNode(173...176)(nil, (173...176), nil, "foo")],
-         (170...173),
-         (176...177)
-       ),
-       (167...169)
-     ),
-     MatchRequiredNode(178...192)(
-       CallNode(178...181)(
-         nil,
-         nil,
-         (178...181),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayNode(185...192)(
-         [StringNode(188...191)(nil, (188...191), nil, "foo")],
-         (185...188),
-         (191...192)
-       ),
-       (182...184)
-     ),
-     MatchRequiredNode(193...207)(
-       CallNode(193...196)(
-         nil,
-         nil,
-         (193...196),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       StringNode(200...207)((200...203), (203...206), (206...207), "foo"),
-       (197...199)
-     ),
-     MatchRequiredNode(208...222)(
-       CallNode(208...211)(
-         nil,
-         nil,
-         (208...211),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       StringNode(215...222)((215...218), (218...221), (221...222), "foo"),
-       (212...214)
-     ),
-     MatchRequiredNode(223...235)(
-       CallNode(223...226)(
-         nil,
-         nil,
-         (223...226),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       StringNode(230...235)((230...231), (231...234), (234...235), "foo"),
-       (227...229)
-     ),
-     MatchRequiredNode(236...246)(
-       CallNode(236...239)(
-         nil,
-         nil,
-         (236...239),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       NilNode(243...246)(),
-       (240...242)
-     ),
-     MatchRequiredNode(247...258)(
-       CallNode(247...250)(
-         nil,
-         nil,
-         (247...250),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SelfNode(254...258)(),
-       (251...253)
-     ),
-     MatchRequiredNode(259...270)(
-       CallNode(259...262)(
-         nil,
-         nil,
-         (259...262),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       TrueNode(266...270)(),
-       (263...265)
-     ),
-     MatchRequiredNode(271...283)(
-       CallNode(271...274)(
-         nil,
-         nil,
-         (271...274),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       FalseNode(278...283)(),
-       (275...277)
-     ),
-     MatchRequiredNode(284...299)(
-       CallNode(284...287)(
-         nil,
-         nil,
-         (284...287),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SourceFileNode(291...299)("patterns.txt"),
-       (288...290)
-     ),
-     MatchRequiredNode(300...315)(
-       CallNode(300...303)(
-         nil,
-         nil,
-         (300...303),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SourceLineNode(307...315)(),
-       (304...306)
-     ),
-     MatchRequiredNode(316...335)(
-       CallNode(316...319)(
-         nil,
-         nil,
-         (316...319),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SourceEncodingNode(323...335)(),
-       (320...322)
-     ),
-     MatchRequiredNode(336...353)(
-       CallNode(336...339)(
-         nil,
-         nil,
-         (336...339),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       LambdaNode(343...353)(
-         [],
-         (343...345),
-         (346...347),
-         (352...353),
-         nil,
-         StatementsNode(348...351)([LocalVariableReadNode(348...351)(:bar, 1)])
-       ),
-       (340...342)
-     ),
-     MatchRequiredNode(355...368)(
-       CallNode(355...358)(
-         nil,
-         nil,
-         (355...358),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(362...368)(
-         IntegerNode(362...363)(),
-         IntegerNode(367...368)(),
-         (364...366),
-         0
-       ),
-       (359...361)
-     ),
-     MatchRequiredNode(369...386)(
-       CallNode(369...372)(
-         nil,
-         nil,
-         (369...372),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(376...386)(
-         FloatNode(376...379)(),
-         FloatNode(383...386)(),
-         (380...382),
-         0
-       ),
-       (373...375)
-     ),
-     MatchRequiredNode(387...402)(
-       CallNode(387...390)(
-         nil,
-         nil,
-         (387...390),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(394...402)(
-         ImaginaryNode(394...396)(IntegerNode(394...395)()),
-         ImaginaryNode(400...402)(IntegerNode(400...401)()),
-         (397...399),
-         0
-       ),
-       (391...393)
-     ),
-     MatchRequiredNode(403...418)(
-       CallNode(403...406)(
-         nil,
-         nil,
-         (403...406),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(410...418)(
-         RationalNode(410...412)(IntegerNode(410...411)()),
-         RationalNode(416...418)(IntegerNode(416...417)()),
-         (413...415),
-         0
-       ),
-       (407...409)
-     ),
-     MatchRequiredNode(419...438)(
-       CallNode(419...422)(
-         nil,
-         nil,
-         (419...422),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(426...438)(
-         SymbolNode(426...430)((426...427), (427...430), nil, "foo"),
-         SymbolNode(434...438)((434...435), (435...438), nil, "foo"),
-         (431...433),
-         0
-       ),
-       (423...425)
-     ),
-     MatchRequiredNode(439...464)(
-       CallNode(439...442)(
-         nil,
-         nil,
-         (439...442),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(446...464)(
-         SymbolNode(446...453)((446...449), (449...452), (452...453), "foo"),
-         SymbolNode(457...464)((457...460), (460...463), (463...464), "foo"),
-         (454...456),
-         0
-       ),
-       (443...445)
-     ),
-     MatchRequiredNode(465...488)(
-       CallNode(465...468)(
-         nil,
-         nil,
-         (465...468),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(472...488)(
-         SymbolNode(472...478)((472...474), (474...477), (477...478), "foo"),
-         SymbolNode(482...488)((482...484), (484...487), (487...488), "foo"),
-         (479...481),
-         0
-       ),
-       (469...471)
-     ),
-     MatchRequiredNode(489...510)(
-       CallNode(489...492)(
-         nil,
-         nil,
-         (489...492),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(496...510)(
-         RegularExpressionNode(496...501)(
-           (496...497),
-           (497...500),
-           (500...501),
-           "foo",
-           0
-         ),
-         RegularExpressionNode(505...510)(
-           (505...506),
-           (506...509),
-           (509...510),
-           "foo",
-           0
-         ),
-         (502...504),
-         0
-       ),
-       (493...495)
-     ),
-     MatchRequiredNode(511...532)(
-       CallNode(511...514)(
-         nil,
-         nil,
-         (511...514),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(518...532)(
-         XStringNode(518...523)((518...519), (519...522), (522...523), "foo"),
-         XStringNode(527...532)((527...528), (528...531), (531...532), "foo"),
-         (524...526),
-         0
-       ),
-       (515...517)
-     ),
-     MatchRequiredNode(533...558)(
-       CallNode(533...536)(
-         nil,
-         nil,
-         (533...536),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(540...558)(
-         XStringNode(540...547)((540...543), (543...546), (546...547), "foo"),
-         XStringNode(551...558)((551...554), (554...557), (557...558), "foo"),
-         (548...550),
-         0
-       ),
-       (537...539)
-     ),
-     MatchRequiredNode(559...584)(
-       CallNode(559...562)(
-         nil,
-         nil,
-         (559...562),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(566...584)(
-         ArrayNode(566...573)(
-           [SymbolNode(569...572)(nil, (569...572), nil, "foo")],
-           (566...569),
-           (572...573)
-         ),
-         ArrayNode(577...584)(
-           [SymbolNode(580...583)(nil, (580...583), nil, "foo")],
-           (577...580),
-           (583...584)
-         ),
-         (574...576),
-         0
-       ),
-       (563...565)
-     ),
-     MatchRequiredNode(585...610)(
-       CallNode(585...588)(
-         nil,
-         nil,
-         (585...588),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(592...610)(
-         ArrayNode(592...599)(
-           [SymbolNode(595...598)(nil, (595...598), nil, "foo")],
-           (592...595),
-           (598...599)
-         ),
-         ArrayNode(603...610)(
-           [SymbolNode(606...609)(nil, (606...609), nil, "foo")],
-           (603...606),
-           (609...610)
-         ),
-         (600...602),
-         0
-       ),
-       (589...591)
-     ),
-     MatchRequiredNode(611...636)(
-       CallNode(611...614)(
-         nil,
-         nil,
-         (611...614),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(618...636)(
-         ArrayNode(618...625)(
-           [StringNode(621...624)(nil, (621...624), nil, "foo")],
-           (618...621),
-           (624...625)
-         ),
-         ArrayNode(629...636)(
-           [StringNode(632...635)(nil, (632...635), nil, "foo")],
-           (629...632),
-           (635...636)
-         ),
-         (626...628),
-         0
-       ),
-       (615...617)
-     ),
-     MatchRequiredNode(637...662)(
-       CallNode(637...640)(
-         nil,
-         nil,
-         (637...640),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(644...662)(
-         ArrayNode(644...651)(
-           [StringNode(647...650)(nil, (647...650), nil, "foo")],
-           (644...647),
-           (650...651)
-         ),
-         ArrayNode(655...662)(
-           [StringNode(658...661)(nil, (658...661), nil, "foo")],
-           (655...658),
-           (661...662)
-         ),
-         (652...654),
-         0
-       ),
-       (641...643)
-     ),
-     MatchRequiredNode(663...688)(
-       CallNode(663...666)(
-         nil,
-         nil,
-         (663...666),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(670...688)(
-         StringNode(670...677)((670...673), (673...676), (676...677), "foo"),
-         StringNode(681...688)((681...684), (684...687), (687...688), "foo"),
-         (678...680),
-         0
-       ),
-       (667...669)
-     ),
-     MatchRequiredNode(689...714)(
-       CallNode(689...692)(
-         nil,
-         nil,
-         (689...692),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(696...714)(
-         StringNode(696...703)((696...699), (699...702), (702...703), "foo"),
-         StringNode(707...714)((707...710), (710...713), (713...714), "foo"),
-         (704...706),
-         0
-       ),
-       (693...695)
-     ),
-     MatchRequiredNode(715...736)(
-       CallNode(715...718)(
-         nil,
-         nil,
-         (715...718),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(722...736)(
-         StringNode(722...727)((722...723), (723...726), (726...727), "foo"),
-         StringNode(731...736)((731...732), (732...735), (735...736), "foo"),
-         (728...730),
-         0
-       ),
-       (719...721)
-     ),
-     MatchRequiredNode(737...754)(
-       CallNode(737...740)(
-         nil,
-         nil,
-         (737...740),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(744...754)(
-         NilNode(744...747)(),
-         NilNode(751...754)(),
-         (748...750),
-         0
-       ),
-       (741...743)
-     ),
-     MatchRequiredNode(755...774)(
-       CallNode(755...758)(
-         nil,
-         nil,
-         (755...758),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(762...774)(
-         SelfNode(762...766)(),
-         SelfNode(770...774)(),
-         (767...769),
-         0
-       ),
-       (759...761)
-     ),
-     MatchRequiredNode(775...794)(
-       CallNode(775...778)(
-         nil,
-         nil,
-         (775...778),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(782...794)(
-         TrueNode(782...786)(),
-         TrueNode(790...794)(),
-         (787...789),
-         0
-       ),
-       (779...781)
-     ),
-     MatchRequiredNode(795...816)(
-       CallNode(795...798)(
-         nil,
-         nil,
-         (795...798),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(802...816)(
-         FalseNode(802...807)(),
-         FalseNode(811...816)(),
-         (808...810),
-         0
-       ),
-       (799...801)
-     ),
-     MatchRequiredNode(817...844)(
-       CallNode(817...820)(
-         nil,
-         nil,
-         (817...820),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(824...844)(
-         SourceFileNode(824...832)("patterns.txt"),
-         SourceFileNode(836...844)("patterns.txt"),
-         (833...835),
-         0
-       ),
-       (821...823)
-     ),
-     MatchRequiredNode(845...872)(
-       CallNode(845...848)(
-         nil,
-         nil,
-         (845...848),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(852...872)(
-         SourceLineNode(852...860)(),
-         SourceLineNode(864...872)(),
-         (861...863),
-         0
-       ),
-       (849...851)
-     ),
-     MatchRequiredNode(873...908)(
-       CallNode(873...876)(
-         nil,
-         nil,
-         (873...876),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(880...908)(
-         SourceEncodingNode(880...892)(),
-         SourceEncodingNode(896...908)(),
-         (893...895),
-         0
-       ),
-       (877...879)
-     ),
-     MatchRequiredNode(909...940)(
-       CallNode(909...912)(
-         nil,
-         nil,
-         (909...912),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RangeNode(916...940)(
-         LambdaNode(916...926)(
-           [],
-           (916...918),
-           (919...920),
-           (925...926),
-           nil,
-           StatementsNode(921...924)(
-             [LocalVariableReadNode(921...924)(:bar, 1)]
-           )
-         ),
-         LambdaNode(930...940)(
-           [],
-           (930...932),
-           (933...934),
-           (939...940),
-           nil,
-           StatementsNode(935...938)(
-             [LocalVariableReadNode(935...938)(:bar, 1)]
-           )
-         ),
-         (927...929),
-         0
-       ),
-       (913...915)
-     ),
-     MatchRequiredNode(942...953)(
-       CallNode(942...945)(
-         nil,
-         nil,
-         (942...945),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       PinnedVariableNode(949...953)(
-         LocalVariableReadNode(950...953)(:bar, 0),
-         (949...950)
-       ),
-       (946...948)
-     ),
-     MatchRequiredNode(954...966)(
-       CallNode(954...957)(
-         nil,
-         nil,
-         (954...957),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       PinnedVariableNode(961...966)(
-         InstanceVariableReadNode(962...966)(:@bar),
-         (961...962)
-       ),
-       (958...960)
-     ),
-     MatchRequiredNode(967...980)(
-       CallNode(967...970)(
-         nil,
-         nil,
-         (967...970),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       PinnedVariableNode(974...980)(
-         ClassVariableReadNode(975...980)(:@@bar),
-         (974...975)
-       ),
-       (971...973)
-     ),
-     MatchRequiredNode(981...993)(
-       CallNode(981...984)(
-         nil,
-         nil,
-         (981...984),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       PinnedVariableNode(988...993)(
-         GlobalVariableReadNode(989...993)(:$bar),
-         (988...989)
-       ),
-       (985...987)
-     ),
-     MatchRequiredNode(995...1006)(
-       CallNode(995...998)(
-         nil,
-         nil,
-         (995...998),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       PinnedExpressionNode(1002...1006)(
-         IntegerNode(1004...1005)(),
-         (1002...1003),
-         (1003...1004),
-         (1005...1006)
-       ),
-       (999...1001)
-     ),
-     MatchRequiredNode(1007...1020)(
-       CallNode(1007...1010)(
-         nil,
-         nil,
-         (1007...1010),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       PinnedExpressionNode(1014...1020)(
-         NilNode(1016...1019)(),
-         (1014...1015),
-         (1015...1016),
-         (1019...1020)
-       ),
-       (1011...1013)
-     ),
-     MatchRequiredNode(1021...1044)(
-       CallNode(1021...1024)(
-         nil,
-         nil,
-         (1021...1024),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       PinnedExpressionNode(1028...1044)(
-         CallNode(1030...1043)(
-           StringNode(1030...1035)(
-             (1030...1031),
-             (1031...1034),
-             (1034...1035),
-             "bar"
-           ),
-           nil,
-           (1036...1037),
-           nil,
-           ArgumentsNode(1038...1043)(
-             [StringNode(1038...1043)(
-                (1038...1039),
-                (1039...1042),
-                (1042...1043),
-                "baz"
-              )]
-           ),
-           nil,
-           nil,
-           0,
-           "+"
-         ),
-         (1028...1029),
-         (1029...1030),
-         (1043...1044)
-       ),
-       (1025...1027)
-     ),
-     MatchRequiredNode(1046...1056)(
-       CallNode(1046...1049)(
-         nil,
-         nil,
-         (1046...1049),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ConstantReadNode(1053...1056)(:Foo),
-       (1050...1052)
-     ),
-     MatchRequiredNode(1057...1077)(
-       CallNode(1057...1060)(
-         nil,
-         nil,
-         (1057...1060),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ConstantPathNode(1064...1077)(
-         ConstantPathNode(1064...1072)(
-           ConstantReadNode(1064...1067)(:Foo),
-           ConstantReadNode(1069...1072)(:Bar),
-           (1067...1069)
-         ),
-         ConstantReadNode(1074...1077)(:Baz),
-         (1072...1074)
-       ),
-       (1061...1063)
-     ),
-     MatchRequiredNode(1078...1090)(
-       CallNode(1078...1081)(
-         nil,
-         nil,
-         (1078...1081),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ConstantPathNode(1085...1090)(
-         nil,
-         ConstantReadNode(1087...1090)(:Foo),
-         (1085...1087)
-       ),
-       (1082...1084)
-     ),
-     MatchRequiredNode(1091...1113)(
-       CallNode(1091...1094)(
-         nil,
-         nil,
-         (1091...1094),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ConstantPathNode(1098...1113)(
-         ConstantPathNode(1098...1108)(
-           ConstantPathNode(1098...1103)(
-             nil,
-             ConstantReadNode(1100...1103)(:Foo),
-             (1098...1100)
-           ),
-           ConstantReadNode(1105...1108)(:Bar),
-           (1103...1105)
-         ),
-         ConstantReadNode(1110...1113)(:Baz),
-         (1108...1110)
-       ),
-       (1095...1097)
-     ),
-     MatchRequiredNode(1115...1127)(
-       CallNode(1115...1118)(
-         nil,
-         nil,
-         (1115...1118),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1122...1127)(
-         ConstantReadNode(1122...1125)(:Foo),
-         [],
-         nil,
-         [],
-         (1125...1126),
-         (1126...1127)
-       ),
-       (1119...1121)
-     ),
-     MatchRequiredNode(1128...1141)(
-       CallNode(1128...1131)(
-         nil,
-         nil,
-         (1128...1131),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1135...1141)(
-         ConstantReadNode(1135...1138)(:Foo),
-         [IntegerNode(1139...1140)()],
-         nil,
-         [],
-         (1138...1139),
-         (1140...1141)
-       ),
-       (1132...1134)
-     ),
-     MatchRequiredNode(1142...1161)(
-       CallNode(1142...1145)(
-         nil,
-         nil,
-         (1142...1145),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1149...1161)(
-         ConstantReadNode(1149...1152)(:Foo),
-         [IntegerNode(1153...1154)(),
-          IntegerNode(1156...1157)(),
-          IntegerNode(1159...1160)()],
-         nil,
-         [],
-         (1152...1153),
-         (1160...1161)
-       ),
-       (1146...1148)
-     ),
-     MatchRequiredNode(1162...1177)(
-       CallNode(1162...1165)(
-         nil,
-         nil,
-         (1162...1165),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1169...1177)(
-         ConstantReadNode(1169...1172)(:Foo),
-         [LocalVariableTargetNode(1173...1176)(:bar, 0)],
-         nil,
-         [],
-         (1172...1173),
-         (1176...1177)
-       ),
-       (1166...1168)
-     ),
-     MatchRequiredNode(1178...1199)(
-       CallNode(1178...1181)(
-         nil,
-         nil,
-         (1178...1181),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1185...1199)(
-         ConstantReadNode(1185...1188)(:Foo),
-         [],
-         SplatNode(1189...1193)(
-           (1189...1190),
-           LocalVariableTargetNode(1190...1193)(:bar, 0)
-         ),
-         [LocalVariableTargetNode(1195...1198)(:baz, 0)],
-         (1188...1189),
-         (1198...1199)
-       ),
-       (1182...1184)
-     ),
-     MatchRequiredNode(1200...1221)(
-       CallNode(1200...1203)(
-         nil,
-         nil,
-         (1200...1203),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1207...1221)(
-         ConstantReadNode(1207...1210)(:Foo),
-         [LocalVariableTargetNode(1211...1214)(:bar, 0)],
-         SplatNode(1216...1220)(
-           (1216...1217),
-           LocalVariableTargetNode(1217...1220)(:baz, 0)
-         ),
-         [],
-         (1210...1211),
-         (1220...1221)
-       ),
-       (1204...1206)
-     ),
-     MatchRequiredNode(1222...1249)(
-       CallNode(1222...1225)(
-         nil,
-         nil,
-         (1222...1225),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       FindPatternNode(1229...1249)(
-         ConstantReadNode(1229...1232)(:Foo),
-         SplatNode(1233...1237)(
-           (1233...1234),
-           LocalVariableTargetNode(1234...1237)(:bar, 0)
-         ),
-         [LocalVariableTargetNode(1239...1242)(:baz, 0)],
-         SplatNode(1244...1248)(
-           (1244...1245),
-           LocalVariableTargetNode(1245...1248)(:qux, 0)
-         ),
-         (1232...1233),
-         (1248...1249)
-       ),
-       (1226...1228)
-     ),
-     MatchRequiredNode(1251...1263)(
-       CallNode(1251...1254)(
-         nil,
-         nil,
-         (1251...1254),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1258...1263)(
-         ConstantReadNode(1258...1261)(:Foo),
-         [],
-         nil,
-         [],
-         (1261...1262),
-         (1262...1263)
-       ),
-       (1255...1257)
-     ),
-     MatchRequiredNode(1264...1277)(
-       CallNode(1264...1267)(
-         nil,
-         nil,
-         (1264...1267),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1271...1277)(
-         ConstantReadNode(1271...1274)(:Foo),
-         [IntegerNode(1275...1276)()],
-         nil,
-         [],
-         (1274...1275),
-         (1276...1277)
-       ),
-       (1268...1270)
-     ),
-     MatchRequiredNode(1278...1297)(
-       CallNode(1278...1281)(
-         nil,
-         nil,
-         (1278...1281),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1285...1297)(
-         ConstantReadNode(1285...1288)(:Foo),
-         [IntegerNode(1289...1290)(),
-          IntegerNode(1292...1293)(),
-          IntegerNode(1295...1296)()],
-         nil,
-         [],
-         (1288...1289),
-         (1296...1297)
-       ),
-       (1282...1284)
-     ),
-     MatchRequiredNode(1298...1315)(
-       CallNode(1298...1301)(
-         nil,
-         nil,
-         (1298...1301),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1305...1315)(
-         ConstantReadNode(1305...1308)(:Foo),
-         [ArrayPatternNode(1309...1314)(
-            ConstantReadNode(1309...1312)(:Foo),
-            [],
-            nil,
-            [],
-            (1312...1313),
-            (1313...1314)
-          )],
-         nil,
-         [],
-         (1308...1309),
-         (1314...1315)
-       ),
-       (1302...1304)
-     ),
-     MatchRequiredNode(1316...1331)(
-       CallNode(1316...1319)(
-         nil,
-         nil,
-         (1316...1319),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1323...1331)(
-         ConstantReadNode(1323...1326)(:Foo),
-         [LocalVariableTargetNode(1327...1330)(:bar, 0)],
-         nil,
-         [],
-         (1326...1327),
-         (1330...1331)
-       ),
-       (1320...1322)
-     ),
-     MatchRequiredNode(1332...1353)(
-       CallNode(1332...1335)(
-         nil,
-         nil,
-         (1332...1335),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1339...1353)(
-         ConstantReadNode(1339...1342)(:Foo),
-         [],
-         SplatNode(1343...1347)(
-           (1343...1344),
-           LocalVariableTargetNode(1344...1347)(:bar, 0)
-         ),
-         [LocalVariableTargetNode(1349...1352)(:baz, 0)],
-         (1342...1343),
-         (1352...1353)
-       ),
-       (1336...1338)
-     ),
-     MatchRequiredNode(1354...1375)(
-       CallNode(1354...1357)(
-         nil,
-         nil,
-         (1354...1357),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1361...1375)(
-         ConstantReadNode(1361...1364)(:Foo),
-         [LocalVariableTargetNode(1365...1368)(:bar, 0)],
-         SplatNode(1370...1374)(
-           (1370...1371),
-           LocalVariableTargetNode(1371...1374)(:baz, 0)
-         ),
-         [],
-         (1364...1365),
-         (1374...1375)
-       ),
-       (1358...1360)
-     ),
-     MatchRequiredNode(1376...1403)(
-       CallNode(1376...1379)(
-         nil,
-         nil,
-         (1376...1379),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       FindPatternNode(1383...1403)(
-         ConstantReadNode(1383...1386)(:Foo),
-         SplatNode(1387...1391)(
-           (1387...1388),
-           LocalVariableTargetNode(1388...1391)(:bar, 0)
-         ),
-         [LocalVariableTargetNode(1393...1396)(:baz, 0)],
-         SplatNode(1398...1402)(
-           (1398...1399),
-           LocalVariableTargetNode(1399...1402)(:qux, 0)
-         ),
-         (1386...1387),
-         (1402...1403)
-       ),
-       (1380...1382)
-     ),
-     MatchRequiredNode(1405...1416)(
-       CallNode(1405...1408)(
-         nil,
-         nil,
-         (1405...1408),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1412...1416)(
-         nil,
-         [],
-         SplatNode(1412...1416)(
-           (1412...1413),
-           LocalVariableTargetNode(1413...1416)(:bar, 0)
-         ),
-         [],
-         nil,
-         nil
-       ),
-       (1409...1411)
-     ),
-     MatchRequiredNode(1417...1438)(
-       CallNode(1417...1420)(
-         nil,
-         nil,
-         (1417...1420),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1424...1438)(
-         nil,
-         [],
-         SplatNode(1424...1428)(
-           (1424...1425),
-           LocalVariableTargetNode(1425...1428)(:bar, 0)
-         ),
-         [LocalVariableTargetNode(1430...1433)(:baz, 0),
-          LocalVariableTargetNode(1435...1438)(:qux, 0)],
-         nil,
-         nil
-       ),
-       (1421...1423)
-     ),
-     MatchRequiredNode(1439...1460)(
-       CallNode(1439...1442)(
-         nil,
-         nil,
-         (1439...1442),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1446...1460)(
-         nil,
-         [LocalVariableTargetNode(1446...1449)(:bar, 0)],
-         SplatNode(1451...1455)(
-           (1451...1452),
-           LocalVariableTargetNode(1452...1455)(:baz, 0)
-         ),
-         [LocalVariableTargetNode(1457...1460)(:qux, 0)],
-         nil,
-         nil
-       ),
-       (1443...1445)
-     ),
-     MatchRequiredNode(1461...1482)(
-       CallNode(1461...1464)(
-         nil,
-         nil,
-         (1461...1464),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1468...1482)(
-         nil,
-         [LocalVariableTargetNode(1468...1471)(:bar, 0),
-          LocalVariableTargetNode(1473...1476)(:baz, 0)],
-         SplatNode(1478...1482)(
-           (1478...1479),
-           LocalVariableTargetNode(1479...1482)(:qux, 0)
-         ),
-         [],
-         nil,
-         nil
-       ),
-       (1465...1467)
-     ),
-     MatchRequiredNode(1483...1505)(
-       CallNode(1483...1486)(
-         nil,
-         nil,
-         (1483...1486),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       FindPatternNode(1490...1505)(
-         nil,
-         SplatNode(1490...1494)(
-           (1490...1491),
-           LocalVariableTargetNode(1491...1494)(:bar, 0)
-         ),
-         [LocalVariableTargetNode(1496...1499)(:baz, 0)],
-         SplatNode(1501...1505)(
-           (1501...1502),
-           LocalVariableTargetNode(1502...1505)(:qux, 0)
-         ),
-         nil,
-         nil
-       ),
-       (1487...1489)
-     ),
-     MatchRequiredNode(1507...1516)(
-       CallNode(1507...1510)(
-         nil,
-         nil,
-         (1507...1510),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1514...1516)(
-         nil,
-         [],
-         nil,
-         [],
-         (1514...1515),
-         (1515...1516)
-       ),
-       (1511...1513)
-     ),
-     MatchRequiredNode(1517...1534)(
-       CallNode(1517...1520)(
-         nil,
-         nil,
-         (1517...1520),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1524...1534)(
-         nil,
-         [ArrayPatternNode(1525...1533)(
-            nil,
-            [ArrayPatternNode(1526...1532)(
-               nil,
-               [ArrayPatternNode(1527...1531)(
-                  nil,
-                  [ArrayPatternNode(1528...1530)(
-                     nil,
-                     [],
-                     nil,
-                     [],
-                     (1528...1529),
-                     (1529...1530)
-                   )],
-                  nil,
-                  [],
-                  (1527...1528),
-                  (1530...1531)
-                )],
-               nil,
-               [],
-               (1526...1527),
-               (1531...1532)
-             )],
-            nil,
-            [],
-            (1525...1526),
-            (1532...1533)
-          )],
-         nil,
-         [],
-         (1524...1525),
-         (1533...1534)
-       ),
-       (1521...1523)
-     ),
-     MatchRequiredNode(1536...1549)(
-       CallNode(1536...1539)(
-         nil,
-         nil,
-         (1536...1539),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1543...1549)(
-         nil,
-         [],
-         SplatNode(1544...1548)(
-           (1544...1545),
-           LocalVariableTargetNode(1545...1548)(:bar, 0)
-         ),
-         [],
-         (1543...1544),
-         (1548...1549)
-       ),
-       (1540...1542)
-     ),
-     MatchRequiredNode(1550...1573)(
-       CallNode(1550...1553)(
-         nil,
-         nil,
-         (1550...1553),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1557...1573)(
-         nil,
-         [],
-         SplatNode(1558...1562)(
-           (1558...1559),
-           LocalVariableTargetNode(1559...1562)(:bar, 0)
-         ),
-         [LocalVariableTargetNode(1564...1567)(:baz, 0),
-          LocalVariableTargetNode(1569...1572)(:qux, 0)],
-         (1557...1558),
-         (1572...1573)
-       ),
-       (1554...1556)
-     ),
-     MatchRequiredNode(1574...1597)(
-       CallNode(1574...1577)(
-         nil,
-         nil,
-         (1574...1577),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1581...1597)(
-         nil,
-         [LocalVariableTargetNode(1582...1585)(:bar, 0)],
-         SplatNode(1587...1591)(
-           (1587...1588),
-           LocalVariableTargetNode(1588...1591)(:baz, 0)
-         ),
-         [LocalVariableTargetNode(1593...1596)(:qux, 0)],
-         (1581...1582),
-         (1596...1597)
-       ),
-       (1578...1580)
-     ),
-     MatchRequiredNode(1598...1621)(
-       CallNode(1598...1601)(
-         nil,
-         nil,
-         (1598...1601),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayPatternNode(1605...1621)(
-         nil,
-         [LocalVariableTargetNode(1606...1609)(:bar, 0),
-          LocalVariableTargetNode(1611...1614)(:baz, 0)],
-         SplatNode(1616...1620)(
-           (1616...1617),
-           LocalVariableTargetNode(1617...1620)(:qux, 0)
-         ),
-         [],
-         (1605...1606),
-         (1620...1621)
-       ),
-       (1602...1604)
-     ),
-     MatchRequiredNode(1622...1646)(
-       CallNode(1622...1625)(
-         nil,
-         nil,
-         (1622...1625),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       FindPatternNode(1629...1646)(
-         nil,
-         SplatNode(1630...1634)(
-           (1630...1631),
-           LocalVariableTargetNode(1631...1634)(:bar, 0)
-         ),
-         [LocalVariableTargetNode(1636...1639)(:baz, 0)],
-         SplatNode(1641...1645)(
-           (1641...1642),
-           LocalVariableTargetNode(1642...1645)(:qux, 0)
-         ),
-         (1629...1630),
-         (1645...1646)
-       ),
-       (1626...1628)
-     ),
-     MatchPredicateNode(1648...1658)(
-       CallNode(1648...1651)(
-         nil,
-         nil,
-         (1648...1651),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       LocalVariableTargetNode(1655...1658)(:bar, 0),
-       (1652...1654)
-     ),
-     MatchPredicateNode(1659...1667)(
-       CallNode(1659...1662)(
-         nil,
-         nil,
-         (1659...1662),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       IntegerNode(1666...1667)(),
-       (1663...1665)
-     ),
-     MatchPredicateNode(1668...1678)(
-       CallNode(1668...1671)(
-         nil,
-         nil,
-         (1668...1671),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       FloatNode(1675...1678)(),
-       (1672...1674)
-     ),
-     MatchPredicateNode(1679...1688)(
-       CallNode(1679...1682)(
-         nil,
-         nil,
-         (1679...1682),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ImaginaryNode(1686...1688)(IntegerNode(1686...1687)()),
-       (1683...1685)
-     ),
-     MatchPredicateNode(1689...1698)(
-       CallNode(1689...1692)(
-         nil,
-         nil,
-         (1689...1692),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RationalNode(1696...1698)(IntegerNode(1696...1697)()),
-       (1693...1695)
-     ),
-     MatchPredicateNode(1699...1710)(
-       CallNode(1699...1702)(
-         nil,
-         nil,
-         (1699...1702),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SymbolNode(1706...1710)((1706...1707), (1707...1710), nil, "foo"),
-       (1703...1705)
-     ),
-     MatchPredicateNode(1711...1725)(
-       CallNode(1711...1714)(
-         nil,
-         nil,
-         (1711...1714),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SymbolNode(1718...1725)(
-         (1718...1721),
-         (1721...1724),
-         (1724...1725),
-         "foo"
-       ),
-       (1715...1717)
-     ),
-     MatchPredicateNode(1726...1739)(
-       CallNode(1726...1729)(
-         nil,
-         nil,
-         (1726...1729),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SymbolNode(1733...1739)(
-         (1733...1735),
-         (1735...1738),
-         (1738...1739),
-         "foo"
-       ),
-       (1730...1732)
-     ),
-     MatchPredicateNode(1740...1752)(
-       CallNode(1740...1743)(
-         nil,
-         nil,
-         (1740...1743),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       RegularExpressionNode(1747...1752)(
-         (1747...1748),
-         (1748...1751),
-         (1751...1752),
-         "foo",
-         0
-       ),
-       (1744...1746)
-     ),
-     MatchPredicateNode(1753...1765)(
-       CallNode(1753...1756)(
-         nil,
-         nil,
-         (1753...1756),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       XStringNode(1760...1765)(
-         (1760...1761),
-         (1761...1764),
-         (1764...1765),
-         "foo"
-       ),
-       (1757...1759)
-     ),
-     MatchPredicateNode(1766...1780)(
-       CallNode(1766...1769)(
-         nil,
-         nil,
-         (1766...1769),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       XStringNode(1773...1780)(
-         (1773...1776),
-         (1776...1779),
-         (1779...1780),
-         "foo"
-       ),
-       (1770...1772)
-     ),
-     MatchPredicateNode(1781...1795)(
-       CallNode(1781...1784)(
-         nil,
-         nil,
-         (1781...1784),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayNode(1788...1795)(
-         [SymbolNode(1791...1794)(nil, (1791...1794), nil, "foo")],
-         (1788...1791),
-         (1794...1795)
-       ),
-       (1785...1787)
-     ),
-     MatchPredicateNode(1796...1810)(
-       CallNode(1796...1799)(
-         nil,
-         nil,
-         (1796...1799),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayNode(1803...1810)(
-         [SymbolNode(1806...1809)(nil, (1806...1809), nil, "foo")],
-         (1803...1806),
-         (1809...1810)
-       ),
-       (1800...1802)
-     ),
-     MatchPredicateNode(1811...1825)(
-       CallNode(1811...1814)(
-         nil,
-         nil,
-         (1811...1814),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayNode(1818...1825)(
-         [StringNode(1821...1824)(nil, (1821...1824), nil, "foo")],
-         (1818...1821),
-         (1824...1825)
-       ),
-       (1815...1817)
-     ),
-     MatchPredicateNode(1826...1840)(
-       CallNode(1826...1829)(
-         nil,
-         nil,
-         (1826...1829),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       ArrayNode(1833...1840)(
-         [StringNode(1836...1839)(nil, (1836...1839), nil, "foo")],
-         (1833...1836),
-         (1839...1840)
-       ),
-       (1830...1832)
-     ),
-     MatchPredicateNode(1841...1855)(
-       CallNode(1841...1844)(
-         nil,
-         nil,
-         (1841...1844),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       StringNode(1848...1855)(
-         (1848...1851),
-         (1851...1854),
-         (1854...1855),
-         "foo"
-       ),
-       (1845...1847)
-     ),
-     MatchPredicateNode(1856...1870)(
-       CallNode(1856...1859)(
-         nil,
-         nil,
-         (1856...1859),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       StringNode(1863...1870)(
-         (1863...1866),
-         (1866...1869),
-         (1869...1870),
-         "foo"
-       ),
-       (1860...1862)
-     ),
-     MatchPredicateNode(1871...1883)(
-       CallNode(1871...1874)(
-         nil,
-         nil,
-         (1871...1874),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       StringNode(1878...1883)(
-         (1878...1879),
-         (1879...1882),
-         (1882...1883),
-         "foo"
-       ),
-       (1875...1877)
-     ),
-     MatchPredicateNode(1884...1894)(
-       CallNode(1884...1887)(
-         nil,
-         nil,
-         (1884...1887),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       NilNode(1891...1894)(),
-       (1888...1890)
-     ),
-     MatchPredicateNode(1895...1906)(
-       CallNode(1895...1898)(
-         nil,
-         nil,
-         (1895...1898),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SelfNode(1902...1906)(),
-       (1899...1901)
-     ),
-     MatchPredicateNode(1907...1918)(
-       CallNode(1907...1910)(
-         nil,
-         nil,
-         (1907...1910),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       TrueNode(1914...1918)(),
-       (1911...1913)
-     ),
-     MatchPredicateNode(1919...1931)(
-       CallNode(1919...1922)(
-         nil,
-         nil,
-         (1919...1922),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       FalseNode(1926...1931)(),
-       (1923...1925)
-     ),
-     MatchPredicateNode(1932...1947)(
-       CallNode(1932...1935)(
-         nil,
-         nil,
-         (1932...1935),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SourceFileNode(1939...1947)("patterns.txt"),
-       (1936...1938)
-     ),
-     MatchPredicateNode(1948...1963)(
-       CallNode(1948...1951)(
-         nil,
-         nil,
-         (1948...1951),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SourceLineNode(1955...1963)(),
-       (1952...1954)
-     ),
-     MatchPredicateNode(1964...1983)(
-       CallNode(1964...1967)(
-         nil,
-         nil,
-         (1964...1967),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       SourceEncodingNode(1971...1983)(),
-       (1968...1970)
-     ),
-     MatchPredicateNode(1984...2001)(
-       CallNode(1984...1987)(
-         nil,
-         nil,
-         (1984...1987),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       LambdaNode(1991...2001)(
-         [],
-         (1991...1993),
-         (1994...1995),
-         (2000...2001),
-         nil,
-         StatementsNode(1996...1999)(
-           [LocalVariableReadNode(1996...1999)(:bar, 1)]
-         )
-       ),
-       (1988...1990)
-     ),
-     CaseNode(2003...2028)(
-       CallNode(2008...2011)(
-         nil,
-         nil,
-         (2008...2011),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2013...2024)(
-          LocalVariableTargetNode(2016...2019)(:bar, 0),
-          nil,
-          (2013...2015),
-          (2020...2024)
-        )],
-       nil,
-       (2003...2007),
-       (2025...2028)
-     ),
-     CaseNode(2029...2052)(
-       CallNode(2034...2037)(
-         nil,
-         nil,
-         (2034...2037),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2039...2048)(
-          IntegerNode(2042...2043)(),
-          nil,
-          (2039...2041),
-          (2044...2048)
-        )],
-       nil,
-       (2029...2033),
-       (2049...2052)
-     ),
-     CaseNode(2053...2078)(
-       CallNode(2058...2061)(
-         nil,
-         nil,
-         (2058...2061),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2063...2074)(
-          FloatNode(2066...2069)(),
-          nil,
-          (2063...2065),
-          (2070...2074)
-        )],
-       nil,
-       (2053...2057),
-       (2075...2078)
-     ),
-     CaseNode(2079...2103)(
-       CallNode(2084...2087)(
-         nil,
-         nil,
-         (2084...2087),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2089...2099)(
-          ImaginaryNode(2092...2094)(IntegerNode(2092...2093)()),
-          nil,
-          (2089...2091),
-          (2095...2099)
-        )],
-       nil,
-       (2079...2083),
-       (2100...2103)
-     ),
-     CaseNode(2104...2128)(
-       CallNode(2109...2112)(
-         nil,
-         nil,
-         (2109...2112),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2114...2124)(
-          RationalNode(2117...2119)(IntegerNode(2117...2118)()),
-          nil,
-          (2114...2116),
-          (2120...2124)
-        )],
-       nil,
-       (2104...2108),
-       (2125...2128)
-     ),
-     CaseNode(2129...2155)(
-       CallNode(2134...2137)(
-         nil,
-         nil,
-         (2134...2137),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2139...2151)(
-          SymbolNode(2142...2146)((2142...2143), (2143...2146), nil, "foo"),
-          nil,
-          (2139...2141),
-          (2147...2151)
-        )],
-       nil,
-       (2129...2133),
-       (2152...2155)
-     ),
-     CaseNode(2156...2185)(
-       CallNode(2161...2164)(
-         nil,
-         nil,
-         (2161...2164),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2166...2181)(
-          SymbolNode(2169...2176)(
-            (2169...2172),
-            (2172...2175),
-            (2175...2176),
-            "foo"
-          ),
-          nil,
-          (2166...2168),
-          (2177...2181)
-        )],
-       nil,
-       (2156...2160),
-       (2182...2185)
-     ),
-     CaseNode(2186...2214)(
-       CallNode(2191...2194)(
-         nil,
-         nil,
-         (2191...2194),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2196...2210)(
-          SymbolNode(2199...2205)(
-            (2199...2201),
-            (2201...2204),
-            (2204...2205),
-            "foo"
-          ),
-          nil,
-          (2196...2198),
-          (2206...2210)
-        )],
-       nil,
-       (2186...2190),
-       (2211...2214)
-     ),
-     CaseNode(2215...2242)(
-       CallNode(2220...2223)(
-         nil,
-         nil,
-         (2220...2223),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2225...2238)(
-          RegularExpressionNode(2228...2233)(
-            (2228...2229),
-            (2229...2232),
-            (2232...2233),
-            "foo",
-            0
-          ),
-          nil,
-          (2225...2227),
-          (2234...2238)
-        )],
-       nil,
-       (2215...2219),
-       (2239...2242)
-     ),
-     CaseNode(2243...2270)(
-       CallNode(2248...2251)(
-         nil,
-         nil,
-         (2248...2251),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2253...2266)(
-          XStringNode(2256...2261)(
-            (2256...2257),
-            (2257...2260),
-            (2260...2261),
-            "foo"
-          ),
-          nil,
-          (2253...2255),
-          (2262...2266)
-        )],
-       nil,
-       (2243...2247),
-       (2267...2270)
-     ),
-     CaseNode(2271...2300)(
-       CallNode(2276...2279)(
-         nil,
-         nil,
-         (2276...2279),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2281...2296)(
-          XStringNode(2284...2291)(
-            (2284...2287),
-            (2287...2290),
-            (2290...2291),
-            "foo"
-          ),
-          nil,
-          (2281...2283),
-          (2292...2296)
-        )],
-       nil,
-       (2271...2275),
-       (2297...2300)
-     ),
-     CaseNode(2301...2330)(
-       CallNode(2306...2309)(
-         nil,
-         nil,
-         (2306...2309),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2311...2326)(
-          ArrayNode(2314...2321)(
-            [SymbolNode(2317...2320)(nil, (2317...2320), nil, "foo")],
-            (2314...2317),
-            (2320...2321)
-          ),
-          nil,
-          (2311...2313),
-          (2322...2326)
-        )],
-       nil,
-       (2301...2305),
-       (2327...2330)
-     ),
-     CaseNode(2331...2360)(
-       CallNode(2336...2339)(
-         nil,
-         nil,
-         (2336...2339),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2341...2356)(
-          ArrayNode(2344...2351)(
-            [SymbolNode(2347...2350)(nil, (2347...2350), nil, "foo")],
-            (2344...2347),
-            (2350...2351)
-          ),
-          nil,
-          (2341...2343),
-          (2352...2356)
-        )],
-       nil,
-       (2331...2335),
-       (2357...2360)
-     ),
-     CaseNode(2361...2390)(
-       CallNode(2366...2369)(
-         nil,
-         nil,
-         (2366...2369),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2371...2386)(
-          ArrayNode(2374...2381)(
-            [StringNode(2377...2380)(nil, (2377...2380), nil, "foo")],
-            (2374...2377),
-            (2380...2381)
-          ),
-          nil,
-          (2371...2373),
-          (2382...2386)
-        )],
-       nil,
-       (2361...2365),
-       (2387...2390)
-     ),
-     CaseNode(2391...2420)(
-       CallNode(2396...2399)(
-         nil,
-         nil,
-         (2396...2399),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2401...2416)(
-          ArrayNode(2404...2411)(
-            [StringNode(2407...2410)(nil, (2407...2410), nil, "foo")],
-            (2404...2407),
-            (2410...2411)
-          ),
-          nil,
-          (2401...2403),
-          (2412...2416)
-        )],
-       nil,
-       (2391...2395),
-       (2417...2420)
-     ),
-     CaseNode(2421...2450)(
-       CallNode(2426...2429)(
-         nil,
-         nil,
-         (2426...2429),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2431...2446)(
-          StringNode(2434...2441)(
-            (2434...2437),
-            (2437...2440),
-            (2440...2441),
-            "foo"
-          ),
-          nil,
-          (2431...2433),
-          (2442...2446)
-        )],
-       nil,
-       (2421...2425),
-       (2447...2450)
-     ),
-     CaseNode(2451...2480)(
-       CallNode(2456...2459)(
-         nil,
-         nil,
-         (2456...2459),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2461...2476)(
-          StringNode(2464...2471)(
-            (2464...2467),
-            (2467...2470),
-            (2470...2471),
-            "foo"
-          ),
-          nil,
-          (2461...2463),
-          (2472...2476)
-        )],
-       nil,
-       (2451...2455),
-       (2477...2480)
-     ),
-     CaseNode(2481...2508)(
-       CallNode(2486...2489)(
-         nil,
-         nil,
-         (2486...2489),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2491...2504)(
-          StringNode(2494...2499)(
-            (2494...2495),
-            (2495...2498),
-            (2498...2499),
-            "foo"
-          ),
-          nil,
-          (2491...2493),
-          (2500...2504)
-        )],
-       nil,
-       (2481...2485),
-       (2505...2508)
-     ),
-     CaseNode(2509...2534)(
-       CallNode(2514...2517)(
-         nil,
-         nil,
-         (2514...2517),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2519...2530)(
-          NilNode(2522...2525)(),
-          nil,
-          (2519...2521),
-          (2526...2530)
-        )],
-       nil,
-       (2509...2513),
-       (2531...2534)
-     ),
-     CaseNode(2535...2561)(
-       CallNode(2540...2543)(
-         nil,
-         nil,
-         (2540...2543),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2545...2557)(
-          SelfNode(2548...2552)(),
-          nil,
-          (2545...2547),
-          (2553...2557)
-        )],
-       nil,
-       (2535...2539),
-       (2558...2561)
-     ),
-     CaseNode(2562...2588)(
-       CallNode(2567...2570)(
-         nil,
-         nil,
-         (2567...2570),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2572...2584)(
-          TrueNode(2575...2579)(),
-          nil,
-          (2572...2574),
-          (2580...2584)
-        )],
-       nil,
-       (2562...2566),
-       (2585...2588)
-     ),
-     CaseNode(2589...2616)(
-       CallNode(2594...2597)(
-         nil,
-         nil,
-         (2594...2597),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2599...2612)(
-          FalseNode(2602...2607)(),
-          nil,
-          (2599...2601),
-          (2608...2612)
-        )],
-       nil,
-       (2589...2593),
-       (2613...2616)
-     ),
-     CaseNode(2617...2647)(
-       CallNode(2622...2625)(
-         nil,
-         nil,
-         (2622...2625),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2627...2643)(
-          SourceFileNode(2630...2638)("patterns.txt"),
-          nil,
-          (2627...2629),
-          (2639...2643)
-        )],
-       nil,
-       (2617...2621),
-       (2644...2647)
-     ),
-     CaseNode(2648...2678)(
-       CallNode(2653...2656)(
-         nil,
-         nil,
-         (2653...2656),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2658...2674)(
-          SourceLineNode(2661...2669)(),
-          nil,
-          (2658...2660),
-          (2670...2674)
-        )],
-       nil,
-       (2648...2652),
-       (2675...2678)
-     ),
-     CaseNode(2679...2713)(
-       CallNode(2684...2687)(
-         nil,
-         nil,
-         (2684...2687),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2689...2709)(
-          SourceEncodingNode(2692...2704)(),
-          nil,
-          (2689...2691),
-          (2705...2709)
-        )],
-       nil,
-       (2679...2683),
-       (2710...2713)
-     ),
-     CaseNode(2714...2746)(
-       CallNode(2719...2722)(
-         nil,
-         nil,
-         (2719...2722),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2724...2742)(
-          LambdaNode(2727...2737)(
-            [],
-            (2727...2729),
-            (2730...2731),
-            (2736...2737),
-            nil,
-            StatementsNode(2732...2735)(
-              [LocalVariableReadNode(2732...2735)(:bar, 1)]
-            )
-          ),
-          nil,
-          (2724...2726),
-          (2738...2742)
-        )],
-       nil,
-       (2714...2718),
-       (2743...2746)
-     ),
-     CaseNode(2748...2780)(
-       CallNode(2753...2756)(
-         nil,
-         nil,
-         (2753...2756),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2758...2776)(
-          IfNode(2761...2771)(
-            (2765...2767),
-            LocalVariableReadNode(2768...2771)(:baz, 0),
-            StatementsNode(2761...2764)(
-              [LocalVariableTargetNode(2761...2764)(:bar, 0)]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (2758...2760),
-          (2772...2776)
-        )],
-       nil,
-       (2748...2752),
-       (2777...2780)
-     ),
-     CaseNode(2781...2811)(
-       CallNode(2786...2789)(
-         nil,
-         nil,
-         (2786...2789),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2791...2807)(
-          IfNode(2794...2802)(
-            (2796...2798),
-            LocalVariableReadNode(2799...2802)(:baz, 0),
-            StatementsNode(2794...2795)([IntegerNode(2794...2795)()]),
-            nil,
-            nil
-          ),
-          nil,
-          (2791...2793),
-          (2803...2807)
-        )],
-       nil,
-       (2781...2785),
-       (2808...2811)
-     ),
-     CaseNode(2812...2844)(
-       CallNode(2817...2820)(
-         nil,
-         nil,
-         (2817...2820),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2822...2840)(
-          IfNode(2825...2835)(
-            (2829...2831),
-            LocalVariableReadNode(2832...2835)(:baz, 0),
-            StatementsNode(2825...2828)([FloatNode(2825...2828)()]),
-            nil,
-            nil
-          ),
-          nil,
-          (2822...2824),
-          (2836...2840)
-        )],
-       nil,
-       (2812...2816),
-       (2841...2844)
-     ),
-     CaseNode(2845...2876)(
-       CallNode(2850...2853)(
-         nil,
-         nil,
-         (2850...2853),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2855...2872)(
-          IfNode(2858...2867)(
-            (2861...2863),
-            LocalVariableReadNode(2864...2867)(:baz, 0),
-            StatementsNode(2858...2860)(
-              [ImaginaryNode(2858...2860)(IntegerNode(2858...2859)())]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (2855...2857),
-          (2868...2872)
-        )],
-       nil,
-       (2845...2849),
-       (2873...2876)
-     ),
-     CaseNode(2877...2908)(
-       CallNode(2882...2885)(
-         nil,
-         nil,
-         (2882...2885),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2887...2904)(
-          IfNode(2890...2899)(
-            (2893...2895),
-            LocalVariableReadNode(2896...2899)(:baz, 0),
-            StatementsNode(2890...2892)(
-              [RationalNode(2890...2892)(IntegerNode(2890...2891)())]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (2887...2889),
-          (2900...2904)
-        )],
-       nil,
-       (2877...2881),
-       (2905...2908)
-     ),
-     CaseNode(2909...2942)(
-       CallNode(2914...2917)(
-         nil,
-         nil,
-         (2914...2917),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2919...2938)(
-          IfNode(2922...2933)(
-            (2927...2929),
-            LocalVariableReadNode(2930...2933)(:baz, 0),
-            StatementsNode(2922...2926)(
-              [SymbolNode(2922...2926)(
-                 (2922...2923),
-                 (2923...2926),
-                 nil,
-                 "foo"
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (2919...2921),
-          (2934...2938)
-        )],
-       nil,
-       (2909...2913),
-       (2939...2942)
-     ),
-     CaseNode(2943...2979)(
-       CallNode(2948...2951)(
-         nil,
-         nil,
-         (2948...2951),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2953...2975)(
-          IfNode(2956...2970)(
-            (2964...2966),
-            LocalVariableReadNode(2967...2970)(:baz, 0),
-            StatementsNode(2956...2963)(
-              [SymbolNode(2956...2963)(
-                 (2956...2959),
-                 (2959...2962),
-                 (2962...2963),
-                 "foo"
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (2953...2955),
-          (2971...2975)
-        )],
-       nil,
-       (2943...2947),
-       (2976...2979)
-     ),
-     CaseNode(2980...3015)(
-       CallNode(2985...2988)(
-         nil,
-         nil,
-         (2985...2988),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(2990...3011)(
-          IfNode(2993...3006)(
-            (3000...3002),
-            LocalVariableReadNode(3003...3006)(:baz, 0),
-            StatementsNode(2993...2999)(
-              [SymbolNode(2993...2999)(
-                 (2993...2995),
-                 (2995...2998),
-                 (2998...2999),
-                 "foo"
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (2990...2992),
-          (3007...3011)
-        )],
-       nil,
-       (2980...2984),
-       (3012...3015)
-     ),
-     CaseNode(3016...3050)(
-       CallNode(3021...3024)(
-         nil,
-         nil,
-         (3021...3024),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3026...3046)(
-          IfNode(3029...3041)(
-            (3035...3037),
-            LocalVariableReadNode(3038...3041)(:baz, 0),
-            StatementsNode(3029...3034)(
-              [RegularExpressionNode(3029...3034)(
-                 (3029...3030),
-                 (3030...3033),
-                 (3033...3034),
-                 "foo",
-                 0
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3026...3028),
-          (3042...3046)
-        )],
-       nil,
-       (3016...3020),
-       (3047...3050)
-     ),
-     CaseNode(3051...3085)(
-       CallNode(3056...3059)(
-         nil,
-         nil,
-         (3056...3059),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3061...3081)(
-          IfNode(3064...3076)(
-            (3070...3072),
-            LocalVariableReadNode(3073...3076)(:baz, 0),
-            StatementsNode(3064...3069)(
-              [XStringNode(3064...3069)(
-                 (3064...3065),
-                 (3065...3068),
-                 (3068...3069),
-                 "foo"
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3061...3063),
-          (3077...3081)
-        )],
-       nil,
-       (3051...3055),
-       (3082...3085)
-     ),
-     CaseNode(3086...3122)(
-       CallNode(3091...3094)(
-         nil,
-         nil,
-         (3091...3094),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3096...3118)(
-          IfNode(3099...3113)(
-            (3107...3109),
-            LocalVariableReadNode(3110...3113)(:baz, 0),
-            StatementsNode(3099...3106)(
-              [XStringNode(3099...3106)(
-                 (3099...3102),
-                 (3102...3105),
-                 (3105...3106),
-                 "foo"
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3096...3098),
-          (3114...3118)
-        )],
-       nil,
-       (3086...3090),
-       (3119...3122)
-     ),
-     CaseNode(3123...3159)(
-       CallNode(3128...3131)(
-         nil,
-         nil,
-         (3128...3131),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3133...3155)(
-          IfNode(3136...3150)(
-            (3144...3146),
-            LocalVariableReadNode(3147...3150)(:baz, 0),
-            StatementsNode(3136...3143)(
-              [ArrayNode(3136...3143)(
-                 [SymbolNode(3139...3142)(nil, (3139...3142), nil, "foo")],
-                 (3136...3139),
-                 (3142...3143)
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3133...3135),
-          (3151...3155)
-        )],
-       nil,
-       (3123...3127),
-       (3156...3159)
-     ),
-     CaseNode(3160...3196)(
-       CallNode(3165...3168)(
-         nil,
-         nil,
-         (3165...3168),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3170...3192)(
-          IfNode(3173...3187)(
-            (3181...3183),
-            LocalVariableReadNode(3184...3187)(:baz, 0),
-            StatementsNode(3173...3180)(
-              [ArrayNode(3173...3180)(
-                 [SymbolNode(3176...3179)(nil, (3176...3179), nil, "foo")],
-                 (3173...3176),
-                 (3179...3180)
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3170...3172),
-          (3188...3192)
-        )],
-       nil,
-       (3160...3164),
-       (3193...3196)
-     ),
-     CaseNode(3197...3233)(
-       CallNode(3202...3205)(
-         nil,
-         nil,
-         (3202...3205),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3207...3229)(
-          IfNode(3210...3224)(
-            (3218...3220),
-            LocalVariableReadNode(3221...3224)(:baz, 0),
-            StatementsNode(3210...3217)(
-              [ArrayNode(3210...3217)(
-                 [StringNode(3213...3216)(nil, (3213...3216), nil, "foo")],
-                 (3210...3213),
-                 (3216...3217)
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3207...3209),
-          (3225...3229)
-        )],
-       nil,
-       (3197...3201),
-       (3230...3233)
-     ),
-     CaseNode(3234...3270)(
-       CallNode(3239...3242)(
-         nil,
-         nil,
-         (3239...3242),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3244...3266)(
-          IfNode(3247...3261)(
-            (3255...3257),
-            LocalVariableReadNode(3258...3261)(:baz, 0),
-            StatementsNode(3247...3254)(
-              [ArrayNode(3247...3254)(
-                 [StringNode(3250...3253)(nil, (3250...3253), nil, "foo")],
-                 (3247...3250),
-                 (3253...3254)
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3244...3246),
-          (3262...3266)
-        )],
-       nil,
-       (3234...3238),
-       (3267...3270)
-     ),
-     CaseNode(3271...3307)(
-       CallNode(3276...3279)(
-         nil,
-         nil,
-         (3276...3279),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3281...3303)(
-          IfNode(3284...3298)(
-            (3292...3294),
-            LocalVariableReadNode(3295...3298)(:baz, 0),
-            StatementsNode(3284...3291)(
-              [StringNode(3284...3291)(
-                 (3284...3287),
-                 (3287...3290),
-                 (3290...3291),
-                 "foo"
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3281...3283),
-          (3299...3303)
-        )],
-       nil,
-       (3271...3275),
-       (3304...3307)
-     ),
-     CaseNode(3308...3344)(
-       CallNode(3313...3316)(
-         nil,
-         nil,
-         (3313...3316),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3318...3340)(
-          IfNode(3321...3335)(
-            (3329...3331),
-            LocalVariableReadNode(3332...3335)(:baz, 0),
-            StatementsNode(3321...3328)(
-              [StringNode(3321...3328)(
-                 (3321...3324),
-                 (3324...3327),
-                 (3327...3328),
-                 "foo"
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3318...3320),
-          (3336...3340)
-        )],
-       nil,
-       (3308...3312),
-       (3341...3344)
-     ),
-     CaseNode(3345...3379)(
-       CallNode(3350...3353)(
-         nil,
-         nil,
-         (3350...3353),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3355...3375)(
-          IfNode(3358...3370)(
-            (3364...3366),
-            LocalVariableReadNode(3367...3370)(:baz, 0),
-            StatementsNode(3358...3363)(
-              [StringNode(3358...3363)(
-                 (3358...3359),
-                 (3359...3362),
-                 (3362...3363),
-                 "foo"
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3355...3357),
-          (3371...3375)
-        )],
-       nil,
-       (3345...3349),
-       (3376...3379)
-     ),
-     CaseNode(3380...3412)(
-       CallNode(3385...3388)(
-         nil,
-         nil,
-         (3385...3388),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3390...3408)(
-          IfNode(3393...3403)(
-            (3397...3399),
-            LocalVariableReadNode(3400...3403)(:baz, 0),
-            StatementsNode(3393...3396)([NilNode(3393...3396)()]),
-            nil,
-            nil
-          ),
-          nil,
-          (3390...3392),
-          (3404...3408)
-        )],
-       nil,
-       (3380...3384),
-       (3409...3412)
-     ),
-     CaseNode(3413...3446)(
-       CallNode(3418...3421)(
-         nil,
-         nil,
-         (3418...3421),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3423...3442)(
-          IfNode(3426...3437)(
-            (3431...3433),
-            LocalVariableReadNode(3434...3437)(:baz, 0),
-            StatementsNode(3426...3430)([SelfNode(3426...3430)()]),
-            nil,
-            nil
-          ),
-          nil,
-          (3423...3425),
-          (3438...3442)
-        )],
-       nil,
-       (3413...3417),
-       (3443...3446)
-     ),
-     CaseNode(3447...3480)(
-       CallNode(3452...3455)(
-         nil,
-         nil,
-         (3452...3455),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3457...3476)(
-          IfNode(3460...3471)(
-            (3465...3467),
-            LocalVariableReadNode(3468...3471)(:baz, 0),
-            StatementsNode(3460...3464)([TrueNode(3460...3464)()]),
-            nil,
-            nil
-          ),
-          nil,
-          (3457...3459),
-          (3472...3476)
-        )],
-       nil,
-       (3447...3451),
-       (3477...3480)
-     ),
-     CaseNode(3481...3515)(
-       CallNode(3486...3489)(
-         nil,
-         nil,
-         (3486...3489),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3491...3511)(
-          IfNode(3494...3506)(
-            (3500...3502),
-            LocalVariableReadNode(3503...3506)(:baz, 0),
-            StatementsNode(3494...3499)([FalseNode(3494...3499)()]),
-            nil,
-            nil
-          ),
-          nil,
-          (3491...3493),
-          (3507...3511)
-        )],
-       nil,
-       (3481...3485),
-       (3512...3515)
-     ),
-     CaseNode(3516...3553)(
-       CallNode(3521...3524)(
-         nil,
-         nil,
-         (3521...3524),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3526...3549)(
-          IfNode(3529...3544)(
-            (3538...3540),
-            LocalVariableReadNode(3541...3544)(:baz, 0),
-            StatementsNode(3529...3537)(
-              [SourceFileNode(3529...3537)("patterns.txt")]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3526...3528),
-          (3545...3549)
-        )],
-       nil,
-       (3516...3520),
-       (3550...3553)
-     ),
-     CaseNode(3554...3591)(
-       CallNode(3559...3562)(
-         nil,
-         nil,
-         (3559...3562),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3564...3587)(
-          IfNode(3567...3582)(
-            (3576...3578),
-            LocalVariableReadNode(3579...3582)(:baz, 0),
-            StatementsNode(3567...3575)([SourceLineNode(3567...3575)()]),
-            nil,
-            nil
-          ),
-          nil,
-          (3564...3566),
-          (3583...3587)
-        )],
-       nil,
-       (3554...3558),
-       (3588...3591)
-     ),
-     CaseNode(3592...3633)(
-       CallNode(3597...3600)(
-         nil,
-         nil,
-         (3597...3600),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3602...3629)(
-          IfNode(3605...3624)(
-            (3618...3620),
-            LocalVariableReadNode(3621...3624)(:baz, 0),
-            StatementsNode(3605...3617)([SourceEncodingNode(3605...3617)()]),
-            nil,
-            nil
-          ),
-          nil,
-          (3602...3604),
-          (3625...3629)
-        )],
-       nil,
-       (3592...3596),
-       (3630...3633)
-     ),
-     CaseNode(3634...3673)(
-       CallNode(3639...3642)(
-         nil,
-         nil,
-         (3639...3642),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(3644...3669)(
-          IfNode(3647...3664)(
-            (3658...3660),
-            LocalVariableReadNode(3661...3664)(:baz, 0),
-            StatementsNode(3647...3657)(
-              [LambdaNode(3647...3657)(
-                 [],
-                 (3647...3649),
-                 (3650...3651),
-                 (3656...3657),
-                 nil,
-                 StatementsNode(3652...3655)(
-                   [LocalVariableReadNode(3652...3655)(:bar, 1)]
-                 )
-               )]
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (3644...3646),
-          (3665...3669)
-        )],
-       nil,
-       (3634...3638),
-       (3670...3673)
-     ),
-     IfNode(3675...3689)(
-       (3675...3677),
-       MatchPredicateNode(3678...3685)(
-         CallNode(3678...3679)(
-           nil,
-           nil,
-           (3678...3679),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "a"
-         ),
-         ArrayPatternNode(3683...3685)(
-           nil,
-           [],
-           nil,
-           [],
-           (3683...3684),
-           (3684...3685)
-         ),
-         (3680...3682)
-       ),
-       nil,
-       nil,
-       (3686...3689)
-     ),
-     MatchRequiredNode(3691...3703)(
-       CallNode(3691...3692)(
-         nil,
-         nil,
-         (3691...3692),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "a"
-       ),
-       ArrayPatternNode(3696...3703)(
-         nil,
-         [LocalVariableTargetNode(3700...3701)(:b, 0)],
-         nil,
-         [],
-         (3696...3697),
-         (3702...3703)
-       ),
-       (3693...3695)
-     ),
-     MatchPredicateNode(3705...3743)(
-       CallNode(3705...3708)(
-         nil,
-         nil,
-         (3705...3708),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       HashPatternNode(3712...3743)(
-         ConstantReadNode(3712...3713)(:A),
-         [AssocNode(3717...3741)(
-            SymbolNode(3717...3721)(nil, (3717...3720), (3720...3721), "bar"),
-            HashPatternNode(3722...3741)(
-              ConstantReadNode(3722...3723)(:B),
-              [AssocNode(3729...3737)(
-                 SymbolNode(3729...3735)(
-                   nil,
-                   (3729...3734),
-                   (3734...3735),
-                   "value"
-                 ),
-                 LocalVariableTargetNode(3736...3737)(:a, 0),
-                 nil
-               )],
-              nil,
-              (3723...3724),
-              (3740...3741)
-            ),
-            nil
-          )],
-         nil,
-         (3713...3714),
-         (3742...3743)
-       ),
-       (3709...3711)
-     )]
-  )
-)
+@ ProgramNode (location: (0...3743))
+├── locals: [:bar, :baz, :qux, :b, :a]
+└── statements:
+    @ StatementsNode (location: (0...3743))
+    └── body: (length: 170)
+        ├── @ MatchRequiredNode (location: (0...10))
+        │   ├── value:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ LocalVariableTargetNode (location: (7...10))
+        │   │   ├── name: :bar
+        │   │   └── depth: 0
+        │   └── operator_loc: (4...6) = "=>"
+        ├── @ MatchRequiredNode (location: (11...19))
+        │   ├── value:
+        │   │   @ CallNode (location: (11...14))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (11...14) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ IntegerNode (location: (18...19))
+        │   └── operator_loc: (15...17) = "=>"
+        ├── @ MatchRequiredNode (location: (20...30))
+        │   ├── value:
+        │   │   @ CallNode (location: (20...23))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (20...23) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ FloatNode (location: (27...30))
+        │   └── operator_loc: (24...26) = "=>"
+        ├── @ MatchRequiredNode (location: (31...40))
+        │   ├── value:
+        │   │   @ CallNode (location: (31...34))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (31...34) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ImaginaryNode (location: (38...40))
+        │   │   └── numeric:
+        │   │       @ IntegerNode (location: (38...39))
+        │   └── operator_loc: (35...37) = "=>"
+        ├── @ MatchRequiredNode (location: (41...50))
+        │   ├── value:
+        │   │   @ CallNode (location: (41...44))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (41...44) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RationalNode (location: (48...50))
+        │   │   └── numeric:
+        │   │       @ IntegerNode (location: (48...49))
+        │   └── operator_loc: (45...47) = "=>"
+        ├── @ MatchRequiredNode (location: (51...62))
+        │   ├── value:
+        │   │   @ CallNode (location: (51...54))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (51...54) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SymbolNode (location: (58...62))
+        │   │   ├── opening_loc: (58...59) = ":"
+        │   │   ├── value_loc: (59...62) = "foo"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (55...57) = "=>"
+        ├── @ MatchRequiredNode (location: (63...77))
+        │   ├── value:
+        │   │   @ CallNode (location: (63...66))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (63...66) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SymbolNode (location: (70...77))
+        │   │   ├── opening_loc: (70...73) = "%s["
+        │   │   ├── value_loc: (73...76) = "foo"
+        │   │   ├── closing_loc: (76...77) = "]"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (67...69) = "=>"
+        ├── @ MatchRequiredNode (location: (78...91))
+        │   ├── value:
+        │   │   @ CallNode (location: (78...81))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (78...81) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SymbolNode (location: (85...91))
+        │   │   ├── opening_loc: (85...87) = ":\""
+        │   │   ├── value_loc: (87...90) = "foo"
+        │   │   ├── closing_loc: (90...91) = "\""
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (82...84) = "=>"
+        ├── @ MatchRequiredNode (location: (92...104))
+        │   ├── value:
+        │   │   @ CallNode (location: (92...95))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (92...95) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RegularExpressionNode (location: (99...104))
+        │   │   ├── opening_loc: (99...100) = "/"
+        │   │   ├── content_loc: (100...103) = "foo"
+        │   │   ├── closing_loc: (103...104) = "/"
+        │   │   ├── unescaped: "foo"
+        │   │   └── flags: 
+        │   └── operator_loc: (96...98) = "=>"
+        ├── @ MatchRequiredNode (location: (105...117))
+        │   ├── value:
+        │   │   @ CallNode (location: (105...108))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (105...108) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ XStringNode (location: (112...117))
+        │   │   ├── opening_loc: (112...113) = "`"
+        │   │   ├── content_loc: (113...116) = "foo"
+        │   │   ├── closing_loc: (116...117) = "`"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (109...111) = "=>"
+        ├── @ MatchRequiredNode (location: (118...132))
+        │   ├── value:
+        │   │   @ CallNode (location: (118...121))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (118...121) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ XStringNode (location: (125...132))
+        │   │   ├── opening_loc: (125...128) = "%x["
+        │   │   ├── content_loc: (128...131) = "foo"
+        │   │   ├── closing_loc: (131...132) = "]"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (122...124) = "=>"
+        ├── @ MatchRequiredNode (location: (133...147))
+        │   ├── value:
+        │   │   @ CallNode (location: (133...136))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (133...136) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayNode (location: (140...147))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ SymbolNode (location: (143...146))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── value_loc: (143...146) = "foo"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "foo"
+        │   │   ├── opening_loc: (140...143) = "%i["
+        │   │   └── closing_loc: (146...147) = "]"
+        │   └── operator_loc: (137...139) = "=>"
+        ├── @ MatchRequiredNode (location: (148...162))
+        │   ├── value:
+        │   │   @ CallNode (location: (148...151))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (148...151) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayNode (location: (155...162))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ SymbolNode (location: (158...161))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── value_loc: (158...161) = "foo"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "foo"
+        │   │   ├── opening_loc: (155...158) = "%I["
+        │   │   └── closing_loc: (161...162) = "]"
+        │   └── operator_loc: (152...154) = "=>"
+        ├── @ MatchRequiredNode (location: (163...177))
+        │   ├── value:
+        │   │   @ CallNode (location: (163...166))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (163...166) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayNode (location: (170...177))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ StringNode (location: (173...176))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (173...176) = "foo"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "foo"
+        │   │   ├── opening_loc: (170...173) = "%w["
+        │   │   └── closing_loc: (176...177) = "]"
+        │   └── operator_loc: (167...169) = "=>"
+        ├── @ MatchRequiredNode (location: (178...192))
+        │   ├── value:
+        │   │   @ CallNode (location: (178...181))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (178...181) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayNode (location: (185...192))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ StringNode (location: (188...191))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (188...191) = "foo"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "foo"
+        │   │   ├── opening_loc: (185...188) = "%W["
+        │   │   └── closing_loc: (191...192) = "]"
+        │   └── operator_loc: (182...184) = "=>"
+        ├── @ MatchRequiredNode (location: (193...207))
+        │   ├── value:
+        │   │   @ CallNode (location: (193...196))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (193...196) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ StringNode (location: (200...207))
+        │   │   ├── opening_loc: (200...203) = "%q["
+        │   │   ├── content_loc: (203...206) = "foo"
+        │   │   ├── closing_loc: (206...207) = "]"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (197...199) = "=>"
+        ├── @ MatchRequiredNode (location: (208...222))
+        │   ├── value:
+        │   │   @ CallNode (location: (208...211))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (208...211) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ StringNode (location: (215...222))
+        │   │   ├── opening_loc: (215...218) = "%Q["
+        │   │   ├── content_loc: (218...221) = "foo"
+        │   │   ├── closing_loc: (221...222) = "]"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (212...214) = "=>"
+        ├── @ MatchRequiredNode (location: (223...235))
+        │   ├── value:
+        │   │   @ CallNode (location: (223...226))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (223...226) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ StringNode (location: (230...235))
+        │   │   ├── opening_loc: (230...231) = "\""
+        │   │   ├── content_loc: (231...234) = "foo"
+        │   │   ├── closing_loc: (234...235) = "\""
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (227...229) = "=>"
+        ├── @ MatchRequiredNode (location: (236...246))
+        │   ├── value:
+        │   │   @ CallNode (location: (236...239))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (236...239) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ NilNode (location: (243...246))
+        │   └── operator_loc: (240...242) = "=>"
+        ├── @ MatchRequiredNode (location: (247...258))
+        │   ├── value:
+        │   │   @ CallNode (location: (247...250))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (247...250) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SelfNode (location: (254...258))
+        │   └── operator_loc: (251...253) = "=>"
+        ├── @ MatchRequiredNode (location: (259...270))
+        │   ├── value:
+        │   │   @ CallNode (location: (259...262))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (259...262) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ TrueNode (location: (266...270))
+        │   └── operator_loc: (263...265) = "=>"
+        ├── @ MatchRequiredNode (location: (271...283))
+        │   ├── value:
+        │   │   @ CallNode (location: (271...274))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (271...274) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ FalseNode (location: (278...283))
+        │   └── operator_loc: (275...277) = "=>"
+        ├── @ MatchRequiredNode (location: (284...299))
+        │   ├── value:
+        │   │   @ CallNode (location: (284...287))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (284...287) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SourceFileNode (location: (291...299))
+        │   │   └── filepath: "patterns.txt"
+        │   └── operator_loc: (288...290) = "=>"
+        ├── @ MatchRequiredNode (location: (300...315))
+        │   ├── value:
+        │   │   @ CallNode (location: (300...303))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (300...303) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SourceLineNode (location: (307...315))
+        │   └── operator_loc: (304...306) = "=>"
+        ├── @ MatchRequiredNode (location: (316...335))
+        │   ├── value:
+        │   │   @ CallNode (location: (316...319))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (316...319) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SourceEncodingNode (location: (323...335))
+        │   └── operator_loc: (320...322) = "=>"
+        ├── @ MatchRequiredNode (location: (336...353))
+        │   ├── value:
+        │   │   @ CallNode (location: (336...339))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (336...339) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ LambdaNode (location: (343...353))
+        │   │   ├── locals: []
+        │   │   ├── operator_loc: (343...345) = "->"
+        │   │   ├── opening_loc: (346...347) = "{"
+        │   │   ├── closing_loc: (352...353) = "}"
+        │   │   ├── parameters: ∅
+        │   │   └── body:
+        │   │       @ StatementsNode (location: (348...351))
+        │   │       └── body: (length: 1)
+        │   │           └── @ LocalVariableReadNode (location: (348...351))
+        │   │               ├── name: :bar
+        │   │               └── depth: 1
+        │   └── operator_loc: (340...342) = "=>"
+        ├── @ MatchRequiredNode (location: (355...368))
+        │   ├── value:
+        │   │   @ CallNode (location: (355...358))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (355...358) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (362...368))
+        │   │   ├── left:
+        │   │   │   @ IntegerNode (location: (362...363))
+        │   │   ├── right:
+        │   │   │   @ IntegerNode (location: (367...368))
+        │   │   ├── operator_loc: (364...366) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (359...361) = "=>"
+        ├── @ MatchRequiredNode (location: (369...386))
+        │   ├── value:
+        │   │   @ CallNode (location: (369...372))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (369...372) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (376...386))
+        │   │   ├── left:
+        │   │   │   @ FloatNode (location: (376...379))
+        │   │   ├── right:
+        │   │   │   @ FloatNode (location: (383...386))
+        │   │   ├── operator_loc: (380...382) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (373...375) = "=>"
+        ├── @ MatchRequiredNode (location: (387...402))
+        │   ├── value:
+        │   │   @ CallNode (location: (387...390))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (387...390) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (394...402))
+        │   │   ├── left:
+        │   │   │   @ ImaginaryNode (location: (394...396))
+        │   │   │   └── numeric:
+        │   │   │       @ IntegerNode (location: (394...395))
+        │   │   ├── right:
+        │   │   │   @ ImaginaryNode (location: (400...402))
+        │   │   │   └── numeric:
+        │   │   │       @ IntegerNode (location: (400...401))
+        │   │   ├── operator_loc: (397...399) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (391...393) = "=>"
+        ├── @ MatchRequiredNode (location: (403...418))
+        │   ├── value:
+        │   │   @ CallNode (location: (403...406))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (403...406) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (410...418))
+        │   │   ├── left:
+        │   │   │   @ RationalNode (location: (410...412))
+        │   │   │   └── numeric:
+        │   │   │       @ IntegerNode (location: (410...411))
+        │   │   ├── right:
+        │   │   │   @ RationalNode (location: (416...418))
+        │   │   │   └── numeric:
+        │   │   │       @ IntegerNode (location: (416...417))
+        │   │   ├── operator_loc: (413...415) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (407...409) = "=>"
+        ├── @ MatchRequiredNode (location: (419...438))
+        │   ├── value:
+        │   │   @ CallNode (location: (419...422))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (419...422) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (426...438))
+        │   │   ├── left:
+        │   │   │   @ SymbolNode (location: (426...430))
+        │   │   │   ├── opening_loc: (426...427) = ":"
+        │   │   │   ├── value_loc: (427...430) = "foo"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── right:
+        │   │   │   @ SymbolNode (location: (434...438))
+        │   │   │   ├── opening_loc: (434...435) = ":"
+        │   │   │   ├── value_loc: (435...438) = "foo"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── operator_loc: (431...433) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (423...425) = "=>"
+        ├── @ MatchRequiredNode (location: (439...464))
+        │   ├── value:
+        │   │   @ CallNode (location: (439...442))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (439...442) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (446...464))
+        │   │   ├── left:
+        │   │   │   @ SymbolNode (location: (446...453))
+        │   │   │   ├── opening_loc: (446...449) = "%s["
+        │   │   │   ├── value_loc: (449...452) = "foo"
+        │   │   │   ├── closing_loc: (452...453) = "]"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── right:
+        │   │   │   @ SymbolNode (location: (457...464))
+        │   │   │   ├── opening_loc: (457...460) = "%s["
+        │   │   │   ├── value_loc: (460...463) = "foo"
+        │   │   │   ├── closing_loc: (463...464) = "]"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── operator_loc: (454...456) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (443...445) = "=>"
+        ├── @ MatchRequiredNode (location: (465...488))
+        │   ├── value:
+        │   │   @ CallNode (location: (465...468))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (465...468) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (472...488))
+        │   │   ├── left:
+        │   │   │   @ SymbolNode (location: (472...478))
+        │   │   │   ├── opening_loc: (472...474) = ":\""
+        │   │   │   ├── value_loc: (474...477) = "foo"
+        │   │   │   ├── closing_loc: (477...478) = "\""
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── right:
+        │   │   │   @ SymbolNode (location: (482...488))
+        │   │   │   ├── opening_loc: (482...484) = ":\""
+        │   │   │   ├── value_loc: (484...487) = "foo"
+        │   │   │   ├── closing_loc: (487...488) = "\""
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── operator_loc: (479...481) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (469...471) = "=>"
+        ├── @ MatchRequiredNode (location: (489...510))
+        │   ├── value:
+        │   │   @ CallNode (location: (489...492))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (489...492) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (496...510))
+        │   │   ├── left:
+        │   │   │   @ RegularExpressionNode (location: (496...501))
+        │   │   │   ├── opening_loc: (496...497) = "/"
+        │   │   │   ├── content_loc: (497...500) = "foo"
+        │   │   │   ├── closing_loc: (500...501) = "/"
+        │   │   │   ├── unescaped: "foo"
+        │   │   │   └── flags: 
+        │   │   ├── right:
+        │   │   │   @ RegularExpressionNode (location: (505...510))
+        │   │   │   ├── opening_loc: (505...506) = "/"
+        │   │   │   ├── content_loc: (506...509) = "foo"
+        │   │   │   ├── closing_loc: (509...510) = "/"
+        │   │   │   ├── unescaped: "foo"
+        │   │   │   └── flags: 
+        │   │   ├── operator_loc: (502...504) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (493...495) = "=>"
+        ├── @ MatchRequiredNode (location: (511...532))
+        │   ├── value:
+        │   │   @ CallNode (location: (511...514))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (511...514) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (518...532))
+        │   │   ├── left:
+        │   │   │   @ XStringNode (location: (518...523))
+        │   │   │   ├── opening_loc: (518...519) = "`"
+        │   │   │   ├── content_loc: (519...522) = "foo"
+        │   │   │   ├── closing_loc: (522...523) = "`"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── right:
+        │   │   │   @ XStringNode (location: (527...532))
+        │   │   │   ├── opening_loc: (527...528) = "`"
+        │   │   │   ├── content_loc: (528...531) = "foo"
+        │   │   │   ├── closing_loc: (531...532) = "`"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── operator_loc: (524...526) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (515...517) = "=>"
+        ├── @ MatchRequiredNode (location: (533...558))
+        │   ├── value:
+        │   │   @ CallNode (location: (533...536))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (533...536) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (540...558))
+        │   │   ├── left:
+        │   │   │   @ XStringNode (location: (540...547))
+        │   │   │   ├── opening_loc: (540...543) = "%x["
+        │   │   │   ├── content_loc: (543...546) = "foo"
+        │   │   │   ├── closing_loc: (546...547) = "]"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── right:
+        │   │   │   @ XStringNode (location: (551...558))
+        │   │   │   ├── opening_loc: (551...554) = "%x["
+        │   │   │   ├── content_loc: (554...557) = "foo"
+        │   │   │   ├── closing_loc: (557...558) = "]"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── operator_loc: (548...550) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (537...539) = "=>"
+        ├── @ MatchRequiredNode (location: (559...584))
+        │   ├── value:
+        │   │   @ CallNode (location: (559...562))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (559...562) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (566...584))
+        │   │   ├── left:
+        │   │   │   @ ArrayNode (location: (566...573))
+        │   │   │   ├── elements: (length: 1)
+        │   │   │   │   └── @ SymbolNode (location: (569...572))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── value_loc: (569...572) = "foo"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "foo"
+        │   │   │   ├── opening_loc: (566...569) = "%i["
+        │   │   │   └── closing_loc: (572...573) = "]"
+        │   │   ├── right:
+        │   │   │   @ ArrayNode (location: (577...584))
+        │   │   │   ├── elements: (length: 1)
+        │   │   │   │   └── @ SymbolNode (location: (580...583))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── value_loc: (580...583) = "foo"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "foo"
+        │   │   │   ├── opening_loc: (577...580) = "%i["
+        │   │   │   └── closing_loc: (583...584) = "]"
+        │   │   ├── operator_loc: (574...576) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (563...565) = "=>"
+        ├── @ MatchRequiredNode (location: (585...610))
+        │   ├── value:
+        │   │   @ CallNode (location: (585...588))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (585...588) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (592...610))
+        │   │   ├── left:
+        │   │   │   @ ArrayNode (location: (592...599))
+        │   │   │   ├── elements: (length: 1)
+        │   │   │   │   └── @ SymbolNode (location: (595...598))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── value_loc: (595...598) = "foo"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "foo"
+        │   │   │   ├── opening_loc: (592...595) = "%I["
+        │   │   │   └── closing_loc: (598...599) = "]"
+        │   │   ├── right:
+        │   │   │   @ ArrayNode (location: (603...610))
+        │   │   │   ├── elements: (length: 1)
+        │   │   │   │   └── @ SymbolNode (location: (606...609))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── value_loc: (606...609) = "foo"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "foo"
+        │   │   │   ├── opening_loc: (603...606) = "%I["
+        │   │   │   └── closing_loc: (609...610) = "]"
+        │   │   ├── operator_loc: (600...602) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (589...591) = "=>"
+        ├── @ MatchRequiredNode (location: (611...636))
+        │   ├── value:
+        │   │   @ CallNode (location: (611...614))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (611...614) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (618...636))
+        │   │   ├── left:
+        │   │   │   @ ArrayNode (location: (618...625))
+        │   │   │   ├── elements: (length: 1)
+        │   │   │   │   └── @ StringNode (location: (621...624))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── content_loc: (621...624) = "foo"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "foo"
+        │   │   │   ├── opening_loc: (618...621) = "%w["
+        │   │   │   └── closing_loc: (624...625) = "]"
+        │   │   ├── right:
+        │   │   │   @ ArrayNode (location: (629...636))
+        │   │   │   ├── elements: (length: 1)
+        │   │   │   │   └── @ StringNode (location: (632...635))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── content_loc: (632...635) = "foo"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "foo"
+        │   │   │   ├── opening_loc: (629...632) = "%w["
+        │   │   │   └── closing_loc: (635...636) = "]"
+        │   │   ├── operator_loc: (626...628) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (615...617) = "=>"
+        ├── @ MatchRequiredNode (location: (637...662))
+        │   ├── value:
+        │   │   @ CallNode (location: (637...640))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (637...640) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (644...662))
+        │   │   ├── left:
+        │   │   │   @ ArrayNode (location: (644...651))
+        │   │   │   ├── elements: (length: 1)
+        │   │   │   │   └── @ StringNode (location: (647...650))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── content_loc: (647...650) = "foo"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "foo"
+        │   │   │   ├── opening_loc: (644...647) = "%W["
+        │   │   │   └── closing_loc: (650...651) = "]"
+        │   │   ├── right:
+        │   │   │   @ ArrayNode (location: (655...662))
+        │   │   │   ├── elements: (length: 1)
+        │   │   │   │   └── @ StringNode (location: (658...661))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── content_loc: (658...661) = "foo"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "foo"
+        │   │   │   ├── opening_loc: (655...658) = "%W["
+        │   │   │   └── closing_loc: (661...662) = "]"
+        │   │   ├── operator_loc: (652...654) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (641...643) = "=>"
+        ├── @ MatchRequiredNode (location: (663...688))
+        │   ├── value:
+        │   │   @ CallNode (location: (663...666))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (663...666) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (670...688))
+        │   │   ├── left:
+        │   │   │   @ StringNode (location: (670...677))
+        │   │   │   ├── opening_loc: (670...673) = "%q["
+        │   │   │   ├── content_loc: (673...676) = "foo"
+        │   │   │   ├── closing_loc: (676...677) = "]"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── right:
+        │   │   │   @ StringNode (location: (681...688))
+        │   │   │   ├── opening_loc: (681...684) = "%q["
+        │   │   │   ├── content_loc: (684...687) = "foo"
+        │   │   │   ├── closing_loc: (687...688) = "]"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── operator_loc: (678...680) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (667...669) = "=>"
+        ├── @ MatchRequiredNode (location: (689...714))
+        │   ├── value:
+        │   │   @ CallNode (location: (689...692))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (689...692) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (696...714))
+        │   │   ├── left:
+        │   │   │   @ StringNode (location: (696...703))
+        │   │   │   ├── opening_loc: (696...699) = "%Q["
+        │   │   │   ├── content_loc: (699...702) = "foo"
+        │   │   │   ├── closing_loc: (702...703) = "]"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── right:
+        │   │   │   @ StringNode (location: (707...714))
+        │   │   │   ├── opening_loc: (707...710) = "%Q["
+        │   │   │   ├── content_loc: (710...713) = "foo"
+        │   │   │   ├── closing_loc: (713...714) = "]"
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── operator_loc: (704...706) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (693...695) = "=>"
+        ├── @ MatchRequiredNode (location: (715...736))
+        │   ├── value:
+        │   │   @ CallNode (location: (715...718))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (715...718) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (722...736))
+        │   │   ├── left:
+        │   │   │   @ StringNode (location: (722...727))
+        │   │   │   ├── opening_loc: (722...723) = "\""
+        │   │   │   ├── content_loc: (723...726) = "foo"
+        │   │   │   ├── closing_loc: (726...727) = "\""
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── right:
+        │   │   │   @ StringNode (location: (731...736))
+        │   │   │   ├── opening_loc: (731...732) = "\""
+        │   │   │   ├── content_loc: (732...735) = "foo"
+        │   │   │   ├── closing_loc: (735...736) = "\""
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── operator_loc: (728...730) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (719...721) = "=>"
+        ├── @ MatchRequiredNode (location: (737...754))
+        │   ├── value:
+        │   │   @ CallNode (location: (737...740))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (737...740) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (744...754))
+        │   │   ├── left:
+        │   │   │   @ NilNode (location: (744...747))
+        │   │   ├── right:
+        │   │   │   @ NilNode (location: (751...754))
+        │   │   ├── operator_loc: (748...750) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (741...743) = "=>"
+        ├── @ MatchRequiredNode (location: (755...774))
+        │   ├── value:
+        │   │   @ CallNode (location: (755...758))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (755...758) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (762...774))
+        │   │   ├── left:
+        │   │   │   @ SelfNode (location: (762...766))
+        │   │   ├── right:
+        │   │   │   @ SelfNode (location: (770...774))
+        │   │   ├── operator_loc: (767...769) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (759...761) = "=>"
+        ├── @ MatchRequiredNode (location: (775...794))
+        │   ├── value:
+        │   │   @ CallNode (location: (775...778))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (775...778) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (782...794))
+        │   │   ├── left:
+        │   │   │   @ TrueNode (location: (782...786))
+        │   │   ├── right:
+        │   │   │   @ TrueNode (location: (790...794))
+        │   │   ├── operator_loc: (787...789) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (779...781) = "=>"
+        ├── @ MatchRequiredNode (location: (795...816))
+        │   ├── value:
+        │   │   @ CallNode (location: (795...798))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (795...798) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (802...816))
+        │   │   ├── left:
+        │   │   │   @ FalseNode (location: (802...807))
+        │   │   ├── right:
+        │   │   │   @ FalseNode (location: (811...816))
+        │   │   ├── operator_loc: (808...810) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (799...801) = "=>"
+        ├── @ MatchRequiredNode (location: (817...844))
+        │   ├── value:
+        │   │   @ CallNode (location: (817...820))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (817...820) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (824...844))
+        │   │   ├── left:
+        │   │   │   @ SourceFileNode (location: (824...832))
+        │   │   │   └── filepath: "patterns.txt"
+        │   │   ├── right:
+        │   │   │   @ SourceFileNode (location: (836...844))
+        │   │   │   └── filepath: "patterns.txt"
+        │   │   ├── operator_loc: (833...835) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (821...823) = "=>"
+        ├── @ MatchRequiredNode (location: (845...872))
+        │   ├── value:
+        │   │   @ CallNode (location: (845...848))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (845...848) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (852...872))
+        │   │   ├── left:
+        │   │   │   @ SourceLineNode (location: (852...860))
+        │   │   ├── right:
+        │   │   │   @ SourceLineNode (location: (864...872))
+        │   │   ├── operator_loc: (861...863) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (849...851) = "=>"
+        ├── @ MatchRequiredNode (location: (873...908))
+        │   ├── value:
+        │   │   @ CallNode (location: (873...876))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (873...876) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (880...908))
+        │   │   ├── left:
+        │   │   │   @ SourceEncodingNode (location: (880...892))
+        │   │   ├── right:
+        │   │   │   @ SourceEncodingNode (location: (896...908))
+        │   │   ├── operator_loc: (893...895) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (877...879) = "=>"
+        ├── @ MatchRequiredNode (location: (909...940))
+        │   ├── value:
+        │   │   @ CallNode (location: (909...912))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (909...912) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RangeNode (location: (916...940))
+        │   │   ├── left:
+        │   │   │   @ LambdaNode (location: (916...926))
+        │   │   │   ├── locals: []
+        │   │   │   ├── operator_loc: (916...918) = "->"
+        │   │   │   ├── opening_loc: (919...920) = "{"
+        │   │   │   ├── closing_loc: (925...926) = "}"
+        │   │   │   ├── parameters: ∅
+        │   │   │   └── body:
+        │   │   │       @ StatementsNode (location: (921...924))
+        │   │   │       └── body: (length: 1)
+        │   │   │           └── @ LocalVariableReadNode (location: (921...924))
+        │   │   │               ├── name: :bar
+        │   │   │               └── depth: 1
+        │   │   ├── right:
+        │   │   │   @ LambdaNode (location: (930...940))
+        │   │   │   ├── locals: []
+        │   │   │   ├── operator_loc: (930...932) = "->"
+        │   │   │   ├── opening_loc: (933...934) = "{"
+        │   │   │   ├── closing_loc: (939...940) = "}"
+        │   │   │   ├── parameters: ∅
+        │   │   │   └── body:
+        │   │   │       @ StatementsNode (location: (935...938))
+        │   │   │       └── body: (length: 1)
+        │   │   │           └── @ LocalVariableReadNode (location: (935...938))
+        │   │   │               ├── name: :bar
+        │   │   │               └── depth: 1
+        │   │   ├── operator_loc: (927...929) = ".."
+        │   │   └── flags: 
+        │   └── operator_loc: (913...915) = "=>"
+        ├── @ MatchRequiredNode (location: (942...953))
+        │   ├── value:
+        │   │   @ CallNode (location: (942...945))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (942...945) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ PinnedVariableNode (location: (949...953))
+        │   │   ├── variable:
+        │   │   │   @ LocalVariableReadNode (location: (950...953))
+        │   │   │   ├── name: :bar
+        │   │   │   └── depth: 0
+        │   │   └── operator_loc: (949...950) = "^"
+        │   └── operator_loc: (946...948) = "=>"
+        ├── @ MatchRequiredNode (location: (954...966))
+        │   ├── value:
+        │   │   @ CallNode (location: (954...957))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (954...957) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ PinnedVariableNode (location: (961...966))
+        │   │   ├── variable:
+        │   │   │   @ InstanceVariableReadNode (location: (962...966))
+        │   │   │   └── name: :@bar
+        │   │   └── operator_loc: (961...962) = "^"
+        │   └── operator_loc: (958...960) = "=>"
+        ├── @ MatchRequiredNode (location: (967...980))
+        │   ├── value:
+        │   │   @ CallNode (location: (967...970))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (967...970) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ PinnedVariableNode (location: (974...980))
+        │   │   ├── variable:
+        │   │   │   @ ClassVariableReadNode (location: (975...980))
+        │   │   │   └── name: :@@bar
+        │   │   └── operator_loc: (974...975) = "^"
+        │   └── operator_loc: (971...973) = "=>"
+        ├── @ MatchRequiredNode (location: (981...993))
+        │   ├── value:
+        │   │   @ CallNode (location: (981...984))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (981...984) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ PinnedVariableNode (location: (988...993))
+        │   │   ├── variable:
+        │   │   │   @ GlobalVariableReadNode (location: (989...993))
+        │   │   │   └── name: :$bar
+        │   │   └── operator_loc: (988...989) = "^"
+        │   └── operator_loc: (985...987) = "=>"
+        ├── @ MatchRequiredNode (location: (995...1006))
+        │   ├── value:
+        │   │   @ CallNode (location: (995...998))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (995...998) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ PinnedExpressionNode (location: (1002...1006))
+        │   │   ├── expression:
+        │   │   │   @ IntegerNode (location: (1004...1005))
+        │   │   ├── operator_loc: (1002...1003) = "^"
+        │   │   ├── lparen_loc: (1003...1004) = "("
+        │   │   └── rparen_loc: (1005...1006) = ")"
+        │   └── operator_loc: (999...1001) = "=>"
+        ├── @ MatchRequiredNode (location: (1007...1020))
+        │   ├── value:
+        │   │   @ CallNode (location: (1007...1010))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1007...1010) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ PinnedExpressionNode (location: (1014...1020))
+        │   │   ├── expression:
+        │   │   │   @ NilNode (location: (1016...1019))
+        │   │   ├── operator_loc: (1014...1015) = "^"
+        │   │   ├── lparen_loc: (1015...1016) = "("
+        │   │   └── rparen_loc: (1019...1020) = ")"
+        │   └── operator_loc: (1011...1013) = "=>"
+        ├── @ MatchRequiredNode (location: (1021...1044))
+        │   ├── value:
+        │   │   @ CallNode (location: (1021...1024))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1021...1024) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ PinnedExpressionNode (location: (1028...1044))
+        │   │   ├── expression:
+        │   │   │   @ CallNode (location: (1030...1043))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ StringNode (location: (1030...1035))
+        │   │   │   │   ├── opening_loc: (1030...1031) = "\""
+        │   │   │   │   ├── content_loc: (1031...1034) = "bar"
+        │   │   │   │   ├── closing_loc: (1034...1035) = "\""
+        │   │   │   │   └── unescaped: "bar"
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (1036...1037) = "+"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (1038...1043))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ StringNode (location: (1038...1043))
+        │   │   │   │           ├── opening_loc: (1038...1039) = "\""
+        │   │   │   │           ├── content_loc: (1039...1042) = "baz"
+        │   │   │   │           ├── closing_loc: (1042...1043) = "\""
+        │   │   │   │           └── unescaped: "baz"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "+"
+        │   │   ├── operator_loc: (1028...1029) = "^"
+        │   │   ├── lparen_loc: (1029...1030) = "("
+        │   │   └── rparen_loc: (1043...1044) = ")"
+        │   └── operator_loc: (1025...1027) = "=>"
+        ├── @ MatchRequiredNode (location: (1046...1056))
+        │   ├── value:
+        │   │   @ CallNode (location: (1046...1049))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1046...1049) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ConstantReadNode (location: (1053...1056))
+        │   │   └── name: :Foo
+        │   └── operator_loc: (1050...1052) = "=>"
+        ├── @ MatchRequiredNode (location: (1057...1077))
+        │   ├── value:
+        │   │   @ CallNode (location: (1057...1060))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1057...1060) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ConstantPathNode (location: (1064...1077))
+        │   │   ├── parent:
+        │   │   │   @ ConstantPathNode (location: (1064...1072))
+        │   │   │   ├── parent:
+        │   │   │   │   @ ConstantReadNode (location: (1064...1067))
+        │   │   │   │   └── name: :Foo
+        │   │   │   ├── child:
+        │   │   │   │   @ ConstantReadNode (location: (1069...1072))
+        │   │   │   │   └── name: :Bar
+        │   │   │   └── delimiter_loc: (1067...1069) = "::"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (1074...1077))
+        │   │   │   └── name: :Baz
+        │   │   └── delimiter_loc: (1072...1074) = "::"
+        │   └── operator_loc: (1061...1063) = "=>"
+        ├── @ MatchRequiredNode (location: (1078...1090))
+        │   ├── value:
+        │   │   @ CallNode (location: (1078...1081))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1078...1081) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ConstantPathNode (location: (1085...1090))
+        │   │   ├── parent: ∅
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (1087...1090))
+        │   │   │   └── name: :Foo
+        │   │   └── delimiter_loc: (1085...1087) = "::"
+        │   └── operator_loc: (1082...1084) = "=>"
+        ├── @ MatchRequiredNode (location: (1091...1113))
+        │   ├── value:
+        │   │   @ CallNode (location: (1091...1094))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1091...1094) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ConstantPathNode (location: (1098...1113))
+        │   │   ├── parent:
+        │   │   │   @ ConstantPathNode (location: (1098...1108))
+        │   │   │   ├── parent:
+        │   │   │   │   @ ConstantPathNode (location: (1098...1103))
+        │   │   │   │   ├── parent: ∅
+        │   │   │   │   ├── child:
+        │   │   │   │   │   @ ConstantReadNode (location: (1100...1103))
+        │   │   │   │   │   └── name: :Foo
+        │   │   │   │   └── delimiter_loc: (1098...1100) = "::"
+        │   │   │   ├── child:
+        │   │   │   │   @ ConstantReadNode (location: (1105...1108))
+        │   │   │   │   └── name: :Bar
+        │   │   │   └── delimiter_loc: (1103...1105) = "::"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (1110...1113))
+        │   │   │   └── name: :Baz
+        │   │   └── delimiter_loc: (1108...1110) = "::"
+        │   └── operator_loc: (1095...1097) = "=>"
+        ├── @ MatchRequiredNode (location: (1115...1127))
+        │   ├── value:
+        │   │   @ CallNode (location: (1115...1118))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1115...1118) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1122...1127))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1122...1125))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1125...1126) = "("
+        │   │   └── closing_loc: (1126...1127) = ")"
+        │   └── operator_loc: (1119...1121) = "=>"
+        ├── @ MatchRequiredNode (location: (1128...1141))
+        │   ├── value:
+        │   │   @ CallNode (location: (1128...1131))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1128...1131) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1135...1141))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1135...1138))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ IntegerNode (location: (1139...1140))
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1138...1139) = "("
+        │   │   └── closing_loc: (1140...1141) = ")"
+        │   └── operator_loc: (1132...1134) = "=>"
+        ├── @ MatchRequiredNode (location: (1142...1161))
+        │   ├── value:
+        │   │   @ CallNode (location: (1142...1145))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1142...1145) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1149...1161))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1149...1152))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 3)
+        │   │   │   ├── @ IntegerNode (location: (1153...1154))
+        │   │   │   ├── @ IntegerNode (location: (1156...1157))
+        │   │   │   └── @ IntegerNode (location: (1159...1160))
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1152...1153) = "("
+        │   │   └── closing_loc: (1160...1161) = ")"
+        │   └── operator_loc: (1146...1148) = "=>"
+        ├── @ MatchRequiredNode (location: (1162...1177))
+        │   ├── value:
+        │   │   @ CallNode (location: (1162...1165))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1162...1165) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1169...1177))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1169...1172))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1173...1176))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1172...1173) = "("
+        │   │   └── closing_loc: (1176...1177) = ")"
+        │   └── operator_loc: (1166...1168) = "=>"
+        ├── @ MatchRequiredNode (location: (1178...1199))
+        │   ├── value:
+        │   │   @ CallNode (location: (1178...1181))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1178...1181) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1185...1199))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1185...1188))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1189...1193))
+        │   │   │   ├── operator_loc: (1189...1190) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1190...1193))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1195...1198))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: (1188...1189) = "("
+        │   │   └── closing_loc: (1198...1199) = ")"
+        │   └── operator_loc: (1182...1184) = "=>"
+        ├── @ MatchRequiredNode (location: (1200...1221))
+        │   ├── value:
+        │   │   @ CallNode (location: (1200...1203))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1200...1203) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1207...1221))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1207...1210))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1211...1214))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1216...1220))
+        │   │   │   ├── operator_loc: (1216...1217) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1217...1220))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1210...1211) = "("
+        │   │   └── closing_loc: (1220...1221) = ")"
+        │   └── operator_loc: (1204...1206) = "=>"
+        ├── @ MatchRequiredNode (location: (1222...1249))
+        │   ├── value:
+        │   │   @ CallNode (location: (1222...1225))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1222...1225) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ FindPatternNode (location: (1229...1249))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1229...1232))
+        │   │   │   └── name: :Foo
+        │   │   ├── left:
+        │   │   │   @ SplatNode (location: (1233...1237))
+        │   │   │   ├── operator_loc: (1233...1234) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1234...1237))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1239...1242))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── right:
+        │   │   │   @ SplatNode (location: (1244...1248))
+        │   │   │   ├── operator_loc: (1244...1245) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1245...1248))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: (1232...1233) = "("
+        │   │   └── closing_loc: (1248...1249) = ")"
+        │   └── operator_loc: (1226...1228) = "=>"
+        ├── @ MatchRequiredNode (location: (1251...1263))
+        │   ├── value:
+        │   │   @ CallNode (location: (1251...1254))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1251...1254) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1258...1263))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1258...1261))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1261...1262) = "["
+        │   │   └── closing_loc: (1262...1263) = "]"
+        │   └── operator_loc: (1255...1257) = "=>"
+        ├── @ MatchRequiredNode (location: (1264...1277))
+        │   ├── value:
+        │   │   @ CallNode (location: (1264...1267))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1264...1267) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1271...1277))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1271...1274))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ IntegerNode (location: (1275...1276))
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1274...1275) = "["
+        │   │   └── closing_loc: (1276...1277) = "]"
+        │   └── operator_loc: (1268...1270) = "=>"
+        ├── @ MatchRequiredNode (location: (1278...1297))
+        │   ├── value:
+        │   │   @ CallNode (location: (1278...1281))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1278...1281) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1285...1297))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1285...1288))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 3)
+        │   │   │   ├── @ IntegerNode (location: (1289...1290))
+        │   │   │   ├── @ IntegerNode (location: (1292...1293))
+        │   │   │   └── @ IntegerNode (location: (1295...1296))
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1288...1289) = "["
+        │   │   └── closing_loc: (1296...1297) = "]"
+        │   └── operator_loc: (1282...1284) = "=>"
+        ├── @ MatchRequiredNode (location: (1298...1315))
+        │   ├── value:
+        │   │   @ CallNode (location: (1298...1301))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1298...1301) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1305...1315))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1305...1308))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ ArrayPatternNode (location: (1309...1314))
+        │   │   │       ├── constant:
+        │   │   │       │   @ ConstantReadNode (location: (1309...1312))
+        │   │   │       │   └── name: :Foo
+        │   │   │       ├── requireds: (length: 0)
+        │   │   │       ├── rest: ∅
+        │   │   │       ├── posts: (length: 0)
+        │   │   │       ├── opening_loc: (1312...1313) = "["
+        │   │   │       └── closing_loc: (1313...1314) = "]"
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1308...1309) = "["
+        │   │   └── closing_loc: (1314...1315) = "]"
+        │   └── operator_loc: (1302...1304) = "=>"
+        ├── @ MatchRequiredNode (location: (1316...1331))
+        │   ├── value:
+        │   │   @ CallNode (location: (1316...1319))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1316...1319) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1323...1331))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1323...1326))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1327...1330))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1326...1327) = "["
+        │   │   └── closing_loc: (1330...1331) = "]"
+        │   └── operator_loc: (1320...1322) = "=>"
+        ├── @ MatchRequiredNode (location: (1332...1353))
+        │   ├── value:
+        │   │   @ CallNode (location: (1332...1335))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1332...1335) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1339...1353))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1339...1342))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1343...1347))
+        │   │   │   ├── operator_loc: (1343...1344) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1344...1347))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1349...1352))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: (1342...1343) = "["
+        │   │   └── closing_loc: (1352...1353) = "]"
+        │   └── operator_loc: (1336...1338) = "=>"
+        ├── @ MatchRequiredNode (location: (1354...1375))
+        │   ├── value:
+        │   │   @ CallNode (location: (1354...1357))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1354...1357) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1361...1375))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1361...1364))
+        │   │   │   └── name: :Foo
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1365...1368))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1370...1374))
+        │   │   │   ├── operator_loc: (1370...1371) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1371...1374))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1364...1365) = "["
+        │   │   └── closing_loc: (1374...1375) = "]"
+        │   └── operator_loc: (1358...1360) = "=>"
+        ├── @ MatchRequiredNode (location: (1376...1403))
+        │   ├── value:
+        │   │   @ CallNode (location: (1376...1379))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1376...1379) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ FindPatternNode (location: (1383...1403))
+        │   │   ├── constant:
+        │   │   │   @ ConstantReadNode (location: (1383...1386))
+        │   │   │   └── name: :Foo
+        │   │   ├── left:
+        │   │   │   @ SplatNode (location: (1387...1391))
+        │   │   │   ├── operator_loc: (1387...1388) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1388...1391))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1393...1396))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── right:
+        │   │   │   @ SplatNode (location: (1398...1402))
+        │   │   │   ├── operator_loc: (1398...1399) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1399...1402))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: (1386...1387) = "["
+        │   │   └── closing_loc: (1402...1403) = "]"
+        │   └── operator_loc: (1380...1382) = "=>"
+        ├── @ MatchRequiredNode (location: (1405...1416))
+        │   ├── value:
+        │   │   @ CallNode (location: (1405...1408))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1405...1408) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1412...1416))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1412...1416))
+        │   │   │   ├── operator_loc: (1412...1413) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1413...1416))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (1409...1411) = "=>"
+        ├── @ MatchRequiredNode (location: (1417...1438))
+        │   ├── value:
+        │   │   @ CallNode (location: (1417...1420))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1417...1420) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1424...1438))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1424...1428))
+        │   │   │   ├── operator_loc: (1424...1425) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1425...1428))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 2)
+        │   │   │   ├── @ LocalVariableTargetNode (location: (1430...1433))
+        │   │   │   │   ├── name: :baz
+        │   │   │   │   └── depth: 0
+        │   │   │   └── @ LocalVariableTargetNode (location: (1435...1438))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (1421...1423) = "=>"
+        ├── @ MatchRequiredNode (location: (1439...1460))
+        │   ├── value:
+        │   │   @ CallNode (location: (1439...1442))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1439...1442) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1446...1460))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1446...1449))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1451...1455))
+        │   │   │   ├── operator_loc: (1451...1452) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1452...1455))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1457...1460))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (1443...1445) = "=>"
+        ├── @ MatchRequiredNode (location: (1461...1482))
+        │   ├── value:
+        │   │   @ CallNode (location: (1461...1464))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1461...1464) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1468...1482))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 2)
+        │   │   │   ├── @ LocalVariableTargetNode (location: (1468...1471))
+        │   │   │   │   ├── name: :bar
+        │   │   │   │   └── depth: 0
+        │   │   │   └── @ LocalVariableTargetNode (location: (1473...1476))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1478...1482))
+        │   │   │   ├── operator_loc: (1478...1479) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1479...1482))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (1465...1467) = "=>"
+        ├── @ MatchRequiredNode (location: (1483...1505))
+        │   ├── value:
+        │   │   @ CallNode (location: (1483...1486))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1483...1486) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ FindPatternNode (location: (1490...1505))
+        │   │   ├── constant: ∅
+        │   │   ├── left:
+        │   │   │   @ SplatNode (location: (1490...1494))
+        │   │   │   ├── operator_loc: (1490...1491) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1491...1494))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1496...1499))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── right:
+        │   │   │   @ SplatNode (location: (1501...1505))
+        │   │   │   ├── operator_loc: (1501...1502) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1502...1505))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (1487...1489) = "=>"
+        ├── @ MatchRequiredNode (location: (1507...1516))
+        │   ├── value:
+        │   │   @ CallNode (location: (1507...1510))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1507...1510) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1514...1516))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1514...1515) = "["
+        │   │   └── closing_loc: (1515...1516) = "]"
+        │   └── operator_loc: (1511...1513) = "=>"
+        ├── @ MatchRequiredNode (location: (1517...1534))
+        │   ├── value:
+        │   │   @ CallNode (location: (1517...1520))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1517...1520) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1524...1534))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ ArrayPatternNode (location: (1525...1533))
+        │   │   │       ├── constant: ∅
+        │   │   │       ├── requireds: (length: 1)
+        │   │   │       │   └── @ ArrayPatternNode (location: (1526...1532))
+        │   │   │       │       ├── constant: ∅
+        │   │   │       │       ├── requireds: (length: 1)
+        │   │   │       │       │   └── @ ArrayPatternNode (location: (1527...1531))
+        │   │   │       │       │       ├── constant: ∅
+        │   │   │       │       │       ├── requireds: (length: 1)
+        │   │   │       │       │       │   └── @ ArrayPatternNode (location: (1528...1530))
+        │   │   │       │       │       │       ├── constant: ∅
+        │   │   │       │       │       │       ├── requireds: (length: 0)
+        │   │   │       │       │       │       ├── rest: ∅
+        │   │   │       │       │       │       ├── posts: (length: 0)
+        │   │   │       │       │       │       ├── opening_loc: (1528...1529) = "["
+        │   │   │       │       │       │       └── closing_loc: (1529...1530) = "]"
+        │   │   │       │       │       ├── rest: ∅
+        │   │   │       │       │       ├── posts: (length: 0)
+        │   │   │       │       │       ├── opening_loc: (1527...1528) = "["
+        │   │   │       │       │       └── closing_loc: (1530...1531) = "]"
+        │   │   │       │       ├── rest: ∅
+        │   │   │       │       ├── posts: (length: 0)
+        │   │   │       │       ├── opening_loc: (1526...1527) = "["
+        │   │   │       │       └── closing_loc: (1531...1532) = "]"
+        │   │   │       ├── rest: ∅
+        │   │   │       ├── posts: (length: 0)
+        │   │   │       ├── opening_loc: (1525...1526) = "["
+        │   │   │       └── closing_loc: (1532...1533) = "]"
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1524...1525) = "["
+        │   │   └── closing_loc: (1533...1534) = "]"
+        │   └── operator_loc: (1521...1523) = "=>"
+        ├── @ MatchRequiredNode (location: (1536...1549))
+        │   ├── value:
+        │   │   @ CallNode (location: (1536...1539))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1536...1539) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1543...1549))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1544...1548))
+        │   │   │   ├── operator_loc: (1544...1545) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1545...1548))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1543...1544) = "["
+        │   │   └── closing_loc: (1548...1549) = "]"
+        │   └── operator_loc: (1540...1542) = "=>"
+        ├── @ MatchRequiredNode (location: (1550...1573))
+        │   ├── value:
+        │   │   @ CallNode (location: (1550...1553))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1550...1553) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1557...1573))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1558...1562))
+        │   │   │   ├── operator_loc: (1558...1559) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1559...1562))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 2)
+        │   │   │   ├── @ LocalVariableTargetNode (location: (1564...1567))
+        │   │   │   │   ├── name: :baz
+        │   │   │   │   └── depth: 0
+        │   │   │   └── @ LocalVariableTargetNode (location: (1569...1572))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: (1557...1558) = "["
+        │   │   └── closing_loc: (1572...1573) = "]"
+        │   └── operator_loc: (1554...1556) = "=>"
+        ├── @ MatchRequiredNode (location: (1574...1597))
+        │   ├── value:
+        │   │   @ CallNode (location: (1574...1577))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1574...1577) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1581...1597))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1582...1585))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1587...1591))
+        │   │   │   ├── operator_loc: (1587...1588) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1588...1591))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1593...1596))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: (1581...1582) = "["
+        │   │   └── closing_loc: (1596...1597) = "]"
+        │   └── operator_loc: (1578...1580) = "=>"
+        ├── @ MatchRequiredNode (location: (1598...1621))
+        │   ├── value:
+        │   │   @ CallNode (location: (1598...1601))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1598...1601) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (1605...1621))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 2)
+        │   │   │   ├── @ LocalVariableTargetNode (location: (1606...1609))
+        │   │   │   │   ├── name: :bar
+        │   │   │   │   └── depth: 0
+        │   │   │   └── @ LocalVariableTargetNode (location: (1611...1614))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (1616...1620))
+        │   │   │   ├── operator_loc: (1616...1617) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1617...1620))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (1605...1606) = "["
+        │   │   └── closing_loc: (1620...1621) = "]"
+        │   └── operator_loc: (1602...1604) = "=>"
+        ├── @ MatchRequiredNode (location: (1622...1646))
+        │   ├── value:
+        │   │   @ CallNode (location: (1622...1625))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1622...1625) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ FindPatternNode (location: (1629...1646))
+        │   │   ├── constant: ∅
+        │   │   ├── left:
+        │   │   │   @ SplatNode (location: (1630...1634))
+        │   │   │   ├── operator_loc: (1630...1631) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1631...1634))
+        │   │   │       ├── name: :bar
+        │   │   │       └── depth: 0
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (1636...1639))
+        │   │   │       ├── name: :baz
+        │   │   │       └── depth: 0
+        │   │   ├── right:
+        │   │   │   @ SplatNode (location: (1641...1645))
+        │   │   │   ├── operator_loc: (1641...1642) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (1642...1645))
+        │   │   │       ├── name: :qux
+        │   │   │       └── depth: 0
+        │   │   ├── opening_loc: (1629...1630) = "["
+        │   │   └── closing_loc: (1645...1646) = "]"
+        │   └── operator_loc: (1626...1628) = "=>"
+        ├── @ MatchPredicateNode (location: (1648...1658))
+        │   ├── value:
+        │   │   @ CallNode (location: (1648...1651))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1648...1651) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ LocalVariableTargetNode (location: (1655...1658))
+        │   │   ├── name: :bar
+        │   │   └── depth: 0
+        │   └── operator_loc: (1652...1654) = "in"
+        ├── @ MatchPredicateNode (location: (1659...1667))
+        │   ├── value:
+        │   │   @ CallNode (location: (1659...1662))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1659...1662) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ IntegerNode (location: (1666...1667))
+        │   └── operator_loc: (1663...1665) = "in"
+        ├── @ MatchPredicateNode (location: (1668...1678))
+        │   ├── value:
+        │   │   @ CallNode (location: (1668...1671))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1668...1671) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ FloatNode (location: (1675...1678))
+        │   └── operator_loc: (1672...1674) = "in"
+        ├── @ MatchPredicateNode (location: (1679...1688))
+        │   ├── value:
+        │   │   @ CallNode (location: (1679...1682))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1679...1682) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ImaginaryNode (location: (1686...1688))
+        │   │   └── numeric:
+        │   │       @ IntegerNode (location: (1686...1687))
+        │   └── operator_loc: (1683...1685) = "in"
+        ├── @ MatchPredicateNode (location: (1689...1698))
+        │   ├── value:
+        │   │   @ CallNode (location: (1689...1692))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1689...1692) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RationalNode (location: (1696...1698))
+        │   │   └── numeric:
+        │   │       @ IntegerNode (location: (1696...1697))
+        │   └── operator_loc: (1693...1695) = "in"
+        ├── @ MatchPredicateNode (location: (1699...1710))
+        │   ├── value:
+        │   │   @ CallNode (location: (1699...1702))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1699...1702) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SymbolNode (location: (1706...1710))
+        │   │   ├── opening_loc: (1706...1707) = ":"
+        │   │   ├── value_loc: (1707...1710) = "foo"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (1703...1705) = "in"
+        ├── @ MatchPredicateNode (location: (1711...1725))
+        │   ├── value:
+        │   │   @ CallNode (location: (1711...1714))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1711...1714) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SymbolNode (location: (1718...1725))
+        │   │   ├── opening_loc: (1718...1721) = "%s["
+        │   │   ├── value_loc: (1721...1724) = "foo"
+        │   │   ├── closing_loc: (1724...1725) = "]"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (1715...1717) = "in"
+        ├── @ MatchPredicateNode (location: (1726...1739))
+        │   ├── value:
+        │   │   @ CallNode (location: (1726...1729))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1726...1729) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SymbolNode (location: (1733...1739))
+        │   │   ├── opening_loc: (1733...1735) = ":\""
+        │   │   ├── value_loc: (1735...1738) = "foo"
+        │   │   ├── closing_loc: (1738...1739) = "\""
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (1730...1732) = "in"
+        ├── @ MatchPredicateNode (location: (1740...1752))
+        │   ├── value:
+        │   │   @ CallNode (location: (1740...1743))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1740...1743) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ RegularExpressionNode (location: (1747...1752))
+        │   │   ├── opening_loc: (1747...1748) = "/"
+        │   │   ├── content_loc: (1748...1751) = "foo"
+        │   │   ├── closing_loc: (1751...1752) = "/"
+        │   │   ├── unescaped: "foo"
+        │   │   └── flags: 
+        │   └── operator_loc: (1744...1746) = "in"
+        ├── @ MatchPredicateNode (location: (1753...1765))
+        │   ├── value:
+        │   │   @ CallNode (location: (1753...1756))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1753...1756) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ XStringNode (location: (1760...1765))
+        │   │   ├── opening_loc: (1760...1761) = "`"
+        │   │   ├── content_loc: (1761...1764) = "foo"
+        │   │   ├── closing_loc: (1764...1765) = "`"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (1757...1759) = "in"
+        ├── @ MatchPredicateNode (location: (1766...1780))
+        │   ├── value:
+        │   │   @ CallNode (location: (1766...1769))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1766...1769) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ XStringNode (location: (1773...1780))
+        │   │   ├── opening_loc: (1773...1776) = "%x["
+        │   │   ├── content_loc: (1776...1779) = "foo"
+        │   │   ├── closing_loc: (1779...1780) = "]"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (1770...1772) = "in"
+        ├── @ MatchPredicateNode (location: (1781...1795))
+        │   ├── value:
+        │   │   @ CallNode (location: (1781...1784))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1781...1784) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayNode (location: (1788...1795))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ SymbolNode (location: (1791...1794))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── value_loc: (1791...1794) = "foo"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "foo"
+        │   │   ├── opening_loc: (1788...1791) = "%i["
+        │   │   └── closing_loc: (1794...1795) = "]"
+        │   └── operator_loc: (1785...1787) = "in"
+        ├── @ MatchPredicateNode (location: (1796...1810))
+        │   ├── value:
+        │   │   @ CallNode (location: (1796...1799))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1796...1799) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayNode (location: (1803...1810))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ SymbolNode (location: (1806...1809))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── value_loc: (1806...1809) = "foo"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "foo"
+        │   │   ├── opening_loc: (1803...1806) = "%I["
+        │   │   └── closing_loc: (1809...1810) = "]"
+        │   └── operator_loc: (1800...1802) = "in"
+        ├── @ MatchPredicateNode (location: (1811...1825))
+        │   ├── value:
+        │   │   @ CallNode (location: (1811...1814))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1811...1814) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayNode (location: (1818...1825))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ StringNode (location: (1821...1824))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (1821...1824) = "foo"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "foo"
+        │   │   ├── opening_loc: (1818...1821) = "%w["
+        │   │   └── closing_loc: (1824...1825) = "]"
+        │   └── operator_loc: (1815...1817) = "in"
+        ├── @ MatchPredicateNode (location: (1826...1840))
+        │   ├── value:
+        │   │   @ CallNode (location: (1826...1829))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1826...1829) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ ArrayNode (location: (1833...1840))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ StringNode (location: (1836...1839))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (1836...1839) = "foo"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "foo"
+        │   │   ├── opening_loc: (1833...1836) = "%W["
+        │   │   └── closing_loc: (1839...1840) = "]"
+        │   └── operator_loc: (1830...1832) = "in"
+        ├── @ MatchPredicateNode (location: (1841...1855))
+        │   ├── value:
+        │   │   @ CallNode (location: (1841...1844))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1841...1844) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ StringNode (location: (1848...1855))
+        │   │   ├── opening_loc: (1848...1851) = "%q["
+        │   │   ├── content_loc: (1851...1854) = "foo"
+        │   │   ├── closing_loc: (1854...1855) = "]"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (1845...1847) = "in"
+        ├── @ MatchPredicateNode (location: (1856...1870))
+        │   ├── value:
+        │   │   @ CallNode (location: (1856...1859))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1856...1859) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ StringNode (location: (1863...1870))
+        │   │   ├── opening_loc: (1863...1866) = "%Q["
+        │   │   ├── content_loc: (1866...1869) = "foo"
+        │   │   ├── closing_loc: (1869...1870) = "]"
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (1860...1862) = "in"
+        ├── @ MatchPredicateNode (location: (1871...1883))
+        │   ├── value:
+        │   │   @ CallNode (location: (1871...1874))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1871...1874) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ StringNode (location: (1878...1883))
+        │   │   ├── opening_loc: (1878...1879) = "\""
+        │   │   ├── content_loc: (1879...1882) = "foo"
+        │   │   ├── closing_loc: (1882...1883) = "\""
+        │   │   └── unescaped: "foo"
+        │   └── operator_loc: (1875...1877) = "in"
+        ├── @ MatchPredicateNode (location: (1884...1894))
+        │   ├── value:
+        │   │   @ CallNode (location: (1884...1887))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1884...1887) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ NilNode (location: (1891...1894))
+        │   └── operator_loc: (1888...1890) = "in"
+        ├── @ MatchPredicateNode (location: (1895...1906))
+        │   ├── value:
+        │   │   @ CallNode (location: (1895...1898))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1895...1898) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SelfNode (location: (1902...1906))
+        │   └── operator_loc: (1899...1901) = "in"
+        ├── @ MatchPredicateNode (location: (1907...1918))
+        │   ├── value:
+        │   │   @ CallNode (location: (1907...1910))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1907...1910) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ TrueNode (location: (1914...1918))
+        │   └── operator_loc: (1911...1913) = "in"
+        ├── @ MatchPredicateNode (location: (1919...1931))
+        │   ├── value:
+        │   │   @ CallNode (location: (1919...1922))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1919...1922) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ FalseNode (location: (1926...1931))
+        │   └── operator_loc: (1923...1925) = "in"
+        ├── @ MatchPredicateNode (location: (1932...1947))
+        │   ├── value:
+        │   │   @ CallNode (location: (1932...1935))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1932...1935) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SourceFileNode (location: (1939...1947))
+        │   │   └── filepath: "patterns.txt"
+        │   └── operator_loc: (1936...1938) = "in"
+        ├── @ MatchPredicateNode (location: (1948...1963))
+        │   ├── value:
+        │   │   @ CallNode (location: (1948...1951))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1948...1951) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SourceLineNode (location: (1955...1963))
+        │   └── operator_loc: (1952...1954) = "in"
+        ├── @ MatchPredicateNode (location: (1964...1983))
+        │   ├── value:
+        │   │   @ CallNode (location: (1964...1967))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1964...1967) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ SourceEncodingNode (location: (1971...1983))
+        │   └── operator_loc: (1968...1970) = "in"
+        ├── @ MatchPredicateNode (location: (1984...2001))
+        │   ├── value:
+        │   │   @ CallNode (location: (1984...1987))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1984...1987) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── pattern:
+        │   │   @ LambdaNode (location: (1991...2001))
+        │   │   ├── locals: []
+        │   │   ├── operator_loc: (1991...1993) = "->"
+        │   │   ├── opening_loc: (1994...1995) = "{"
+        │   │   ├── closing_loc: (2000...2001) = "}"
+        │   │   ├── parameters: ∅
+        │   │   └── body:
+        │   │       @ StatementsNode (location: (1996...1999))
+        │   │       └── body: (length: 1)
+        │   │           └── @ LocalVariableReadNode (location: (1996...1999))
+        │   │               ├── name: :bar
+        │   │               └── depth: 1
+        │   └── operator_loc: (1988...1990) = "in"
+        ├── @ CaseNode (location: (2003...2028))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2008...2011))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2008...2011) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2013...2024))
+        │   │       ├── pattern:
+        │   │       │   @ LocalVariableTargetNode (location: (2016...2019))
+        │   │       │   ├── name: :bar
+        │   │       │   └── depth: 0
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2013...2015) = "in"
+        │   │       └── then_loc: (2020...2024) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2003...2007) = "case"
+        │   └── end_keyword_loc: (2025...2028) = "end"
+        ├── @ CaseNode (location: (2029...2052))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2034...2037))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2034...2037) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2039...2048))
+        │   │       ├── pattern:
+        │   │       │   @ IntegerNode (location: (2042...2043))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2039...2041) = "in"
+        │   │       └── then_loc: (2044...2048) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2029...2033) = "case"
+        │   └── end_keyword_loc: (2049...2052) = "end"
+        ├── @ CaseNode (location: (2053...2078))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2058...2061))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2058...2061) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2063...2074))
+        │   │       ├── pattern:
+        │   │       │   @ FloatNode (location: (2066...2069))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2063...2065) = "in"
+        │   │       └── then_loc: (2070...2074) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2053...2057) = "case"
+        │   └── end_keyword_loc: (2075...2078) = "end"
+        ├── @ CaseNode (location: (2079...2103))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2084...2087))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2084...2087) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2089...2099))
+        │   │       ├── pattern:
+        │   │       │   @ ImaginaryNode (location: (2092...2094))
+        │   │       │   └── numeric:
+        │   │       │       @ IntegerNode (location: (2092...2093))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2089...2091) = "in"
+        │   │       └── then_loc: (2095...2099) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2079...2083) = "case"
+        │   └── end_keyword_loc: (2100...2103) = "end"
+        ├── @ CaseNode (location: (2104...2128))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2109...2112))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2109...2112) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2114...2124))
+        │   │       ├── pattern:
+        │   │       │   @ RationalNode (location: (2117...2119))
+        │   │       │   └── numeric:
+        │   │       │       @ IntegerNode (location: (2117...2118))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2114...2116) = "in"
+        │   │       └── then_loc: (2120...2124) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2104...2108) = "case"
+        │   └── end_keyword_loc: (2125...2128) = "end"
+        ├── @ CaseNode (location: (2129...2155))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2134...2137))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2134...2137) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2139...2151))
+        │   │       ├── pattern:
+        │   │       │   @ SymbolNode (location: (2142...2146))
+        │   │       │   ├── opening_loc: (2142...2143) = ":"
+        │   │       │   ├── value_loc: (2143...2146) = "foo"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2139...2141) = "in"
+        │   │       └── then_loc: (2147...2151) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2129...2133) = "case"
+        │   └── end_keyword_loc: (2152...2155) = "end"
+        ├── @ CaseNode (location: (2156...2185))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2161...2164))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2161...2164) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2166...2181))
+        │   │       ├── pattern:
+        │   │       │   @ SymbolNode (location: (2169...2176))
+        │   │       │   ├── opening_loc: (2169...2172) = "%s["
+        │   │       │   ├── value_loc: (2172...2175) = "foo"
+        │   │       │   ├── closing_loc: (2175...2176) = "]"
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2166...2168) = "in"
+        │   │       └── then_loc: (2177...2181) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2156...2160) = "case"
+        │   └── end_keyword_loc: (2182...2185) = "end"
+        ├── @ CaseNode (location: (2186...2214))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2191...2194))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2191...2194) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2196...2210))
+        │   │       ├── pattern:
+        │   │       │   @ SymbolNode (location: (2199...2205))
+        │   │       │   ├── opening_loc: (2199...2201) = ":\""
+        │   │       │   ├── value_loc: (2201...2204) = "foo"
+        │   │       │   ├── closing_loc: (2204...2205) = "\""
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2196...2198) = "in"
+        │   │       └── then_loc: (2206...2210) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2186...2190) = "case"
+        │   └── end_keyword_loc: (2211...2214) = "end"
+        ├── @ CaseNode (location: (2215...2242))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2220...2223))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2220...2223) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2225...2238))
+        │   │       ├── pattern:
+        │   │       │   @ RegularExpressionNode (location: (2228...2233))
+        │   │       │   ├── opening_loc: (2228...2229) = "/"
+        │   │       │   ├── content_loc: (2229...2232) = "foo"
+        │   │       │   ├── closing_loc: (2232...2233) = "/"
+        │   │       │   ├── unescaped: "foo"
+        │   │       │   └── flags: 
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2225...2227) = "in"
+        │   │       └── then_loc: (2234...2238) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2215...2219) = "case"
+        │   └── end_keyword_loc: (2239...2242) = "end"
+        ├── @ CaseNode (location: (2243...2270))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2248...2251))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2248...2251) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2253...2266))
+        │   │       ├── pattern:
+        │   │       │   @ XStringNode (location: (2256...2261))
+        │   │       │   ├── opening_loc: (2256...2257) = "`"
+        │   │       │   ├── content_loc: (2257...2260) = "foo"
+        │   │       │   ├── closing_loc: (2260...2261) = "`"
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2253...2255) = "in"
+        │   │       └── then_loc: (2262...2266) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2243...2247) = "case"
+        │   └── end_keyword_loc: (2267...2270) = "end"
+        ├── @ CaseNode (location: (2271...2300))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2276...2279))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2276...2279) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2281...2296))
+        │   │       ├── pattern:
+        │   │       │   @ XStringNode (location: (2284...2291))
+        │   │       │   ├── opening_loc: (2284...2287) = "%x["
+        │   │       │   ├── content_loc: (2287...2290) = "foo"
+        │   │       │   ├── closing_loc: (2290...2291) = "]"
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2281...2283) = "in"
+        │   │       └── then_loc: (2292...2296) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2271...2275) = "case"
+        │   └── end_keyword_loc: (2297...2300) = "end"
+        ├── @ CaseNode (location: (2301...2330))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2306...2309))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2306...2309) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2311...2326))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayNode (location: (2314...2321))
+        │   │       │   ├── elements: (length: 1)
+        │   │       │   │   └── @ SymbolNode (location: (2317...2320))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── value_loc: (2317...2320) = "foo"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "foo"
+        │   │       │   ├── opening_loc: (2314...2317) = "%i["
+        │   │       │   └── closing_loc: (2320...2321) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2311...2313) = "in"
+        │   │       └── then_loc: (2322...2326) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2301...2305) = "case"
+        │   └── end_keyword_loc: (2327...2330) = "end"
+        ├── @ CaseNode (location: (2331...2360))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2336...2339))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2336...2339) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2341...2356))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayNode (location: (2344...2351))
+        │   │       │   ├── elements: (length: 1)
+        │   │       │   │   └── @ SymbolNode (location: (2347...2350))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── value_loc: (2347...2350) = "foo"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "foo"
+        │   │       │   ├── opening_loc: (2344...2347) = "%I["
+        │   │       │   └── closing_loc: (2350...2351) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2341...2343) = "in"
+        │   │       └── then_loc: (2352...2356) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2331...2335) = "case"
+        │   └── end_keyword_loc: (2357...2360) = "end"
+        ├── @ CaseNode (location: (2361...2390))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2366...2369))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2366...2369) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2371...2386))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayNode (location: (2374...2381))
+        │   │       │   ├── elements: (length: 1)
+        │   │       │   │   └── @ StringNode (location: (2377...2380))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (2377...2380) = "foo"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "foo"
+        │   │       │   ├── opening_loc: (2374...2377) = "%w["
+        │   │       │   └── closing_loc: (2380...2381) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2371...2373) = "in"
+        │   │       └── then_loc: (2382...2386) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2361...2365) = "case"
+        │   └── end_keyword_loc: (2387...2390) = "end"
+        ├── @ CaseNode (location: (2391...2420))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2396...2399))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2396...2399) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2401...2416))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayNode (location: (2404...2411))
+        │   │       │   ├── elements: (length: 1)
+        │   │       │   │   └── @ StringNode (location: (2407...2410))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (2407...2410) = "foo"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "foo"
+        │   │       │   ├── opening_loc: (2404...2407) = "%W["
+        │   │       │   └── closing_loc: (2410...2411) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2401...2403) = "in"
+        │   │       └── then_loc: (2412...2416) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2391...2395) = "case"
+        │   └── end_keyword_loc: (2417...2420) = "end"
+        ├── @ CaseNode (location: (2421...2450))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2426...2429))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2426...2429) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2431...2446))
+        │   │       ├── pattern:
+        │   │       │   @ StringNode (location: (2434...2441))
+        │   │       │   ├── opening_loc: (2434...2437) = "%q["
+        │   │       │   ├── content_loc: (2437...2440) = "foo"
+        │   │       │   ├── closing_loc: (2440...2441) = "]"
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2431...2433) = "in"
+        │   │       └── then_loc: (2442...2446) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2421...2425) = "case"
+        │   └── end_keyword_loc: (2447...2450) = "end"
+        ├── @ CaseNode (location: (2451...2480))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2456...2459))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2456...2459) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2461...2476))
+        │   │       ├── pattern:
+        │   │       │   @ StringNode (location: (2464...2471))
+        │   │       │   ├── opening_loc: (2464...2467) = "%Q["
+        │   │       │   ├── content_loc: (2467...2470) = "foo"
+        │   │       │   ├── closing_loc: (2470...2471) = "]"
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2461...2463) = "in"
+        │   │       └── then_loc: (2472...2476) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2451...2455) = "case"
+        │   └── end_keyword_loc: (2477...2480) = "end"
+        ├── @ CaseNode (location: (2481...2508))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2486...2489))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2486...2489) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2491...2504))
+        │   │       ├── pattern:
+        │   │       │   @ StringNode (location: (2494...2499))
+        │   │       │   ├── opening_loc: (2494...2495) = "\""
+        │   │       │   ├── content_loc: (2495...2498) = "foo"
+        │   │       │   ├── closing_loc: (2498...2499) = "\""
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2491...2493) = "in"
+        │   │       └── then_loc: (2500...2504) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2481...2485) = "case"
+        │   └── end_keyword_loc: (2505...2508) = "end"
+        ├── @ CaseNode (location: (2509...2534))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2514...2517))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2514...2517) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2519...2530))
+        │   │       ├── pattern:
+        │   │       │   @ NilNode (location: (2522...2525))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2519...2521) = "in"
+        │   │       └── then_loc: (2526...2530) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2509...2513) = "case"
+        │   └── end_keyword_loc: (2531...2534) = "end"
+        ├── @ CaseNode (location: (2535...2561))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2540...2543))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2540...2543) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2545...2557))
+        │   │       ├── pattern:
+        │   │       │   @ SelfNode (location: (2548...2552))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2545...2547) = "in"
+        │   │       └── then_loc: (2553...2557) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2535...2539) = "case"
+        │   └── end_keyword_loc: (2558...2561) = "end"
+        ├── @ CaseNode (location: (2562...2588))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2567...2570))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2567...2570) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2572...2584))
+        │   │       ├── pattern:
+        │   │       │   @ TrueNode (location: (2575...2579))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2572...2574) = "in"
+        │   │       └── then_loc: (2580...2584) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2562...2566) = "case"
+        │   └── end_keyword_loc: (2585...2588) = "end"
+        ├── @ CaseNode (location: (2589...2616))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2594...2597))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2594...2597) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2599...2612))
+        │   │       ├── pattern:
+        │   │       │   @ FalseNode (location: (2602...2607))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2599...2601) = "in"
+        │   │       └── then_loc: (2608...2612) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2589...2593) = "case"
+        │   └── end_keyword_loc: (2613...2616) = "end"
+        ├── @ CaseNode (location: (2617...2647))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2622...2625))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2622...2625) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2627...2643))
+        │   │       ├── pattern:
+        │   │       │   @ SourceFileNode (location: (2630...2638))
+        │   │       │   └── filepath: "patterns.txt"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2627...2629) = "in"
+        │   │       └── then_loc: (2639...2643) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2617...2621) = "case"
+        │   └── end_keyword_loc: (2644...2647) = "end"
+        ├── @ CaseNode (location: (2648...2678))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2653...2656))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2653...2656) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2658...2674))
+        │   │       ├── pattern:
+        │   │       │   @ SourceLineNode (location: (2661...2669))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2658...2660) = "in"
+        │   │       └── then_loc: (2670...2674) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2648...2652) = "case"
+        │   └── end_keyword_loc: (2675...2678) = "end"
+        ├── @ CaseNode (location: (2679...2713))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2684...2687))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2684...2687) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2689...2709))
+        │   │       ├── pattern:
+        │   │       │   @ SourceEncodingNode (location: (2692...2704))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2689...2691) = "in"
+        │   │       └── then_loc: (2705...2709) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2679...2683) = "case"
+        │   └── end_keyword_loc: (2710...2713) = "end"
+        ├── @ CaseNode (location: (2714...2746))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2719...2722))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2719...2722) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2724...2742))
+        │   │       ├── pattern:
+        │   │       │   @ LambdaNode (location: (2727...2737))
+        │   │       │   ├── locals: []
+        │   │       │   ├── operator_loc: (2727...2729) = "->"
+        │   │       │   ├── opening_loc: (2730...2731) = "{"
+        │   │       │   ├── closing_loc: (2736...2737) = "}"
+        │   │       │   ├── parameters: ∅
+        │   │       │   └── body:
+        │   │       │       @ StatementsNode (location: (2732...2735))
+        │   │       │       └── body: (length: 1)
+        │   │       │           └── @ LocalVariableReadNode (location: (2732...2735))
+        │   │       │               ├── name: :bar
+        │   │       │               └── depth: 1
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2724...2726) = "in"
+        │   │       └── then_loc: (2738...2742) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2714...2718) = "case"
+        │   └── end_keyword_loc: (2743...2746) = "end"
+        ├── @ CaseNode (location: (2748...2780))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2753...2756))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2753...2756) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2758...2776))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (2761...2771))
+        │   │       │   ├── if_keyword_loc: (2765...2767) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (2768...2771))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (2761...2764))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ LocalVariableTargetNode (location: (2761...2764))
+        │   │       │   │           ├── name: :bar
+        │   │       │   │           └── depth: 0
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2758...2760) = "in"
+        │   │       └── then_loc: (2772...2776) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2748...2752) = "case"
+        │   └── end_keyword_loc: (2777...2780) = "end"
+        ├── @ CaseNode (location: (2781...2811))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2786...2789))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2786...2789) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2791...2807))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (2794...2802))
+        │   │       │   ├── if_keyword_loc: (2796...2798) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (2799...2802))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (2794...2795))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ IntegerNode (location: (2794...2795))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2791...2793) = "in"
+        │   │       └── then_loc: (2803...2807) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2781...2785) = "case"
+        │   └── end_keyword_loc: (2808...2811) = "end"
+        ├── @ CaseNode (location: (2812...2844))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2817...2820))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2817...2820) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2822...2840))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (2825...2835))
+        │   │       │   ├── if_keyword_loc: (2829...2831) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (2832...2835))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (2825...2828))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ FloatNode (location: (2825...2828))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2822...2824) = "in"
+        │   │       └── then_loc: (2836...2840) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2812...2816) = "case"
+        │   └── end_keyword_loc: (2841...2844) = "end"
+        ├── @ CaseNode (location: (2845...2876))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2850...2853))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2850...2853) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2855...2872))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (2858...2867))
+        │   │       │   ├── if_keyword_loc: (2861...2863) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (2864...2867))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (2858...2860))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ ImaginaryNode (location: (2858...2860))
+        │   │       │   │           └── numeric:
+        │   │       │   │               @ IntegerNode (location: (2858...2859))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2855...2857) = "in"
+        │   │       └── then_loc: (2868...2872) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2845...2849) = "case"
+        │   └── end_keyword_loc: (2873...2876) = "end"
+        ├── @ CaseNode (location: (2877...2908))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2882...2885))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2882...2885) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2887...2904))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (2890...2899))
+        │   │       │   ├── if_keyword_loc: (2893...2895) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (2896...2899))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (2890...2892))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ RationalNode (location: (2890...2892))
+        │   │       │   │           └── numeric:
+        │   │       │   │               @ IntegerNode (location: (2890...2891))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2887...2889) = "in"
+        │   │       └── then_loc: (2900...2904) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2877...2881) = "case"
+        │   └── end_keyword_loc: (2905...2908) = "end"
+        ├── @ CaseNode (location: (2909...2942))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2914...2917))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2914...2917) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2919...2938))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (2922...2933))
+        │   │       │   ├── if_keyword_loc: (2927...2929) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (2930...2933))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (2922...2926))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ SymbolNode (location: (2922...2926))
+        │   │       │   │           ├── opening_loc: (2922...2923) = ":"
+        │   │       │   │           ├── value_loc: (2923...2926) = "foo"
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           └── unescaped: "foo"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2919...2921) = "in"
+        │   │       └── then_loc: (2934...2938) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2909...2913) = "case"
+        │   └── end_keyword_loc: (2939...2942) = "end"
+        ├── @ CaseNode (location: (2943...2979))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2948...2951))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2948...2951) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2953...2975))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (2956...2970))
+        │   │       │   ├── if_keyword_loc: (2964...2966) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (2967...2970))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (2956...2963))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ SymbolNode (location: (2956...2963))
+        │   │       │   │           ├── opening_loc: (2956...2959) = "%s["
+        │   │       │   │           ├── value_loc: (2959...2962) = "foo"
+        │   │       │   │           ├── closing_loc: (2962...2963) = "]"
+        │   │       │   │           └── unescaped: "foo"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2953...2955) = "in"
+        │   │       └── then_loc: (2971...2975) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2943...2947) = "case"
+        │   └── end_keyword_loc: (2976...2979) = "end"
+        ├── @ CaseNode (location: (2980...3015))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (2985...2988))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (2985...2988) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (2990...3011))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (2993...3006))
+        │   │       │   ├── if_keyword_loc: (3000...3002) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3003...3006))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (2993...2999))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ SymbolNode (location: (2993...2999))
+        │   │       │   │           ├── opening_loc: (2993...2995) = ":\""
+        │   │       │   │           ├── value_loc: (2995...2998) = "foo"
+        │   │       │   │           ├── closing_loc: (2998...2999) = "\""
+        │   │       │   │           └── unescaped: "foo"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (2990...2992) = "in"
+        │   │       └── then_loc: (3007...3011) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (2980...2984) = "case"
+        │   └── end_keyword_loc: (3012...3015) = "end"
+        ├── @ CaseNode (location: (3016...3050))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3021...3024))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3021...3024) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3026...3046))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3029...3041))
+        │   │       │   ├── if_keyword_loc: (3035...3037) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3038...3041))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3029...3034))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ RegularExpressionNode (location: (3029...3034))
+        │   │       │   │           ├── opening_loc: (3029...3030) = "/"
+        │   │       │   │           ├── content_loc: (3030...3033) = "foo"
+        │   │       │   │           ├── closing_loc: (3033...3034) = "/"
+        │   │       │   │           ├── unescaped: "foo"
+        │   │       │   │           └── flags: 
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3026...3028) = "in"
+        │   │       └── then_loc: (3042...3046) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3016...3020) = "case"
+        │   └── end_keyword_loc: (3047...3050) = "end"
+        ├── @ CaseNode (location: (3051...3085))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3056...3059))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3056...3059) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3061...3081))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3064...3076))
+        │   │       │   ├── if_keyword_loc: (3070...3072) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3073...3076))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3064...3069))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ XStringNode (location: (3064...3069))
+        │   │       │   │           ├── opening_loc: (3064...3065) = "`"
+        │   │       │   │           ├── content_loc: (3065...3068) = "foo"
+        │   │       │   │           ├── closing_loc: (3068...3069) = "`"
+        │   │       │   │           └── unescaped: "foo"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3061...3063) = "in"
+        │   │       └── then_loc: (3077...3081) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3051...3055) = "case"
+        │   └── end_keyword_loc: (3082...3085) = "end"
+        ├── @ CaseNode (location: (3086...3122))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3091...3094))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3091...3094) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3096...3118))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3099...3113))
+        │   │       │   ├── if_keyword_loc: (3107...3109) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3110...3113))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3099...3106))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ XStringNode (location: (3099...3106))
+        │   │       │   │           ├── opening_loc: (3099...3102) = "%x["
+        │   │       │   │           ├── content_loc: (3102...3105) = "foo"
+        │   │       │   │           ├── closing_loc: (3105...3106) = "]"
+        │   │       │   │           └── unescaped: "foo"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3096...3098) = "in"
+        │   │       └── then_loc: (3114...3118) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3086...3090) = "case"
+        │   └── end_keyword_loc: (3119...3122) = "end"
+        ├── @ CaseNode (location: (3123...3159))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3128...3131))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3128...3131) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3133...3155))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3136...3150))
+        │   │       │   ├── if_keyword_loc: (3144...3146) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3147...3150))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3136...3143))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ ArrayNode (location: (3136...3143))
+        │   │       │   │           ├── elements: (length: 1)
+        │   │       │   │           │   └── @ SymbolNode (location: (3139...3142))
+        │   │       │   │           │       ├── opening_loc: ∅
+        │   │       │   │           │       ├── value_loc: (3139...3142) = "foo"
+        │   │       │   │           │       ├── closing_loc: ∅
+        │   │       │   │           │       └── unescaped: "foo"
+        │   │       │   │           ├── opening_loc: (3136...3139) = "%i["
+        │   │       │   │           └── closing_loc: (3142...3143) = "]"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3133...3135) = "in"
+        │   │       └── then_loc: (3151...3155) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3123...3127) = "case"
+        │   └── end_keyword_loc: (3156...3159) = "end"
+        ├── @ CaseNode (location: (3160...3196))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3165...3168))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3165...3168) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3170...3192))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3173...3187))
+        │   │       │   ├── if_keyword_loc: (3181...3183) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3184...3187))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3173...3180))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ ArrayNode (location: (3173...3180))
+        │   │       │   │           ├── elements: (length: 1)
+        │   │       │   │           │   └── @ SymbolNode (location: (3176...3179))
+        │   │       │   │           │       ├── opening_loc: ∅
+        │   │       │   │           │       ├── value_loc: (3176...3179) = "foo"
+        │   │       │   │           │       ├── closing_loc: ∅
+        │   │       │   │           │       └── unescaped: "foo"
+        │   │       │   │           ├── opening_loc: (3173...3176) = "%I["
+        │   │       │   │           └── closing_loc: (3179...3180) = "]"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3170...3172) = "in"
+        │   │       └── then_loc: (3188...3192) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3160...3164) = "case"
+        │   └── end_keyword_loc: (3193...3196) = "end"
+        ├── @ CaseNode (location: (3197...3233))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3202...3205))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3202...3205) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3207...3229))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3210...3224))
+        │   │       │   ├── if_keyword_loc: (3218...3220) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3221...3224))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3210...3217))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ ArrayNode (location: (3210...3217))
+        │   │       │   │           ├── elements: (length: 1)
+        │   │       │   │           │   └── @ StringNode (location: (3213...3216))
+        │   │       │   │           │       ├── opening_loc: ∅
+        │   │       │   │           │       ├── content_loc: (3213...3216) = "foo"
+        │   │       │   │           │       ├── closing_loc: ∅
+        │   │       │   │           │       └── unescaped: "foo"
+        │   │       │   │           ├── opening_loc: (3210...3213) = "%w["
+        │   │       │   │           └── closing_loc: (3216...3217) = "]"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3207...3209) = "in"
+        │   │       └── then_loc: (3225...3229) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3197...3201) = "case"
+        │   └── end_keyword_loc: (3230...3233) = "end"
+        ├── @ CaseNode (location: (3234...3270))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3239...3242))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3239...3242) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3244...3266))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3247...3261))
+        │   │       │   ├── if_keyword_loc: (3255...3257) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3258...3261))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3247...3254))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ ArrayNode (location: (3247...3254))
+        │   │       │   │           ├── elements: (length: 1)
+        │   │       │   │           │   └── @ StringNode (location: (3250...3253))
+        │   │       │   │           │       ├── opening_loc: ∅
+        │   │       │   │           │       ├── content_loc: (3250...3253) = "foo"
+        │   │       │   │           │       ├── closing_loc: ∅
+        │   │       │   │           │       └── unescaped: "foo"
+        │   │       │   │           ├── opening_loc: (3247...3250) = "%W["
+        │   │       │   │           └── closing_loc: (3253...3254) = "]"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3244...3246) = "in"
+        │   │       └── then_loc: (3262...3266) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3234...3238) = "case"
+        │   └── end_keyword_loc: (3267...3270) = "end"
+        ├── @ CaseNode (location: (3271...3307))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3276...3279))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3276...3279) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3281...3303))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3284...3298))
+        │   │       │   ├── if_keyword_loc: (3292...3294) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3295...3298))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3284...3291))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ StringNode (location: (3284...3291))
+        │   │       │   │           ├── opening_loc: (3284...3287) = "%q["
+        │   │       │   │           ├── content_loc: (3287...3290) = "foo"
+        │   │       │   │           ├── closing_loc: (3290...3291) = "]"
+        │   │       │   │           └── unescaped: "foo"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3281...3283) = "in"
+        │   │       └── then_loc: (3299...3303) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3271...3275) = "case"
+        │   └── end_keyword_loc: (3304...3307) = "end"
+        ├── @ CaseNode (location: (3308...3344))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3313...3316))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3313...3316) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3318...3340))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3321...3335))
+        │   │       │   ├── if_keyword_loc: (3329...3331) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3332...3335))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3321...3328))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ StringNode (location: (3321...3328))
+        │   │       │   │           ├── opening_loc: (3321...3324) = "%Q["
+        │   │       │   │           ├── content_loc: (3324...3327) = "foo"
+        │   │       │   │           ├── closing_loc: (3327...3328) = "]"
+        │   │       │   │           └── unescaped: "foo"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3318...3320) = "in"
+        │   │       └── then_loc: (3336...3340) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3308...3312) = "case"
+        │   └── end_keyword_loc: (3341...3344) = "end"
+        ├── @ CaseNode (location: (3345...3379))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3350...3353))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3350...3353) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3355...3375))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3358...3370))
+        │   │       │   ├── if_keyword_loc: (3364...3366) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3367...3370))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3358...3363))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ StringNode (location: (3358...3363))
+        │   │       │   │           ├── opening_loc: (3358...3359) = "\""
+        │   │       │   │           ├── content_loc: (3359...3362) = "foo"
+        │   │       │   │           ├── closing_loc: (3362...3363) = "\""
+        │   │       │   │           └── unescaped: "foo"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3355...3357) = "in"
+        │   │       └── then_loc: (3371...3375) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3345...3349) = "case"
+        │   └── end_keyword_loc: (3376...3379) = "end"
+        ├── @ CaseNode (location: (3380...3412))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3385...3388))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3385...3388) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3390...3408))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3393...3403))
+        │   │       │   ├── if_keyword_loc: (3397...3399) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3400...3403))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3393...3396))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ NilNode (location: (3393...3396))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3390...3392) = "in"
+        │   │       └── then_loc: (3404...3408) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3380...3384) = "case"
+        │   └── end_keyword_loc: (3409...3412) = "end"
+        ├── @ CaseNode (location: (3413...3446))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3418...3421))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3418...3421) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3423...3442))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3426...3437))
+        │   │       │   ├── if_keyword_loc: (3431...3433) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3434...3437))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3426...3430))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ SelfNode (location: (3426...3430))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3423...3425) = "in"
+        │   │       └── then_loc: (3438...3442) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3413...3417) = "case"
+        │   └── end_keyword_loc: (3443...3446) = "end"
+        ├── @ CaseNode (location: (3447...3480))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3452...3455))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3452...3455) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3457...3476))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3460...3471))
+        │   │       │   ├── if_keyword_loc: (3465...3467) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3468...3471))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3460...3464))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ TrueNode (location: (3460...3464))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3457...3459) = "in"
+        │   │       └── then_loc: (3472...3476) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3447...3451) = "case"
+        │   └── end_keyword_loc: (3477...3480) = "end"
+        ├── @ CaseNode (location: (3481...3515))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3486...3489))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3486...3489) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3491...3511))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3494...3506))
+        │   │       │   ├── if_keyword_loc: (3500...3502) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3503...3506))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3494...3499))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ FalseNode (location: (3494...3499))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3491...3493) = "in"
+        │   │       └── then_loc: (3507...3511) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3481...3485) = "case"
+        │   └── end_keyword_loc: (3512...3515) = "end"
+        ├── @ CaseNode (location: (3516...3553))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3521...3524))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3521...3524) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3526...3549))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3529...3544))
+        │   │       │   ├── if_keyword_loc: (3538...3540) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3541...3544))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3529...3537))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ SourceFileNode (location: (3529...3537))
+        │   │       │   │           └── filepath: "patterns.txt"
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3526...3528) = "in"
+        │   │       └── then_loc: (3545...3549) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3516...3520) = "case"
+        │   └── end_keyword_loc: (3550...3553) = "end"
+        ├── @ CaseNode (location: (3554...3591))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3559...3562))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3559...3562) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3564...3587))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3567...3582))
+        │   │       │   ├── if_keyword_loc: (3576...3578) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3579...3582))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3567...3575))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ SourceLineNode (location: (3567...3575))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3564...3566) = "in"
+        │   │       └── then_loc: (3583...3587) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3554...3558) = "case"
+        │   └── end_keyword_loc: (3588...3591) = "end"
+        ├── @ CaseNode (location: (3592...3633))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3597...3600))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3597...3600) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3602...3629))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3605...3624))
+        │   │       │   ├── if_keyword_loc: (3618...3620) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3621...3624))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3605...3617))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ SourceEncodingNode (location: (3605...3617))
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3602...3604) = "in"
+        │   │       └── then_loc: (3625...3629) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3592...3596) = "case"
+        │   └── end_keyword_loc: (3630...3633) = "end"
+        ├── @ CaseNode (location: (3634...3673))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3639...3642))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3639...3642) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (3644...3669))
+        │   │       ├── pattern:
+        │   │       │   @ IfNode (location: (3647...3664))
+        │   │       │   ├── if_keyword_loc: (3658...3660) = "if"
+        │   │       │   ├── predicate:
+        │   │       │   │   @ LocalVariableReadNode (location: (3661...3664))
+        │   │       │   │   ├── name: :baz
+        │   │       │   │   └── depth: 0
+        │   │       │   ├── statements:
+        │   │       │   │   @ StatementsNode (location: (3647...3657))
+        │   │       │   │   └── body: (length: 1)
+        │   │       │   │       └── @ LambdaNode (location: (3647...3657))
+        │   │       │   │           ├── locals: []
+        │   │       │   │           ├── operator_loc: (3647...3649) = "->"
+        │   │       │   │           ├── opening_loc: (3650...3651) = "{"
+        │   │       │   │           ├── closing_loc: (3656...3657) = "}"
+        │   │       │   │           ├── parameters: ∅
+        │   │       │   │           └── body:
+        │   │       │   │               @ StatementsNode (location: (3652...3655))
+        │   │       │   │               └── body: (length: 1)
+        │   │       │   │                   └── @ LocalVariableReadNode (location: (3652...3655))
+        │   │       │   │                       ├── name: :bar
+        │   │       │   │                       └── depth: 1
+        │   │       │   ├── consequent: ∅
+        │   │       │   └── end_keyword_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (3644...3646) = "in"
+        │   │       └── then_loc: (3665...3669) = "then"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (3634...3638) = "case"
+        │   └── end_keyword_loc: (3670...3673) = "end"
+        ├── @ IfNode (location: (3675...3689))
+        │   ├── if_keyword_loc: (3675...3677) = "if"
+        │   ├── predicate:
+        │   │   @ MatchPredicateNode (location: (3678...3685))
+        │   │   ├── value:
+        │   │   │   @ CallNode (location: (3678...3679))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (3678...3679) = "a"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "a"
+        │   │   ├── pattern:
+        │   │   │   @ ArrayPatternNode (location: (3683...3685))
+        │   │   │   ├── constant: ∅
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── opening_loc: (3683...3684) = "["
+        │   │   │   └── closing_loc: (3684...3685) = "]"
+        │   │   └── operator_loc: (3680...3682) = "in"
+        │   ├── statements: ∅
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (3686...3689) = "end"
+        ├── @ MatchRequiredNode (location: (3691...3703))
+        │   ├── value:
+        │   │   @ CallNode (location: (3691...3692))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3691...3692) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (3696...3703))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (3700...3701))
+        │   │   │       ├── name: :b
+        │   │   │       └── depth: 0
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (3696...3697) = "["
+        │   │   └── closing_loc: (3702...3703) = "]"
+        │   └── operator_loc: (3693...3695) = "=>"
+        └── @ MatchPredicateNode (location: (3705...3743))
+            ├── value:
+            │   @ CallNode (location: (3705...3708))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (3705...3708) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── pattern:
+            │   @ HashPatternNode (location: (3712...3743))
+            │   ├── constant:
+            │   │   @ ConstantReadNode (location: (3712...3713))
+            │   │   └── name: :A
+            │   ├── assocs: (length: 1)
+            │   │   └── @ AssocNode (location: (3717...3741))
+            │   │       ├── key:
+            │   │       │   @ SymbolNode (location: (3717...3721))
+            │   │       │   ├── opening_loc: ∅
+            │   │       │   ├── value_loc: (3717...3720) = "bar"
+            │   │       │   ├── closing_loc: (3720...3721) = ":"
+            │   │       │   └── unescaped: "bar"
+            │   │       ├── value:
+            │   │       │   @ HashPatternNode (location: (3722...3741))
+            │   │       │   ├── constant:
+            │   │       │   │   @ ConstantReadNode (location: (3722...3723))
+            │   │       │   │   └── name: :B
+            │   │       │   ├── assocs: (length: 1)
+            │   │       │   │   └── @ AssocNode (location: (3729...3737))
+            │   │       │   │       ├── key:
+            │   │       │   │       │   @ SymbolNode (location: (3729...3735))
+            │   │       │   │       │   ├── opening_loc: ∅
+            │   │       │   │       │   ├── value_loc: (3729...3734) = "value"
+            │   │       │   │       │   ├── closing_loc: (3734...3735) = ":"
+            │   │       │   │       │   └── unescaped: "value"
+            │   │       │   │       ├── value:
+            │   │       │   │       │   @ LocalVariableTargetNode (location: (3736...3737))
+            │   │       │   │       │   ├── name: :a
+            │   │       │   │       │   └── depth: 0
+            │   │       │   │       └── operator_loc: ∅
+            │   │       │   ├── kwrest: ∅
+            │   │       │   ├── opening_loc: (3723...3724) = "["
+            │   │       │   └── closing_loc: (3740...3741) = "]"
+            │   │       └── operator_loc: ∅
+            │   ├── kwrest: ∅
+            │   ├── opening_loc: (3713...3714) = "["
+            │   └── closing_loc: (3742...3743) = "]"
+            └── operator_loc: (3709...3711) = "in"
diff --git a/test/yarp/snapshots/procs.txt b/test/yarp/snapshots/procs.txt
index fca9ccb710..1d65ab2a05 100644
--- a/test/yarp/snapshots/procs.txt
+++ b/test/yarp/snapshots/procs.txt
@@ -1,242 +1,372 @@
-ProgramNode(0...266)(
-  [],
-  StatementsNode(0...266)(
-    [LambdaNode(0...21)(
-       [:a, :b, :c, :d],
-       (0...2),
-       (16...17),
-       (20...21),
-       BlockParametersNode(3...15)(
-         ParametersNode(4...5)(
-           [RequiredParameterNode(4...5)(:a)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [BlockLocalVariableNode(7...8)(:b),
-          BlockLocalVariableNode(10...11)(:c),
-          BlockLocalVariableNode(13...14)(:d)],
-         (3...4),
-         (14...15)
-       ),
-       StatementsNode(18...19)([LocalVariableReadNode(18...19)(:b, 0)])
-     ),
-     LambdaNode(23...39)(
-       [],
-       (23...25),
-       (26...28),
-       (36...39),
-       nil,
-       BeginNode(29...39)(
-         nil,
-         nil,
-         nil,
-         nil,
-         EnsureNode(29...39)((29...35), nil, (36...39)),
-         (36...39)
-       )
-     ),
-     LambdaNode(41...69)(
-       [],
-       (41...43),
-       (44...46),
-       (66...69),
-       nil,
-       BeginNode(47...69)(
-         nil,
-         nil,
-         RescueNode(47...53)((47...53), [], nil, nil, nil, nil),
-         ElseNode(54...65)((54...58), nil, (59...65)),
-         EnsureNode(59...69)((59...65), nil, (66...69)),
-         (66...69)
-       )
-     ),
-     LambdaNode(71...81)(
-       [],
-       (71...73),
-       (74...75),
-       (80...81),
-       nil,
-       StatementsNode(76...79)(
-         [CallNode(76...79)(nil, nil, (76...79), nil, nil, nil, nil, 2, "foo")]
-       )
-     ),
-     LambdaNode(83...98)(
-       [],
-       (83...85),
-       (86...88),
-       (95...98),
-       nil,
-       StatementsNode(90...93)(
-         [CallNode(90...93)(nil, nil, (90...93), nil, nil, nil, nil, 2, "foo")]
-       )
-     ),
-     LambdaNode(100...129)(
-       [:a, :b, :c, :d, :e],
-       (100...102),
-       (124...125),
-       (128...129),
-       BlockParametersNode(103...123)(
-         ParametersNode(103...123)(
-           [RequiredParameterNode(103...104)(:a)],
-           [OptionalParameterNode(106...111)(
-              :b,
-              (106...107),
-              (108...109),
-              IntegerNode(110...111)()
-            )],
-           [],
-           nil,
-           [KeywordParameterNode(113...115)(:c, (113...115), nil),
-            KeywordParameterNode(117...119)(:d, (117...119), nil)],
-           nil,
-           BlockParameterNode(121...123)(:e, (122...123), (121...122))
-         ),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(126...127)([LocalVariableReadNode(126...127)(:a, 0)])
-     ),
-     LambdaNode(131...171)(
-       [:a, :b, :c, :d, :e, :f, :g],
-       (131...133),
-       (166...167),
-       (170...171),
-       BlockParametersNode(134...165)(
-         ParametersNode(135...164)(
-           [RequiredParameterNode(135...136)(:a)],
-           [OptionalParameterNode(138...143)(
-              :b,
-              (138...139),
-              (140...141),
-              IntegerNode(142...143)()
-            )],
-           [],
-           RestParameterNode(145...147)(:c, (146...147), (145...146)),
-           [KeywordParameterNode(149...151)(:d, (149...151), nil),
-            KeywordParameterNode(153...155)(:e, (153...155), nil)],
-           KeywordRestParameterNode(157...160)(:f, (159...160), (157...159)),
-           BlockParameterNode(162...164)(:g, (163...164), (162...163))
-         ),
-         [],
-         (134...135),
-         (164...165)
-       ),
-       StatementsNode(168...169)([LocalVariableReadNode(168...169)(:a, 0)])
-     ),
-     LambdaNode(173...218)(
-       [:a, :b, :c, :d, :e, :f, :g],
-       (173...175),
-       (208...210),
-       (215...218),
-       BlockParametersNode(176...207)(
-         ParametersNode(177...206)(
-           [RequiredParameterNode(177...178)(:a)],
-           [OptionalParameterNode(180...185)(
-              :b,
-              (180...181),
-              (182...183),
-              IntegerNode(184...185)()
-            )],
-           [],
-           RestParameterNode(187...189)(:c, (188...189), (187...188)),
-           [KeywordParameterNode(191...193)(:d, (191...193), nil),
-            KeywordParameterNode(195...197)(:e, (195...197), nil)],
-           KeywordRestParameterNode(199...202)(:f, (201...202), (199...201)),
-           BlockParameterNode(204...206)(:g, (205...206), (204...205))
-         ),
-         [],
-         (176...177),
-         (206...207)
-       ),
-       StatementsNode(213...214)([LocalVariableReadNode(213...214)(:a, 0)])
-     ),
-     LambdaNode(220...245)(
-       [:a],
-       (220...222),
-       (227...228),
-       (244...245),
-       BlockParametersNode(223...226)(
-         ParametersNode(224...225)(
-           [RequiredParameterNode(224...225)(:a)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (223...224),
-         (225...226)
-       ),
-       StatementsNode(229...243)(
-         [LambdaNode(229...243)(
-            [:b],
-            (229...231),
-            (234...235),
-            (242...243),
-            BlockParametersNode(232...233)(
-              ParametersNode(232...233)(
-                [RequiredParameterNode(232...233)(:b)],
-                [],
-                [],
-                nil,
-                [],
-                nil,
-                nil
-              ),
-              [],
-              nil,
-              nil
-            ),
-            StatementsNode(236...241)(
-              [CallNode(236...241)(
-                 LocalVariableReadNode(236...237)(:a, 1),
-                 nil,
-                 (238...239),
-                 nil,
-                 ArgumentsNode(240...241)(
-                   [LocalVariableReadNode(240...241)(:b, 0)]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "*"
-               )]
-            )
-          )]
-       )
-     ),
-     LambdaNode(247...266)(
-       [:a, :b, :c],
-       (247...249),
-       (263...264),
-       (265...266),
-       BlockParametersNode(250...262)(
-         ParametersNode(251...261)(
-           [RequiredDestructuredParameterNode(251...257)(
-              [RequiredParameterNode(252...253)(:a),
-               RequiredParameterNode(255...256)(:b)],
-              (251...252),
-              (256...257)
-            )],
-           [],
-           [],
-           RestParameterNode(259...261)(:c, (260...261), (259...260)),
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (250...251),
-         (261...262)
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...266))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...266))
+    └── body: (length: 10)
+        ├── @ LambdaNode (location: (0...21))
+        │   ├── locals: [:a, :b, :c, :d]
+        │   ├── operator_loc: (0...2) = "->"
+        │   ├── opening_loc: (16...17) = "{"
+        │   ├── closing_loc: (20...21) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (3...15))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (4...5))
+        │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   └── @ RequiredParameterNode (location: (4...5))
+        │   │   │   │       └── name: :a
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 3)
+        │   │   │   ├── @ BlockLocalVariableNode (location: (7...8))
+        │   │   │   │   └── name: :b
+        │   │   │   ├── @ BlockLocalVariableNode (location: (10...11))
+        │   │   │   │   └── name: :c
+        │   │   │   └── @ BlockLocalVariableNode (location: (13...14))
+        │   │   │       └── name: :d
+        │   │   ├── opening_loc: (3...4) = "("
+        │   │   └── closing_loc: (14...15) = ")"
+        │   └── body:
+        │       @ StatementsNode (location: (18...19))
+        │       └── body: (length: 1)
+        │           └── @ LocalVariableReadNode (location: (18...19))
+        │               ├── name: :b
+        │               └── depth: 0
+        ├── @ LambdaNode (location: (23...39))
+        │   ├── locals: []
+        │   ├── operator_loc: (23...25) = "->"
+        │   ├── opening_loc: (26...28) = "do"
+        │   ├── closing_loc: (36...39) = "end"
+        │   ├── parameters: ∅
+        │   └── body:
+        │       @ BeginNode (location: (29...39))
+        │       ├── begin_keyword_loc: ∅
+        │       ├── statements: ∅
+        │       ├── rescue_clause: ∅
+        │       ├── else_clause: ∅
+        │       ├── ensure_clause:
+        │       │   @ EnsureNode (location: (29...39))
+        │       │   ├── ensure_keyword_loc: (29...35) = "ensure"
+        │       │   ├── statements: ∅
+        │       │   └── end_keyword_loc: (36...39) = "end"
+        │       └── end_keyword_loc: (36...39) = "end"
+        ├── @ LambdaNode (location: (41...69))
+        │   ├── locals: []
+        │   ├── operator_loc: (41...43) = "->"
+        │   ├── opening_loc: (44...46) = "do"
+        │   ├── closing_loc: (66...69) = "end"
+        │   ├── parameters: ∅
+        │   └── body:
+        │       @ BeginNode (location: (47...69))
+        │       ├── begin_keyword_loc: ∅
+        │       ├── statements: ∅
+        │       ├── rescue_clause:
+        │       │   @ RescueNode (location: (47...53))
+        │       │   ├── keyword_loc: (47...53) = "rescue"
+        │       │   ├── exceptions: (length: 0)
+        │       │   ├── operator_loc: ∅
+        │       │   ├── reference: ∅
+        │       │   ├── statements: ∅
+        │       │   └── consequent: ∅
+        │       ├── else_clause:
+        │       │   @ ElseNode (location: (54...65))
+        │       │   ├── else_keyword_loc: (54...58) = "else"
+        │       │   ├── statements: ∅
+        │       │   └── end_keyword_loc: (59...65) = "ensure"
+        │       ├── ensure_clause:
+        │       │   @ EnsureNode (location: (59...69))
+        │       │   ├── ensure_keyword_loc: (59...65) = "ensure"
+        │       │   ├── statements: ∅
+        │       │   └── end_keyword_loc: (66...69) = "end"
+        │       └── end_keyword_loc: (66...69) = "end"
+        ├── @ LambdaNode (location: (71...81))
+        │   ├── locals: []
+        │   ├── operator_loc: (71...73) = "->"
+        │   ├── opening_loc: (74...75) = "{"
+        │   ├── closing_loc: (80...81) = "}"
+        │   ├── parameters: ∅
+        │   └── body:
+        │       @ StatementsNode (location: (76...79))
+        │       └── body: (length: 1)
+        │           └── @ CallNode (location: (76...79))
+        │               ├── receiver: ∅
+        │               ├── call_operator_loc: ∅
+        │               ├── message_loc: (76...79) = "foo"
+        │               ├── opening_loc: ∅
+        │               ├── arguments: ∅
+        │               ├── closing_loc: ∅
+        │               ├── block: ∅
+        │               ├── flags: variable_call
+        │               └── name: "foo"
+        ├── @ LambdaNode (location: (83...98))
+        │   ├── locals: []
+        │   ├── operator_loc: (83...85) = "->"
+        │   ├── opening_loc: (86...88) = "do"
+        │   ├── closing_loc: (95...98) = "end"
+        │   ├── parameters: ∅
+        │   └── body:
+        │       @ StatementsNode (location: (90...93))
+        │       └── body: (length: 1)
+        │           └── @ CallNode (location: (90...93))
+        │               ├── receiver: ∅
+        │               ├── call_operator_loc: ∅
+        │               ├── message_loc: (90...93) = "foo"
+        │               ├── opening_loc: ∅
+        │               ├── arguments: ∅
+        │               ├── closing_loc: ∅
+        │               ├── block: ∅
+        │               ├── flags: variable_call
+        │               └── name: "foo"
+        ├── @ LambdaNode (location: (100...129))
+        │   ├── locals: [:a, :b, :c, :d, :e]
+        │   ├── operator_loc: (100...102) = "->"
+        │   ├── opening_loc: (124...125) = "{"
+        │   ├── closing_loc: (128...129) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (103...123))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (103...123))
+        │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   └── @ RequiredParameterNode (location: (103...104))
+        │   │   │   │       └── name: :a
+        │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   └── @ OptionalParameterNode (location: (106...111))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (106...107) = "b"
+        │   │   │   │       ├── operator_loc: (108...109) = "="
+        │   │   │   │       └── value:
+        │   │   │   │           @ IntegerNode (location: (110...111))
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 2)
+        │   │   │   │   ├── @ KeywordParameterNode (location: (113...115))
+        │   │   │   │   │   ├── name: :c
+        │   │   │   │   │   ├── name_loc: (113...115) = "c:"
+        │   │   │   │   │   └── value: ∅
+        │   │   │   │   └── @ KeywordParameterNode (location: (117...119))
+        │   │   │   │       ├── name: :d
+        │   │   │   │       ├── name_loc: (117...119) = "d:"
+        │   │   │   │       └── value: ∅
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block:
+        │   │   │       @ BlockParameterNode (location: (121...123))
+        │   │   │       ├── name: :e
+        │   │   │       ├── name_loc: (122...123) = "e"
+        │   │   │       └── operator_loc: (121...122) = "&"
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── body:
+        │       @ StatementsNode (location: (126...127))
+        │       └── body: (length: 1)
+        │           └── @ LocalVariableReadNode (location: (126...127))
+        │               ├── name: :a
+        │               └── depth: 0
+        ├── @ LambdaNode (location: (131...171))
+        │   ├── locals: [:a, :b, :c, :d, :e, :f, :g]
+        │   ├── operator_loc: (131...133) = "->"
+        │   ├── opening_loc: (166...167) = "{"
+        │   ├── closing_loc: (170...171) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (134...165))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (135...164))
+        │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   └── @ RequiredParameterNode (location: (135...136))
+        │   │   │   │       └── name: :a
+        │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   └── @ OptionalParameterNode (location: (138...143))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (138...139) = "b"
+        │   │   │   │       ├── operator_loc: (140...141) = "="
+        │   │   │   │       └── value:
+        │   │   │   │           @ IntegerNode (location: (142...143))
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest:
+        │   │   │   │   @ RestParameterNode (location: (145...147))
+        │   │   │   │   ├── name: :c
+        │   │   │   │   ├── name_loc: (146...147) = "c"
+        │   │   │   │   └── operator_loc: (145...146) = "*"
+        │   │   │   ├── keywords: (length: 2)
+        │   │   │   │   ├── @ KeywordParameterNode (location: (149...151))
+        │   │   │   │   │   ├── name: :d
+        │   │   │   │   │   ├── name_loc: (149...151) = "d:"
+        │   │   │   │   │   └── value: ∅
+        │   │   │   │   └── @ KeywordParameterNode (location: (153...155))
+        │   │   │   │       ├── name: :e
+        │   │   │   │       ├── name_loc: (153...155) = "e:"
+        │   │   │   │       └── value: ∅
+        │   │   │   ├── keyword_rest:
+        │   │   │   │   @ KeywordRestParameterNode (location: (157...160))
+        │   │   │   │   ├── name: :f
+        │   │   │   │   ├── name_loc: (159...160) = "f"
+        │   │   │   │   └── operator_loc: (157...159) = "**"
+        │   │   │   └── block:
+        │   │   │       @ BlockParameterNode (location: (162...164))
+        │   │   │       ├── name: :g
+        │   │   │       ├── name_loc: (163...164) = "g"
+        │   │   │       └── operator_loc: (162...163) = "&"
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (134...135) = "("
+        │   │   └── closing_loc: (164...165) = ")"
+        │   └── body:
+        │       @ StatementsNode (location: (168...169))
+        │       └── body: (length: 1)
+        │           └── @ LocalVariableReadNode (location: (168...169))
+        │               ├── name: :a
+        │               └── depth: 0
+        ├── @ LambdaNode (location: (173...218))
+        │   ├── locals: [:a, :b, :c, :d, :e, :f, :g]
+        │   ├── operator_loc: (173...175) = "->"
+        │   ├── opening_loc: (208...210) = "do"
+        │   ├── closing_loc: (215...218) = "end"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (176...207))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (177...206))
+        │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   └── @ RequiredParameterNode (location: (177...178))
+        │   │   │   │       └── name: :a
+        │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   └── @ OptionalParameterNode (location: (180...185))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (180...181) = "b"
+        │   │   │   │       ├── operator_loc: (182...183) = "="
+        │   │   │   │       └── value:
+        │   │   │   │           @ IntegerNode (location: (184...185))
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest:
+        │   │   │   │   @ RestParameterNode (location: (187...189))
+        │   │   │   │   ├── name: :c
+        │   │   │   │   ├── name_loc: (188...189) = "c"
+        │   │   │   │   └── operator_loc: (187...188) = "*"
+        │   │   │   ├── keywords: (length: 2)
+        │   │   │   │   ├── @ KeywordParameterNode (location: (191...193))
+        │   │   │   │   │   ├── name: :d
+        │   │   │   │   │   ├── name_loc: (191...193) = "d:"
+        │   │   │   │   │   └── value: ∅
+        │   │   │   │   └── @ KeywordParameterNode (location: (195...197))
+        │   │   │   │       ├── name: :e
+        │   │   │   │       ├── name_loc: (195...197) = "e:"
+        │   │   │   │       └── value: ∅
+        │   │   │   ├── keyword_rest:
+        │   │   │   │   @ KeywordRestParameterNode (location: (199...202))
+        │   │   │   │   ├── name: :f
+        │   │   │   │   ├── name_loc: (201...202) = "f"
+        │   │   │   │   └── operator_loc: (199...201) = "**"
+        │   │   │   └── block:
+        │   │   │       @ BlockParameterNode (location: (204...206))
+        │   │   │       ├── name: :g
+        │   │   │       ├── name_loc: (205...206) = "g"
+        │   │   │       └── operator_loc: (204...205) = "&"
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (176...177) = "("
+        │   │   └── closing_loc: (206...207) = ")"
+        │   └── body:
+        │       @ StatementsNode (location: (213...214))
+        │       └── body: (length: 1)
+        │           └── @ LocalVariableReadNode (location: (213...214))
+        │               ├── name: :a
+        │               └── depth: 0
+        ├── @ LambdaNode (location: (220...245))
+        │   ├── locals: [:a]
+        │   ├── operator_loc: (220...222) = "->"
+        │   ├── opening_loc: (227...228) = "{"
+        │   ├── closing_loc: (244...245) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (223...226))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (224...225))
+        │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   └── @ RequiredParameterNode (location: (224...225))
+        │   │   │   │       └── name: :a
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (223...224) = "("
+        │   │   └── closing_loc: (225...226) = ")"
+        │   └── body:
+        │       @ StatementsNode (location: (229...243))
+        │       └── body: (length: 1)
+        │           └── @ LambdaNode (location: (229...243))
+        │               ├── locals: [:b]
+        │               ├── operator_loc: (229...231) = "->"
+        │               ├── opening_loc: (234...235) = "{"
+        │               ├── closing_loc: (242...243) = "}"
+        │               ├── parameters:
+        │               │   @ BlockParametersNode (location: (232...233))
+        │               │   ├── parameters:
+        │               │   │   @ ParametersNode (location: (232...233))
+        │               │   │   ├── requireds: (length: 1)
+        │               │   │   │   └── @ RequiredParameterNode (location: (232...233))
+        │               │   │   │       └── name: :b
+        │               │   │   ├── optionals: (length: 0)
+        │               │   │   ├── posts: (length: 0)
+        │               │   │   ├── rest: ∅
+        │               │   │   ├── keywords: (length: 0)
+        │               │   │   ├── keyword_rest: ∅
+        │               │   │   └── block: ∅
+        │               │   ├── locals: (length: 0)
+        │               │   ├── opening_loc: ∅
+        │               │   └── closing_loc: ∅
+        │               └── body:
+        │                   @ StatementsNode (location: (236...241))
+        │                   └── body: (length: 1)
+        │                       └── @ CallNode (location: (236...241))
+        │                           ├── receiver:
+        │                           │   @ LocalVariableReadNode (location: (236...237))
+        │                           │   ├── name: :a
+        │                           │   └── depth: 1
+        │                           ├── call_operator_loc: ∅
+        │                           ├── message_loc: (238...239) = "*"
+        │                           ├── opening_loc: ∅
+        │                           ├── arguments:
+        │                           │   @ ArgumentsNode (location: (240...241))
+        │                           │   └── arguments: (length: 1)
+        │                           │       └── @ LocalVariableReadNode (location: (240...241))
+        │                           │           ├── name: :b
+        │                           │           └── depth: 0
+        │                           ├── closing_loc: ∅
+        │                           ├── block: ∅
+        │                           ├── flags: 
+        │                           └── name: "*"
+        └── @ LambdaNode (location: (247...266))
+            ├── locals: [:a, :b, :c]
+            ├── operator_loc: (247...249) = "->"
+            ├── opening_loc: (263...264) = "{"
+            ├── closing_loc: (265...266) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (250...262))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (251...261))
+            │   │   ├── requireds: (length: 1)
+            │   │   │   └── @ RequiredDestructuredParameterNode (location: (251...257))
+            │   │   │       ├── parameters: (length: 2)
+            │   │   │       │   ├── @ RequiredParameterNode (location: (252...253))
+            │   │   │       │   │   └── name: :a
+            │   │   │       │   └── @ RequiredParameterNode (location: (255...256))
+            │   │   │       │       └── name: :b
+            │   │   │       ├── opening_loc: (251...252) = "("
+            │   │   │       └── closing_loc: (256...257) = ")"
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest:
+            │   │   │   @ RestParameterNode (location: (259...261))
+            │   │   │   ├── name: :c
+            │   │   │   ├── name_loc: (260...261) = "c"
+            │   │   │   └── operator_loc: (259...260) = "*"
+            │   │   ├── keywords: (length: 0)
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: (250...251) = "("
+            │   └── closing_loc: (261...262) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/range_begin_open_exclusive.txt b/test/yarp/snapshots/range_begin_open_exclusive.txt
index 50a6593c46..60617e20c8 100644
--- a/test/yarp/snapshots/range_begin_open_exclusive.txt
+++ b/test/yarp/snapshots/range_begin_open_exclusive.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [RangeNode(0...4)(nil, IntegerNode(3...4)(), (0...3), 1)]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ RangeNode (location: (0...4))
+            ├── left: ∅
+            ├── right:
+            │   @ IntegerNode (location: (3...4))
+            ├── operator_loc: (0...3) = "..."
+            └── flags: exclude_end
diff --git a/test/yarp/snapshots/range_begin_open_inclusive.txt b/test/yarp/snapshots/range_begin_open_inclusive.txt
index 7d09381f30..968f1cbc4b 100644
--- a/test/yarp/snapshots/range_begin_open_inclusive.txt
+++ b/test/yarp/snapshots/range_begin_open_inclusive.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...3)(
-  [],
-  StatementsNode(0...3)(
-    [RangeNode(0...3)(nil, IntegerNode(2...3)(), (0...2), 0)]
-  )
-)
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ RangeNode (location: (0...3))
+            ├── left: ∅
+            ├── right:
+            │   @ IntegerNode (location: (2...3))
+            ├── operator_loc: (0...2) = ".."
+            └── flags: 
diff --git a/test/yarp/snapshots/range_end_open_exclusive.txt b/test/yarp/snapshots/range_end_open_exclusive.txt
index 3da37b123c..0c0172e453 100644
--- a/test/yarp/snapshots/range_end_open_exclusive.txt
+++ b/test/yarp/snapshots/range_end_open_exclusive.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [RangeNode(0...4)(IntegerNode(0...1)(), nil, (1...4), 1)]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ RangeNode (location: (0...4))
+            ├── left:
+            │   @ IntegerNode (location: (0...1))
+            ├── right: ∅
+            ├── operator_loc: (1...4) = "..."
+            └── flags: exclude_end
diff --git a/test/yarp/snapshots/range_end_open_inclusive.txt b/test/yarp/snapshots/range_end_open_inclusive.txt
index e1b90bdffc..8fd08d2168 100644
--- a/test/yarp/snapshots/range_end_open_inclusive.txt
+++ b/test/yarp/snapshots/range_end_open_inclusive.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...3)(
-  [],
-  StatementsNode(0...3)(
-    [RangeNode(0...3)(IntegerNode(0...1)(), nil, (1...3), 0)]
-  )
-)
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ RangeNode (location: (0...3))
+            ├── left:
+            │   @ IntegerNode (location: (0...1))
+            ├── right: ∅
+            ├── operator_loc: (1...3) = ".."
+            └── flags: 
diff --git a/test/yarp/snapshots/ranges.txt b/test/yarp/snapshots/ranges.txt
index 8873f61b0a..72843aa9fc 100644
--- a/test/yarp/snapshots/ranges.txt
+++ b/test/yarp/snapshots/ranges.txt
@@ -1,106 +1,151 @@
-ProgramNode(0...85)(
-  [],
-  StatementsNode(0...85)(
-    [ParenthesesNode(0...6)(
-       StatementsNode(1...5)(
-         [RangeNode(1...5)(nil, IntegerNode(4...5)(), (1...4), 1)]
-       ),
-       (0...1),
-       (5...6)
-     ),
-     ParenthesesNode(8...13)(
-       StatementsNode(9...12)(
-         [RangeNode(9...12)(nil, IntegerNode(11...12)(), (9...11), 0)]
-       ),
-       (8...9),
-       (12...13)
-     ),
-     RangeNode(15...20)(
-       IntegerNode(15...16)(),
-       IntegerNode(19...20)(),
-       (16...19),
-       1
-     ),
-     CallNode(22...31)(
-       CallNode(22...25)(nil, nil, (22...25), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (25...31),
-       (25...26),
-       ArgumentsNode(26...30)(
-         [RangeNode(26...30)(nil, IntegerNode(29...30)(), (26...29), 1)]
-       ),
-       (30...31),
-       nil,
-       0,
-       "[]"
-     ),
-     HashNode(33...48)(
-       (33...34),
-       [AssocNode(35...46)(
-          SymbolNode(35...39)(nil, (35...38), (38...39), "foo"),
-          RangeNode(40...46)(
-            nil,
-            CallNode(43...46)(
-              nil,
-              nil,
-              (43...46),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            ),
-            (40...43),
-            1
-          ),
-          nil
-        )],
-       (47...48)
-     ),
-     ParenthesesNode(50...56)(
-       StatementsNode(51...55)(
-         [RangeNode(51...55)(IntegerNode(51...52)(), nil, (52...55), 1)]
-       ),
-       (50...51),
-       (55...56)
-     ),
-     RangeNode(58...62)(
-       IntegerNode(58...59)(),
-       IntegerNode(61...62)(),
-       (59...61),
-       0
-     ),
-     HashNode(64...78)(
-       (64...65),
-       [AssocNode(66...76)(
-          SymbolNode(66...70)(nil, (66...69), (69...70), "foo"),
-          RangeNode(71...76)(
-            nil,
-            CallNode(73...76)(
-              nil,
-              nil,
-              (73...76),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            ),
-            (71...73),
-            0
-          ),
-          nil
-        )],
-       (77...78)
-     ),
-     ParenthesesNode(80...85)(
-       StatementsNode(81...84)(
-         [RangeNode(81...84)(IntegerNode(81...82)(), nil, (82...84), 0)]
-       ),
-       (80...81),
-       (84...85)
-     )]
-  )
-)
+@ ProgramNode (location: (0...85))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...85))
+    └── body: (length: 9)
+        ├── @ ParenthesesNode (location: (0...6))
+        │   ├── body:
+        │   │   @ StatementsNode (location: (1...5))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RangeNode (location: (1...5))
+        │   │           ├── left: ∅
+        │   │           ├── right:
+        │   │           │   @ IntegerNode (location: (4...5))
+        │   │           ├── operator_loc: (1...4) = "..."
+        │   │           └── flags: exclude_end
+        │   ├── opening_loc: (0...1) = "("
+        │   └── closing_loc: (5...6) = ")"
+        ├── @ ParenthesesNode (location: (8...13))
+        │   ├── body:
+        │   │   @ StatementsNode (location: (9...12))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RangeNode (location: (9...12))
+        │   │           ├── left: ∅
+        │   │           ├── right:
+        │   │           │   @ IntegerNode (location: (11...12))
+        │   │           ├── operator_loc: (9...11) = ".."
+        │   │           └── flags: 
+        │   ├── opening_loc: (8...9) = "("
+        │   └── closing_loc: (12...13) = ")"
+        ├── @ RangeNode (location: (15...20))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (15...16))
+        │   ├── right:
+        │   │   @ IntegerNode (location: (19...20))
+        │   ├── operator_loc: (16...19) = "..."
+        │   └── flags: exclude_end
+        ├── @ CallNode (location: (22...31))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (22...25))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (22...25) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (25...31) = "[...2]"
+        │   ├── opening_loc: (25...26) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (26...30))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ RangeNode (location: (26...30))
+        │   │           ├── left: ∅
+        │   │           ├── right:
+        │   │           │   @ IntegerNode (location: (29...30))
+        │   │           ├── operator_loc: (26...29) = "..."
+        │   │           └── flags: exclude_end
+        │   ├── closing_loc: (30...31) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ HashNode (location: (33...48))
+        │   ├── opening_loc: (33...34) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (35...46))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (35...39))
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── value_loc: (35...38) = "foo"
+        │   │       │   ├── closing_loc: (38...39) = ":"
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── value:
+        │   │       │   @ RangeNode (location: (40...46))
+        │   │       │   ├── left: ∅
+        │   │       │   ├── right:
+        │   │       │   │   @ CallNode (location: (43...46))
+        │   │       │   │   ├── receiver: ∅
+        │   │       │   │   ├── call_operator_loc: ∅
+        │   │       │   │   ├── message_loc: (43...46) = "bar"
+        │   │       │   │   ├── opening_loc: ∅
+        │   │       │   │   ├── arguments: ∅
+        │   │       │   │   ├── closing_loc: ∅
+        │   │       │   │   ├── block: ∅
+        │   │       │   │   ├── flags: variable_call
+        │   │       │   │   └── name: "bar"
+        │   │       │   ├── operator_loc: (40...43) = "..."
+        │   │       │   └── flags: exclude_end
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (47...48) = "}"
+        ├── @ ParenthesesNode (location: (50...56))
+        │   ├── body:
+        │   │   @ StatementsNode (location: (51...55))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RangeNode (location: (51...55))
+        │   │           ├── left:
+        │   │           │   @ IntegerNode (location: (51...52))
+        │   │           ├── right: ∅
+        │   │           ├── operator_loc: (52...55) = "..."
+        │   │           └── flags: exclude_end
+        │   ├── opening_loc: (50...51) = "("
+        │   └── closing_loc: (55...56) = ")"
+        ├── @ RangeNode (location: (58...62))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (58...59))
+        │   ├── right:
+        │   │   @ IntegerNode (location: (61...62))
+        │   ├── operator_loc: (59...61) = ".."
+        │   └── flags: 
+        ├── @ HashNode (location: (64...78))
+        │   ├── opening_loc: (64...65) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (66...76))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (66...70))
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── value_loc: (66...69) = "foo"
+        │   │       │   ├── closing_loc: (69...70) = ":"
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── value:
+        │   │       │   @ RangeNode (location: (71...76))
+        │   │       │   ├── left: ∅
+        │   │       │   ├── right:
+        │   │       │   │   @ CallNode (location: (73...76))
+        │   │       │   │   ├── receiver: ∅
+        │   │       │   │   ├── call_operator_loc: ∅
+        │   │       │   │   ├── message_loc: (73...76) = "bar"
+        │   │       │   │   ├── opening_loc: ∅
+        │   │       │   │   ├── arguments: ∅
+        │   │       │   │   ├── closing_loc: ∅
+        │   │       │   │   ├── block: ∅
+        │   │       │   │   ├── flags: variable_call
+        │   │       │   │   └── name: "bar"
+        │   │       │   ├── operator_loc: (71...73) = ".."
+        │   │       │   └── flags: 
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (77...78) = "}"
+        └── @ ParenthesesNode (location: (80...85))
+            ├── body:
+            │   @ StatementsNode (location: (81...84))
+            │   └── body: (length: 1)
+            │       └── @ RangeNode (location: (81...84))
+            │           ├── left:
+            │           │   @ IntegerNode (location: (81...82))
+            │           ├── right: ∅
+            │           ├── operator_loc: (82...84) = ".."
+            │           └── flags: 
+            ├── opening_loc: (80...81) = "("
+            └── closing_loc: (84...85) = ")"
diff --git a/test/yarp/snapshots/regex.txt b/test/yarp/snapshots/regex.txt
index 37e32c4dd8..23c2020b5d 100644
--- a/test/yarp/snapshots/regex.txt
+++ b/test/yarp/snapshots/regex.txt
@@ -1,166 +1,201 @@
-ProgramNode(0...293)(
-  [:foo],
-  StatementsNode(0...293)(
-    [CallNode(0...9)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...9)(
-         [RegularExpressionNode(4...9)((4...5), (5...8), (8...9), "bar", 0)]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     RegularExpressionNode(11...19)((11...14), (14...17), (17...19), "abc", 1),
-     RegularExpressionNode(21...26)((21...22), (22...25), (25...26), "a\b", 0),
-     InterpolatedRegularExpressionNode(28...39)(
-       (28...29),
-       [StringNode(29...33)(nil, (29...33), nil, "aaa "),
-        EmbeddedVariableNode(33...38)(
-          (33...34),
-          GlobalVariableReadNode(34...38)(:$bbb)
-        )],
-       (38...39),
-       0
-     ),
-     InterpolatedRegularExpressionNode(41...57)(
-       (41...42),
-       [StringNode(42...46)(nil, (42...46), nil, "aaa "),
-        EmbeddedStatementsNode(46...52)(
-          (46...48),
-          StatementsNode(48...51)(
-            [CallNode(48...51)(
-               nil,
-               nil,
-               (48...51),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bbb"
-             )]
-          ),
-          (51...52)
-        ),
-        StringNode(52...56)(nil, (52...56), nil, " ccc")],
-       (56...57),
-       0
-     ),
-     ArrayNode(59...86)(
-       [CallNode(60...80)(
-          RegularExpressionNode(60...73)(
-            (60...61),
-            (61...72),
-            (72...73),
-            "(?<foo>bar)",
-            0
-          ),
-          nil,
-          (74...76),
-          nil,
-          ArgumentsNode(77...80)(
-            [CallNode(77...80)(
-               nil,
-               nil,
-               (77...80),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "baz"
-             )]
-          ),
-          nil,
-          nil,
-          0,
-          "=~"
-        ),
-        LocalVariableReadNode(82...85)(:foo, 0)],
-       (59...60),
-       (85...86)
-     ),
-     RegularExpressionNode(88...94)((88...89), (89...92), (92...94), "abc", 1),
-     RegularExpressionNode(96...122)(
-       (96...99),
-       (99...120),
-       (120...122),
-       "[a-z$._?][w$.?\#@~]*:",
-       1
-     ),
-     RegularExpressionNode(124...161)(
-       (124...127),
-       (127...159),
-       (159...161),
-       "([a-z$._?][w$.?\#@~]*)( +)(equ)",
-       1
-     ),
-     RegularExpressionNode(163...188)(
-       (163...166),
-       (166...186),
-       (186...188),
-       "[a-z$._?][w$.?\#@~]*",
-       1
-     ),
-     RegularExpressionNode(190...249)(
-       (190...193),
-       (193...248),
-       (248...249),
-       "\n" + "(?:[w\#$%_']|()|(,)|[]|[0-9])*\n" + "  (?:[w\#$%_']+)\n",
-       0
-     ),
-     CallNode(251...267)(
-       RegularExpressionNode(251...259)(
-         (251...252),
-         (252...258),
-         (258...259),
-         "(?#))",
-         0
-       ),
-       nil,
-       (260...262),
-       nil,
-       ArgumentsNode(263...267)(
-         [StringNode(263...267)((263...264), (264...266), (266...267), "hi")]
-       ),
-       nil,
-       nil,
-       0,
-       "=~"
-     ),
-     RegularExpressionNode(269...278)(
-       (269...272),
-       (272...277),
-       (277...278),
-       "pound",
-       0
-     ),
-     InterpolatedRegularExpressionNode(280...293)(
-       (280...281),
-       [StringNode(281...285)(nil, (281...285), nil, "aaa "),
-        EmbeddedStatementsNode(285...291)(
-          (285...287),
-          StatementsNode(287...290)(
-            [CallNode(287...290)(
-               nil,
-               nil,
-               (287...290),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bbb"
-             )]
-          ),
-          (290...291)
-        )],
-       (291...293),
-       128
-     )]
-  )
-)
+@ ProgramNode (location: (0...293))
+├── locals: [:foo]
+└── statements:
+    @ StatementsNode (location: (0...293))
+    └── body: (length: 14)
+        ├── @ CallNode (location: (0...9))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...9))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ RegularExpressionNode (location: (4...9))
+        │   │           ├── opening_loc: (4...5) = "/"
+        │   │           ├── content_loc: (5...8) = "bar"
+        │   │           ├── closing_loc: (8...9) = "/"
+        │   │           ├── unescaped: "bar"
+        │   │           └── flags: 
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ RegularExpressionNode (location: (11...19))
+        │   ├── opening_loc: (11...14) = "%r{"
+        │   ├── content_loc: (14...17) = "abc"
+        │   ├── closing_loc: (17...19) = "}i"
+        │   ├── unescaped: "abc"
+        │   └── flags: ignore_case
+        ├── @ RegularExpressionNode (location: (21...26))
+        │   ├── opening_loc: (21...22) = "/"
+        │   ├── content_loc: (22...25) = "a\\b"
+        │   ├── closing_loc: (25...26) = "/"
+        │   ├── unescaped: "a\b"
+        │   └── flags: 
+        ├── @ InterpolatedRegularExpressionNode (location: (28...39))
+        │   ├── opening_loc: (28...29) = "/"
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (29...33))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (29...33) = "aaa "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "aaa "
+        │   │   └── @ EmbeddedVariableNode (location: (33...38))
+        │   │       ├── operator_loc: (33...34) = "#"
+        │   │       └── variable:
+        │   │           @ GlobalVariableReadNode (location: (34...38))
+        │   │           └── name: :$bbb
+        │   ├── closing_loc: (38...39) = "/"
+        │   └── flags: 
+        ├── @ InterpolatedRegularExpressionNode (location: (41...57))
+        │   ├── opening_loc: (41...42) = "/"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (42...46))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (42...46) = "aaa "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "aaa "
+        │   │   ├── @ EmbeddedStatementsNode (location: (46...52))
+        │   │   │   ├── opening_loc: (46...48) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (48...51))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (48...51))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (48...51) = "bbb"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bbb"
+        │   │   │   └── closing_loc: (51...52) = "}"
+        │   │   └── @ StringNode (location: (52...56))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (52...56) = " ccc"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: " ccc"
+        │   ├── closing_loc: (56...57) = "/"
+        │   └── flags: 
+        ├── @ ArrayNode (location: (59...86))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ CallNode (location: (60...80))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ RegularExpressionNode (location: (60...73))
+        │   │   │   │   ├── opening_loc: (60...61) = "/"
+        │   │   │   │   ├── content_loc: (61...72) = "(?<foo>bar)"
+        │   │   │   │   ├── closing_loc: (72...73) = "/"
+        │   │   │   │   ├── unescaped: "(?<foo>bar)"
+        │   │   │   │   └── flags: 
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (74...76) = "=~"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (77...80))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (77...80))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (77...80) = "baz"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "baz"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "=~"
+        │   │   └── @ LocalVariableReadNode (location: (82...85))
+        │   │       ├── name: :foo
+        │   │       └── depth: 0
+        │   ├── opening_loc: (59...60) = "["
+        │   └── closing_loc: (85...86) = "]"
+        ├── @ RegularExpressionNode (location: (88...94))
+        │   ├── opening_loc: (88...89) = "/"
+        │   ├── content_loc: (89...92) = "abc"
+        │   ├── closing_loc: (92...94) = "/i"
+        │   ├── unescaped: "abc"
+        │   └── flags: ignore_case
+        ├── @ RegularExpressionNode (location: (96...122))
+        │   ├── opening_loc: (96...99) = "%r/"
+        │   ├── content_loc: (99...120) = "[a-z$._?][\\w$.?\#@~]*:"
+        │   ├── closing_loc: (120...122) = "/i"
+        │   ├── unescaped: "[a-z$._?][w$.?\#@~]*:"
+        │   └── flags: ignore_case
+        ├── @ RegularExpressionNode (location: (124...161))
+        │   ├── opening_loc: (124...127) = "%r/"
+        │   ├── content_loc: (127...159) = "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)"
+        │   ├── closing_loc: (159...161) = "/i"
+        │   ├── unescaped: "([a-z$._?][w$.?\#@~]*)( +)(equ)"
+        │   └── flags: ignore_case
+        ├── @ RegularExpressionNode (location: (163...188))
+        │   ├── opening_loc: (163...166) = "%r/"
+        │   ├── content_loc: (166...186) = "[a-z$._?][\\w$.?\#@~]*"
+        │   ├── closing_loc: (186...188) = "/i"
+        │   ├── unescaped: "[a-z$._?][w$.?\#@~]*"
+        │   └── flags: ignore_case
+        ├── @ RegularExpressionNode (location: (190...249))
+        │   ├── opening_loc: (190...193) = "%r("
+        │   ├── content_loc: (193...248) = "\n(?:[\\w\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n  (?:[\\w\#$%_']+)\n"
+        │   ├── closing_loc: (248...249) = ")"
+        │   ├── unescaped: "\n(?:[w\#$%_']|()|(,)|[]|[0-9])*\n  (?:[w\#$%_']+)\n"
+        │   └── flags: 
+        ├── @ CallNode (location: (251...267))
+        │   ├── receiver:
+        │   │   @ RegularExpressionNode (location: (251...259))
+        │   │   ├── opening_loc: (251...252) = "/"
+        │   │   ├── content_loc: (252...258) = "(?#\\))"
+        │   │   ├── closing_loc: (258...259) = "/"
+        │   │   ├── unescaped: "(?#))"
+        │   │   └── flags: 
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (260...262) = "=~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (263...267))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (263...267))
+        │   │           ├── opening_loc: (263...264) = "\""
+        │   │           ├── content_loc: (264...266) = "hi"
+        │   │           ├── closing_loc: (266...267) = "\""
+        │   │           └── unescaped: "hi"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=~"
+        ├── @ RegularExpressionNode (location: (269...278))
+        │   ├── opening_loc: (269...272) = "%r#"
+        │   ├── content_loc: (272...277) = "pound"
+        │   ├── closing_loc: (277...278) = "#"
+        │   ├── unescaped: "pound"
+        │   └── flags: 
+        └── @ InterpolatedRegularExpressionNode (location: (280...293))
+            ├── opening_loc: (280...281) = "/"
+            ├── parts: (length: 2)
+            │   ├── @ StringNode (location: (281...285))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (281...285) = "aaa "
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "aaa "
+            │   └── @ EmbeddedStatementsNode (location: (285...291))
+            │       ├── opening_loc: (285...287) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (287...290))
+            │       │   └── body: (length: 1)
+            │       │       └── @ CallNode (location: (287...290))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (287...290) = "bbb"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments: ∅
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: variable_call
+            │       │           └── name: "bbb"
+            │       └── closing_loc: (290...291) = "}"
+            ├── closing_loc: (291...293) = "/o"
+            └── flags: once
diff --git a/test/yarp/snapshots/rescue.txt b/test/yarp/snapshots/rescue.txt
index 9decb56292..e4a24d170b 100644
--- a/test/yarp/snapshots/rescue.txt
+++ b/test/yarp/snapshots/rescue.txt
@@ -1,308 +1,361 @@
-ProgramNode(0...316)(
-  [:a],
-  StatementsNode(0...316)(
-    [RescueModifierNode(0...14)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (4...10),
-       NilNode(11...14)()
-     ),
-     RescueModifierNode(16...30)(
-       CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "foo"),
-       (20...26),
-       NilNode(27...30)()
-     ),
-     RescueModifierNode(32...48)(
-       BreakNode(32...37)(nil, (32...37)),
-       (38...44),
-       NilNode(45...48)()
-     ),
-     RescueModifierNode(50...65)(
-       NextNode(50...54)(nil, (50...54)),
-       (55...61),
-       NilNode(62...65)()
-     ),
-     RescueModifierNode(67...84)(
-       ReturnNode(67...73)((67...73), nil),
-       (74...80),
-       NilNode(81...84)()
-     ),
-     RescueModifierNode(86...105)(
-       CallNode(86...89)(nil, nil, (86...89), nil, nil, nil, nil, 2, "foo"),
-       (90...96),
-       OrNode(97...105)(
-         NilNode(97...100)(),
-         IntegerNode(104...105)(),
-         (101...103)
-       )
-     ),
-     RescueModifierNode(107...129)(
-       CallNode(107...110)(
-         nil,
-         nil,
-         (107...110),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (111...117),
-       IfNode(118...129)(
-         nil,
-         NilNode(118...121)(),
-         StatementsNode(124...125)([IntegerNode(124...125)()]),
-         ElseNode(126...129)(
-           (126...127),
-           StatementsNode(128...129)([IntegerNode(128...129)()]),
-           nil
-         ),
-         nil
-       )
-     ),
-     BeginNode(131...155)(
-       (131...136),
-       StatementsNode(138...139)(
-         [CallNode(138...139)(
-            nil,
-            nil,
-            (138...139),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(141...150)(
-         (141...147),
-         [SplatNode(148...150)(
-            (148...149),
-            CallNode(149...150)(
-              nil,
-              nil,
-              (149...150),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )
-          )],
-         nil,
-         nil,
-         nil,
-         nil
-       ),
-       nil,
-       nil,
-       (152...155)
-     ),
-     CallNode(157...212)(
-       nil,
-       nil,
-       (157...160),
-       nil,
-       nil,
-       nil,
-       BlockNode(161...212)(
-         [:x],
-         BlockParametersNode(164...167)(
-           ParametersNode(165...166)(
-             [RequiredParameterNode(165...166)(:x)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (164...165),
-           (166...167)
-         ),
-         StatementsNode(170...208)(
-           [RescueModifierNode(170...208)(
-              CallNode(170...176)(
-                nil,
-                nil,
-                (170...173),
-                (173...174),
-                ArgumentsNode(174...175)(
-                  [CallNode(174...175)(
-                     nil,
-                     nil,
-                     (174...175),
-                     nil,
-                     nil,
-                     nil,
-                     nil,
-                     2,
-                     "y"
-                   )]
-                ),
-                (175...176),
-                nil,
-                0,
-                "bar"
-              ),
-              (177...183),
-              CallNode(184...208)(
-                nil,
-                nil,
-                (184...197),
-                nil,
-                ArgumentsNode(198...208)(
-                  [CallNode(198...208)(
-                     nil,
-                     nil,
-                     (198...202),
-                     nil,
-                     ArgumentsNode(203...208)(
-                       [StringNode(203...208)(
-                          (203...204),
-                          (204...207),
-                          (207...208),
-                          "baz"
-                        )]
-                     ),
-                     nil,
-                     nil,
-                     0,
-                     "fail"
-                   )]
-                ),
-                nil,
-                nil,
-                0,
-                "ArgumentError"
-              )
-            )]
-         ),
-         (161...163),
-         (209...212)
-       ),
-       0,
-       "foo"
-     ),
-     IfNode(214...245)(
-       (214...216),
-       LocalVariableWriteNode(217...235)(
-         :a,
-         0,
-         (217...218),
-         RescueModifierNode(221...235)(
-           CallNode(221...224)(
-             nil,
-             nil,
-             (221...224),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "foo"
-           ),
-           (225...231),
-           NilNode(232...235)()
-         ),
-         (219...220)
-       ),
-       StatementsNode(238...241)(
-         [CallNode(238...241)(
-            nil,
-            nil,
-            (238...241),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       nil,
-       (242...245)
-     ),
-     DefNode(247...291)(
-       :some_method,
-       (251...262),
-       nil,
-       nil,
-       StatementsNode(265...291)(
-         [CallNode(265...291)(
-            nil,
-            nil,
-            (265...277),
-            nil,
-            ArgumentsNode(278...291)(
-              [RescueModifierNode(278...291)(
-                 IntegerNode(278...280)(),
-                 (281...287),
-                 NilNode(288...291)()
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "other_method"
-          )]
-       ),
-       [],
-       (247...250),
-       nil,
-       nil,
-       nil,
-       (263...264),
-       nil
-     ),
-     DefNode(293...316)(
-       :a,
-       (297...298),
-       nil,
-       nil,
-       BeginNode(301...316)(
-         nil,
-         StatementsNode(301...305)(
-           [CallNode(301...305)(
-              nil,
-              nil,
-              (301...302),
-              nil,
-              ArgumentsNode(303...305)(
-                [KeywordHashNode(303...305)(
-                   [AssocNode(303...305)(
-                      SymbolNode(303...305)(
-                        nil,
-                        (303...304),
-                        (304...305),
-                        "b"
-                      ),
-                      nil,
-                      nil
-                    )]
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "a"
-            )]
-         ),
-         RescueNode(306...312)((306...312), [], nil, nil, nil, nil),
-         nil,
-         nil,
-         (313...316)
-       ),
-       [],
-       (293...296),
-       nil,
-       nil,
-       nil,
-       nil,
-       (313...316)
-     )]
-  )
-)
+@ ProgramNode (location: (0...316))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...316))
+    └── body: (length: 12)
+        ├── @ RescueModifierNode (location: (0...14))
+        │   ├── expression:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── keyword_loc: (4...10) = "rescue"
+        │   └── rescue_expression:
+        │       @ NilNode (location: (11...14))
+        ├── @ RescueModifierNode (location: (16...30))
+        │   ├── expression:
+        │   │   @ CallNode (location: (16...19))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (16...19) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── keyword_loc: (20...26) = "rescue"
+        │   └── rescue_expression:
+        │       @ NilNode (location: (27...30))
+        ├── @ RescueModifierNode (location: (32...48))
+        │   ├── expression:
+        │   │   @ BreakNode (location: (32...37))
+        │   │   ├── arguments: ∅
+        │   │   └── keyword_loc: (32...37) = "break"
+        │   ├── keyword_loc: (38...44) = "rescue"
+        │   └── rescue_expression:
+        │       @ NilNode (location: (45...48))
+        ├── @ RescueModifierNode (location: (50...65))
+        │   ├── expression:
+        │   │   @ NextNode (location: (50...54))
+        │   │   ├── arguments: ∅
+        │   │   └── keyword_loc: (50...54) = "next"
+        │   ├── keyword_loc: (55...61) = "rescue"
+        │   └── rescue_expression:
+        │       @ NilNode (location: (62...65))
+        ├── @ RescueModifierNode (location: (67...84))
+        │   ├── expression:
+        │   │   @ ReturnNode (location: (67...73))
+        │   │   ├── keyword_loc: (67...73) = "return"
+        │   │   └── arguments: ∅
+        │   ├── keyword_loc: (74...80) = "rescue"
+        │   └── rescue_expression:
+        │       @ NilNode (location: (81...84))
+        ├── @ RescueModifierNode (location: (86...105))
+        │   ├── expression:
+        │   │   @ CallNode (location: (86...89))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (86...89) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── keyword_loc: (90...96) = "rescue"
+        │   └── rescue_expression:
+        │       @ OrNode (location: (97...105))
+        │       ├── left:
+        │       │   @ NilNode (location: (97...100))
+        │       ├── right:
+        │       │   @ IntegerNode (location: (104...105))
+        │       └── operator_loc: (101...103) = "||"
+        ├── @ RescueModifierNode (location: (107...129))
+        │   ├── expression:
+        │   │   @ CallNode (location: (107...110))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (107...110) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── keyword_loc: (111...117) = "rescue"
+        │   └── rescue_expression:
+        │       @ IfNode (location: (118...129))
+        │       ├── if_keyword_loc: ∅
+        │       ├── predicate:
+        │       │   @ NilNode (location: (118...121))
+        │       ├── statements:
+        │       │   @ StatementsNode (location: (124...125))
+        │       │   └── body: (length: 1)
+        │       │       └── @ IntegerNode (location: (124...125))
+        │       ├── consequent:
+        │       │   @ ElseNode (location: (126...129))
+        │       │   ├── else_keyword_loc: (126...127) = ":"
+        │       │   ├── statements:
+        │       │   │   @ StatementsNode (location: (128...129))
+        │       │   │   └── body: (length: 1)
+        │       │   │       └── @ IntegerNode (location: (128...129))
+        │       │   └── end_keyword_loc: ∅
+        │       └── end_keyword_loc: ∅
+        ├── @ BeginNode (location: (131...155))
+        │   ├── begin_keyword_loc: (131...136) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (138...139))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (138...139))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (138...139) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (141...150))
+        │   │   ├── keyword_loc: (141...147) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ SplatNode (location: (148...150))
+        │   │   │       ├── operator_loc: (148...149) = "*"
+        │   │   │       └── expression:
+        │   │   │           @ CallNode (location: (149...150))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (149...150) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements: ∅
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (152...155) = "end"
+        ├── @ CallNode (location: (157...212))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (157...160) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (161...212))
+        │   │   ├── locals: [:x]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (164...167))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (165...166))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (165...166))
+        │   │   │   │   │       └── name: :x
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (164...165) = "|"
+        │   │   │   └── closing_loc: (166...167) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (170...208))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ RescueModifierNode (location: (170...208))
+        │   │   │           ├── expression:
+        │   │   │           │   @ CallNode (location: (170...176))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (170...173) = "bar"
+        │   │   │           │   ├── opening_loc: (173...174) = "("
+        │   │   │           │   ├── arguments:
+        │   │   │           │   │   @ ArgumentsNode (location: (174...175))
+        │   │   │           │   │   └── arguments: (length: 1)
+        │   │   │           │   │       └── @ CallNode (location: (174...175))
+        │   │   │           │   │           ├── receiver: ∅
+        │   │   │           │   │           ├── call_operator_loc: ∅
+        │   │   │           │   │           ├── message_loc: (174...175) = "y"
+        │   │   │           │   │           ├── opening_loc: ∅
+        │   │   │           │   │           ├── arguments: ∅
+        │   │   │           │   │           ├── closing_loc: ∅
+        │   │   │           │   │           ├── block: ∅
+        │   │   │           │   │           ├── flags: variable_call
+        │   │   │           │   │           └── name: "y"
+        │   │   │           │   ├── closing_loc: (175...176) = ")"
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: 
+        │   │   │           │   └── name: "bar"
+        │   │   │           ├── keyword_loc: (177...183) = "rescue"
+        │   │   │           └── rescue_expression:
+        │   │   │               @ CallNode (location: (184...208))
+        │   │   │               ├── receiver: ∅
+        │   │   │               ├── call_operator_loc: ∅
+        │   │   │               ├── message_loc: (184...197) = "ArgumentError"
+        │   │   │               ├── opening_loc: ∅
+        │   │   │               ├── arguments:
+        │   │   │               │   @ ArgumentsNode (location: (198...208))
+        │   │   │               │   └── arguments: (length: 1)
+        │   │   │               │       └── @ CallNode (location: (198...208))
+        │   │   │               │           ├── receiver: ∅
+        │   │   │               │           ├── call_operator_loc: ∅
+        │   │   │               │           ├── message_loc: (198...202) = "fail"
+        │   │   │               │           ├── opening_loc: ∅
+        │   │   │               │           ├── arguments:
+        │   │   │               │           │   @ ArgumentsNode (location: (203...208))
+        │   │   │               │           │   └── arguments: (length: 1)
+        │   │   │               │           │       └── @ StringNode (location: (203...208))
+        │   │   │               │           │           ├── opening_loc: (203...204) = "\""
+        │   │   │               │           │           ├── content_loc: (204...207) = "baz"
+        │   │   │               │           │           ├── closing_loc: (207...208) = "\""
+        │   │   │               │           │           └── unescaped: "baz"
+        │   │   │               │           ├── closing_loc: ∅
+        │   │   │               │           ├── block: ∅
+        │   │   │               │           ├── flags: 
+        │   │   │               │           └── name: "fail"
+        │   │   │               ├── closing_loc: ∅
+        │   │   │               ├── block: ∅
+        │   │   │               ├── flags: 
+        │   │   │               └── name: "ArgumentError"
+        │   │   ├── opening_loc: (161...163) = "do"
+        │   │   └── closing_loc: (209...212) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ IfNode (location: (214...245))
+        │   ├── if_keyword_loc: (214...216) = "if"
+        │   ├── predicate:
+        │   │   @ LocalVariableWriteNode (location: (217...235))
+        │   │   ├── name: :a
+        │   │   ├── depth: 0
+        │   │   ├── name_loc: (217...218) = "a"
+        │   │   ├── value:
+        │   │   │   @ RescueModifierNode (location: (221...235))
+        │   │   │   ├── expression:
+        │   │   │   │   @ CallNode (location: (221...224))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (221...224) = "foo"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "foo"
+        │   │   │   ├── keyword_loc: (225...231) = "rescue"
+        │   │   │   └── rescue_expression:
+        │   │   │       @ NilNode (location: (232...235))
+        │   │   └── operator_loc: (219...220) = "="
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (238...241))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (238...241))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (238...241) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (242...245) = "end"
+        ├── @ DefNode (location: (247...291))
+        │   ├── name: :some_method
+        │   ├── name_loc: (251...262) = "some_method"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (265...291))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (265...291))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (265...277) = "other_method"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (278...291))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ RescueModifierNode (location: (278...291))
+        │   │           │           ├── expression:
+        │   │           │           │   @ IntegerNode (location: (278...280))
+        │   │           │           ├── keyword_loc: (281...287) = "rescue"
+        │   │           │           └── rescue_expression:
+        │   │           │               @ NilNode (location: (288...291))
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "other_method"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (247...250) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (263...264) = "="
+        │   └── end_keyword_loc: ∅
+        └── @ DefNode (location: (293...316))
+            ├── name: :a
+            ├── name_loc: (297...298) = "a"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ BeginNode (location: (301...316))
+            │   ├── begin_keyword_loc: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (301...305))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (301...305))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (301...302) = "a"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments:
+            │   │           │   @ ArgumentsNode (location: (303...305))
+            │   │           │   └── arguments: (length: 1)
+            │   │           │       └── @ KeywordHashNode (location: (303...305))
+            │   │           │           └── elements: (length: 1)
+            │   │           │               └── @ AssocNode (location: (303...305))
+            │   │           │                   ├── key:
+            │   │           │                   │   @ SymbolNode (location: (303...305))
+            │   │           │                   │   ├── opening_loc: ∅
+            │   │           │                   │   ├── value_loc: (303...304) = "b"
+            │   │           │                   │   ├── closing_loc: (304...305) = ":"
+            │   │           │                   │   └── unescaped: "b"
+            │   │           │                   ├── value: ∅
+            │   │           │                   └── operator_loc: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "a"
+            │   ├── rescue_clause:
+            │   │   @ RescueNode (location: (306...312))
+            │   │   ├── keyword_loc: (306...312) = "rescue"
+            │   │   ├── exceptions: (length: 0)
+            │   │   ├── operator_loc: ∅
+            │   │   ├── reference: ∅
+            │   │   ├── statements: ∅
+            │   │   └── consequent: ∅
+            │   ├── else_clause: ∅
+            │   ├── ensure_clause: ∅
+            │   └── end_keyword_loc: (313...316) = "end"
+            ├── locals: []
+            ├── def_keyword_loc: (293...296) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (313...316) = "end"
diff --git a/test/yarp/snapshots/return.txt b/test/yarp/snapshots/return.txt
index bbb4b63af2..04d527038d 100644
--- a/test/yarp/snapshots/return.txt
+++ b/test/yarp/snapshots/return.txt
@@ -1,92 +1,111 @@
-ProgramNode(0...139)(
-  [],
-  StatementsNode(0...139)(
-    [ReturnNode(0...6)((0...6), nil),
-     ReturnNode(8...28)(
-       (8...14),
-       ArgumentsNode(15...28)(
-         [ParenthesesNode(15...18)(
-            StatementsNode(16...17)([IntegerNode(16...17)()]),
-            (15...16),
-            (17...18)
-          ),
-          ParenthesesNode(20...23)(
-            StatementsNode(21...22)([IntegerNode(21...22)()]),
-            (20...21),
-            (22...23)
-          ),
-          ParenthesesNode(25...28)(
-            StatementsNode(26...27)([IntegerNode(26...27)()]),
-            (25...26),
-            (27...28)
-          )]
-       )
-     ),
-     ReturnNode(30...39)(
-       (30...36),
-       ArgumentsNode(37...39)(
-         [SplatNode(37...39)((37...38), IntegerNode(38...39)())]
-       )
-     ),
-     ReturnNode(41...49)(
-       (41...47),
-       ArgumentsNode(48...49)([IntegerNode(48...49)()])
-     ),
-     ReturnNode(51...65)(
-       (51...57),
-       ArgumentsNode(58...65)(
-         [IntegerNode(58...59)(),
-          IntegerNode(61...62)(),
-          IntegerNode(64...65)()]
-       )
-     ),
-     ReturnNode(67...81)(
-       (67...73),
-       ArgumentsNode(74...81)(
-         [IntegerNode(74...75)(),
-          IntegerNode(77...78)(),
-          IntegerNode(80...81)()]
-       )
-     ),
-     ReturnNode(83...99)(
-       (83...89),
-       ArgumentsNode(90...99)(
-         [ArrayNode(90...99)(
-            [IntegerNode(91...92)(),
-             IntegerNode(94...95)(),
-             IntegerNode(97...98)()],
-            (90...91),
-            (98...99)
-          )]
-       )
-     ),
-     ReturnNode(101...118)(
-       (101...107),
-       ArgumentsNode(107...118)(
-         [ParenthesesNode(107...118)(
-            StatementsNode(111...116)(
-              [IntegerNode(111...112)(), IntegerNode(115...116)()]
-            ),
-            (107...108),
-            (117...118)
-          )]
-       )
-     ),
-     ReturnNode(120...128)(
-       (120...126),
-       ArgumentsNode(126...128)(
-         [ParenthesesNode(126...128)(nil, (126...127), (127...128))]
-       )
-     ),
-     ReturnNode(130...139)(
-       (130...136),
-       ArgumentsNode(136...139)(
-         [ParenthesesNode(136...139)(
-            StatementsNode(137...138)([IntegerNode(137...138)()]),
-            (136...137),
-            (138...139)
-          )]
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...139))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...139))
+    └── body: (length: 10)
+        ├── @ ReturnNode (location: (0...6))
+        │   ├── keyword_loc: (0...6) = "return"
+        │   └── arguments: ∅
+        ├── @ ReturnNode (location: (8...28))
+        │   ├── keyword_loc: (8...14) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (15...28))
+        │       └── arguments: (length: 3)
+        │           ├── @ ParenthesesNode (location: (15...18))
+        │           │   ├── body:
+        │           │   │   @ StatementsNode (location: (16...17))
+        │           │   │   └── body: (length: 1)
+        │           │   │       └── @ IntegerNode (location: (16...17))
+        │           │   ├── opening_loc: (15...16) = "("
+        │           │   └── closing_loc: (17...18) = ")"
+        │           ├── @ ParenthesesNode (location: (20...23))
+        │           │   ├── body:
+        │           │   │   @ StatementsNode (location: (21...22))
+        │           │   │   └── body: (length: 1)
+        │           │   │       └── @ IntegerNode (location: (21...22))
+        │           │   ├── opening_loc: (20...21) = "("
+        │           │   └── closing_loc: (22...23) = ")"
+        │           └── @ ParenthesesNode (location: (25...28))
+        │               ├── body:
+        │               │   @ StatementsNode (location: (26...27))
+        │               │   └── body: (length: 1)
+        │               │       └── @ IntegerNode (location: (26...27))
+        │               ├── opening_loc: (25...26) = "("
+        │               └── closing_loc: (27...28) = ")"
+        ├── @ ReturnNode (location: (30...39))
+        │   ├── keyword_loc: (30...36) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (37...39))
+        │       └── arguments: (length: 1)
+        │           └── @ SplatNode (location: (37...39))
+        │               ├── operator_loc: (37...38) = "*"
+        │               └── expression:
+        │                   @ IntegerNode (location: (38...39))
+        ├── @ ReturnNode (location: (41...49))
+        │   ├── keyword_loc: (41...47) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (48...49))
+        │       └── arguments: (length: 1)
+        │           └── @ IntegerNode (location: (48...49))
+        ├── @ ReturnNode (location: (51...65))
+        │   ├── keyword_loc: (51...57) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (58...65))
+        │       └── arguments: (length: 3)
+        │           ├── @ IntegerNode (location: (58...59))
+        │           ├── @ IntegerNode (location: (61...62))
+        │           └── @ IntegerNode (location: (64...65))
+        ├── @ ReturnNode (location: (67...81))
+        │   ├── keyword_loc: (67...73) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (74...81))
+        │       └── arguments: (length: 3)
+        │           ├── @ IntegerNode (location: (74...75))
+        │           ├── @ IntegerNode (location: (77...78))
+        │           └── @ IntegerNode (location: (80...81))
+        ├── @ ReturnNode (location: (83...99))
+        │   ├── keyword_loc: (83...89) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (90...99))
+        │       └── arguments: (length: 1)
+        │           └── @ ArrayNode (location: (90...99))
+        │               ├── elements: (length: 3)
+        │               │   ├── @ IntegerNode (location: (91...92))
+        │               │   ├── @ IntegerNode (location: (94...95))
+        │               │   └── @ IntegerNode (location: (97...98))
+        │               ├── opening_loc: (90...91) = "["
+        │               └── closing_loc: (98...99) = "]"
+        ├── @ ReturnNode (location: (101...118))
+        │   ├── keyword_loc: (101...107) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (107...118))
+        │       └── arguments: (length: 1)
+        │           └── @ ParenthesesNode (location: (107...118))
+        │               ├── body:
+        │               │   @ StatementsNode (location: (111...116))
+        │               │   └── body: (length: 2)
+        │               │       ├── @ IntegerNode (location: (111...112))
+        │               │       └── @ IntegerNode (location: (115...116))
+        │               ├── opening_loc: (107...108) = "("
+        │               └── closing_loc: (117...118) = ")"
+        ├── @ ReturnNode (location: (120...128))
+        │   ├── keyword_loc: (120...126) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (126...128))
+        │       └── arguments: (length: 1)
+        │           └── @ ParenthesesNode (location: (126...128))
+        │               ├── body: ∅
+        │               ├── opening_loc: (126...127) = "("
+        │               └── closing_loc: (127...128) = ")"
+        └── @ ReturnNode (location: (130...139))
+            ├── keyword_loc: (130...136) = "return"
+            └── arguments:
+                @ ArgumentsNode (location: (136...139))
+                └── arguments: (length: 1)
+                    └── @ ParenthesesNode (location: (136...139))
+                        ├── body:
+                        │   @ StatementsNode (location: (137...138))
+                        │   └── body: (length: 1)
+                        │       └── @ IntegerNode (location: (137...138))
+                        ├── opening_loc: (136...137) = "("
+                        └── closing_loc: (138...139) = ")"
diff --git a/test/yarp/snapshots/seattlerb/BEGIN.txt b/test/yarp/snapshots/seattlerb/BEGIN.txt
index f3366c5610..ed4bcd8d39 100644
--- a/test/yarp/snapshots/seattlerb/BEGIN.txt
+++ b/test/yarp/snapshots/seattlerb/BEGIN.txt
@@ -1,11 +1,13 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [PreExecutionNode(0...12)(
-       StatementsNode(8...10)([IntegerNode(8...10)()]),
-       (0...5),
-       (6...7),
-       (11...12)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ PreExecutionNode (location: (0...12))
+            ├── statements:
+            │   @ StatementsNode (location: (8...10))
+            │   └── body: (length: 1)
+            │       └── @ IntegerNode (location: (8...10))
+            ├── keyword_loc: (0...5) = "BEGIN"
+            ├── opening_loc: (6...7) = "{"
+            └── closing_loc: (11...12) = "}"
diff --git a/test/yarp/snapshots/seattlerb/TestRubyParserShared.txt b/test/yarp/snapshots/seattlerb/TestRubyParserShared.txt
index 8c4c0ecc50..d58647a38a 100644
--- a/test/yarp/snapshots/seattlerb/TestRubyParserShared.txt
+++ b/test/yarp/snapshots/seattlerb/TestRubyParserShared.txt
@@ -1,228 +1,326 @@
-ProgramNode(0...689)(
-  [],
-  StatementsNode(0...689)(
-    [ArrayNode(0...7)([], (0...3), (6...7)),
-     ArrayNode(9...26)(
-       [SymbolNode(13...18)(nil, (13...18), nil, "line2"),
-        SymbolNode(19...24)(nil, (19...24), nil, "line3")],
-       (9...12),
-       (25...26)
-     ),
-     ArrayNode(28...35)([], (28...31), (34...35)),
-     ArrayNode(37...54)(
-       [StringNode(41...46)(nil, (41...46), nil, "line2"),
-        StringNode(47...52)(nil, (47...52), nil, "line3")],
-       (37...40),
-       (53...54)
-     ),
-     ArrayNode(56...63)([], (56...59), (62...63)),
-     ArrayNode(65...82)(
-       [SymbolNode(69...74)(nil, (69...74), nil, "line2"),
-        SymbolNode(75...80)(nil, (75...80), nil, "line3")],
-       (65...68),
-       (81...82)
-     ),
-     RegularExpressionNode(84...91)(
-       (84...87),
-       (87...90),
-       (90...91),
-       "\n" + "\n" + "\n",
-       0
-     ),
-     ArrayNode(93...100)([], (93...96), (99...100)),
-     ArrayNode(102...119)(
-       [StringNode(106...111)(nil, (106...111), nil, "line2"),
-        StringNode(112...117)(nil, (112...117), nil, "line3")],
-       (102...105),
-       (118...119)
-     ),
-     ArrayNode(121...139)(
-       [SymbolNode(123...129)((123...124), (124...129), nil, "line2"),
-        SymbolNode(131...137)((131...132), (132...137), nil, "line3")],
-       (121...122),
-       (138...139)
-     ),
-     ClassNode(141...269)(
-       [],
-       (141...146),
-       ConstantReadNode(147...148)(:X),
-       nil,
-       nil,
-       StatementsNode(168...246)(
-         [DefNode(168...246)(
-            :y,
-            (177...178),
-            SelfNode(172...176)(),
-            ParametersNode(179...200)(
-              [RequiredParameterNode(179...180)(:a),
-               RequiredParameterNode(199...200)(:b)],
-              [],
-              [],
-              nil,
-              [],
-              nil,
-              nil
-            ),
-            StatementsNode(220...225)(
-              [CallNode(220...225)(
-                 LocalVariableReadNode(220...221)(:a, 0),
-                 nil,
-                 (222...223),
-                 nil,
-                 ArgumentsNode(224...225)(
-                   [LocalVariableReadNode(224...225)(:b, 0)]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "+"
-               )]
-            ),
-            [:a, :b],
-            (168...171),
-            (176...177),
-            (178...179),
-            (200...201),
-            nil,
-            (243...246)
-          )]
-       ),
-       (266...269),
-       :X
-     ),
-     ClassNode(293...376)(
-       [],
-       (293...298),
-       ConstantReadNode(299...300)(:X),
-       nil,
-       nil,
-       StatementsNode(315...358)(
-         [ClassNode(315...358)(
-            [],
-            (315...320),
-            ConstantReadNode(321...322)(:Y),
-            nil,
-            nil,
-            StatementsNode(337...343)(
-              [ConstantWriteNode(337...343)(
-                 :Z,
-                 (337...338),
-                 IntegerNode(341...343)(),
-                 (339...340)
-               )]
-            ),
-            (355...358),
-            :Y
-          )]
-       ),
-       (373...376),
-       :X
-     ),
-     ClassNode(395...498)(
-       [],
-       (395...400),
-       ConstantReadNode(401...402)(:X),
-       nil,
-       nil,
-       StatementsNode(417...480)(
-         [DefNode(417...480)(
-            :y,
-            (421...422),
-            nil,
-            ParametersNode(423...444)(
-              [RequiredParameterNode(423...424)(:a),
-               RequiredParameterNode(443...444)(:b)],
-              [],
-              [],
-              nil,
-              [],
-              nil,
-              nil
-            ),
-            StatementsNode(459...464)(
-              [CallNode(459...464)(
-                 LocalVariableReadNode(459...460)(:a, 0),
-                 nil,
-                 (461...462),
-                 nil,
-                 ArgumentsNode(463...464)(
-                   [LocalVariableReadNode(463...464)(:b, 0)]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "+"
-               )]
-            ),
-            [:a, :b],
-            (417...420),
-            nil,
-            (422...423),
-            (444...445),
-            nil,
-            (477...480)
-          )]
-       ),
-       (495...498),
-       :X
-     ),
-     ModuleNode(517...565)(
-       [],
-       (517...523),
-       ConstantReadNode(524...525)(:X),
-       StatementsNode(528...561)(
-         [ConstantWriteNode(528...561)(
-            :X,
-            (528...529),
-            ArrayNode(532...561)(
-              [SymbolNode(538...544)((538...539), (539...544), nil, "line3"),
-               SymbolNode(550...556)((550...551), (551...556), nil, "line4")],
-              (532...533),
-              (560...561)
-            ),
-            (530...531)
-          )]
-       ),
-       (562...565),
-       :X
-     ),
-     ModuleNode(568...651)(
-       [],
-       (568...574),
-       ConstantReadNode(575...576)(:X),
-       StatementsNode(590...633)(
-         [ModuleNode(590...633)(
-            [],
-            (590...596),
-            ConstantReadNode(597...598)(:Y),
-            StatementsNode(612...618)(
-              [ConstantWriteNode(612...618)(
-                 :Z,
-                 (612...613),
-                 IntegerNode(616...618)(),
-                 (614...615)
-               )]
-            ),
-            (630...633),
-            :Y
-          )]
-       ),
-       (648...651),
-       :X
-     ),
-     CallNode(670...689)(
-       nil,
-       nil,
-       (670...671),
-       (671...672),
-       ArgumentsNode(673...687)(
-         [SymbolNode(673...679)((673...674), (674...679), nil, "line2"),
-          SymbolNode(681...687)((681...682), (682...687), nil, "line3")]
-       ),
-       (688...689),
-       nil,
-       0,
-       "x"
-     )]
-  )
-)
+@ ProgramNode (location: (0...689))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...689))
+    └── body: (length: 16)
+        ├── @ ArrayNode (location: (0...7))
+        │   ├── elements: (length: 0)
+        │   ├── opening_loc: (0...3) = "%I["
+        │   └── closing_loc: (6...7) = "]"
+        ├── @ ArrayNode (location: (9...26))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ SymbolNode (location: (13...18))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (13...18) = "line2"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "line2"
+        │   │   └── @ SymbolNode (location: (19...24))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (19...24) = "line3"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "line3"
+        │   ├── opening_loc: (9...12) = "%I["
+        │   └── closing_loc: (25...26) = "]"
+        ├── @ ArrayNode (location: (28...35))
+        │   ├── elements: (length: 0)
+        │   ├── opening_loc: (28...31) = "%W["
+        │   └── closing_loc: (34...35) = "]"
+        ├── @ ArrayNode (location: (37...54))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ StringNode (location: (41...46))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (41...46) = "line2"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "line2"
+        │   │   └── @ StringNode (location: (47...52))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (47...52) = "line3"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "line3"
+        │   ├── opening_loc: (37...40) = "%W["
+        │   └── closing_loc: (53...54) = "]"
+        ├── @ ArrayNode (location: (56...63))
+        │   ├── elements: (length: 0)
+        │   ├── opening_loc: (56...59) = "%i["
+        │   └── closing_loc: (62...63) = "]"
+        ├── @ ArrayNode (location: (65...82))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ SymbolNode (location: (69...74))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (69...74) = "line2"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "line2"
+        │   │   └── @ SymbolNode (location: (75...80))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (75...80) = "line3"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "line3"
+        │   ├── opening_loc: (65...68) = "%i["
+        │   └── closing_loc: (81...82) = "]"
+        ├── @ RegularExpressionNode (location: (84...91))
+        │   ├── opening_loc: (84...87) = "%r["
+        │   ├── content_loc: (87...90) = "\n\n\n"
+        │   ├── closing_loc: (90...91) = "]"
+        │   ├── unescaped: "\n\n\n"
+        │   └── flags: 
+        ├── @ ArrayNode (location: (93...100))
+        │   ├── elements: (length: 0)
+        │   ├── opening_loc: (93...96) = "%w["
+        │   └── closing_loc: (99...100) = "]"
+        ├── @ ArrayNode (location: (102...119))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ StringNode (location: (106...111))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (106...111) = "line2"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "line2"
+        │   │   └── @ StringNode (location: (112...117))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (112...117) = "line3"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "line3"
+        │   ├── opening_loc: (102...105) = "%w["
+        │   └── closing_loc: (118...119) = "]"
+        ├── @ ArrayNode (location: (121...139))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ SymbolNode (location: (123...129))
+        │   │   │   ├── opening_loc: (123...124) = ":"
+        │   │   │   ├── value_loc: (124...129) = "line2"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "line2"
+        │   │   └── @ SymbolNode (location: (131...137))
+        │   │       ├── opening_loc: (131...132) = ":"
+        │   │       ├── value_loc: (132...137) = "line3"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "line3"
+        │   ├── opening_loc: (121...122) = "["
+        │   └── closing_loc: (138...139) = "]"
+        ├── @ ClassNode (location: (141...269))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (141...146) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (147...148))
+        │   │   └── name: :X
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (168...246))
+        │   │   └── body: (length: 1)
+        │   │       └── @ DefNode (location: (168...246))
+        │   │           ├── name: :y
+        │   │           ├── name_loc: (177...178) = "y"
+        │   │           ├── receiver:
+        │   │           │   @ SelfNode (location: (172...176))
+        │   │           ├── parameters:
+        │   │           │   @ ParametersNode (location: (179...200))
+        │   │           │   ├── requireds: (length: 2)
+        │   │           │   │   ├── @ RequiredParameterNode (location: (179...180))
+        │   │           │   │   │   └── name: :a
+        │   │           │   │   └── @ RequiredParameterNode (location: (199...200))
+        │   │           │   │       └── name: :b
+        │   │           │   ├── optionals: (length: 0)
+        │   │           │   ├── posts: (length: 0)
+        │   │           │   ├── rest: ∅
+        │   │           │   ├── keywords: (length: 0)
+        │   │           │   ├── keyword_rest: ∅
+        │   │           │   └── block: ∅
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (220...225))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (220...225))
+        │   │           │           ├── receiver:
+        │   │           │           │   @ LocalVariableReadNode (location: (220...221))
+        │   │           │           │   ├── name: :a
+        │   │           │           │   └── depth: 0
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (222...223) = "+"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments:
+        │   │           │           │   @ ArgumentsNode (location: (224...225))
+        │   │           │           │   └── arguments: (length: 1)
+        │   │           │           │       └── @ LocalVariableReadNode (location: (224...225))
+        │   │           │           │           ├── name: :b
+        │   │           │           │           └── depth: 0
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "+"
+        │   │           ├── locals: [:a, :b]
+        │   │           ├── def_keyword_loc: (168...171) = "def"
+        │   │           ├── operator_loc: (176...177) = "."
+        │   │           ├── lparen_loc: (178...179) = "("
+        │   │           ├── rparen_loc: (200...201) = ")"
+        │   │           ├── equal_loc: ∅
+        │   │           └── end_keyword_loc: (243...246) = "end"
+        │   ├── end_keyword_loc: (266...269) = "end"
+        │   └── name: :X
+        ├── @ ClassNode (location: (293...376))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (293...298) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (299...300))
+        │   │   └── name: :X
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (315...358))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ClassNode (location: (315...358))
+        │   │           ├── locals: []
+        │   │           ├── class_keyword_loc: (315...320) = "class"
+        │   │           ├── constant_path:
+        │   │           │   @ ConstantReadNode (location: (321...322))
+        │   │           │   └── name: :Y
+        │   │           ├── inheritance_operator_loc: ∅
+        │   │           ├── superclass: ∅
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (337...343))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ ConstantWriteNode (location: (337...343))
+        │   │           │           ├── name: :Z
+        │   │           │           ├── name_loc: (337...338) = "Z"
+        │   │           │           ├── value:
+        │   │           │           │   @ IntegerNode (location: (341...343))
+        │   │           │           └── operator_loc: (339...340) = "="
+        │   │           ├── end_keyword_loc: (355...358) = "end"
+        │   │           └── name: :Y
+        │   ├── end_keyword_loc: (373...376) = "end"
+        │   └── name: :X
+        ├── @ ClassNode (location: (395...498))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (395...400) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (401...402))
+        │   │   └── name: :X
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (417...480))
+        │   │   └── body: (length: 1)
+        │   │       └── @ DefNode (location: (417...480))
+        │   │           ├── name: :y
+        │   │           ├── name_loc: (421...422) = "y"
+        │   │           ├── receiver: ∅
+        │   │           ├── parameters:
+        │   │           │   @ ParametersNode (location: (423...444))
+        │   │           │   ├── requireds: (length: 2)
+        │   │           │   │   ├── @ RequiredParameterNode (location: (423...424))
+        │   │           │   │   │   └── name: :a
+        │   │           │   │   └── @ RequiredParameterNode (location: (443...444))
+        │   │           │   │       └── name: :b
+        │   │           │   ├── optionals: (length: 0)
+        │   │           │   ├── posts: (length: 0)
+        │   │           │   ├── rest: ∅
+        │   │           │   ├── keywords: (length: 0)
+        │   │           │   ├── keyword_rest: ∅
+        │   │           │   └── block: ∅
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (459...464))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (459...464))
+        │   │           │           ├── receiver:
+        │   │           │           │   @ LocalVariableReadNode (location: (459...460))
+        │   │           │           │   ├── name: :a
+        │   │           │           │   └── depth: 0
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (461...462) = "+"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments:
+        │   │           │           │   @ ArgumentsNode (location: (463...464))
+        │   │           │           │   └── arguments: (length: 1)
+        │   │           │           │       └── @ LocalVariableReadNode (location: (463...464))
+        │   │           │           │           ├── name: :b
+        │   │           │           │           └── depth: 0
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "+"
+        │   │           ├── locals: [:a, :b]
+        │   │           ├── def_keyword_loc: (417...420) = "def"
+        │   │           ├── operator_loc: ∅
+        │   │           ├── lparen_loc: (422...423) = "("
+        │   │           ├── rparen_loc: (444...445) = ")"
+        │   │           ├── equal_loc: ∅
+        │   │           └── end_keyword_loc: (477...480) = "end"
+        │   ├── end_keyword_loc: (495...498) = "end"
+        │   └── name: :X
+        ├── @ ModuleNode (location: (517...565))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (517...523) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (524...525))
+        │   │   └── name: :X
+        │   ├── body:
+        │   │   @ StatementsNode (location: (528...561))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ConstantWriteNode (location: (528...561))
+        │   │           ├── name: :X
+        │   │           ├── name_loc: (528...529) = "X"
+        │   │           ├── value:
+        │   │           │   @ ArrayNode (location: (532...561))
+        │   │           │   ├── elements: (length: 2)
+        │   │           │   │   ├── @ SymbolNode (location: (538...544))
+        │   │           │   │   │   ├── opening_loc: (538...539) = ":"
+        │   │           │   │   │   ├── value_loc: (539...544) = "line3"
+        │   │           │   │   │   ├── closing_loc: ∅
+        │   │           │   │   │   └── unescaped: "line3"
+        │   │           │   │   └── @ SymbolNode (location: (550...556))
+        │   │           │   │       ├── opening_loc: (550...551) = ":"
+        │   │           │   │       ├── value_loc: (551...556) = "line4"
+        │   │           │   │       ├── closing_loc: ∅
+        │   │           │   │       └── unescaped: "line4"
+        │   │           │   ├── opening_loc: (532...533) = "["
+        │   │           │   └── closing_loc: (560...561) = "]"
+        │   │           └── operator_loc: (530...531) = "="
+        │   ├── end_keyword_loc: (562...565) = "end"
+        │   └── name: :X
+        ├── @ ModuleNode (location: (568...651))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (568...574) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (575...576))
+        │   │   └── name: :X
+        │   ├── body:
+        │   │   @ StatementsNode (location: (590...633))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ModuleNode (location: (590...633))
+        │   │           ├── locals: []
+        │   │           ├── module_keyword_loc: (590...596) = "module"
+        │   │           ├── constant_path:
+        │   │           │   @ ConstantReadNode (location: (597...598))
+        │   │           │   └── name: :Y
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (612...618))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ ConstantWriteNode (location: (612...618))
+        │   │           │           ├── name: :Z
+        │   │           │           ├── name_loc: (612...613) = "Z"
+        │   │           │           ├── value:
+        │   │           │           │   @ IntegerNode (location: (616...618))
+        │   │           │           └── operator_loc: (614...615) = "="
+        │   │           ├── end_keyword_loc: (630...633) = "end"
+        │   │           └── name: :Y
+        │   ├── end_keyword_loc: (648...651) = "end"
+        │   └── name: :X
+        └── @ CallNode (location: (670...689))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (670...671) = "x"
+            ├── opening_loc: (671...672) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (673...687))
+            │   └── arguments: (length: 2)
+            │       ├── @ SymbolNode (location: (673...679))
+            │       │   ├── opening_loc: (673...674) = ":"
+            │       │   ├── value_loc: (674...679) = "line2"
+            │       │   ├── closing_loc: ∅
+            │       │   └── unescaped: "line2"
+            │       └── @ SymbolNode (location: (681...687))
+            │           ├── opening_loc: (681...682) = ":"
+            │           ├── value_loc: (682...687) = "line3"
+            │           ├── closing_loc: ∅
+            │           └── unescaped: "line3"
+            ├── closing_loc: (688...689) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/__ENCODING__.txt b/test/yarp/snapshots/seattlerb/__ENCODING__.txt
index 2f5aaa5dfc..aa300aa827 100644
--- a/test/yarp/snapshots/seattlerb/__ENCODING__.txt
+++ b/test/yarp/snapshots/seattlerb/__ENCODING__.txt
@@ -1 +1,6 @@
-ProgramNode(0...12)([], StatementsNode(0...12)([SourceEncodingNode(0...12)()]))
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ SourceEncodingNode (location: (0...12))
diff --git a/test/yarp/snapshots/seattlerb/alias_gvar_backref.txt b/test/yarp/snapshots/seattlerb/alias_gvar_backref.txt
index d4890ed587..c667bbfc3d 100644
--- a/test/yarp/snapshots/seattlerb/alias_gvar_backref.txt
+++ b/test/yarp/snapshots/seattlerb/alias_gvar_backref.txt
@@ -1,10 +1,12 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [AliasNode(0...15)(
-       GlobalVariableReadNode(6...12)(:$MATCH),
-       BackReferenceReadNode(13...15)(),
-       (0...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ AliasNode (location: (0...15))
+            ├── new_name:
+            │   @ GlobalVariableReadNode (location: (6...12))
+            │   └── name: :$MATCH
+            ├── old_name:
+            │   @ BackReferenceReadNode (location: (13...15))
+            └── keyword_loc: (0...5) = "alias"
diff --git a/test/yarp/snapshots/seattlerb/alias_resword.txt b/test/yarp/snapshots/seattlerb/alias_resword.txt
index 8452f54826..0a0b7b1833 100644
--- a/test/yarp/snapshots/seattlerb/alias_resword.txt
+++ b/test/yarp/snapshots/seattlerb/alias_resword.txt
@@ -1,10 +1,19 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [AliasNode(0...12)(
-       SymbolNode(6...8)(nil, (6...8), nil, "in"),
-       SymbolNode(9...12)(nil, (9...12), nil, "out"),
-       (0...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ AliasNode (location: (0...12))
+            ├── new_name:
+            │   @ SymbolNode (location: (6...8))
+            │   ├── opening_loc: ∅
+            │   ├── value_loc: (6...8) = "in"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "in"
+            ├── old_name:
+            │   @ SymbolNode (location: (9...12))
+            │   ├── opening_loc: ∅
+            │   ├── value_loc: (9...12) = "out"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "out"
+            └── keyword_loc: (0...5) = "alias"
diff --git a/test/yarp/snapshots/seattlerb/and_multi.txt b/test/yarp/snapshots/seattlerb/and_multi.txt
index 2db7d7cedd..9799f8049b 100644
--- a/test/yarp/snapshots/seattlerb/and_multi.txt
+++ b/test/yarp/snapshots/seattlerb/and_multi.txt
@@ -1,24 +1,26 @@
-ProgramNode(0...27)(
-  [],
-  StatementsNode(0...27)(
-    [AndNode(0...27)(
-       AndNode(0...18)(
-         TrueNode(0...4)(),
-         CallNode(9...18)(
-           FalseNode(13...18)(),
-           nil,
-           (9...12),
-           nil,
-           nil,
-           nil,
-           nil,
-           0,
-           "!"
-         ),
-         (5...8)
-       ),
-       TrueNode(23...27)(),
-       (19...22)
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 1)
+        └── @ AndNode (location: (0...27))
+            ├── left:
+            │   @ AndNode (location: (0...18))
+            │   ├── left:
+            │   │   @ TrueNode (location: (0...4))
+            │   ├── right:
+            │   │   @ CallNode (location: (9...18))
+            │   │   ├── receiver:
+            │   │   │   @ FalseNode (location: (13...18))
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (9...12) = "not"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "!"
+            │   └── operator_loc: (5...8) = "and"
+            ├── right:
+            │   @ TrueNode (location: (23...27))
+            └── operator_loc: (19...22) = "and"
diff --git a/test/yarp/snapshots/seattlerb/aref_args_assocs.txt b/test/yarp/snapshots/seattlerb/aref_args_assocs.txt
index aac10a6763..1a0a456fae 100644
--- a/test/yarp/snapshots/seattlerb/aref_args_assocs.txt
+++ b/test/yarp/snapshots/seattlerb/aref_args_assocs.txt
@@ -1,16 +1,17 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [ArrayNode(0...8)(
-       [KeywordHashNode(1...7)(
-          [AssocNode(1...7)(
-             IntegerNode(1...2)(),
-             IntegerNode(6...7)(),
-             (3...5)
-           )]
-        )],
-       (0...1),
-       (7...8)
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...8))
+            ├── elements: (length: 1)
+            │   └── @ KeywordHashNode (location: (1...7))
+            │       └── elements: (length: 1)
+            │           └── @ AssocNode (location: (1...7))
+            │               ├── key:
+            │               │   @ IntegerNode (location: (1...2))
+            │               ├── value:
+            │               │   @ IntegerNode (location: (6...7))
+            │               └── operator_loc: (3...5) = "=>"
+            ├── opening_loc: (0...1) = "["
+            └── closing_loc: (7...8) = "]"
diff --git a/test/yarp/snapshots/seattlerb/aref_args_lit_assocs.txt b/test/yarp/snapshots/seattlerb/aref_args_lit_assocs.txt
index 24857076d0..7940b9c613 100644
--- a/test/yarp/snapshots/seattlerb/aref_args_lit_assocs.txt
+++ b/test/yarp/snapshots/seattlerb/aref_args_lit_assocs.txt
@@ -1,17 +1,18 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [ArrayNode(0...11)(
-       [IntegerNode(1...2)(),
-        KeywordHashNode(4...10)(
-          [AssocNode(4...10)(
-             IntegerNode(4...5)(),
-             IntegerNode(9...10)(),
-             (6...8)
-           )]
-        )],
-       (0...1),
-       (10...11)
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...11))
+            ├── elements: (length: 2)
+            │   ├── @ IntegerNode (location: (1...2))
+            │   └── @ KeywordHashNode (location: (4...10))
+            │       └── elements: (length: 1)
+            │           └── @ AssocNode (location: (4...10))
+            │               ├── key:
+            │               │   @ IntegerNode (location: (4...5))
+            │               ├── value:
+            │               │   @ IntegerNode (location: (9...10))
+            │               └── operator_loc: (6...8) = "=>"
+            ├── opening_loc: (0...1) = "["
+            └── closing_loc: (10...11) = "]"
diff --git a/test/yarp/snapshots/seattlerb/args_kw_block.txt b/test/yarp/snapshots/seattlerb/args_kw_block.txt
index 6aef28d170..a7cf356308 100644
--- a/test/yarp/snapshots/seattlerb/args_kw_block.txt
+++ b/test/yarp/snapshots/seattlerb/args_kw_block.txt
@@ -1,27 +1,35 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [DefNode(0...20)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...14)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...10)(:a, (6...8), IntegerNode(9...10)())],
-         nil,
-         BlockParameterNode(12...14)(:b, (13...14), (12...13))
-       ),
-       nil,
-       [:a, :b],
-       (0...3),
-       nil,
-       (5...6),
-       (14...15),
-       nil,
-       (17...20)
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...20))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...14))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (6...10))
+            │   │       ├── name: :a
+            │   │       ├── name_loc: (6...8) = "a:"
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (9...10))
+            │   ├── keyword_rest: ∅
+            │   └── block:
+            │       @ BlockParameterNode (location: (12...14))
+            │       ├── name: :b
+            │       ├── name_loc: (13...14) = "b"
+            │       └── operator_loc: (12...13) = "&"
+            ├── body: ∅
+            ├── locals: [:a, :b]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (14...15) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (17...20) = "end"
diff --git a/test/yarp/snapshots/seattlerb/array_line_breaks.txt b/test/yarp/snapshots/seattlerb/array_line_breaks.txt
index 4d5224564b..73b274f97c 100644
--- a/test/yarp/snapshots/seattlerb/array_line_breaks.txt
+++ b/test/yarp/snapshots/seattlerb/array_line_breaks.txt
@@ -1,12 +1,20 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [ArrayNode(0...11)(
-       [StringNode(2...5)((2...3), (3...4), (4...5), "a"),
-        StringNode(7...10)((7...8), (8...9), (9...10), "b")],
-       (0...1),
-       (10...11)
-     ),
-     IntegerNode(12...13)()]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...11))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ StringNode (location: (2...5))
+        │   │   │   ├── opening_loc: (2...3) = "'"
+        │   │   │   ├── content_loc: (3...4) = "a"
+        │   │   │   ├── closing_loc: (4...5) = "'"
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ StringNode (location: (7...10))
+        │   │       ├── opening_loc: (7...8) = "'"
+        │   │       ├── content_loc: (8...9) = "b"
+        │   │       ├── closing_loc: (9...10) = "'"
+        │   │       └── unescaped: "b"
+        │   ├── opening_loc: (0...1) = "["
+        │   └── closing_loc: (10...11) = "]"
+        └── @ IntegerNode (location: (12...13))
diff --git a/test/yarp/snapshots/seattlerb/array_lits_trailing_calls.txt b/test/yarp/snapshots/seattlerb/array_lits_trailing_calls.txt
index 8e9c131846..3b61a45579 100644
--- a/test/yarp/snapshots/seattlerb/array_lits_trailing_calls.txt
+++ b/test/yarp/snapshots/seattlerb/array_lits_trailing_calls.txt
@@ -1,27 +1,33 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...6)(
-       ArrayNode(0...4)([], (0...3), (3...4)),
-       (4...5),
-       (5...6),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "b"
-     ),
-     CallNode(8...12)(
-       ArrayNode(8...10)([], (8...9), (9...10)),
-       (10...11),
-       (11...12),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...6))
+        │   ├── receiver:
+        │   │   @ ArrayNode (location: (0...4))
+        │   │   ├── elements: (length: 0)
+        │   │   ├── opening_loc: (0...3) = "%w["
+        │   │   └── closing_loc: (3...4) = "]"
+        │   ├── call_operator_loc: (4...5) = "."
+        │   ├── message_loc: (5...6) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "b"
+        └── @ CallNode (location: (8...12))
+            ├── receiver:
+            │   @ ArrayNode (location: (8...10))
+            │   ├── elements: (length: 0)
+            │   ├── opening_loc: (8...9) = "["
+            │   └── closing_loc: (9...10) = "]"
+            ├── call_operator_loc: (10...11) = "."
+            ├── message_loc: (11...12) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/assoc__bare.txt b/test/yarp/snapshots/seattlerb/assoc__bare.txt
index ddefbd1f62..87ae0f72aa 100644
--- a/test/yarp/snapshots/seattlerb/assoc__bare.txt
+++ b/test/yarp/snapshots/seattlerb/assoc__bare.txt
@@ -1,14 +1,18 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [HashNode(0...6)(
-       (0...1),
-       [AssocNode(2...4)(
-          SymbolNode(2...4)(nil, (2...3), (3...4), "y"),
-          nil,
-          nil
-        )],
-       (5...6)
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ HashNode (location: (0...6))
+            ├── opening_loc: (0...1) = "{"
+            ├── elements: (length: 1)
+            │   └── @ AssocNode (location: (2...4))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (2...4))
+            │       │   ├── opening_loc: ∅
+            │       │   ├── value_loc: (2...3) = "y"
+            │       │   ├── closing_loc: (3...4) = ":"
+            │       │   └── unescaped: "y"
+            │       ├── value: ∅
+            │       └── operator_loc: ∅
+            └── closing_loc: (5...6) = "}"
diff --git a/test/yarp/snapshots/seattlerb/assoc_label.txt b/test/yarp/snapshots/seattlerb/assoc_label.txt
index 4fa881d191..7bd8c22b72 100644
--- a/test/yarp/snapshots/seattlerb/assoc_label.txt
+++ b/test/yarp/snapshots/seattlerb/assoc_label.txt
@@ -1,24 +1,29 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...5)(
-         [KeywordHashNode(2...5)(
-            [AssocNode(2...5)(
-               SymbolNode(2...4)(nil, (2...3), (3...4), "b"),
-               IntegerNode(4...5)(),
-               nil
-             )]
-          )]
-       ),
-       (5...6),
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...5))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (2...5))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (2...5))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (2...4))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (2...3) = "b"
+            │                   │   ├── closing_loc: (3...4) = ":"
+            │                   │   └── unescaped: "b"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (4...5))
+            │                   └── operator_loc: ∅
+            ├── closing_loc: (5...6) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/attr_asgn_colon_id.txt b/test/yarp/snapshots/seattlerb/attr_asgn_colon_id.txt
index b9f459e5f1..ed44c31c59 100644
--- a/test/yarp/snapshots/seattlerb/attr_asgn_colon_id.txt
+++ b/test/yarp/snapshots/seattlerb/attr_asgn_colon_id.txt
@@ -1,16 +1,20 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...8)(
-       ConstantReadNode(0...1)(:A),
-       (1...3),
-       (3...4),
-       nil,
-       ArgumentsNode(7...8)([IntegerNode(7...8)()]),
-       nil,
-       nil,
-       0,
-       "b="
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...8))
+            ├── receiver:
+            │   @ ConstantReadNode (location: (0...1))
+            │   └── name: :A
+            ├── call_operator_loc: (1...3) = "::"
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (7...8))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (7...8))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "b="
diff --git a/test/yarp/snapshots/seattlerb/attrasgn_array_arg.txt b/test/yarp/snapshots/seattlerb/attrasgn_array_arg.txt
index b9a116975a..6597260048 100644
--- a/test/yarp/snapshots/seattlerb/attrasgn_array_arg.txt
+++ b/test/yarp/snapshots/seattlerb/attrasgn_array_arg.txt
@@ -1,23 +1,34 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (1...9),
-       (1...2),
-       ArgumentsNode(2...13)(
-         [ArrayNode(2...8)(
-            [IntegerNode(3...4)(), IntegerNode(6...7)()],
-            (2...3),
-            (7...8)
-          ),
-          IntegerNode(12...13)()]
-       ),
-       (8...9),
-       nil,
-       0,
-       "[]="
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (1...9) = "[[1, 2]]"
+            ├── opening_loc: (1...2) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...13))
+            │   └── arguments: (length: 2)
+            │       ├── @ ArrayNode (location: (2...8))
+            │       │   ├── elements: (length: 2)
+            │       │   │   ├── @ IntegerNode (location: (3...4))
+            │       │   │   └── @ IntegerNode (location: (6...7))
+            │       │   ├── opening_loc: (2...3) = "["
+            │       │   └── closing_loc: (7...8) = "]"
+            │       └── @ IntegerNode (location: (12...13))
+            ├── closing_loc: (8...9) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]="
diff --git a/test/yarp/snapshots/seattlerb/attrasgn_array_lhs.txt b/test/yarp/snapshots/seattlerb/attrasgn_array_lhs.txt
index 666f9e3476..4d406450d7 100644
--- a/test/yarp/snapshots/seattlerb/attrasgn_array_lhs.txt
+++ b/test/yarp/snapshots/seattlerb/attrasgn_array_lhs.txt
@@ -1,57 +1,69 @@
-ProgramNode(0...42)(
-  [],
-  StatementsNode(0...42)(
-    [CallNode(0...42)(
-       ArrayNode(0...12)(
-         [IntegerNode(1...2)(),
-          IntegerNode(4...5)(),
-          IntegerNode(7...8)(),
-          IntegerNode(10...11)()],
-         (0...1),
-         (11...12)
-       ),
-       nil,
-       (12...24),
-       (12...13),
-       ArgumentsNode(13...42)(
-         [RangeNode(13...23)(
-            CallNode(13...17)(
-              nil,
-              nil,
-              (13...17),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "from"
-            ),
-            CallNode(21...23)(
-              nil,
-              nil,
-              (21...23),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "to"
-            ),
-            (18...20),
-            0
-          ),
-          ArrayNode(27...42)(
-            [StringNode(28...31)((28...29), (29...30), (30...31), "a"),
-             StringNode(33...36)((33...34), (34...35), (35...36), "b"),
-             StringNode(38...41)((38...39), (39...40), (40...41), "c")],
-            (27...28),
-            (41...42)
-          )]
-       ),
-       (23...24),
-       nil,
-       0,
-       "[]="
-     )]
-  )
-)
+@ ProgramNode (location: (0...42))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...42))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...42))
+            ├── receiver:
+            │   @ ArrayNode (location: (0...12))
+            │   ├── elements: (length: 4)
+            │   │   ├── @ IntegerNode (location: (1...2))
+            │   │   ├── @ IntegerNode (location: (4...5))
+            │   │   ├── @ IntegerNode (location: (7...8))
+            │   │   └── @ IntegerNode (location: (10...11))
+            │   ├── opening_loc: (0...1) = "["
+            │   └── closing_loc: (11...12) = "]"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (12...24) = "[from .. to]"
+            ├── opening_loc: (12...13) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (13...42))
+            │   └── arguments: (length: 2)
+            │       ├── @ RangeNode (location: (13...23))
+            │       │   ├── left:
+            │       │   │   @ CallNode (location: (13...17))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (13...17) = "from"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "from"
+            │       │   ├── right:
+            │       │   │   @ CallNode (location: (21...23))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (21...23) = "to"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "to"
+            │       │   ├── operator_loc: (18...20) = ".."
+            │       │   └── flags: 
+            │       └── @ ArrayNode (location: (27...42))
+            │           ├── elements: (length: 3)
+            │           │   ├── @ StringNode (location: (28...31))
+            │           │   │   ├── opening_loc: (28...29) = "\""
+            │           │   │   ├── content_loc: (29...30) = "a"
+            │           │   │   ├── closing_loc: (30...31) = "\""
+            │           │   │   └── unescaped: "a"
+            │           │   ├── @ StringNode (location: (33...36))
+            │           │   │   ├── opening_loc: (33...34) = "\""
+            │           │   │   ├── content_loc: (34...35) = "b"
+            │           │   │   ├── closing_loc: (35...36) = "\""
+            │           │   │   └── unescaped: "b"
+            │           │   └── @ StringNode (location: (38...41))
+            │           │       ├── opening_loc: (38...39) = "\""
+            │           │       ├── content_loc: (39...40) = "c"
+            │           │       ├── closing_loc: (40...41) = "\""
+            │           │       └── unescaped: "c"
+            │           ├── opening_loc: (27...28) = "["
+            │           └── closing_loc: (41...42) = "]"
+            ├── closing_loc: (23...24) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]="
diff --git a/test/yarp/snapshots/seattlerb/attrasgn_primary_dot_constant.txt b/test/yarp/snapshots/seattlerb/attrasgn_primary_dot_constant.txt
index f9d549a27b..5d5417a78c 100644
--- a/test/yarp/snapshots/seattlerb/attrasgn_primary_dot_constant.txt
+++ b/test/yarp/snapshots/seattlerb/attrasgn_primary_dot_constant.txt
@@ -1,16 +1,28 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...3),
-       nil,
-       ArgumentsNode(6...7)([IntegerNode(6...7)()]),
-       nil,
-       nil,
-       0,
-       "B="
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...3) = "B"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (6...7))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (6...7))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "B="
diff --git a/test/yarp/snapshots/seattlerb/backticks_interpolation_line.txt b/test/yarp/snapshots/seattlerb/backticks_interpolation_line.txt
index 86c78947fa..2e2508388a 100644
--- a/test/yarp/snapshots/seattlerb/backticks_interpolation_line.txt
+++ b/test/yarp/snapshots/seattlerb/backticks_interpolation_line.txt
@@ -1,38 +1,37 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...8)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...8)(
-         [InterpolatedXStringNode(2...8)(
-            (2...3),
-            [EmbeddedStatementsNode(3...7)(
-               (3...5),
-               StatementsNode(5...6)(
-                 [CallNode(5...6)(
-                    nil,
-                    nil,
-                    (5...6),
-                    nil,
-                    nil,
-                    nil,
-                    nil,
-                    2,
-                    "y"
-                  )]
-               ),
-               (6...7)
-             )],
-            (7...8)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "x"
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...8))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "x"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...8))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedXStringNode (location: (2...8))
+            │           ├── opening_loc: (2...3) = "`"
+            │           ├── parts: (length: 1)
+            │           │   └── @ EmbeddedStatementsNode (location: (3...7))
+            │           │       ├── opening_loc: (3...5) = "\#{"
+            │           │       ├── statements:
+            │           │       │   @ StatementsNode (location: (5...6))
+            │           │       │   └── body: (length: 1)
+            │           │       │       └── @ CallNode (location: (5...6))
+            │           │       │           ├── receiver: ∅
+            │           │       │           ├── call_operator_loc: ∅
+            │           │       │           ├── message_loc: (5...6) = "y"
+            │           │       │           ├── opening_loc: ∅
+            │           │       │           ├── arguments: ∅
+            │           │       │           ├── closing_loc: ∅
+            │           │       │           ├── block: ∅
+            │           │       │           ├── flags: variable_call
+            │           │       │           └── name: "y"
+            │           │       └── closing_loc: (6...7) = "}"
+            │           └── closing_loc: (7...8) = "`"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/bang_eq.txt b/test/yarp/snapshots/seattlerb/bang_eq.txt
index 3a04d4603a..452b96abfc 100644
--- a/test/yarp/snapshots/seattlerb/bang_eq.txt
+++ b/test/yarp/snapshots/seattlerb/bang_eq.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...4),
-       nil,
-       ArgumentsNode(5...6)([IntegerNode(5...6)()]),
-       nil,
-       nil,
-       0,
-       "!="
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...4) = "!="
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...6))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (5...6))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!="
diff --git a/test/yarp/snapshots/seattlerb/bdot2.txt b/test/yarp/snapshots/seattlerb/bdot2.txt
index ff960bce8e..bedf632af0 100644
--- a/test/yarp/snapshots/seattlerb/bdot2.txt
+++ b/test/yarp/snapshots/seattlerb/bdot2.txt
@@ -1,13 +1,36 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [RangeNode(0...4)(nil, IntegerNode(2...4)(), (0...2), 0),
-     RangeNode(7...10)(
-       nil,
-       CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "a"),
-       (7...9),
-       0
-     ),
-     CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "c")]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 3)
+        ├── @ RangeNode (location: (0...4))
+        │   ├── left: ∅
+        │   ├── right:
+        │   │   @ IntegerNode (location: (2...4))
+        │   ├── operator_loc: (0...2) = ".."
+        │   └── flags: 
+        ├── @ RangeNode (location: (7...10))
+        │   ├── left: ∅
+        │   ├── right:
+        │   │   @ CallNode (location: (9...10))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (9...10) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── operator_loc: (7...9) = ".."
+        │   └── flags: 
+        └── @ CallNode (location: (13...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (13...14) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/bdot3.txt b/test/yarp/snapshots/seattlerb/bdot3.txt
index abc8a679f1..3f1ec496ce 100644
--- a/test/yarp/snapshots/seattlerb/bdot3.txt
+++ b/test/yarp/snapshots/seattlerb/bdot3.txt
@@ -1,13 +1,36 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [RangeNode(0...5)(nil, IntegerNode(3...5)(), (0...3), 1),
-     RangeNode(8...12)(
-       nil,
-       CallNode(11...12)(nil, nil, (11...12), nil, nil, nil, nil, 2, "a"),
-       (8...11),
-       1
-     ),
-     CallNode(15...16)(nil, nil, (15...16), nil, nil, nil, nil, 2, "c")]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 3)
+        ├── @ RangeNode (location: (0...5))
+        │   ├── left: ∅
+        │   ├── right:
+        │   │   @ IntegerNode (location: (3...5))
+        │   ├── operator_loc: (0...3) = "..."
+        │   └── flags: exclude_end
+        ├── @ RangeNode (location: (8...12))
+        │   ├── left: ∅
+        │   ├── right:
+        │   │   @ CallNode (location: (11...12))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (11...12) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── operator_loc: (8...11) = "..."
+        │   └── flags: exclude_end
+        └── @ CallNode (location: (15...16))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (15...16) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/begin_ensure_no_bodies.txt b/test/yarp/snapshots/seattlerb/begin_ensure_no_bodies.txt
index 39ac8bfea1..8a01f305dd 100644
--- a/test/yarp/snapshots/seattlerb/begin_ensure_no_bodies.txt
+++ b/test/yarp/snapshots/seattlerb/begin_ensure_no_bodies.txt
@@ -1,13 +1,16 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [BeginNode(0...16)(
-       (0...5),
-       nil,
-       nil,
-       nil,
-       EnsureNode(6...16)((6...12), nil, (13...16)),
-       (13...16)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...16))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements: ∅
+            ├── rescue_clause: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause:
+            │   @ EnsureNode (location: (6...16))
+            │   ├── ensure_keyword_loc: (6...12) = "ensure"
+            │   ├── statements: ∅
+            │   └── end_keyword_loc: (13...16) = "end"
+            └── end_keyword_loc: (13...16) = "end"
diff --git a/test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_bodies.txt b/test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_bodies.txt
index 4ad22bbc28..4af7f0247f 100644
--- a/test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_bodies.txt
+++ b/test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_bodies.txt
@@ -1,28 +1,39 @@
-ProgramNode(0...44)(
-  [],
-  StatementsNode(0...44)(
-    [BeginNode(0...44)(
-       (0...5),
-       StatementsNode(8...9)([IntegerNode(8...9)()]),
-       RescueNode(10...20)(
-         (10...16),
-         [],
-         nil,
-         nil,
-         StatementsNode(19...20)([IntegerNode(19...20)()]),
-         nil
-       ),
-       ElseNode(21...36)(
-         (21...25),
-         StatementsNode(28...29)([IntegerNode(28...29)()]),
-         (30...36)
-       ),
-       EnsureNode(30...44)(
-         (30...36),
-         StatementsNode(39...40)([IntegerNode(39...40)()]),
-         (41...44)
-       ),
-       (41...44)
-     )]
-  )
-)
+@ ProgramNode (location: (0...44))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...44))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...44))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (8...9))
+            │   └── body: (length: 1)
+            │       └── @ IntegerNode (location: (8...9))
+            ├── rescue_clause:
+            │   @ RescueNode (location: (10...20))
+            │   ├── keyword_loc: (10...16) = "rescue"
+            │   ├── exceptions: (length: 0)
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (19...20))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (19...20))
+            │   └── consequent: ∅
+            ├── else_clause:
+            │   @ ElseNode (location: (21...36))
+            │   ├── else_keyword_loc: (21...25) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (28...29))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (28...29))
+            │   └── end_keyword_loc: (30...36) = "ensure"
+            ├── ensure_clause:
+            │   @ EnsureNode (location: (30...44))
+            │   ├── ensure_keyword_loc: (30...36) = "ensure"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (39...40))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (39...40))
+            │   └── end_keyword_loc: (41...44) = "end"
+            └── end_keyword_loc: (41...44) = "end"
diff --git a/test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_no_bodies.txt b/test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_no_bodies.txt
index f8cc5345e3..a5112e34fa 100644
--- a/test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_no_bodies.txt
+++ b/test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_no_bodies.txt
@@ -1,13 +1,27 @@
-ProgramNode(0...32)(
-  [],
-  StatementsNode(0...32)(
-    [BeginNode(0...32)(
-       (0...5),
-       nil,
-       RescueNode(7...13)((7...13), [], nil, nil, nil, nil),
-       ElseNode(15...27)((15...19), nil, (21...27)),
-       EnsureNode(21...32)((21...27), nil, (29...32)),
-       (29...32)
-     )]
-  )
-)
+@ ProgramNode (location: (0...32))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...32))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...32))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements: ∅
+            ├── rescue_clause:
+            │   @ RescueNode (location: (7...13))
+            │   ├── keyword_loc: (7...13) = "rescue"
+            │   ├── exceptions: (length: 0)
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements: ∅
+            │   └── consequent: ∅
+            ├── else_clause:
+            │   @ ElseNode (location: (15...27))
+            │   ├── else_keyword_loc: (15...19) = "else"
+            │   ├── statements: ∅
+            │   └── end_keyword_loc: (21...27) = "ensure"
+            ├── ensure_clause:
+            │   @ EnsureNode (location: (21...32))
+            │   ├── ensure_keyword_loc: (21...27) = "ensure"
+            │   ├── statements: ∅
+            │   └── end_keyword_loc: (29...32) = "end"
+            └── end_keyword_loc: (29...32) = "end"
diff --git a/test/yarp/snapshots/seattlerb/begin_rescue_ensure_no_bodies.txt b/test/yarp/snapshots/seattlerb/begin_rescue_ensure_no_bodies.txt
index 1152a0cddf..4661ead290 100644
--- a/test/yarp/snapshots/seattlerb/begin_rescue_ensure_no_bodies.txt
+++ b/test/yarp/snapshots/seattlerb/begin_rescue_ensure_no_bodies.txt
@@ -1,13 +1,23 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [BeginNode(0...23)(
-       (0...5),
-       nil,
-       RescueNode(6...12)((6...12), [], nil, nil, nil, nil),
-       nil,
-       EnsureNode(13...23)((13...19), nil, (20...23)),
-       (20...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...23))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements: ∅
+            ├── rescue_clause:
+            │   @ RescueNode (location: (6...12))
+            │   ├── keyword_loc: (6...12) = "rescue"
+            │   ├── exceptions: (length: 0)
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements: ∅
+            │   └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause:
+            │   @ EnsureNode (location: (13...23))
+            │   ├── ensure_keyword_loc: (13...19) = "ensure"
+            │   ├── statements: ∅
+            │   └── end_keyword_loc: (20...23) = "end"
+            └── end_keyword_loc: (20...23) = "end"
diff --git a/test/yarp/snapshots/seattlerb/block_arg__bare.txt b/test/yarp/snapshots/seattlerb/block_arg__bare.txt
index 2634a94099..6db709cee3 100644
--- a/test/yarp/snapshots/seattlerb/block_arg__bare.txt
+++ b/test/yarp/snapshots/seattlerb/block_arg__bare.txt
@@ -1,27 +1,30 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [DefNode(0...13)(
-       :x,
-       (4...5),
-       nil,
-       ParametersNode(6...7)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(6...7)(nil, nil, (6...7))
-       ),
-       nil,
-       [:&],
-       (0...3),
-       nil,
-       (5...6),
-       (7...8),
-       nil,
-       (10...13)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...13))
+            ├── name: :x
+            ├── name_loc: (4...5) = "x"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...7))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block:
+            │       @ BlockParameterNode (location: (6...7))
+            │       ├── name: nil
+            │       ├── name_loc: ∅
+            │       └── operator_loc: (6...7) = "&"
+            ├── body: ∅
+            ├── locals: [:&]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (7...8) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (10...13) = "end"
diff --git a/test/yarp/snapshots/seattlerb/block_arg_kwsplat.txt b/test/yarp/snapshots/seattlerb/block_arg_kwsplat.txt
index 196b4d250f..39e9b1bf6d 100644
--- a/test/yarp/snapshots/seattlerb/block_arg_kwsplat.txt
+++ b/test/yarp/snapshots/seattlerb/block_arg_kwsplat.txt
@@ -1,35 +1,38 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallNode(0...11)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...11)(
-         [:b],
-         BlockParametersNode(4...9)(
-           ParametersNode(5...8)(
-             [],
-             [],
-             [],
-             nil,
-             [],
-             KeywordRestParameterNode(5...8)(:b, (7...8), (5...7)),
-             nil
-           ),
-           [],
-           (4...5),
-           (8...9)
-         ),
-         nil,
-         (2...3),
-         (10...11)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...11))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...11))
+            │   ├── locals: [:b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...9))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...8))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest:
+            │   │   │   │   @ KeywordRestParameterNode (location: (5...8))
+            │   │   │   │   ├── name: :b
+            │   │   │   │   ├── name_loc: (7...8) = "b"
+            │   │   │   │   └── operator_loc: (5...7) = "**"
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (8...9) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (10...11) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_arg_opt_arg_block.txt b/test/yarp/snapshots/seattlerb/block_arg_opt_arg_block.txt
index dd24630442..4795530f6e 100644
--- a/test/yarp/snapshots/seattlerb/block_arg_opt_arg_block.txt
+++ b/test/yarp/snapshots/seattlerb/block_arg_opt_arg_block.txt
@@ -1,40 +1,48 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [CallNode(0...21)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...21)(
-         [:b, :c, :d, :e],
-         BlockParametersNode(4...19)(
-           ParametersNode(5...18)(
-             [RequiredParameterNode(5...6)(:b)],
-             [OptionalParameterNode(8...11)(
-                :c,
-                (8...9),
-                (9...10),
-                IntegerNode(10...11)()
-              )],
-             [RequiredParameterNode(13...14)(:d)],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(16...18)(:e, (17...18), (16...17))
-           ),
-           [],
-           (4...5),
-           (18...19)
-         ),
-         nil,
-         (2...3),
-         (20...21)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...21))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...21))
+            │   ├── locals: [:b, :c, :d, :e]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...19))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...18))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...11))
+            │   │   │   │       ├── name: :c
+            │   │   │   │       ├── name_loc: (8...9) = "c"
+            │   │   │   │       ├── operator_loc: (9...10) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (10...11))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (13...14))
+            │   │   │   │       └── name: :d
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (16...18))
+            │   │   │       ├── name: :e
+            │   │   │       ├── name_loc: (17...18) = "e"
+            │   │   │       └── operator_loc: (16...17) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (18...19) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (20...21) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_arg_opt_splat.txt b/test/yarp/snapshots/seattlerb/block_arg_opt_splat.txt
index 28e355ebe5..b72cb87ca9 100644
--- a/test/yarp/snapshots/seattlerb/block_arg_opt_splat.txt
+++ b/test/yarp/snapshots/seattlerb/block_arg_opt_splat.txt
@@ -1,40 +1,46 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [CallNode(0...20)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...20)(
-         [:b, :c, :d],
-         BlockParametersNode(4...18)(
-           ParametersNode(5...17)(
-             [RequiredParameterNode(5...6)(:b)],
-             [OptionalParameterNode(8...13)(
-                :c,
-                (8...9),
-                (10...11),
-                IntegerNode(12...13)()
-              )],
-             [],
-             RestParameterNode(15...17)(:d, (16...17), (15...16)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (17...18)
-         ),
-         nil,
-         (2...3),
-         (19...20)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...20))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...20))
+            │   ├── locals: [:b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...18))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...17))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...13))
+            │   │   │   │       ├── name: :c
+            │   │   │   │       ├── name_loc: (8...9) = "c"
+            │   │   │   │       ├── operator_loc: (10...11) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (12...13))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (15...17))
+            │   │   │   │   ├── name: :d
+            │   │   │   │   ├── name_loc: (16...17) = "d"
+            │   │   │   │   └── operator_loc: (15...16) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (17...18) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (19...20) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_arg_opt_splat_arg_block_omfg.txt b/test/yarp/snapshots/seattlerb/block_arg_opt_splat_arg_block_omfg.txt
index 2bfb380f06..8cb9cf27a9 100644
--- a/test/yarp/snapshots/seattlerb/block_arg_opt_splat_arg_block_omfg.txt
+++ b/test/yarp/snapshots/seattlerb/block_arg_opt_splat_arg_block_omfg.txt
@@ -1,40 +1,52 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [CallNode(0...25)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...25)(
-         [:b, :c, :d, :e, :f],
-         BlockParametersNode(4...23)(
-           ParametersNode(5...22)(
-             [RequiredParameterNode(5...6)(:b)],
-             [OptionalParameterNode(8...11)(
-                :c,
-                (8...9),
-                (9...10),
-                IntegerNode(10...11)()
-              )],
-             [RequiredParameterNode(17...18)(:e)],
-             RestParameterNode(13...15)(:d, (14...15), (13...14)),
-             [],
-             nil,
-             BlockParameterNode(20...22)(:f, (21...22), (20...21))
-           ),
-           [],
-           (4...5),
-           (22...23)
-         ),
-         nil,
-         (2...3),
-         (24...25)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...25))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...25))
+            │   ├── locals: [:b, :c, :d, :e, :f]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...23))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...22))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...11))
+            │   │   │   │       ├── name: :c
+            │   │   │   │       ├── name_loc: (8...9) = "c"
+            │   │   │   │       ├── operator_loc: (9...10) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (10...11))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (17...18))
+            │   │   │   │       └── name: :e
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (13...15))
+            │   │   │   │   ├── name: :d
+            │   │   │   │   ├── name_loc: (14...15) = "d"
+            │   │   │   │   └── operator_loc: (13...14) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (20...22))
+            │   │   │       ├── name: :f
+            │   │   │       ├── name_loc: (21...22) = "f"
+            │   │   │       └── operator_loc: (20...21) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (22...23) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (24...25) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_arg_optional.txt b/test/yarp/snapshots/seattlerb/block_arg_optional.txt
index cb71821778..5e4115da23 100644
--- a/test/yarp/snapshots/seattlerb/block_arg_optional.txt
+++ b/test/yarp/snapshots/seattlerb/block_arg_optional.txt
@@ -1,40 +1,40 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...13)(
-         [:b],
-         BlockParametersNode(4...11)(
-           ParametersNode(5...10)(
-             [],
-             [OptionalParameterNode(5...10)(
-                :b,
-                (5...6),
-                (7...8),
-                IntegerNode(9...10)()
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (10...11)
-         ),
-         nil,
-         (2...3),
-         (12...13)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...13))
+            │   ├── locals: [:b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...11))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...10))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...10))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (5...6) = "b"
+            │   │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (9...10))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (10...11) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (12...13) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_arg_scope.txt b/test/yarp/snapshots/seattlerb/block_arg_scope.txt
index be99e78eec..1ec87bb718 100644
--- a/test/yarp/snapshots/seattlerb/block_arg_scope.txt
+++ b/test/yarp/snapshots/seattlerb/block_arg_scope.txt
@@ -1,35 +1,38 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...12)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...12)(
-         [:b, :c],
-         BlockParametersNode(4...10)(
-           ParametersNode(5...6)(
-             [RequiredParameterNode(5...6)(:b)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [BlockLocalVariableNode(8...9)(:c)],
-           (4...5),
-           (9...10)
-         ),
-         nil,
-         (2...3),
-         (11...12)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...12))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...12))
+            │   ├── locals: [:b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...10))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...6))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 1)
+            │   │   │   └── @ BlockLocalVariableNode (location: (8...9))
+            │   │   │       └── name: :c
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (9...10) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (11...12) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_arg_scope2.txt b/test/yarp/snapshots/seattlerb/block_arg_scope2.txt
index fcee4898aa..1472f3afe3 100644
--- a/test/yarp/snapshots/seattlerb/block_arg_scope2.txt
+++ b/test/yarp/snapshots/seattlerb/block_arg_scope2.txt
@@ -1,36 +1,40 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...14)(
-         [:b, :c, :d],
-         BlockParametersNode(3...12)(
-           ParametersNode(4...5)(
-             [RequiredParameterNode(4...5)(:b)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [BlockLocalVariableNode(7...8)(:c),
-            BlockLocalVariableNode(10...11)(:d)],
-           (3...4),
-           (11...12)
-         ),
-         nil,
-         (2...3),
-         (13...14)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...14))
+            │   ├── locals: [:b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (3...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (4...5))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (4...5))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 2)
+            │   │   │   ├── @ BlockLocalVariableNode (location: (7...8))
+            │   │   │   │   └── name: :c
+            │   │   │   └── @ BlockLocalVariableNode (location: (10...11))
+            │   │   │       └── name: :d
+            │   │   ├── opening_loc: (3...4) = "|"
+            │   │   └── closing_loc: (11...12) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (13...14) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_arg_splat_arg.txt b/test/yarp/snapshots/seattlerb/block_arg_splat_arg.txt
index bc2cb81b64..73269efb2e 100644
--- a/test/yarp/snapshots/seattlerb/block_arg_splat_arg.txt
+++ b/test/yarp/snapshots/seattlerb/block_arg_splat_arg.txt
@@ -1,35 +1,42 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...16)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...16)(
-         [:b, :c, :d],
-         BlockParametersNode(4...14)(
-           ParametersNode(5...13)(
-             [RequiredParameterNode(5...6)(:b)],
-             [],
-             [RequiredParameterNode(12...13)(:d)],
-             RestParameterNode(8...10)(:c, (9...10), (8...9)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (13...14)
-         ),
-         nil,
-         (2...3),
-         (15...16)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...16))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...16))
+            │   ├── locals: [:b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...14))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...13))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (12...13))
+            │   │   │   │       └── name: :d
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (8...10))
+            │   │   │   │   ├── name: :c
+            │   │   │   │   ├── name_loc: (9...10) = "c"
+            │   │   │   │   └── operator_loc: (8...9) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (13...14) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (15...16) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_args_kwargs.txt b/test/yarp/snapshots/seattlerb/block_args_kwargs.txt
index 8db4d3f0ea..fc6579174a 100644
--- a/test/yarp/snapshots/seattlerb/block_args_kwargs.txt
+++ b/test/yarp/snapshots/seattlerb/block_args_kwargs.txt
@@ -1,35 +1,43 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [CallNode(0...23)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...23)(
-         [:kwargs],
-         BlockParametersNode(4...14)(
-           ParametersNode(5...13)(
-             [],
-             [],
-             [],
-             nil,
-             [],
-             KeywordRestParameterNode(5...13)(:kwargs, (7...13), (5...7)),
-             nil
-           ),
-           [],
-           (4...5),
-           (13...14)
-         ),
-         StatementsNode(15...21)([LocalVariableReadNode(15...21)(:kwargs, 0)]),
-         (2...3),
-         (22...23)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...23))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...23))
+            │   ├── locals: [:kwargs]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...14))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...13))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest:
+            │   │   │   │   @ KeywordRestParameterNode (location: (5...13))
+            │   │   │   │   ├── name: :kwargs
+            │   │   │   │   ├── name_loc: (7...13) = "kwargs"
+            │   │   │   │   └── operator_loc: (5...7) = "**"
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (13...14) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (15...21))
+            │   │   └── body: (length: 1)
+            │   │       └── @ LocalVariableReadNode (location: (15...21))
+            │   │           ├── name: :kwargs
+            │   │           └── depth: 0
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (22...23) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/block_args_no_kwargs.txt b/test/yarp/snapshots/seattlerb/block_args_no_kwargs.txt
index 7e4fa1e9f8..4c350e2fe8 100644
--- a/test/yarp/snapshots/seattlerb/block_args_no_kwargs.txt
+++ b/test/yarp/snapshots/seattlerb/block_args_no_kwargs.txt
@@ -1,35 +1,37 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...13)(
-         [],
-         BlockParametersNode(4...11)(
-           ParametersNode(5...10)(
-             [],
-             [],
-             [],
-             nil,
-             [],
-             NoKeywordsParameterNode(5...10)((5...7), (7...10)),
-             nil
-           ),
-           [],
-           (4...5),
-           (10...11)
-         ),
-         nil,
-         (2...3),
-         (12...13)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...13))
+            │   ├── locals: []
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...11))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...10))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest:
+            │   │   │   │   @ NoKeywordsParameterNode (location: (5...10))
+            │   │   │   │   ├── operator_loc: (5...7) = "**"
+            │   │   │   │   └── keyword_loc: (7...10) = "nil"
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (10...11) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (12...13) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/block_args_opt1.txt b/test/yarp/snapshots/seattlerb/block_args_opt1.txt
index 271638e3d8..0d26f06c3c 100644
--- a/test/yarp/snapshots/seattlerb/block_args_opt1.txt
+++ b/test/yarp/snapshots/seattlerb/block_args_opt1.txt
@@ -1,47 +1,54 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [CallNode(0...24)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...24)(
-         [:a, :b],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [RequiredParameterNode(5...6)(:a)],
-             [OptionalParameterNode(8...14)(
-                :b,
-                (8...9),
-                (10...11),
-                IntegerNode(12...14)()
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         StatementsNode(16...22)(
-           [ArrayNode(16...22)(
-              [LocalVariableReadNode(17...18)(:a, 0),
-               LocalVariableReadNode(20...21)(:b, 0)],
-              (16...17),
-              (21...22)
-            )]
-         ),
-         (2...3),
-         (23...24)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...24))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...24))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...14))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (8...9) = "b"
+            │   │   │   │       ├── operator_loc: (10...11) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (12...14))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (16...22))
+            │   │   └── body: (length: 1)
+            │   │       └── @ ArrayNode (location: (16...22))
+            │   │           ├── elements: (length: 2)
+            │   │           │   ├── @ LocalVariableReadNode (location: (17...18))
+            │   │           │   │   ├── name: :a
+            │   │           │   │   └── depth: 0
+            │   │           │   └── @ LocalVariableReadNode (location: (20...21))
+            │   │           │       ├── name: :b
+            │   │           │       └── depth: 0
+            │   │           ├── opening_loc: (16...17) = "["
+            │   │           └── closing_loc: (21...22) = "]"
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (23...24) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/block_args_opt2.txt b/test/yarp/snapshots/seattlerb/block_args_opt2.txt
index 6b98d4f75c..6e3bb30419 100644
--- a/test/yarp/snapshots/seattlerb/block_args_opt2.txt
+++ b/test/yarp/snapshots/seattlerb/block_args_opt2.txt
@@ -1,46 +1,46 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...18)(
-         [:b, :c],
-         BlockParametersNode(4...16)(
-           ParametersNode(6...14)(
-             [],
-             [OptionalParameterNode(6...9)(
-                :b,
-                (6...7),
-                (7...8),
-                IntegerNode(8...9)()
-              ),
-              OptionalParameterNode(11...14)(
-                :c,
-                (11...12),
-                (12...13),
-                IntegerNode(13...14)()
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (15...16)
-         ),
-         nil,
-         (2...3),
-         (17...18)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...18))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...18))
+            │   ├── locals: [:b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...16))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (6...14))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 2)
+            │   │   │   │   ├── @ OptionalParameterNode (location: (6...9))
+            │   │   │   │   │   ├── name: :b
+            │   │   │   │   │   ├── name_loc: (6...7) = "b"
+            │   │   │   │   │   ├── operator_loc: (7...8) = "="
+            │   │   │   │   │   └── value:
+            │   │   │   │   │       @ IntegerNode (location: (8...9))
+            │   │   │   │   └── @ OptionalParameterNode (location: (11...14))
+            │   │   │   │       ├── name: :c
+            │   │   │   │       ├── name_loc: (11...12) = "c"
+            │   │   │   │       ├── operator_loc: (12...13) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (13...14))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (15...16) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (17...18) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_args_opt2_2.txt b/test/yarp/snapshots/seattlerb/block_args_opt2_2.txt
index cdda0997df..15c683de60 100644
--- a/test/yarp/snapshots/seattlerb/block_args_opt2_2.txt
+++ b/test/yarp/snapshots/seattlerb/block_args_opt2_2.txt
@@ -1,54 +1,63 @@
-ProgramNode(0...35)(
-  [],
-  StatementsNode(0...35)(
-    [CallNode(0...35)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...35)(
-         [:a, :b, :c],
-         BlockParametersNode(4...23)(
-           ParametersNode(5...22)(
-             [RequiredParameterNode(5...6)(:a)],
-             [OptionalParameterNode(8...14)(
-                :b,
-                (8...9),
-                (10...11),
-                IntegerNode(12...14)()
-              ),
-              OptionalParameterNode(16...22)(
-                :c,
-                (16...17),
-                (18...19),
-                IntegerNode(20...22)()
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (22...23)
-         ),
-         StatementsNode(24...33)(
-           [ArrayNode(24...33)(
-              [LocalVariableReadNode(25...26)(:a, 0),
-               LocalVariableReadNode(28...29)(:b, 0),
-               LocalVariableReadNode(31...32)(:c, 0)],
-              (24...25),
-              (32...33)
-            )]
-         ),
-         (2...3),
-         (34...35)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...35))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...35))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...35))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...35))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...23))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...22))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 2)
+            │   │   │   │   ├── @ OptionalParameterNode (location: (8...14))
+            │   │   │   │   │   ├── name: :b
+            │   │   │   │   │   ├── name_loc: (8...9) = "b"
+            │   │   │   │   │   ├── operator_loc: (10...11) = "="
+            │   │   │   │   │   └── value:
+            │   │   │   │   │       @ IntegerNode (location: (12...14))
+            │   │   │   │   └── @ OptionalParameterNode (location: (16...22))
+            │   │   │   │       ├── name: :c
+            │   │   │   │       ├── name_loc: (16...17) = "c"
+            │   │   │   │       ├── operator_loc: (18...19) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (20...22))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (22...23) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (24...33))
+            │   │   └── body: (length: 1)
+            │   │       └── @ ArrayNode (location: (24...33))
+            │   │           ├── elements: (length: 3)
+            │   │           │   ├── @ LocalVariableReadNode (location: (25...26))
+            │   │           │   │   ├── name: :a
+            │   │           │   │   └── depth: 0
+            │   │           │   ├── @ LocalVariableReadNode (location: (28...29))
+            │   │           │   │   ├── name: :b
+            │   │           │   │   └── depth: 0
+            │   │           │   └── @ LocalVariableReadNode (location: (31...32))
+            │   │           │       ├── name: :c
+            │   │           │       └── depth: 0
+            │   │           ├── opening_loc: (24...25) = "["
+            │   │           └── closing_loc: (32...33) = "]"
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (34...35) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/block_args_opt3.txt b/test/yarp/snapshots/seattlerb/block_args_opt3.txt
index 6d4e26c8ed..794382690d 100644
--- a/test/yarp/snapshots/seattlerb/block_args_opt3.txt
+++ b/test/yarp/snapshots/seattlerb/block_args_opt3.txt
@@ -1,55 +1,70 @@
-ProgramNode(0...42)(
-  [],
-  StatementsNode(0...42)(
-    [CallNode(0...42)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...42)(
-         [:a, :b, :c, :d],
-         BlockParametersNode(4...27)(
-           ParametersNode(5...26)(
-             [RequiredParameterNode(5...6)(:a)],
-             [OptionalParameterNode(8...14)(
-                :b,
-                (8...9),
-                (10...11),
-                IntegerNode(12...14)()
-              ),
-              OptionalParameterNode(16...22)(
-                :c,
-                (16...17),
-                (18...19),
-                IntegerNode(20...22)()
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(24...26)(:d, (25...26), (24...25))
-           ),
-           [],
-           (4...5),
-           (26...27)
-         ),
-         StatementsNode(28...40)(
-           [ArrayNode(28...40)(
-              [LocalVariableReadNode(29...30)(:a, 0),
-               LocalVariableReadNode(32...33)(:b, 0),
-               LocalVariableReadNode(35...36)(:c, 0),
-               LocalVariableReadNode(38...39)(:d, 0)],
-              (28...29),
-              (39...40)
-            )]
-         ),
-         (2...3),
-         (41...42)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...42))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...42))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...42))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...42))
+            │   ├── locals: [:a, :b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...27))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...26))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 2)
+            │   │   │   │   ├── @ OptionalParameterNode (location: (8...14))
+            │   │   │   │   │   ├── name: :b
+            │   │   │   │   │   ├── name_loc: (8...9) = "b"
+            │   │   │   │   │   ├── operator_loc: (10...11) = "="
+            │   │   │   │   │   └── value:
+            │   │   │   │   │       @ IntegerNode (location: (12...14))
+            │   │   │   │   └── @ OptionalParameterNode (location: (16...22))
+            │   │   │   │       ├── name: :c
+            │   │   │   │       ├── name_loc: (16...17) = "c"
+            │   │   │   │       ├── operator_loc: (18...19) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (20...22))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (24...26))
+            │   │   │       ├── name: :d
+            │   │   │       ├── name_loc: (25...26) = "d"
+            │   │   │       └── operator_loc: (24...25) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (26...27) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (28...40))
+            │   │   └── body: (length: 1)
+            │   │       └── @ ArrayNode (location: (28...40))
+            │   │           ├── elements: (length: 4)
+            │   │           │   ├── @ LocalVariableReadNode (location: (29...30))
+            │   │           │   │   ├── name: :a
+            │   │           │   │   └── depth: 0
+            │   │           │   ├── @ LocalVariableReadNode (location: (32...33))
+            │   │           │   │   ├── name: :b
+            │   │           │   │   └── depth: 0
+            │   │           │   ├── @ LocalVariableReadNode (location: (35...36))
+            │   │           │   │   ├── name: :c
+            │   │           │   │   └── depth: 0
+            │   │           │   └── @ LocalVariableReadNode (location: (38...39))
+            │   │           │       ├── name: :d
+            │   │           │       └── depth: 0
+            │   │           ├── opening_loc: (28...29) = "["
+            │   │           └── closing_loc: (39...40) = "]"
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (41...42) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/block_break.txt b/test/yarp/snapshots/seattlerb/block_break.txt
index 9ebe2b1488..12da5265b9 100644
--- a/test/yarp/snapshots/seattlerb/block_break.txt
+++ b/test/yarp/snapshots/seattlerb/block_break.txt
@@ -1,52 +1,53 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [BreakNode(0...26)(
-       ArgumentsNode(6...26)(
-         [CallNode(6...26)(
-            nil,
-            nil,
-            (6...9),
-            nil,
-            ArgumentsNode(10...13)(
-              [CallNode(10...13)(
-                 nil,
-                 nil,
-                 (10...13),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "arg"
-               )]
-            ),
-            nil,
-            BlockNode(14...26)(
-              [:bar],
-              BlockParametersNode(17...22)(
-                ParametersNode(18...21)(
-                  [RequiredParameterNode(18...21)(:bar)],
-                  [],
-                  [],
-                  nil,
-                  [],
-                  nil,
-                  nil
-                ),
-                [],
-                (17...18),
-                (21...22)
-              ),
-              nil,
-              (14...16),
-              (23...26)
-            ),
-            0,
-            "foo"
-          )]
-       ),
-       (0...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ BreakNode (location: (0...26))
+            ├── arguments:
+            │   @ ArgumentsNode (location: (6...26))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (6...26))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (6...9) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (10...13))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ CallNode (location: (10...13))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (10...13) = "arg"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "arg"
+            │           ├── closing_loc: ∅
+            │           ├── block:
+            │           │   @ BlockNode (location: (14...26))
+            │           │   ├── locals: [:bar]
+            │           │   ├── parameters:
+            │           │   │   @ BlockParametersNode (location: (17...22))
+            │           │   │   ├── parameters:
+            │           │   │   │   @ ParametersNode (location: (18...21))
+            │           │   │   │   ├── requireds: (length: 1)
+            │           │   │   │   │   └── @ RequiredParameterNode (location: (18...21))
+            │           │   │   │   │       └── name: :bar
+            │           │   │   │   ├── optionals: (length: 0)
+            │           │   │   │   ├── posts: (length: 0)
+            │           │   │   │   ├── rest: ∅
+            │           │   │   │   ├── keywords: (length: 0)
+            │           │   │   │   ├── keyword_rest: ∅
+            │           │   │   │   └── block: ∅
+            │           │   │   ├── locals: (length: 0)
+            │           │   │   ├── opening_loc: (17...18) = "|"
+            │           │   │   └── closing_loc: (21...22) = "|"
+            │           │   ├── body: ∅
+            │           │   ├── opening_loc: (14...16) = "do"
+            │           │   └── closing_loc: (23...26) = "end"
+            │           ├── flags: 
+            │           └── name: "foo"
+            └── keyword_loc: (0...5) = "break"
diff --git a/test/yarp/snapshots/seattlerb/block_call_defn_call_block_call.txt b/test/yarp/snapshots/seattlerb/block_call_defn_call_block_call.txt
index 79c6b347e5..ef1352179a 100644
--- a/test/yarp/snapshots/seattlerb/block_call_defn_call_block_call.txt
+++ b/test/yarp/snapshots/seattlerb/block_call_defn_call_block_call.txt
@@ -1,62 +1,78 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...18)(
-         [DefNode(2...18)(
-            :b,
-            (6...7),
-            nil,
-            ParametersNode(8...9)(
-              [RequiredParameterNode(8...9)(:c)],
-              [],
-              [],
-              nil,
-              [],
-              nil,
-              nil
-            ),
-            StatementsNode(12...13)(
-              [CallNode(12...13)(
-                 nil,
-                 nil,
-                 (12...13),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "d"
-               )]
-            ),
-            [:c],
-            (2...5),
-            nil,
-            (7...8),
-            (9...10),
-            nil,
-            (15...18)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(20...30)(
-       CallNode(20...21)(nil, nil, (20...21), nil, nil, nil, nil, 2, "e"),
-       (21...22),
-       (22...23),
-       nil,
-       nil,
-       nil,
-       BlockNode(24...30)([], nil, nil, (24...26), (27...30)),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...18))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...18))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ DefNode (location: (2...18))
+        │   │           ├── name: :b
+        │   │           ├── name_loc: (6...7) = "b"
+        │   │           ├── receiver: ∅
+        │   │           ├── parameters:
+        │   │           │   @ ParametersNode (location: (8...9))
+        │   │           │   ├── requireds: (length: 1)
+        │   │           │   │   └── @ RequiredParameterNode (location: (8...9))
+        │   │           │   │       └── name: :c
+        │   │           │   ├── optionals: (length: 0)
+        │   │           │   ├── posts: (length: 0)
+        │   │           │   ├── rest: ∅
+        │   │           │   ├── keywords: (length: 0)
+        │   │           │   ├── keyword_rest: ∅
+        │   │           │   └── block: ∅
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (12...13))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (12...13))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (12...13) = "d"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "d"
+        │   │           ├── locals: [:c]
+        │   │           ├── def_keyword_loc: (2...5) = "def"
+        │   │           ├── operator_loc: ∅
+        │   │           ├── lparen_loc: (7...8) = "("
+        │   │           ├── rparen_loc: (9...10) = ")"
+        │   │           ├── equal_loc: ∅
+        │   │           └── end_keyword_loc: (15...18) = "end"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (20...30))
+            ├── receiver:
+            │   @ CallNode (location: (20...21))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (20...21) = "e"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "e"
+            ├── call_operator_loc: (21...22) = "."
+            ├── message_loc: (22...23) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (24...30))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (24...26) = "do"
+            │   └── closing_loc: (27...30) = "end"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/block_call_dot_op2_brace_block.txt b/test/yarp/snapshots/seattlerb/block_call_dot_op2_brace_block.txt
index 60c529a425..f2ba566eed 100644
--- a/test/yarp/snapshots/seattlerb/block_call_dot_op2_brace_block.txt
+++ b/test/yarp/snapshots/seattlerb/block_call_dot_op2_brace_block.txt
@@ -1,77 +1,98 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)(
-    [CallNode(0...31)(
-       CallNode(0...16)(
-         CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-         (1...2),
-         (2...3),
-         nil,
-         ArgumentsNode(4...7)(
-           [CallNode(4...7)(
-              nil,
-              nil,
-              (4...5),
-              (5...6),
-              nil,
-              (6...7),
-              nil,
-              0,
-              "c"
-            )]
-         ),
-         nil,
-         BlockNode(8...16)(
-           [],
-           nil,
-           StatementsNode(11...12)(
-             [CallNode(11...12)(
-                nil,
-                nil,
-                (11...12),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "d"
-              )]
-           ),
-           (8...10),
-           (13...16)
-         ),
-         0,
-         "b"
-       ),
-       (16...17),
-       (17...18),
-       nil,
-       nil,
-       nil,
-       BlockNode(19...31)(
-         [:f],
-         BlockParametersNode(22...25)(
-           ParametersNode(23...24)(
-             [RequiredParameterNode(23...24)(:f)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (22...23),
-           (24...25)
-         ),
-         StatementsNode(26...27)(
-           [CallNode(26...27)(nil, nil, (26...27), nil, nil, nil, nil, 2, "g")]
-         ),
-         (19...21),
-         (28...31)
-       ),
-       0,
-       "e"
-     )]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...31))
+            ├── receiver:
+            │   @ CallNode (location: (0...16))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (0...1))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (0...1) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (1...2) = "."
+            │   ├── message_loc: (2...3) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (4...7))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (4...7))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (4...5) = "c"
+            │   │           ├── opening_loc: (5...6) = "("
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: (6...7) = ")"
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "c"
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (8...16))
+            │   │   ├── locals: []
+            │   │   ├── parameters: ∅
+            │   │   ├── body:
+            │   │   │   @ StatementsNode (location: (11...12))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (11...12))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (11...12) = "d"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "d"
+            │   │   ├── opening_loc: (8...10) = "do"
+            │   │   └── closing_loc: (13...16) = "end"
+            │   ├── flags: 
+            │   └── name: "b"
+            ├── call_operator_loc: (16...17) = "."
+            ├── message_loc: (17...18) = "e"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (19...31))
+            │   ├── locals: [:f]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (22...25))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (23...24))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (23...24))
+            │   │   │   │       └── name: :f
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (22...23) = "|"
+            │   │   └── closing_loc: (24...25) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (26...27))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (26...27))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (26...27) = "g"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "g"
+            │   ├── opening_loc: (19...21) = "do"
+            │   └── closing_loc: (28...31) = "end"
+            ├── flags: 
+            └── name: "e"
diff --git a/test/yarp/snapshots/seattlerb/block_call_dot_op2_cmd_args_do_block.txt b/test/yarp/snapshots/seattlerb/block_call_dot_op2_cmd_args_do_block.txt
index c41a55f13f..f91b3e4cf1 100644
--- a/test/yarp/snapshots/seattlerb/block_call_dot_op2_cmd_args_do_block.txt
+++ b/test/yarp/snapshots/seattlerb/block_call_dot_op2_cmd_args_do_block.txt
@@ -1,79 +1,110 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [CallNode(0...33)(
-       CallNode(0...16)(
-         CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-         (1...2),
-         (2...3),
-         nil,
-         ArgumentsNode(4...7)(
-           [CallNode(4...7)(
-              nil,
-              nil,
-              (4...5),
-              (5...6),
-              nil,
-              (6...7),
-              nil,
-              0,
-              "c"
-            )]
-         ),
-         nil,
-         BlockNode(8...16)(
-           [],
-           nil,
-           StatementsNode(11...12)(
-             [CallNode(11...12)(
-                nil,
-                nil,
-                (11...12),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "d"
-              )]
-           ),
-           (8...10),
-           (13...16)
-         ),
-         0,
-         "b"
-       ),
-       (16...17),
-       (17...18),
-       nil,
-       ArgumentsNode(19...20)(
-         [CallNode(19...20)(nil, nil, (19...20), nil, nil, nil, nil, 2, "f")]
-       ),
-       nil,
-       BlockNode(21...33)(
-         [:g],
-         BlockParametersNode(24...27)(
-           ParametersNode(25...26)(
-             [RequiredParameterNode(25...26)(:g)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (24...25),
-           (26...27)
-         ),
-         StatementsNode(28...29)(
-           [CallNode(28...29)(nil, nil, (28...29), nil, nil, nil, nil, 2, "h")]
-         ),
-         (21...23),
-         (30...33)
-       ),
-       0,
-       "e"
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...33))
+            ├── receiver:
+            │   @ CallNode (location: (0...16))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (0...1))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (0...1) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (1...2) = "."
+            │   ├── message_loc: (2...3) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (4...7))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (4...7))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (4...5) = "c"
+            │   │           ├── opening_loc: (5...6) = "("
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: (6...7) = ")"
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "c"
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (8...16))
+            │   │   ├── locals: []
+            │   │   ├── parameters: ∅
+            │   │   ├── body:
+            │   │   │   @ StatementsNode (location: (11...12))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (11...12))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (11...12) = "d"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "d"
+            │   │   ├── opening_loc: (8...10) = "do"
+            │   │   └── closing_loc: (13...16) = "end"
+            │   ├── flags: 
+            │   └── name: "b"
+            ├── call_operator_loc: (16...17) = "."
+            ├── message_loc: (17...18) = "e"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (19...20))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (19...20))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (19...20) = "f"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "f"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (21...33))
+            │   ├── locals: [:g]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (24...27))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (25...26))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (25...26))
+            │   │   │   │       └── name: :g
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (24...25) = "|"
+            │   │   └── closing_loc: (26...27) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (28...29))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (28...29))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (28...29) = "h"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "h"
+            │   ├── opening_loc: (21...23) = "do"
+            │   └── closing_loc: (30...33) = "end"
+            ├── flags: 
+            └── name: "e"
diff --git a/test/yarp/snapshots/seattlerb/block_call_operation_colon.txt b/test/yarp/snapshots/seattlerb/block_call_operation_colon.txt
index 348e82f706..e68502b63e 100644
--- a/test/yarp/snapshots/seattlerb/block_call_operation_colon.txt
+++ b/test/yarp/snapshots/seattlerb/block_call_operation_colon.txt
@@ -1,28 +1,53 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...15)(
-       CallNode(0...12)(
-         CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-         (1...2),
-         (2...3),
-         nil,
-         ArgumentsNode(4...5)(
-           [CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "c")]
-         ),
-         nil,
-         BlockNode(6...12)([], nil, nil, (6...8), (9...12)),
-         0,
-         "b"
-       ),
-       (12...14),
-       (14...15),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "d"
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...15))
+            ├── receiver:
+            │   @ CallNode (location: (0...12))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (0...1))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (0...1) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (1...2) = "."
+            │   ├── message_loc: (2...3) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (4...5))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (4...5))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (4...5) = "c"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "c"
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (6...12))
+            │   │   ├── locals: []
+            │   │   ├── parameters: ∅
+            │   │   ├── body: ∅
+            │   │   ├── opening_loc: (6...8) = "do"
+            │   │   └── closing_loc: (9...12) = "end"
+            │   ├── flags: 
+            │   └── name: "b"
+            ├── call_operator_loc: (12...14) = "::"
+            ├── message_loc: (14...15) = "d"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/block_call_operation_dot.txt b/test/yarp/snapshots/seattlerb/block_call_operation_dot.txt
index 05edca98a4..5cff9a8b4b 100644
--- a/test/yarp/snapshots/seattlerb/block_call_operation_dot.txt
+++ b/test/yarp/snapshots/seattlerb/block_call_operation_dot.txt
@@ -1,28 +1,53 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       CallNode(0...12)(
-         CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-         (1...2),
-         (2...3),
-         nil,
-         ArgumentsNode(4...5)(
-           [CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "c")]
-         ),
-         nil,
-         BlockNode(6...12)([], nil, nil, (6...8), (9...12)),
-         0,
-         "b"
-       ),
-       (12...13),
-       (13...14),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "d"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver:
+            │   @ CallNode (location: (0...12))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (0...1))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (0...1) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (1...2) = "."
+            │   ├── message_loc: (2...3) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (4...5))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (4...5))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (4...5) = "c"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "c"
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (6...12))
+            │   │   ├── locals: []
+            │   │   ├── parameters: ∅
+            │   │   ├── body: ∅
+            │   │   ├── opening_loc: (6...8) = "do"
+            │   │   └── closing_loc: (9...12) = "end"
+            │   ├── flags: 
+            │   └── name: "b"
+            ├── call_operator_loc: (12...13) = "."
+            ├── message_loc: (13...14) = "d"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/block_call_paren_call_block_call.txt b/test/yarp/snapshots/seattlerb/block_call_paren_call_block_call.txt
index 4b7916f0e6..1f2dfdaef9 100644
--- a/test/yarp/snapshots/seattlerb/block_call_paren_call_block_call.txt
+++ b/test/yarp/snapshots/seattlerb/block_call_paren_call_block_call.txt
@@ -1,35 +1,59 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...5)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...5)(
-         [ParenthesesNode(2...5)(
-            StatementsNode(3...4)(
-              [CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b")]
-            ),
-            (2...3),
-            (4...5)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(6...16)(
-       CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "c"),
-       (7...8),
-       (8...9),
-       nil,
-       nil,
-       nil,
-       BlockNode(10...16)([], nil, nil, (10...12), (13...16)),
-       0,
-       "d"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...5))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...5))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (2...5))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (3...4))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (3...4))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (3...4) = "b"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "b"
+        │   │           ├── opening_loc: (2...3) = "("
+        │   │           └── closing_loc: (4...5) = ")"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (6...16))
+            ├── receiver:
+            │   @ CallNode (location: (6...7))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (6...7) = "c"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "c"
+            ├── call_operator_loc: (7...8) = "."
+            ├── message_loc: (8...9) = "d"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (10...16))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (10...12) = "do"
+            │   └── closing_loc: (13...16) = "end"
+            ├── flags: 
+            └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/block_command_operation_colon.txt b/test/yarp/snapshots/seattlerb/block_command_operation_colon.txt
index afac178321..a805b7de01 100644
--- a/test/yarp/snapshots/seattlerb/block_command_operation_colon.txt
+++ b/test/yarp/snapshots/seattlerb/block_command_operation_colon.txt
@@ -1,28 +1,45 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       CallNode(0...11)(
-         nil,
-         nil,
-         (0...1),
-         nil,
-         ArgumentsNode(2...4)([SymbolNode(2...4)((2...3), (3...4), nil, "b")]),
-         nil,
-         BlockNode(5...11)([], nil, nil, (5...7), (8...11)),
-         0,
-         "a"
-       ),
-       (11...13),
-       (13...14),
-       nil,
-       ArgumentsNode(15...17)(
-         [SymbolNode(15...17)((15...16), (16...17), nil, "d")]
-       ),
-       nil,
-       nil,
-       0,
-       "c"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver:
+            │   @ CallNode (location: (0...11))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (2...4))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ SymbolNode (location: (2...4))
+            │   │           ├── opening_loc: (2...3) = ":"
+            │   │           ├── value_loc: (3...4) = "b"
+            │   │           ├── closing_loc: ∅
+            │   │           └── unescaped: "b"
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (5...11))
+            │   │   ├── locals: []
+            │   │   ├── parameters: ∅
+            │   │   ├── body: ∅
+            │   │   ├── opening_loc: (5...7) = "do"
+            │   │   └── closing_loc: (8...11) = "end"
+            │   ├── flags: 
+            │   └── name: "a"
+            ├── call_operator_loc: (11...13) = "::"
+            ├── message_loc: (13...14) = "c"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (15...17))
+            │   └── arguments: (length: 1)
+            │       └── @ SymbolNode (location: (15...17))
+            │           ├── opening_loc: (15...16) = ":"
+            │           ├── value_loc: (16...17) = "d"
+            │           ├── closing_loc: ∅
+            │           └── unescaped: "d"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/block_command_operation_dot.txt b/test/yarp/snapshots/seattlerb/block_command_operation_dot.txt
index 8225ce403f..1ec16c91b1 100644
--- a/test/yarp/snapshots/seattlerb/block_command_operation_dot.txt
+++ b/test/yarp/snapshots/seattlerb/block_command_operation_dot.txt
@@ -1,28 +1,45 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...16)(
-       CallNode(0...11)(
-         nil,
-         nil,
-         (0...1),
-         nil,
-         ArgumentsNode(2...4)([SymbolNode(2...4)((2...3), (3...4), nil, "b")]),
-         nil,
-         BlockNode(5...11)([], nil, nil, (5...7), (8...11)),
-         0,
-         "a"
-       ),
-       (11...12),
-       (12...13),
-       nil,
-       ArgumentsNode(14...16)(
-         [SymbolNode(14...16)((14...15), (15...16), nil, "d")]
-       ),
-       nil,
-       nil,
-       0,
-       "c"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...16))
+            ├── receiver:
+            │   @ CallNode (location: (0...11))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (2...4))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ SymbolNode (location: (2...4))
+            │   │           ├── opening_loc: (2...3) = ":"
+            │   │           ├── value_loc: (3...4) = "b"
+            │   │           ├── closing_loc: ∅
+            │   │           └── unescaped: "b"
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (5...11))
+            │   │   ├── locals: []
+            │   │   ├── parameters: ∅
+            │   │   ├── body: ∅
+            │   │   ├── opening_loc: (5...7) = "do"
+            │   │   └── closing_loc: (8...11) = "end"
+            │   ├── flags: 
+            │   └── name: "a"
+            ├── call_operator_loc: (11...12) = "."
+            ├── message_loc: (12...13) = "c"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (14...16))
+            │   └── arguments: (length: 1)
+            │       └── @ SymbolNode (location: (14...16))
+            │           ├── opening_loc: (14...15) = ":"
+            │           ├── value_loc: (15...16) = "d"
+            │           ├── closing_loc: ∅
+            │           └── unescaped: "d"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/block_decomp_anon_splat_arg.txt b/test/yarp/snapshots/seattlerb/block_decomp_anon_splat_arg.txt
index f5bee5b926..5cdc24ebfc 100644
--- a/test/yarp/snapshots/seattlerb/block_decomp_anon_splat_arg.txt
+++ b/test/yarp/snapshots/seattlerb/block_decomp_anon_splat_arg.txt
@@ -1,40 +1,43 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...14)(
-         [:a],
-         BlockParametersNode(4...12)(
-           ParametersNode(5...11)(
-             [RequiredDestructuredParameterNode(5...11)(
-                [SplatNode(6...7)((6...7), nil),
-                 RequiredParameterNode(9...10)(:a)],
-                (5...6),
-                (10...11)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (11...12)
-         ),
-         nil,
-         (2...3),
-         (13...14)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...14))
+            │   ├── locals: [:a]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...11))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (5...11))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ SplatNode (location: (6...7))
+            │   │   │   │       │   │   ├── operator_loc: (6...7) = "*"
+            │   │   │   │       │   │   └── expression: ∅
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       │       └── name: :a
+            │   │   │   │       ├── opening_loc: (5...6) = "("
+            │   │   │   │       └── closing_loc: (10...11) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (11...12) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (13...14) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/block_decomp_arg_splat.txt b/test/yarp/snapshots/seattlerb/block_decomp_arg_splat.txt
index b1c8e2e9b8..06806d0113 100644
--- a/test/yarp/snapshots/seattlerb/block_decomp_arg_splat.txt
+++ b/test/yarp/snapshots/seattlerb/block_decomp_arg_splat.txt
@@ -1,40 +1,43 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...14)(
-         [:b],
-         BlockParametersNode(4...12)(
-           ParametersNode(5...11)(
-             [RequiredDestructuredParameterNode(5...11)(
-                [RequiredParameterNode(6...7)(:b),
-                 SplatNode(9...10)((9...10), nil)],
-                (5...6),
-                (10...11)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (11...12)
-         ),
-         nil,
-         (2...3),
-         (13...14)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...14))
+            │   ├── locals: [:b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...11))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (5...11))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (6...7))
+            │   │   │   │       │   │   └── name: :b
+            │   │   │   │       │   └── @ SplatNode (location: (9...10))
+            │   │   │   │       │       ├── operator_loc: (9...10) = "*"
+            │   │   │   │       │       └── expression: ∅
+            │   │   │   │       ├── opening_loc: (5...6) = "("
+            │   │   │   │       └── closing_loc: (10...11) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (11...12) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (13...14) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_decomp_arg_splat_arg.txt b/test/yarp/snapshots/seattlerb/block_decomp_arg_splat_arg.txt
index f66bef6ccb..994553b86a 100644
--- a/test/yarp/snapshots/seattlerb/block_decomp_arg_splat_arg.txt
+++ b/test/yarp/snapshots/seattlerb/block_decomp_arg_splat_arg.txt
@@ -1,44 +1,47 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...18)(
-         [:a, :b, :c],
-         BlockParametersNode(4...16)(
-           ParametersNode(5...15)(
-             [RequiredDestructuredParameterNode(5...15)(
-                [RequiredParameterNode(6...7)(:a),
-                 SplatNode(9...11)(
-                   (9...10),
-                   RequiredParameterNode(10...11)(:b)
-                 ),
-                 RequiredParameterNode(13...14)(:c)],
-                (5...6),
-                (14...15)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (15...16)
-         ),
-         nil,
-         (2...3),
-         (17...18)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...18))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...18))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...16))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...15))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (5...15))
+            │   │   │   │       ├── parameters: (length: 3)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (6...7))
+            │   │   │   │       │   │   └── name: :a
+            │   │   │   │       │   ├── @ SplatNode (location: (9...11))
+            │   │   │   │       │   │   ├── operator_loc: (9...10) = "*"
+            │   │   │   │       │   │   └── expression:
+            │   │   │   │       │   │       @ RequiredParameterNode (location: (10...11))
+            │   │   │   │       │   │       └── name: :b
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (13...14))
+            │   │   │   │       │       └── name: :c
+            │   │   │   │       ├── opening_loc: (5...6) = "("
+            │   │   │   │       └── closing_loc: (14...15) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (15...16) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (17...18) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/block_decomp_splat.txt b/test/yarp/snapshots/seattlerb/block_decomp_splat.txt
index c78fd82317..bfdb479069 100644
--- a/test/yarp/snapshots/seattlerb/block_decomp_splat.txt
+++ b/test/yarp/snapshots/seattlerb/block_decomp_splat.txt
@@ -1,39 +1,43 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...12)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...12)(
-         [:a],
-         BlockParametersNode(4...10)(
-           ParametersNode(5...9)(
-             [RequiredDestructuredParameterNode(5...9)(
-                [SplatNode(6...8)((6...7), RequiredParameterNode(7...8)(:a))],
-                (5...6),
-                (8...9)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (9...10)
-         ),
-         nil,
-         (2...3),
-         (11...12)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...12))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...12))
+            │   ├── locals: [:a]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...10))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...9))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (5...9))
+            │   │   │   │       ├── parameters: (length: 1)
+            │   │   │   │       │   └── @ SplatNode (location: (6...8))
+            │   │   │   │       │       ├── operator_loc: (6...7) = "*"
+            │   │   │   │       │       └── expression:
+            │   │   │   │       │           @ RequiredParameterNode (location: (7...8))
+            │   │   │   │       │           └── name: :a
+            │   │   │   │       ├── opening_loc: (5...6) = "("
+            │   │   │   │       └── closing_loc: (8...9) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (9...10) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (11...12) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/block_kw.txt b/test/yarp/snapshots/seattlerb/block_kw.txt
index 32a518dc39..38d5542264 100644
--- a/test/yarp/snapshots/seattlerb/block_kw.txt
+++ b/test/yarp/snapshots/seattlerb/block_kw.txt
@@ -1,39 +1,39 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...15)(
-       nil,
-       nil,
-       (0...4),
-       nil,
-       nil,
-       nil,
-       BlockNode(5...15)(
-         [:k],
-         BlockParametersNode(7...13)(
-           ParametersNode(8...12)(
-             [],
-             [],
-             [],
-             nil,
-             [KeywordParameterNode(8...12)(
-                :k,
-                (8...10),
-                IntegerNode(10...12)()
-              )],
-             nil,
-             nil
-           ),
-           [],
-           (7...8),
-           (12...13)
-         ),
-         nil,
-         (5...6),
-         (14...15)
-       ),
-       0,
-       "blah"
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...15))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...4) = "blah"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (5...15))
+            │   ├── locals: [:k]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (7...13))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (8...12))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 1)
+            │   │   │   │   └── @ KeywordParameterNode (location: (8...12))
+            │   │   │   │       ├── name: :k
+            │   │   │   │       ├── name_loc: (8...10) = "k:"
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (10...12))
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (7...8) = "|"
+            │   │   └── closing_loc: (12...13) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (5...6) = "{"
+            │   └── closing_loc: (14...15) = "}"
+            ├── flags: 
+            └── name: "blah"
diff --git a/test/yarp/snapshots/seattlerb/block_kw__required.txt b/test/yarp/snapshots/seattlerb/block_kw__required.txt
index be6125fa1d..ba1fb191c2 100644
--- a/test/yarp/snapshots/seattlerb/block_kw__required.txt
+++ b/test/yarp/snapshots/seattlerb/block_kw__required.txt
@@ -1,35 +1,38 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...16)(
-       nil,
-       nil,
-       (0...4),
-       nil,
-       nil,
-       nil,
-       BlockNode(5...16)(
-         [:k],
-         BlockParametersNode(8...12)(
-           ParametersNode(9...11)(
-             [],
-             [],
-             [],
-             nil,
-             [KeywordParameterNode(9...11)(:k, (9...11), nil)],
-             nil,
-             nil
-           ),
-           [],
-           (8...9),
-           (11...12)
-         ),
-         nil,
-         (5...7),
-         (13...16)
-       ),
-       0,
-       "blah"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...16))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...4) = "blah"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (5...16))
+            │   ├── locals: [:k]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (8...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (9...11))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 1)
+            │   │   │   │   └── @ KeywordParameterNode (location: (9...11))
+            │   │   │   │       ├── name: :k
+            │   │   │   │       ├── name_loc: (9...11) = "k:"
+            │   │   │   │       └── value: ∅
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (8...9) = "|"
+            │   │   └── closing_loc: (11...12) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (5...7) = "do"
+            │   └── closing_loc: (13...16) = "end"
+            ├── flags: 
+            └── name: "blah"
diff --git a/test/yarp/snapshots/seattlerb/block_kwarg_lvar.txt b/test/yarp/snapshots/seattlerb/block_kwarg_lvar.txt
index eb21515108..3c6c950a98 100644
--- a/test/yarp/snapshots/seattlerb/block_kwarg_lvar.txt
+++ b/test/yarp/snapshots/seattlerb/block_kwarg_lvar.txt
@@ -1,39 +1,48 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [CallNode(0...20)(
-       nil,
-       nil,
-       (0...2),
-       nil,
-       nil,
-       nil,
-       BlockNode(3...20)(
-         [:kw],
-         BlockParametersNode(5...15)(
-           ParametersNode(6...14)(
-             [],
-             [],
-             [],
-             nil,
-             [KeywordParameterNode(6...14)(
-                :kw,
-                (6...9),
-                SymbolNode(10...14)((10...11), (11...14), nil, "val")
-              )],
-             nil,
-             nil
-           ),
-           [],
-           (5...6),
-           (14...15)
-         ),
-         StatementsNode(16...18)([LocalVariableReadNode(16...18)(:kw, 0)]),
-         (3...4),
-         (19...20)
-       ),
-       0,
-       "bl"
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...20))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...2) = "bl"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (3...20))
+            │   ├── locals: [:kw]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (5...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (6...14))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 1)
+            │   │   │   │   └── @ KeywordParameterNode (location: (6...14))
+            │   │   │   │       ├── name: :kw
+            │   │   │   │       ├── name_loc: (6...9) = "kw:"
+            │   │   │   │       └── value:
+            │   │   │   │           @ SymbolNode (location: (10...14))
+            │   │   │   │           ├── opening_loc: (10...11) = ":"
+            │   │   │   │           ├── value_loc: (11...14) = "val"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "val"
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (5...6) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (16...18))
+            │   │   └── body: (length: 1)
+            │   │       └── @ LocalVariableReadNode (location: (16...18))
+            │   │           ├── name: :kw
+            │   │           └── depth: 0
+            │   ├── opening_loc: (3...4) = "{"
+            │   └── closing_loc: (19...20) = "}"
+            ├── flags: 
+            └── name: "bl"
diff --git a/test/yarp/snapshots/seattlerb/block_kwarg_lvar_multiple.txt b/test/yarp/snapshots/seattlerb/block_kwarg_lvar_multiple.txt
index 240ece6f70..99c85f8aed 100644
--- a/test/yarp/snapshots/seattlerb/block_kwarg_lvar_multiple.txt
+++ b/test/yarp/snapshots/seattlerb/block_kwarg_lvar_multiple.txt
@@ -1,44 +1,57 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [CallNode(0...33)(
-       nil,
-       nil,
-       (0...2),
-       nil,
-       nil,
-       nil,
-       BlockNode(3...33)(
-         [:kw, :kw2],
-         BlockParametersNode(5...28)(
-           ParametersNode(6...26)(
-             [],
-             [],
-             [],
-             nil,
-             [KeywordParameterNode(6...14)(
-                :kw,
-                (6...9),
-                SymbolNode(10...14)((10...11), (11...14), nil, "val")
-              ),
-              KeywordParameterNode(16...26)(
-                :kw2,
-                (16...20),
-                SymbolNode(21...26)((21...22), (22...26), nil, "val2")
-              )],
-             nil,
-             nil
-           ),
-           [],
-           (5...6),
-           (27...28)
-         ),
-         StatementsNode(29...31)([LocalVariableReadNode(29...31)(:kw, 0)]),
-         (3...4),
-         (32...33)
-       ),
-       0,
-       "bl"
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...33))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...2) = "bl"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (3...33))
+            │   ├── locals: [:kw, :kw2]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (5...28))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (6...26))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 2)
+            │   │   │   │   ├── @ KeywordParameterNode (location: (6...14))
+            │   │   │   │   │   ├── name: :kw
+            │   │   │   │   │   ├── name_loc: (6...9) = "kw:"
+            │   │   │   │   │   └── value:
+            │   │   │   │   │       @ SymbolNode (location: (10...14))
+            │   │   │   │   │       ├── opening_loc: (10...11) = ":"
+            │   │   │   │   │       ├── value_loc: (11...14) = "val"
+            │   │   │   │   │       ├── closing_loc: ∅
+            │   │   │   │   │       └── unescaped: "val"
+            │   │   │   │   └── @ KeywordParameterNode (location: (16...26))
+            │   │   │   │       ├── name: :kw2
+            │   │   │   │       ├── name_loc: (16...20) = "kw2:"
+            │   │   │   │       └── value:
+            │   │   │   │           @ SymbolNode (location: (21...26))
+            │   │   │   │           ├── opening_loc: (21...22) = ":"
+            │   │   │   │           ├── value_loc: (22...26) = "val2"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "val2"
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (5...6) = "|"
+            │   │   └── closing_loc: (27...28) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (29...31))
+            │   │   └── body: (length: 1)
+            │   │       └── @ LocalVariableReadNode (location: (29...31))
+            │   │           ├── name: :kw
+            │   │           └── depth: 0
+            │   ├── opening_loc: (3...4) = "{"
+            │   └── closing_loc: (32...33) = "}"
+            ├── flags: 
+            └── name: "bl"
diff --git a/test/yarp/snapshots/seattlerb/block_next.txt b/test/yarp/snapshots/seattlerb/block_next.txt
index 021f2ed15c..54559af38b 100644
--- a/test/yarp/snapshots/seattlerb/block_next.txt
+++ b/test/yarp/snapshots/seattlerb/block_next.txt
@@ -1,52 +1,53 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [NextNode(0...25)(
-       ArgumentsNode(5...25)(
-         [CallNode(5...25)(
-            nil,
-            nil,
-            (5...8),
-            nil,
-            ArgumentsNode(9...12)(
-              [CallNode(9...12)(
-                 nil,
-                 nil,
-                 (9...12),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "arg"
-               )]
-            ),
-            nil,
-            BlockNode(13...25)(
-              [:bar],
-              BlockParametersNode(16...21)(
-                ParametersNode(17...20)(
-                  [RequiredParameterNode(17...20)(:bar)],
-                  [],
-                  [],
-                  nil,
-                  [],
-                  nil,
-                  nil
-                ),
-                [],
-                (16...17),
-                (20...21)
-              ),
-              nil,
-              (13...15),
-              (22...25)
-            ),
-            0,
-            "foo"
-          )]
-       ),
-       (0...4)
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ NextNode (location: (0...25))
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...25))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (5...25))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (5...8) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (9...12))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ CallNode (location: (9...12))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (9...12) = "arg"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "arg"
+            │           ├── closing_loc: ∅
+            │           ├── block:
+            │           │   @ BlockNode (location: (13...25))
+            │           │   ├── locals: [:bar]
+            │           │   ├── parameters:
+            │           │   │   @ BlockParametersNode (location: (16...21))
+            │           │   │   ├── parameters:
+            │           │   │   │   @ ParametersNode (location: (17...20))
+            │           │   │   │   ├── requireds: (length: 1)
+            │           │   │   │   │   └── @ RequiredParameterNode (location: (17...20))
+            │           │   │   │   │       └── name: :bar
+            │           │   │   │   ├── optionals: (length: 0)
+            │           │   │   │   ├── posts: (length: 0)
+            │           │   │   │   ├── rest: ∅
+            │           │   │   │   ├── keywords: (length: 0)
+            │           │   │   │   ├── keyword_rest: ∅
+            │           │   │   │   └── block: ∅
+            │           │   │   ├── locals: (length: 0)
+            │           │   │   ├── opening_loc: (16...17) = "|"
+            │           │   │   └── closing_loc: (20...21) = "|"
+            │           │   ├── body: ∅
+            │           │   ├── opening_loc: (13...15) = "do"
+            │           │   └── closing_loc: (22...25) = "end"
+            │           ├── flags: 
+            │           └── name: "foo"
+            └── keyword_loc: (0...4) = "next"
diff --git a/test/yarp/snapshots/seattlerb/block_opt_arg.txt b/test/yarp/snapshots/seattlerb/block_opt_arg.txt
index 0927953818..2b0e4cfec5 100644
--- a/test/yarp/snapshots/seattlerb/block_opt_arg.txt
+++ b/test/yarp/snapshots/seattlerb/block_opt_arg.txt
@@ -1,40 +1,42 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...14)(
-         [:b, :c],
-         BlockParametersNode(4...12)(
-           ParametersNode(5...11)(
-             [],
-             [OptionalParameterNode(5...8)(
-                :b,
-                (5...6),
-                (6...7),
-                IntegerNode(7...8)()
-              )],
-             [RequiredParameterNode(10...11)(:c)],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (11...12)
-         ),
-         nil,
-         (2...3),
-         (13...14)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...14))
+            │   ├── locals: [:b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...11))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...8))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (5...6) = "b"
+            │   │   │   │       ├── operator_loc: (6...7) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (7...8))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (10...11))
+            │   │   │   │       └── name: :c
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (11...12) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (13...14) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_opt_splat.txt b/test/yarp/snapshots/seattlerb/block_opt_splat.txt
index 7e5aebff1b..8078ddffb1 100644
--- a/test/yarp/snapshots/seattlerb/block_opt_splat.txt
+++ b/test/yarp/snapshots/seattlerb/block_opt_splat.txt
@@ -1,40 +1,44 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...17)(
-         [:b, :c],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [],
-             [OptionalParameterNode(5...10)(
-                :b,
-                (5...6),
-                (7...8),
-                IntegerNode(9...10)()
-              )],
-             [],
-             RestParameterNode(12...14)(:c, (13...14), (12...13)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         nil,
-         (2...3),
-         (16...17)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...17))
+            │   ├── locals: [:b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...10))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (5...6) = "b"
+            │   │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (9...10))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (12...14))
+            │   │   │   │   ├── name: :c
+            │   │   │   │   ├── name_loc: (13...14) = "c"
+            │   │   │   │   └── operator_loc: (12...13) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (16...17) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_opt_splat_arg_block_omfg.txt b/test/yarp/snapshots/seattlerb/block_opt_splat_arg_block_omfg.txt
index 89ee3553bf..d4da0b133d 100644
--- a/test/yarp/snapshots/seattlerb/block_opt_splat_arg_block_omfg.txt
+++ b/test/yarp/snapshots/seattlerb/block_opt_splat_arg_block_omfg.txt
@@ -1,40 +1,50 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [CallNode(0...22)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...22)(
-         [:b, :c, :d, :e],
-         BlockParametersNode(4...20)(
-           ParametersNode(5...19)(
-             [],
-             [OptionalParameterNode(5...8)(
-                :b,
-                (5...6),
-                (6...7),
-                IntegerNode(7...8)()
-              )],
-             [RequiredParameterNode(14...15)(:d)],
-             RestParameterNode(10...12)(:c, (11...12), (10...11)),
-             [],
-             nil,
-             BlockParameterNode(17...19)(:e, (18...19), (17...18))
-           ),
-           [],
-           (4...5),
-           (19...20)
-         ),
-         nil,
-         (2...3),
-         (21...22)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...22))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...22))
+            │   ├── locals: [:b, :c, :d, :e]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...20))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...19))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...8))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (5...6) = "b"
+            │   │   │   │       ├── operator_loc: (6...7) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (7...8))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (14...15))
+            │   │   │   │       └── name: :d
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (10...12))
+            │   │   │   │   ├── name: :c
+            │   │   │   │   ├── name_loc: (11...12) = "c"
+            │   │   │   │   └── operator_loc: (10...11) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (17...19))
+            │   │   │       ├── name: :e
+            │   │   │       ├── name_loc: (18...19) = "e"
+            │   │   │       └── operator_loc: (17...18) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (19...20) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (21...22) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_optarg.txt b/test/yarp/snapshots/seattlerb/block_optarg.txt
index faaaf22e0e..60280843d1 100644
--- a/test/yarp/snapshots/seattlerb/block_optarg.txt
+++ b/test/yarp/snapshots/seattlerb/block_optarg.txt
@@ -1,40 +1,44 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...14)(
-         [:b],
-         BlockParametersNode(4...12)(
-           ParametersNode(5...11)(
-             [],
-             [OptionalParameterNode(5...11)(
-                :b,
-                (5...6),
-                (7...8),
-                SymbolNode(9...11)((9...10), (10...11), nil, "c")
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (11...12)
-         ),
-         nil,
-         (2...3),
-         (13...14)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...14))
+            │   ├── locals: [:b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...11))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...11))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (5...6) = "b"
+            │   │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ SymbolNode (location: (9...11))
+            │   │   │   │           ├── opening_loc: (9...10) = ":"
+            │   │   │   │           ├── value_loc: (10...11) = "c"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "c"
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (11...12) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (13...14) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_paren_splat.txt b/test/yarp/snapshots/seattlerb/block_paren_splat.txt
index 74a59ed1de..7252dda182 100644
--- a/test/yarp/snapshots/seattlerb/block_paren_splat.txt
+++ b/test/yarp/snapshots/seattlerb/block_paren_splat.txt
@@ -1,43 +1,45 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...15)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...15)(
-         [:b, :c],
-         BlockParametersNode(4...13)(
-           ParametersNode(5...12)(
-             [RequiredDestructuredParameterNode(5...12)(
-                [RequiredParameterNode(6...7)(:b),
-                 SplatNode(9...11)(
-                   (9...10),
-                   RequiredParameterNode(10...11)(:c)
-                 )],
-                (5...6),
-                (11...12)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (12...13)
-         ),
-         nil,
-         (2...3),
-         (14...15)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...15))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...15))
+            │   ├── locals: [:b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...13))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...12))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (5...12))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (6...7))
+            │   │   │   │       │   │   └── name: :b
+            │   │   │   │       │   └── @ SplatNode (location: (9...11))
+            │   │   │   │       │       ├── operator_loc: (9...10) = "*"
+            │   │   │   │       │       └── expression:
+            │   │   │   │       │           @ RequiredParameterNode (location: (10...11))
+            │   │   │   │       │           └── name: :c
+            │   │   │   │       ├── opening_loc: (5...6) = "("
+            │   │   │   │       └── closing_loc: (11...12) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (12...13) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (14...15) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_reg_optarg.txt b/test/yarp/snapshots/seattlerb/block_reg_optarg.txt
index c6cbc623e0..988bcb8370 100644
--- a/test/yarp/snapshots/seattlerb/block_reg_optarg.txt
+++ b/test/yarp/snapshots/seattlerb/block_reg_optarg.txt
@@ -1,40 +1,46 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...17)(
-         [:b, :c],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [RequiredParameterNode(5...6)(:b)],
-             [OptionalParameterNode(8...14)(
-                :c,
-                (8...9),
-                (10...11),
-                SymbolNode(12...14)((12...13), (13...14), nil, "d")
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         nil,
-         (2...3),
-         (16...17)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...17))
+            │   ├── locals: [:b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...14))
+            │   │   │   │       ├── name: :c
+            │   │   │   │       ├── name_loc: (8...9) = "c"
+            │   │   │   │       ├── operator_loc: (10...11) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ SymbolNode (location: (12...14))
+            │   │   │   │           ├── opening_loc: (12...13) = ":"
+            │   │   │   │           ├── value_loc: (13...14) = "d"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "d"
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (16...17) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_return.txt b/test/yarp/snapshots/seattlerb/block_return.txt
index 97fab8c514..a209e2b19d 100644
--- a/test/yarp/snapshots/seattlerb/block_return.txt
+++ b/test/yarp/snapshots/seattlerb/block_return.txt
@@ -1,52 +1,53 @@
-ProgramNode(0...27)(
-  [],
-  StatementsNode(0...27)(
-    [ReturnNode(0...27)(
-       (0...6),
-       ArgumentsNode(7...27)(
-         [CallNode(7...27)(
-            nil,
-            nil,
-            (7...10),
-            nil,
-            ArgumentsNode(11...14)(
-              [CallNode(11...14)(
-                 nil,
-                 nil,
-                 (11...14),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "arg"
-               )]
-            ),
-            nil,
-            BlockNode(15...27)(
-              [:bar],
-              BlockParametersNode(18...23)(
-                ParametersNode(19...22)(
-                  [RequiredParameterNode(19...22)(:bar)],
-                  [],
-                  [],
-                  nil,
-                  [],
-                  nil,
-                  nil
-                ),
-                [],
-                (18...19),
-                (22...23)
-              ),
-              nil,
-              (15...17),
-              (24...27)
-            ),
-            0,
-            "foo"
-          )]
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 1)
+        └── @ ReturnNode (location: (0...27))
+            ├── keyword_loc: (0...6) = "return"
+            └── arguments:
+                @ ArgumentsNode (location: (7...27))
+                └── arguments: (length: 1)
+                    └── @ CallNode (location: (7...27))
+                        ├── receiver: ∅
+                        ├── call_operator_loc: ∅
+                        ├── message_loc: (7...10) = "foo"
+                        ├── opening_loc: ∅
+                        ├── arguments:
+                        │   @ ArgumentsNode (location: (11...14))
+                        │   └── arguments: (length: 1)
+                        │       └── @ CallNode (location: (11...14))
+                        │           ├── receiver: ∅
+                        │           ├── call_operator_loc: ∅
+                        │           ├── message_loc: (11...14) = "arg"
+                        │           ├── opening_loc: ∅
+                        │           ├── arguments: ∅
+                        │           ├── closing_loc: ∅
+                        │           ├── block: ∅
+                        │           ├── flags: variable_call
+                        │           └── name: "arg"
+                        ├── closing_loc: ∅
+                        ├── block:
+                        │   @ BlockNode (location: (15...27))
+                        │   ├── locals: [:bar]
+                        │   ├── parameters:
+                        │   │   @ BlockParametersNode (location: (18...23))
+                        │   │   ├── parameters:
+                        │   │   │   @ ParametersNode (location: (19...22))
+                        │   │   │   ├── requireds: (length: 1)
+                        │   │   │   │   └── @ RequiredParameterNode (location: (19...22))
+                        │   │   │   │       └── name: :bar
+                        │   │   │   ├── optionals: (length: 0)
+                        │   │   │   ├── posts: (length: 0)
+                        │   │   │   ├── rest: ∅
+                        │   │   │   ├── keywords: (length: 0)
+                        │   │   │   ├── keyword_rest: ∅
+                        │   │   │   └── block: ∅
+                        │   │   ├── locals: (length: 0)
+                        │   │   ├── opening_loc: (18...19) = "|"
+                        │   │   └── closing_loc: (22...23) = "|"
+                        │   ├── body: ∅
+                        │   ├── opening_loc: (15...17) = "do"
+                        │   └── closing_loc: (24...27) = "end"
+                        ├── flags: 
+                        └── name: "foo"
diff --git a/test/yarp/snapshots/seattlerb/block_scope.txt b/test/yarp/snapshots/seattlerb/block_scope.txt
index bcdb26caa7..048f4febda 100644
--- a/test/yarp/snapshots/seattlerb/block_scope.txt
+++ b/test/yarp/snapshots/seattlerb/block_scope.txt
@@ -1,27 +1,28 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [CallNode(0...10)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...10)(
-         [:b],
-         BlockParametersNode(4...8)(
-           nil,
-           [BlockLocalVariableNode(6...7)(:b)],
-           (4...5),
-           (7...8)
-         ),
-         nil,
-         (2...3),
-         (9...10)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...10))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...10))
+            │   ├── locals: [:b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...8))
+            │   │   ├── parameters: ∅
+            │   │   ├── locals: (length: 1)
+            │   │   │   └── @ BlockLocalVariableNode (location: (6...7))
+            │   │   │       └── name: :b
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (7...8) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (9...10) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/block_splat_reg.txt b/test/yarp/snapshots/seattlerb/block_splat_reg.txt
index b8d574b454..938b3cf461 100644
--- a/test/yarp/snapshots/seattlerb/block_splat_reg.txt
+++ b/test/yarp/snapshots/seattlerb/block_splat_reg.txt
@@ -1,35 +1,40 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...13)(
-         [:b, :c],
-         BlockParametersNode(4...11)(
-           ParametersNode(5...10)(
-             [],
-             [],
-             [RequiredParameterNode(9...10)(:c)],
-             RestParameterNode(5...7)(:b, (6...7), (5...6)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (10...11)
-         ),
-         nil,
-         (2...3),
-         (12...13)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...13))
+            │   ├── locals: [:b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...11))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...10))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       └── name: :c
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (5...7))
+            │   │   │   │   ├── name: :b
+            │   │   │   │   ├── name_loc: (6...7) = "b"
+            │   │   │   │   └── operator_loc: (5...6) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (10...11) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (12...13) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/bug169.txt b/test/yarp/snapshots/seattlerb/bug169.txt
index d6b75f5369..d00df77513 100644
--- a/test/yarp/snapshots/seattlerb/bug169.txt
+++ b/test/yarp/snapshots/seattlerb/bug169.txt
@@ -1,16 +1,27 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...4)([ParenthesesNode(2...4)(nil, (2...3), (3...4))]),
-       nil,
-       BlockNode(5...7)([], nil, nil, (5...6), (6...7)),
-       0,
-       "m"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "m"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...4))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (2...4))
+            │           ├── body: ∅
+            │           ├── opening_loc: (2...3) = "("
+            │           └── closing_loc: (3...4) = ")"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (5...7))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (5...6) = "{"
+            │   └── closing_loc: (6...7) = "}"
+            ├── flags: 
+            └── name: "m"
diff --git a/test/yarp/snapshots/seattlerb/bug179.txt b/test/yarp/snapshots/seattlerb/bug179.txt
index 9dc2331c93..0a82429fc5 100644
--- a/test/yarp/snapshots/seattlerb/bug179.txt
+++ b/test/yarp/snapshots/seattlerb/bug179.txt
@@ -1,23 +1,27 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...9)(
-         [RangeNode(2...9)(
-            ParenthesesNode(2...4)(nil, (2...3), (3...4)),
-            NilNode(6...9)(),
-            (4...6),
-            0
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...9))
+            │   └── arguments: (length: 1)
+            │       └── @ RangeNode (location: (2...9))
+            │           ├── left:
+            │           │   @ ParenthesesNode (location: (2...4))
+            │           │   ├── body: ∅
+            │           │   ├── opening_loc: (2...3) = "("
+            │           │   └── closing_loc: (3...4) = ")"
+            │           ├── right:
+            │           │   @ NilNode (location: (6...9))
+            │           ├── operator_loc: (4...6) = ".."
+            │           └── flags: 
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/seattlerb/bug190.txt b/test/yarp/snapshots/seattlerb/bug190.txt
index 1ad483ada9..1209e9b885 100644
--- a/test/yarp/snapshots/seattlerb/bug190.txt
+++ b/test/yarp/snapshots/seattlerb/bug190.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [RegularExpressionNode(0...6)((0...3), (3...5), (5...6), "'", 0)]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ RegularExpressionNode (location: (0...6))
+            ├── opening_loc: (0...3) = "%r'"
+            ├── content_loc: (3...5) = "\\'"
+            ├── closing_loc: (5...6) = "'"
+            ├── unescaped: "'"
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/bug191.txt b/test/yarp/snapshots/seattlerb/bug191.txt
index 46d5ed6d74..f0d915712f 100644
--- a/test/yarp/snapshots/seattlerb/bug191.txt
+++ b/test/yarp/snapshots/seattlerb/bug191.txt
@@ -1,35 +1,83 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [IfNode(0...9)(
-       nil,
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       StatementsNode(4...6)(
-         [StringNode(4...6)((4...5), (5...5), (5...6), "")]
-       ),
-       ElseNode(6...9)(
-         (6...7),
-         StatementsNode(8...9)(
-           [CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "b")]
-         ),
-         nil
-       ),
-       nil
-     ),
-     IfNode(11...20)(
-       nil,
-       CallNode(11...12)(nil, nil, (11...12), nil, nil, nil, nil, 2, "a"),
-       StatementsNode(15...17)(
-         [StringNode(15...17)((15...16), (16...16), (16...17), "")]
-       ),
-       ElseNode(17...20)(
-         (17...18),
-         StatementsNode(19...20)(
-           [CallNode(19...20)(nil, nil, (19...20), nil, nil, nil, nil, 2, "b")]
-         ),
-         nil
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 2)
+        ├── @ IfNode (location: (0...9))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (0...1))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...1) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (4...6))
+        │   │   └── body: (length: 1)
+        │   │       └── @ StringNode (location: (4...6))
+        │   │           ├── opening_loc: (4...5) = "\""
+        │   │           ├── content_loc: (5...5) = ""
+        │   │           ├── closing_loc: (5...6) = "\""
+        │   │           └── unescaped: ""
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (6...9))
+        │   │   ├── else_keyword_loc: (6...7) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (8...9))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (8...9))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (8...9) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        └── @ IfNode (location: (11...20))
+            ├── if_keyword_loc: ∅
+            ├── predicate:
+            │   @ CallNode (location: (11...12))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (11...12) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── statements:
+            │   @ StatementsNode (location: (15...17))
+            │   └── body: (length: 1)
+            │       └── @ StringNode (location: (15...17))
+            │           ├── opening_loc: (15...16) = "'"
+            │           ├── content_loc: (16...16) = ""
+            │           ├── closing_loc: (16...17) = "'"
+            │           └── unescaped: ""
+            ├── consequent:
+            │   @ ElseNode (location: (17...20))
+            │   ├── else_keyword_loc: (17...18) = ":"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (19...20))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (19...20))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (19...20) = "b"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "b"
+            │   └── end_keyword_loc: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/bug202.txt b/test/yarp/snapshots/seattlerb/bug202.txt
index 08bcfd6b7d..f8efeee0e5 100644
--- a/test/yarp/snapshots/seattlerb/bug202.txt
+++ b/test/yarp/snapshots/seattlerb/bug202.txt
@@ -1,18 +1,18 @@
-ProgramNode(0...22)(
-  [:测试],
-  StatementsNode(0...22)(
-    [GlobalVariableWriteNode(0...11)(
-       :$测试,
-       (0...7),
-       IntegerNode(10...11)(),
-       (8...9)
-     ),
-     LocalVariableWriteNode(12...22)(
-       :测试,
-       0,
-       (12...18),
-       IntegerNode(21...22)(),
-       (19...20)
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: [:测试]
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 2)
+        ├── @ GlobalVariableWriteNode (location: (0...11))
+        │   ├── name: :$测试
+        │   ├── name_loc: (0...7) = "$测试"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (10...11))
+        │   └── operator_loc: (8...9) = "="
+        └── @ LocalVariableWriteNode (location: (12...22))
+            ├── name: :测试
+            ├── depth: 0
+            ├── name_loc: (12...18) = "测试"
+            ├── value:
+            │   @ IntegerNode (location: (21...22))
+            └── operator_loc: (19...20) = "="
diff --git a/test/yarp/snapshots/seattlerb/bug236.txt b/test/yarp/snapshots/seattlerb/bug236.txt
index c83125b65f..89c892bc35 100644
--- a/test/yarp/snapshots/seattlerb/bug236.txt
+++ b/test/yarp/snapshots/seattlerb/bug236.txt
@@ -1,65 +1,71 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...7)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(1...7)(
-         [:a],
-         BlockParametersNode(2...6)(
-           ParametersNode(3...5)(
-             [RequiredParameterNode(3...4)(:a)],
-             [],
-             [],
-             RestParameterNode(4...5)(nil, nil, (4...5)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (2...3),
-           (5...6)
-         ),
-         nil,
-         (1...2),
-         (6...7)
-       ),
-       0,
-       "x"
-     ),
-     CallNode(9...15)(
-       nil,
-       nil,
-       (9...10),
-       nil,
-       nil,
-       nil,
-       BlockNode(10...15)(
-         [:a],
-         BlockParametersNode(11...14)(
-           ParametersNode(12...13)(
-             [RequiredParameterNode(12...13)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (11...12),
-           (13...14)
-         ),
-         nil,
-         (10...11),
-         (14...15)
-       ),
-       0,
-       "x"
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...7))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "x"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (1...7))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (2...6))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (3...5))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (3...4))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (4...5))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (4...5) = ","
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (2...3) = "|"
+        │   │   │   └── closing_loc: (5...6) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (1...2) = "{"
+        │   │   └── closing_loc: (6...7) = "}"
+        │   ├── flags: 
+        │   └── name: "x"
+        └── @ CallNode (location: (9...15))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (9...10) = "x"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (10...15))
+            │   ├── locals: [:a]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (11...14))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (12...13))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (12...13))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (11...12) = "|"
+            │   │   └── closing_loc: (13...14) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (10...11) = "{"
+            │   └── closing_loc: (14...15) = "}"
+            ├── flags: 
+            └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/bug290.txt b/test/yarp/snapshots/seattlerb/bug290.txt
index 30d5780f50..fcc548230c 100644
--- a/test/yarp/snapshots/seattlerb/bug290.txt
+++ b/test/yarp/snapshots/seattlerb/bug290.txt
@@ -1,15 +1,24 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [BeginNode(0...15)(
-       (0...5),
-       StatementsNode(8...11)(
-         [CallNode(8...11)(nil, nil, (8...11), nil, nil, nil, nil, 2, "foo")]
-       ),
-       nil,
-       nil,
-       nil,
-       (12...15)
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...15))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (8...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (8...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (8...11) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "foo"
+            ├── rescue_clause: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (12...15) = "end"
diff --git a/test/yarp/snapshots/seattlerb/bug_187.txt b/test/yarp/snapshots/seattlerb/bug_187.txt
index a62a9f30be..2de3c838c9 100644
--- a/test/yarp/snapshots/seattlerb/bug_187.txt
+++ b/test/yarp/snapshots/seattlerb/bug_187.txt
@@ -1,53 +1,58 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CallNode(0...28)(
-       nil,
-       nil,
-       (0...7),
-       nil,
-       ArgumentsNode(8...28)(
-         [DefNode(8...28)(
-            :f,
-            (12...13),
-            nil,
-            nil,
-            StatementsNode(14...24)(
-              [CallNode(14...24)(
-                 CallNode(14...15)(
-                   nil,
-                   nil,
-                   (14...15),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "a"
-                 ),
-                 (15...16),
-                 (16...17),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(18...24)([], nil, nil, (18...20), (21...24)),
-                 0,
-                 "b"
-               )]
-            ),
-            [],
-            (8...11),
-            nil,
-            nil,
-            nil,
-            nil,
-            (25...28)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "private"
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...28))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...7) = "private"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (8...28))
+            │   └── arguments: (length: 1)
+            │       └── @ DefNode (location: (8...28))
+            │           ├── name: :f
+            │           ├── name_loc: (12...13) = "f"
+            │           ├── receiver: ∅
+            │           ├── parameters: ∅
+            │           ├── body:
+            │           │   @ StatementsNode (location: (14...24))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (14...24))
+            │           │           ├── receiver:
+            │           │           │   @ CallNode (location: (14...15))
+            │           │           │   ├── receiver: ∅
+            │           │           │   ├── call_operator_loc: ∅
+            │           │           │   ├── message_loc: (14...15) = "a"
+            │           │           │   ├── opening_loc: ∅
+            │           │           │   ├── arguments: ∅
+            │           │           │   ├── closing_loc: ∅
+            │           │           │   ├── block: ∅
+            │           │           │   ├── flags: variable_call
+            │           │           │   └── name: "a"
+            │           │           ├── call_operator_loc: (15...16) = "."
+            │           │           ├── message_loc: (16...17) = "b"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block:
+            │           │           │   @ BlockNode (location: (18...24))
+            │           │           │   ├── locals: []
+            │           │           │   ├── parameters: ∅
+            │           │           │   ├── body: ∅
+            │           │           │   ├── opening_loc: (18...20) = "do"
+            │           │           │   └── closing_loc: (21...24) = "end"
+            │           │           ├── flags: 
+            │           │           └── name: "b"
+            │           ├── locals: []
+            │           ├── def_keyword_loc: (8...11) = "def"
+            │           ├── operator_loc: ∅
+            │           ├── lparen_loc: ∅
+            │           ├── rparen_loc: ∅
+            │           ├── equal_loc: ∅
+            │           └── end_keyword_loc: (25...28) = "end"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "private"
diff --git a/test/yarp/snapshots/seattlerb/bug_215.txt b/test/yarp/snapshots/seattlerb/bug_215.txt
index 16a2ca3be1..c3d3eb3f4f 100644
--- a/test/yarp/snapshots/seattlerb/bug_215.txt
+++ b/test/yarp/snapshots/seattlerb/bug_215.txt
@@ -1,9 +1,13 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [UndefNode(0...13)(
-       [SymbolNode(6...13)((6...9), (9...12), (12...13), "foo")],
-       (0...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ UndefNode (location: (0...13))
+            ├── names: (length: 1)
+            │   └── @ SymbolNode (location: (6...13))
+            │       ├── opening_loc: (6...9) = "%s("
+            │       ├── value_loc: (9...12) = "foo"
+            │       ├── closing_loc: (12...13) = ")"
+            │       └── unescaped: "foo"
+            └── keyword_loc: (0...5) = "undef"
diff --git a/test/yarp/snapshots/seattlerb/bug_249.txt b/test/yarp/snapshots/seattlerb/bug_249.txt
index 776132c6d2..9bcffa3fb9 100644
--- a/test/yarp/snapshots/seattlerb/bug_249.txt
+++ b/test/yarp/snapshots/seattlerb/bug_249.txt
@@ -1,77 +1,82 @@
-ProgramNode(0...67)(
-  [],
-  StatementsNode(0...67)(
-    [CallNode(0...67)(
-       nil,
-       nil,
-       (0...5),
-       nil,
-       ArgumentsNode(6...67)(
-         [CallNode(6...48)(
-            ParenthesesNode(6...44)(
-              StatementsNode(7...43)(
-                [CallNode(7...43)(
-                   ConstantReadNode(7...12)(:Class),
-                   (12...13),
-                   (13...16),
-                   nil,
-                   nil,
-                   nil,
-                   BlockNode(17...43)(
-                     [],
-                     nil,
-                     StatementsNode(20...38)(
-                       [DefNode(20...38)(
-                          :initialize,
-                          (24...34),
-                          nil,
-                          nil,
-                          nil,
-                          [],
-                          (20...23),
-                          nil,
-                          nil,
-                          nil,
-                          nil,
-                          (35...38)
-                        )]
-                     ),
-                     (17...19),
-                     (40...43)
-                   ),
-                   0,
-                   "new"
-                 )]
-              ),
-              (6...7),
-              (43...44)
-            ),
-            (44...45),
-            (45...48),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "new"
-          ),
-          KeywordHashNode(50...67)(
-            [AssocNode(50...67)(
-               SymbolNode(50...53)((50...51), (51...53), nil, "at"),
-               StringNode(57...67)(
-                 (57...58),
-                 (58...66),
-                 (66...67),
-                 "endpoint"
-               ),
-               (54...56)
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "mount"
-     )]
-  )
-)
+@ ProgramNode (location: (0...67))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...67))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...67))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...5) = "mount"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (6...67))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (6...48))
+            │       │   ├── receiver:
+            │       │   │   @ ParenthesesNode (location: (6...44))
+            │       │   │   ├── body:
+            │       │   │   │   @ StatementsNode (location: (7...43))
+            │       │   │   │   └── body: (length: 1)
+            │       │   │   │       └── @ CallNode (location: (7...43))
+            │       │   │   │           ├── receiver:
+            │       │   │   │           │   @ ConstantReadNode (location: (7...12))
+            │       │   │   │           │   └── name: :Class
+            │       │   │   │           ├── call_operator_loc: (12...13) = "."
+            │       │   │   │           ├── message_loc: (13...16) = "new"
+            │       │   │   │           ├── opening_loc: ∅
+            │       │   │   │           ├── arguments: ∅
+            │       │   │   │           ├── closing_loc: ∅
+            │       │   │   │           ├── block:
+            │       │   │   │           │   @ BlockNode (location: (17...43))
+            │       │   │   │           │   ├── locals: []
+            │       │   │   │           │   ├── parameters: ∅
+            │       │   │   │           │   ├── body:
+            │       │   │   │           │   │   @ StatementsNode (location: (20...38))
+            │       │   │   │           │   │   └── body: (length: 1)
+            │       │   │   │           │   │       └── @ DefNode (location: (20...38))
+            │       │   │   │           │   │           ├── name: :initialize
+            │       │   │   │           │   │           ├── name_loc: (24...34) = "initialize"
+            │       │   │   │           │   │           ├── receiver: ∅
+            │       │   │   │           │   │           ├── parameters: ∅
+            │       │   │   │           │   │           ├── body: ∅
+            │       │   │   │           │   │           ├── locals: []
+            │       │   │   │           │   │           ├── def_keyword_loc: (20...23) = "def"
+            │       │   │   │           │   │           ├── operator_loc: ∅
+            │       │   │   │           │   │           ├── lparen_loc: ∅
+            │       │   │   │           │   │           ├── rparen_loc: ∅
+            │       │   │   │           │   │           ├── equal_loc: ∅
+            │       │   │   │           │   │           └── end_keyword_loc: (35...38) = "end"
+            │       │   │   │           │   ├── opening_loc: (17...19) = "do"
+            │       │   │   │           │   └── closing_loc: (40...43) = "end"
+            │       │   │   │           ├── flags: 
+            │       │   │   │           └── name: "new"
+            │       │   │   ├── opening_loc: (6...7) = "("
+            │       │   │   └── closing_loc: (43...44) = ")"
+            │       │   ├── call_operator_loc: (44...45) = "."
+            │       │   ├── message_loc: (45...48) = "new"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "new"
+            │       └── @ KeywordHashNode (location: (50...67))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (50...67))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (50...53))
+            │                   │   ├── opening_loc: (50...51) = ":"
+            │                   │   ├── value_loc: (51...53) = "at"
+            │                   │   ├── closing_loc: ∅
+            │                   │   └── unescaped: "at"
+            │                   ├── value:
+            │                   │   @ StringNode (location: (57...67))
+            │                   │   ├── opening_loc: (57...58) = "'"
+            │                   │   ├── content_loc: (58...66) = "endpoint"
+            │                   │   ├── closing_loc: (66...67) = "'"
+            │                   │   └── unescaped: "endpoint"
+            │                   └── operator_loc: (54...56) = "=>"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "mount"
diff --git a/test/yarp/snapshots/seattlerb/bug_and.txt b/test/yarp/snapshots/seattlerb/bug_and.txt
index b81ddb4d87..6215fceaf7 100644
--- a/test/yarp/snapshots/seattlerb/bug_and.txt
+++ b/test/yarp/snapshots/seattlerb/bug_and.txt
@@ -1,11 +1,20 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [AndNode(0...13)(TrueNode(0...4)(), TrueNode(9...13)(), (5...8)),
-     AndNode(15...26)(
-       TrueNode(15...19)(),
-       ArrayNode(24...26)([], (24...25), (25...26)),
-       (20...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 2)
+        ├── @ AndNode (location: (0...13))
+        │   ├── left:
+        │   │   @ TrueNode (location: (0...4))
+        │   ├── right:
+        │   │   @ TrueNode (location: (9...13))
+        │   └── operator_loc: (5...8) = "and"
+        └── @ AndNode (location: (15...26))
+            ├── left:
+            │   @ TrueNode (location: (15...19))
+            ├── right:
+            │   @ ArrayNode (location: (24...26))
+            │   ├── elements: (length: 0)
+            │   ├── opening_loc: (24...25) = "["
+            │   └── closing_loc: (25...26) = "]"
+            └── operator_loc: (20...23) = "and"
diff --git a/test/yarp/snapshots/seattlerb/bug_args__19.txt b/test/yarp/snapshots/seattlerb/bug_args__19.txt
index eba3f72951..48a0eb828e 100644
--- a/test/yarp/snapshots/seattlerb/bug_args__19.txt
+++ b/test/yarp/snapshots/seattlerb/bug_args__19.txt
@@ -1,42 +1,54 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...16)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...16)(
-         [:a, :b],
-         BlockParametersNode(4...12)(
-           ParametersNode(5...11)(
-             [RequiredDestructuredParameterNode(5...11)(
-                [RequiredParameterNode(6...7)(:a),
-                 RequiredParameterNode(9...10)(:b)],
-                (5...6),
-                (10...11)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (11...12)
-         ),
-         StatementsNode(13...14)(
-           [CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "d")]
-         ),
-         (2...3),
-         (15...16)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...16))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...16))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...11))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (5...11))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (6...7))
+            │   │   │   │       │   │   └── name: :a
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       │       └── name: :b
+            │   │   │   │       ├── opening_loc: (5...6) = "("
+            │   │   │   │       └── closing_loc: (10...11) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (11...12) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (13...14))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (13...14))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (13...14) = "d"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "d"
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (15...16) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/bug_args_masgn.txt b/test/yarp/snapshots/seattlerb/bug_args_masgn.txt
index 5a79af6c92..c64efe75ff 100644
--- a/test/yarp/snapshots/seattlerb/bug_args_masgn.txt
+++ b/test/yarp/snapshots/seattlerb/bug_args_masgn.txt
@@ -1,41 +1,44 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...17)(
-         [:a, :b, :c],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [RequiredDestructuredParameterNode(5...11)(
-                [RequiredParameterNode(6...7)(:a),
-                 RequiredParameterNode(9...10)(:b)],
-                (5...6),
-                (10...11)
-              ),
-              RequiredParameterNode(13...14)(:c)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         nil,
-         (2...3),
-         (16...17)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...17))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredDestructuredParameterNode (location: (5...11))
+            │   │   │   │   │   ├── parameters: (length: 2)
+            │   │   │   │   │   │   ├── @ RequiredParameterNode (location: (6...7))
+            │   │   │   │   │   │   │   └── name: :a
+            │   │   │   │   │   │   └── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │   │   │       └── name: :b
+            │   │   │   │   │   ├── opening_loc: (5...6) = "("
+            │   │   │   │   │   └── closing_loc: (10...11) = ")"
+            │   │   │   │   └── @ RequiredParameterNode (location: (13...14))
+            │   │   │   │       └── name: :c
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (16...17) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/bug_args_masgn2.txt b/test/yarp/snapshots/seattlerb/bug_args_masgn2.txt
index 410d5f7ebd..1405befc52 100644
--- a/test/yarp/snapshots/seattlerb/bug_args_masgn2.txt
+++ b/test/yarp/snapshots/seattlerb/bug_args_masgn2.txt
@@ -1,46 +1,50 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [CallNode(0...22)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...22)(
-         [:a, :b, :c, :d],
-         BlockParametersNode(4...20)(
-           ParametersNode(5...19)(
-             [RequiredDestructuredParameterNode(5...16)(
-                [RequiredDestructuredParameterNode(6...12)(
-                   [RequiredParameterNode(7...8)(:a),
-                    RequiredParameterNode(10...11)(:b)],
-                   (6...7),
-                   (11...12)
-                 ),
-                 RequiredParameterNode(14...15)(:c)],
-                (5...6),
-                (15...16)
-              ),
-              RequiredParameterNode(18...19)(:d)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (19...20)
-         ),
-         nil,
-         (2...3),
-         (21...22)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...22))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...22))
+            │   ├── locals: [:a, :b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...20))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...19))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredDestructuredParameterNode (location: (5...16))
+            │   │   │   │   │   ├── parameters: (length: 2)
+            │   │   │   │   │   │   ├── @ RequiredDestructuredParameterNode (location: (6...12))
+            │   │   │   │   │   │   │   ├── parameters: (length: 2)
+            │   │   │   │   │   │   │   │   ├── @ RequiredParameterNode (location: (7...8))
+            │   │   │   │   │   │   │   │   │   └── name: :a
+            │   │   │   │   │   │   │   │   └── @ RequiredParameterNode (location: (10...11))
+            │   │   │   │   │   │   │   │       └── name: :b
+            │   │   │   │   │   │   │   ├── opening_loc: (6...7) = "("
+            │   │   │   │   │   │   │   └── closing_loc: (11...12) = ")"
+            │   │   │   │   │   │   └── @ RequiredParameterNode (location: (14...15))
+            │   │   │   │   │   │       └── name: :c
+            │   │   │   │   │   ├── opening_loc: (5...6) = "("
+            │   │   │   │   │   └── closing_loc: (15...16) = ")"
+            │   │   │   │   └── @ RequiredParameterNode (location: (18...19))
+            │   │   │   │       └── name: :d
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (19...20) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (21...22) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/bug_args_masgn_outer_parens__19.txt b/test/yarp/snapshots/seattlerb/bug_args_masgn_outer_parens__19.txt
index c0b97dce6b..38904d86a7 100644
--- a/test/yarp/snapshots/seattlerb/bug_args_masgn_outer_parens__19.txt
+++ b/test/yarp/snapshots/seattlerb/bug_args_masgn_outer_parens__19.txt
@@ -1,45 +1,48 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [CallNode(0...19)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...19)(
-         [:k, :v, :i],
-         BlockParametersNode(4...17)(
-           ParametersNode(5...16)(
-             [RequiredDestructuredParameterNode(5...16)(
-                [RequiredDestructuredParameterNode(6...12)(
-                   [RequiredParameterNode(7...8)(:k),
-                    RequiredParameterNode(10...11)(:v)],
-                   (6...7),
-                   (11...12)
-                 ),
-                 RequiredParameterNode(14...15)(:i)],
-                (5...6),
-                (15...16)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (16...17)
-         ),
-         nil,
-         (2...3),
-         (18...19)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...19))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...19))
+            │   ├── locals: [:k, :v, :i]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...17))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...16))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (5...16))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ RequiredDestructuredParameterNode (location: (6...12))
+            │   │   │   │       │   │   ├── parameters: (length: 2)
+            │   │   │   │       │   │   │   ├── @ RequiredParameterNode (location: (7...8))
+            │   │   │   │       │   │   │   │   └── name: :k
+            │   │   │   │       │   │   │   └── @ RequiredParameterNode (location: (10...11))
+            │   │   │   │       │   │   │       └── name: :v
+            │   │   │   │       │   │   ├── opening_loc: (6...7) = "("
+            │   │   │   │       │   │   └── closing_loc: (11...12) = ")"
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (14...15))
+            │   │   │   │       │       └── name: :i
+            │   │   │   │       ├── opening_loc: (5...6) = "("
+            │   │   │   │       └── closing_loc: (15...16) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (16...17) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (18...19) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/bug_call_arglist_parens.txt b/test/yarp/snapshots/seattlerb/bug_call_arglist_parens.txt
index 67934a28dc..6a995dac64 100644
--- a/test/yarp/snapshots/seattlerb/bug_call_arglist_parens.txt
+++ b/test/yarp/snapshots/seattlerb/bug_call_arglist_parens.txt
@@ -1,89 +1,95 @@
-ProgramNode(6...94)(
-  [],
-  StatementsNode(6...94)(
-    [DefNode(6...39)(
-       :f,
-       (10...11),
-       nil,
-       nil,
-       StatementsNode(20...29)(
-         [CallNode(20...29)(
-            nil,
-            nil,
-            (20...21),
-            nil,
-            ArgumentsNode(22...29)(
-              [ParenthesesNode(22...26)(
-                 StatementsNode(24...25)([IntegerNode(24...25)()]),
-                 (22...23),
-                 (25...26)
-               ),
-               IntegerNode(28...29)()]
-            ),
-            nil,
-            nil,
-            0,
-            "g"
-          )]
-       ),
-       [],
-       (6...9),
-       nil,
-       nil,
-       nil,
-       nil,
-       (36...39)
-     ),
-     DefNode(48...82)(
-       :f,
-       (52...53),
-       nil,
-       nil,
-       StatementsNode(64...72)(
-         [CallNode(64...72)(
-            nil,
-            nil,
-            (64...65),
-            nil,
-            ArgumentsNode(66...72)(
-              [ParenthesesNode(66...69)(
-                 StatementsNode(67...68)([IntegerNode(67...68)()]),
-                 (66...67),
-                 (68...69)
-               ),
-               IntegerNode(71...72)()]
-            ),
-            nil,
-            nil,
-            0,
-            "g"
-          )]
-       ),
-       [],
-       (48...51),
-       nil,
-       (53...54),
-       (54...55),
-       nil,
-       (79...82)
-     ),
-     CallNode(85...94)(
-       nil,
-       nil,
-       (85...86),
-       nil,
-       ArgumentsNode(87...94)(
-         [ParenthesesNode(87...91)(
-            StatementsNode(89...90)([IntegerNode(89...90)()]),
-            (87...88),
-            (90...91)
-          ),
-          IntegerNode(93...94)()]
-       ),
-       nil,
-       nil,
-       0,
-       "g"
-     )]
-  )
-)
+@ ProgramNode (location: (6...94))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (6...94))
+    └── body: (length: 3)
+        ├── @ DefNode (location: (6...39))
+        │   ├── name: :f
+        │   ├── name_loc: (10...11) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (20...29))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (20...29))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (20...21) = "g"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (22...29))
+        │   │           │   └── arguments: (length: 2)
+        │   │           │       ├── @ ParenthesesNode (location: (22...26))
+        │   │           │       │   ├── body:
+        │   │           │       │   │   @ StatementsNode (location: (24...25))
+        │   │           │       │   │   └── body: (length: 1)
+        │   │           │       │   │       └── @ IntegerNode (location: (24...25))
+        │   │           │       │   ├── opening_loc: (22...23) = "("
+        │   │           │       │   └── closing_loc: (25...26) = ")"
+        │   │           │       └── @ IntegerNode (location: (28...29))
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "g"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (6...9) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (36...39) = "end"
+        ├── @ DefNode (location: (48...82))
+        │   ├── name: :f
+        │   ├── name_loc: (52...53) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (64...72))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (64...72))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (64...65) = "g"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (66...72))
+        │   │           │   └── arguments: (length: 2)
+        │   │           │       ├── @ ParenthesesNode (location: (66...69))
+        │   │           │       │   ├── body:
+        │   │           │       │   │   @ StatementsNode (location: (67...68))
+        │   │           │       │   │   └── body: (length: 1)
+        │   │           │       │   │       └── @ IntegerNode (location: (67...68))
+        │   │           │       │   ├── opening_loc: (66...67) = "("
+        │   │           │       │   └── closing_loc: (68...69) = ")"
+        │   │           │       └── @ IntegerNode (location: (71...72))
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "g"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (48...51) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (53...54) = "("
+        │   ├── rparen_loc: (54...55) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (79...82) = "end"
+        └── @ CallNode (location: (85...94))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (85...86) = "g"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (87...94))
+            │   └── arguments: (length: 2)
+            │       ├── @ ParenthesesNode (location: (87...91))
+            │       │   ├── body:
+            │       │   │   @ StatementsNode (location: (89...90))
+            │       │   │   └── body: (length: 1)
+            │       │   │       └── @ IntegerNode (location: (89...90))
+            │       │   ├── opening_loc: (87...88) = "("
+            │       │   └── closing_loc: (90...91) = ")"
+            │       └── @ IntegerNode (location: (93...94))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "g"
diff --git a/test/yarp/snapshots/seattlerb/bug_case_when_regexp.txt b/test/yarp/snapshots/seattlerb/bug_case_when_regexp.txt
index 0b898fd523..14a4002a36 100644
--- a/test/yarp/snapshots/seattlerb/bug_case_when_regexp.txt
+++ b/test/yarp/snapshots/seattlerb/bug_case_when_regexp.txt
@@ -1,22 +1,26 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [CaseNode(0...26)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "x"),
-       [WhenNode(9...17)(
-          (9...13),
-          [RegularExpressionNode(14...17)(
-             (14...15),
-             (15...16),
-             (16...17),
-             "x",
-             0
-           )],
-          nil
-        )],
-       nil,
-       (0...4),
-       (23...26)
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...26))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "x"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "x"
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (9...17))
+            │       ├── keyword_loc: (9...13) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ RegularExpressionNode (location: (14...17))
+            │       │       ├── opening_loc: (14...15) = "/"
+            │       │       ├── content_loc: (15...16) = "x"
+            │       │       ├── closing_loc: (16...17) = "/"
+            │       │       ├── unescaped: "x"
+            │       │       └── flags: 
+            │       └── statements: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (23...26) = "end"
diff --git a/test/yarp/snapshots/seattlerb/bug_comma.txt b/test/yarp/snapshots/seattlerb/bug_comma.txt
index a6dd7516ae..ab373aba59 100644
--- a/test/yarp/snapshots/seattlerb/bug_comma.txt
+++ b/test/yarp/snapshots/seattlerb/bug_comma.txt
@@ -1,35 +1,38 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [IfNode(0...24)(
-       (0...2),
-       CallNode(3...15)(
-         nil,
-         nil,
-         (3...7),
-         nil,
-         ArgumentsNode(8...15)(
-           [StringNode(8...10)((8...9), (9...10), nil, "d"),
-            CallNode(12...15)(
-              nil,
-              nil,
-              (12...15),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "dir"
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "test"
-       ),
-       nil,
-       nil,
-       (21...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...24))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (3...15))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (3...7) = "test"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (8...15))
+            │   │   └── arguments: (length: 2)
+            │   │       ├── @ StringNode (location: (8...10))
+            │   │       │   ├── opening_loc: (8...9) = "?"
+            │   │       │   ├── content_loc: (9...10) = "d"
+            │   │       │   ├── closing_loc: ∅
+            │   │       │   └── unescaped: "d"
+            │   │       └── @ CallNode (location: (12...15))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (12...15) = "dir"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "dir"
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "test"
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (21...24) = "end"
diff --git a/test/yarp/snapshots/seattlerb/bug_cond_pct.txt b/test/yarp/snapshots/seattlerb/bug_cond_pct.txt
index 6a73ca7493..e1f5d7bd5b 100644
--- a/test/yarp/snapshots/seattlerb/bug_cond_pct.txt
+++ b/test/yarp/snapshots/seattlerb/bug_cond_pct.txt
@@ -1,22 +1,21 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CaseNode(0...28)(
-       nil,
-       [WhenNode(6...23)(
-          (6...10),
-          [RegularExpressionNode(11...23)(
-             (11...14),
-             (14...22),
-             (22...23),
-             "blahblah",
-             0
-           )],
-          nil
-        )],
-       nil,
-       (0...4),
-       (25...28)
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...28))
+            ├── predicate: ∅
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (6...23))
+            │       ├── keyword_loc: (6...10) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ RegularExpressionNode (location: (11...23))
+            │       │       ├── opening_loc: (11...14) = "%r%"
+            │       │       ├── content_loc: (14...22) = "blahblah"
+            │       │       ├── closing_loc: (22...23) = "%"
+            │       │       ├── unescaped: "blahblah"
+            │       │       └── flags: 
+            │       └── statements: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (25...28) = "end"
diff --git a/test/yarp/snapshots/seattlerb/bug_hash_args.txt b/test/yarp/snapshots/seattlerb/bug_hash_args.txt
index 1eec48e930..08f3497bdd 100644
--- a/test/yarp/snapshots/seattlerb/bug_hash_args.txt
+++ b/test/yarp/snapshots/seattlerb/bug_hash_args.txt
@@ -1,25 +1,34 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [CallNode(0...19)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...18)(
-         [SymbolNode(4...8)((4...5), (5...8), nil, "bar"),
-          KeywordHashNode(10...18)(
-            [AssocNode(10...18)(
-               SymbolNode(10...14)(nil, (10...13), (13...14), "baz"),
-               NilNode(15...18)(),
-               nil
-             )]
-          )]
-       ),
-       (18...19),
-       nil,
-       0,
-       "foo"
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...19))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "foo"
+            ├── opening_loc: (3...4) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...18))
+            │   └── arguments: (length: 2)
+            │       ├── @ SymbolNode (location: (4...8))
+            │       │   ├── opening_loc: (4...5) = ":"
+            │       │   ├── value_loc: (5...8) = "bar"
+            │       │   ├── closing_loc: ∅
+            │       │   └── unescaped: "bar"
+            │       └── @ KeywordHashNode (location: (10...18))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (10...18))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (10...14))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (10...13) = "baz"
+            │                   │   ├── closing_loc: (13...14) = ":"
+            │                   │   └── unescaped: "baz"
+            │                   ├── value:
+            │                   │   @ NilNode (location: (15...18))
+            │                   └── operator_loc: ∅
+            ├── closing_loc: (18...19) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "foo"
diff --git a/test/yarp/snapshots/seattlerb/bug_hash_args_trailing_comma.txt b/test/yarp/snapshots/seattlerb/bug_hash_args_trailing_comma.txt
index 3801df91bf..c2831751bd 100644
--- a/test/yarp/snapshots/seattlerb/bug_hash_args_trailing_comma.txt
+++ b/test/yarp/snapshots/seattlerb/bug_hash_args_trailing_comma.txt
@@ -1,25 +1,34 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [CallNode(0...20)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...18)(
-         [SymbolNode(4...8)((4...5), (5...8), nil, "bar"),
-          KeywordHashNode(10...18)(
-            [AssocNode(10...18)(
-               SymbolNode(10...14)(nil, (10...13), (13...14), "baz"),
-               NilNode(15...18)(),
-               nil
-             )]
-          )]
-       ),
-       (19...20),
-       nil,
-       0,
-       "foo"
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...20))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "foo"
+            ├── opening_loc: (3...4) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...18))
+            │   └── arguments: (length: 2)
+            │       ├── @ SymbolNode (location: (4...8))
+            │       │   ├── opening_loc: (4...5) = ":"
+            │       │   ├── value_loc: (5...8) = "bar"
+            │       │   ├── closing_loc: ∅
+            │       │   └── unescaped: "bar"
+            │       └── @ KeywordHashNode (location: (10...18))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (10...18))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (10...14))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (10...13) = "baz"
+            │                   │   ├── closing_loc: (13...14) = ":"
+            │                   │   └── unescaped: "baz"
+            │                   ├── value:
+            │                   │   @ NilNode (location: (15...18))
+            │                   └── operator_loc: ∅
+            ├── closing_loc: (19...20) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "foo"
diff --git a/test/yarp/snapshots/seattlerb/bug_hash_interp_array.txt b/test/yarp/snapshots/seattlerb/bug_hash_interp_array.txt
index fff5c3bfb6..f05d1aeffc 100644
--- a/test/yarp/snapshots/seattlerb/bug_hash_interp_array.txt
+++ b/test/yarp/snapshots/seattlerb/bug_hash_interp_array.txt
@@ -1,18 +1,25 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [HashNode(0...13)(
-       (0...1),
-       [AssocNode(2...11)(
-          InterpolatedSymbolNode(2...8)(
-            (2...3),
-            [EmbeddedStatementsNode(3...6)((3...5), nil, (5...6))],
-            (6...8)
-          ),
-          ArrayNode(9...11)([], (9...10), (10...11)),
-          nil
-        )],
-       (12...13)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ HashNode (location: (0...13))
+            ├── opening_loc: (0...1) = "{"
+            ├── elements: (length: 1)
+            │   └── @ AssocNode (location: (2...11))
+            │       ├── key:
+            │       │   @ InterpolatedSymbolNode (location: (2...8))
+            │       │   ├── opening_loc: (2...3) = "\""
+            │       │   ├── parts: (length: 1)
+            │       │   │   └── @ EmbeddedStatementsNode (location: (3...6))
+            │       │   │       ├── opening_loc: (3...5) = "\#{"
+            │       │   │       ├── statements: ∅
+            │       │   │       └── closing_loc: (5...6) = "}"
+            │       │   └── closing_loc: (6...8) = "\":"
+            │       ├── value:
+            │       │   @ ArrayNode (location: (9...11))
+            │       │   ├── elements: (length: 0)
+            │       │   ├── opening_loc: (9...10) = "["
+            │       │   └── closing_loc: (10...11) = "]"
+            │       └── operator_loc: ∅
+            └── closing_loc: (12...13) = "}"
diff --git a/test/yarp/snapshots/seattlerb/bug_masgn_right.txt b/test/yarp/snapshots/seattlerb/bug_masgn_right.txt
index beee1f7990..ab558cca6c 100644
--- a/test/yarp/snapshots/seattlerb/bug_masgn_right.txt
+++ b/test/yarp/snapshots/seattlerb/bug_masgn_right.txt
@@ -1,41 +1,44 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...17)(
-         [:a, :b, :c],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...14)(
-                [RequiredParameterNode(9...10)(:b),
-                 RequiredParameterNode(12...13)(:c)],
-                (8...9),
-                (13...14)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         nil,
-         (2...3),
-         (16...17)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...17))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...14))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       │   │   └── name: :b
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (12...13))
+            │   │   │   │       │       └── name: :c
+            │   │   │   │       ├── opening_loc: (8...9) = "("
+            │   │   │   │       └── closing_loc: (13...14) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (16...17) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/bug_not_parens.txt b/test/yarp/snapshots/seattlerb/bug_not_parens.txt
index e4a01de3f4..e9559710e9 100644
--- a/test/yarp/snapshots/seattlerb/bug_not_parens.txt
+++ b/test/yarp/snapshots/seattlerb/bug_not_parens.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (0...3),
-       (3...4),
-       nil,
-       (5...6),
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver:
+            │   @ CallNode (location: (4...5))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (4...5) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "not"
+            ├── opening_loc: (3...4) = "("
+            ├── arguments: ∅
+            ├── closing_loc: (5...6) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/seattlerb/bug_op_asgn_rescue.txt b/test/yarp/snapshots/seattlerb/bug_op_asgn_rescue.txt
index 2bd4f430e3..32ef0af5ff 100644
--- a/test/yarp/snapshots/seattlerb/bug_op_asgn_rescue.txt
+++ b/test/yarp/snapshots/seattlerb/bug_op_asgn_rescue.txt
@@ -1,16 +1,26 @@
-ProgramNode(0...18)(
-  [:a],
-  StatementsNode(0...18)(
-    [LocalVariableOrWriteNode(0...18)(
-       (0...1),
-       (2...5),
-       RescueModifierNode(6...18)(
-         CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b"),
-         (8...14),
-         NilNode(15...18)()
-       ),
-       :a,
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ LocalVariableOrWriteNode (location: (0...18))
+            ├── name_loc: (0...1) = "a"
+            ├── operator_loc: (2...5) = "||="
+            ├── value:
+            │   @ RescueModifierNode (location: (6...18))
+            │   ├── expression:
+            │   │   @ CallNode (location: (6...7))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (6...7) = "b"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "b"
+            │   ├── keyword_loc: (8...14) = "rescue"
+            │   └── rescue_expression:
+            │       @ NilNode (location: (15...18))
+            ├── name: :a
+            └── depth: 0
diff --git a/test/yarp/snapshots/seattlerb/call_and.txt b/test/yarp/snapshots/seattlerb/call_and.txt
index d6b4d8d6ce..fe118a8dc4 100644
--- a/test/yarp/snapshots/seattlerb/call_and.txt
+++ b/test/yarp/snapshots/seattlerb/call_and.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...3),
-       nil,
-       ArgumentsNode(4...5)([IntegerNode(4...5)()]),
-       nil,
-       nil,
-       0,
-       "&"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...3) = "&"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...5))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (4...5))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "&"
diff --git a/test/yarp/snapshots/seattlerb/call_arg_assoc.txt b/test/yarp/snapshots/seattlerb/call_arg_assoc.txt
index e6c88afdf0..3845a3d0c6 100644
--- a/test/yarp/snapshots/seattlerb/call_arg_assoc.txt
+++ b/test/yarp/snapshots/seattlerb/call_arg_assoc.txt
@@ -1,25 +1,26 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [CallNode(0...10)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...9)(
-         [IntegerNode(2...3)(),
-          KeywordHashNode(5...9)(
-            [AssocNode(5...9)(
-               IntegerNode(5...6)(),
-               IntegerNode(8...9)(),
-               (6...8)
-             )]
-          )]
-       ),
-       (9...10),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...10))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...9))
+            │   └── arguments: (length: 2)
+            │       ├── @ IntegerNode (location: (2...3))
+            │       └── @ KeywordHashNode (location: (5...9))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (5...9))
+            │                   ├── key:
+            │                   │   @ IntegerNode (location: (5...6))
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (8...9))
+            │                   └── operator_loc: (6...8) = "=>"
+            ├── closing_loc: (9...10) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/call_arg_assoc_kwsplat.txt b/test/yarp/snapshots/seattlerb/call_arg_assoc_kwsplat.txt
index 076fe7a8b2..22766ae91a 100644
--- a/test/yarp/snapshots/seattlerb/call_arg_assoc_kwsplat.txt
+++ b/test/yarp/snapshots/seattlerb/call_arg_assoc_kwsplat.txt
@@ -1,26 +1,34 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...16)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...15)(
-         [IntegerNode(2...3)(),
-          KeywordHashNode(5...15)(
-            [AssocNode(5...10)(
-               SymbolNode(5...8)(nil, (5...7), (7...8), "kw"),
-               IntegerNode(9...10)(),
-               nil
-             ),
-             AssocSplatNode(12...15)(IntegerNode(14...15)(), (12...14))]
-          )]
-       ),
-       (15...16),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...16))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...15))
+            │   └── arguments: (length: 2)
+            │       ├── @ IntegerNode (location: (2...3))
+            │       └── @ KeywordHashNode (location: (5...15))
+            │           └── elements: (length: 2)
+            │               ├── @ AssocNode (location: (5...10))
+            │               │   ├── key:
+            │               │   │   @ SymbolNode (location: (5...8))
+            │               │   │   ├── opening_loc: ∅
+            │               │   │   ├── value_loc: (5...7) = "kw"
+            │               │   │   ├── closing_loc: (7...8) = ":"
+            │               │   │   └── unescaped: "kw"
+            │               │   ├── value:
+            │               │   │   @ IntegerNode (location: (9...10))
+            │               │   └── operator_loc: ∅
+            │               └── @ AssocSplatNode (location: (12...15))
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (14...15))
+            │                   └── operator_loc: (12...14) = "**"
+            ├── closing_loc: (15...16) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/call_arg_kwsplat.txt b/test/yarp/snapshots/seattlerb/call_arg_kwsplat.txt
index 6a98d992d3..5d5ee7f8b0 100644
--- a/test/yarp/snapshots/seattlerb/call_arg_kwsplat.txt
+++ b/test/yarp/snapshots/seattlerb/call_arg_kwsplat.txt
@@ -1,21 +1,33 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...8)(
-         [CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "b"),
-          KeywordHashNode(5...8)(
-            [AssocSplatNode(5...8)(IntegerNode(7...8)(), (5...7))]
-          )]
-       ),
-       (8...9),
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...8))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (2...3))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (2...3) = "b"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "b"
+            │       └── @ KeywordHashNode (location: (5...8))
+            │           └── elements: (length: 1)
+            │               └── @ AssocSplatNode (location: (5...8))
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (7...8))
+            │                   └── operator_loc: (5...7) = "**"
+            ├── closing_loc: (8...9) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/call_args_assoc_quoted.txt b/test/yarp/snapshots/seattlerb/call_args_assoc_quoted.txt
index b632adc6ba..b1881eeb1c 100644
--- a/test/yarp/snapshots/seattlerb/call_args_assoc_quoted.txt
+++ b/test/yarp/snapshots/seattlerb/call_args_assoc_quoted.txt
@@ -1,82 +1,92 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)(
-    [CallNode(0...11)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...11)(
-         [KeywordHashNode(2...11)(
-            [AssocNode(2...11)(
-               InterpolatedSymbolNode(2...9)(
-                 (2...3),
-                 [EmbeddedStatementsNode(3...7)(
-                    (3...5),
-                    StatementsNode(5...6)(
-                      [CallNode(5...6)(
-                         nil,
-                         nil,
-                         (5...6),
-                         nil,
-                         nil,
-                         nil,
-                         nil,
-                         2,
-                         "k"
-                       )]
-                    ),
-                    (6...7)
-                  )],
-                 (7...9)
-               ),
-               IntegerNode(9...11)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "x"
-     ),
-     CallNode(13...21)(
-       nil,
-       nil,
-       (13...14),
-       nil,
-       ArgumentsNode(15...21)(
-         [KeywordHashNode(15...21)(
-            [AssocNode(15...21)(
-               SymbolNode(15...19)((15...16), (16...17), (17...19), "k"),
-               IntegerNode(19...21)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "x"
-     ),
-     CallNode(23...31)(
-       nil,
-       nil,
-       (23...24),
-       nil,
-       ArgumentsNode(25...31)(
-         [KeywordHashNode(25...31)(
-            [AssocNode(25...31)(
-               SymbolNode(25...29)((25...26), (26...27), (27...29), "k"),
-               IntegerNode(29...31)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "x"
-     )]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...11))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "x"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...11))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (2...11))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (2...11))
+        │   │                   ├── key:
+        │   │                   │   @ InterpolatedSymbolNode (location: (2...9))
+        │   │                   │   ├── opening_loc: (2...3) = "\""
+        │   │                   │   ├── parts: (length: 1)
+        │   │                   │   │   └── @ EmbeddedStatementsNode (location: (3...7))
+        │   │                   │   │       ├── opening_loc: (3...5) = "\#{"
+        │   │                   │   │       ├── statements:
+        │   │                   │   │       │   @ StatementsNode (location: (5...6))
+        │   │                   │   │       │   └── body: (length: 1)
+        │   │                   │   │       │       └── @ CallNode (location: (5...6))
+        │   │                   │   │       │           ├── receiver: ∅
+        │   │                   │   │       │           ├── call_operator_loc: ∅
+        │   │                   │   │       │           ├── message_loc: (5...6) = "k"
+        │   │                   │   │       │           ├── opening_loc: ∅
+        │   │                   │   │       │           ├── arguments: ∅
+        │   │                   │   │       │           ├── closing_loc: ∅
+        │   │                   │   │       │           ├── block: ∅
+        │   │                   │   │       │           ├── flags: variable_call
+        │   │                   │   │       │           └── name: "k"
+        │   │                   │   │       └── closing_loc: (6...7) = "}"
+        │   │                   │   └── closing_loc: (7...9) = "\":"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (9...11))
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "x"
+        ├── @ CallNode (location: (13...21))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (13...14) = "x"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (15...21))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (15...21))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (15...21))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (15...19))
+        │   │                   │   ├── opening_loc: (15...16) = "\""
+        │   │                   │   ├── value_loc: (16...17) = "k"
+        │   │                   │   ├── closing_loc: (17...19) = "\":"
+        │   │                   │   └── unescaped: "k"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (19...21))
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "x"
+        └── @ CallNode (location: (23...31))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (23...24) = "x"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (25...31))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (25...31))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (25...31))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (25...29))
+            │                   │   ├── opening_loc: (25...26) = "'"
+            │                   │   ├── value_loc: (26...27) = "k"
+            │                   │   ├── closing_loc: (27...29) = "':"
+            │                   │   └── unescaped: "k"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (29...31))
+            │                   └── operator_loc: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/call_args_assoc_trailing_comma.txt b/test/yarp/snapshots/seattlerb/call_args_assoc_trailing_comma.txt
index 432a7c0a44..2d5f439bf5 100644
--- a/test/yarp/snapshots/seattlerb/call_args_assoc_trailing_comma.txt
+++ b/test/yarp/snapshots/seattlerb/call_args_assoc_trailing_comma.txt
@@ -1,25 +1,26 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallNode(0...11)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...9)(
-         [IntegerNode(2...3)(),
-          KeywordHashNode(5...9)(
-            [AssocNode(5...9)(
-               IntegerNode(5...6)(),
-               IntegerNode(8...9)(),
-               (6...8)
-             )]
-          )]
-       ),
-       (10...11),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...11))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...9))
+            │   └── arguments: (length: 2)
+            │       ├── @ IntegerNode (location: (2...3))
+            │       └── @ KeywordHashNode (location: (5...9))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (5...9))
+            │                   ├── key:
+            │                   │   @ IntegerNode (location: (5...6))
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (8...9))
+            │                   └── operator_loc: (6...8) = "=>"
+            ├── closing_loc: (10...11) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/call_args_command.txt b/test/yarp/snapshots/seattlerb/call_args_command.txt
index fa5c35b868..8209fdfe16 100644
--- a/test/yarp/snapshots/seattlerb/call_args_command.txt
+++ b/test/yarp/snapshots/seattlerb/call_args_command.txt
@@ -1,28 +1,50 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...3),
-       nil,
-       ArgumentsNode(4...9)(
-         [CallNode(4...9)(
-            CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "c"),
-            (5...6),
-            (6...7),
-            nil,
-            ArgumentsNode(8...9)([IntegerNode(8...9)()]),
-            nil,
-            nil,
-            0,
-            "d"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...3) = "b"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...9))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (4...9))
+            │           ├── receiver:
+            │           │   @ CallNode (location: (4...5))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (4...5) = "c"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "c"
+            │           ├── call_operator_loc: (5...6) = "."
+            │           ├── message_loc: (6...7) = "d"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (8...9))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ IntegerNode (location: (8...9))
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "d"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/call_array_arg.txt b/test/yarp/snapshots/seattlerb/call_array_arg.txt
index ade225a9e6..e278e2d40b 100644
--- a/test/yarp/snapshots/seattlerb/call_array_arg.txt
+++ b/test/yarp/snapshots/seattlerb/call_array_arg.txt
@@ -1,23 +1,32 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...4),
-       nil,
-       ArgumentsNode(5...13)(
-         [ArrayNode(5...13)(
-            [SymbolNode(6...8)((6...7), (7...8), nil, "b"),
-             SymbolNode(10...12)((10...11), (11...12), nil, "c")],
-            (5...6),
-            (12...13)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "=="
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...4) = "=="
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...13))
+            │   └── arguments: (length: 1)
+            │       └── @ ArrayNode (location: (5...13))
+            │           ├── elements: (length: 2)
+            │           │   ├── @ SymbolNode (location: (6...8))
+            │           │   │   ├── opening_loc: (6...7) = ":"
+            │           │   │   ├── value_loc: (7...8) = "b"
+            │           │   │   ├── closing_loc: ∅
+            │           │   │   └── unescaped: "b"
+            │           │   └── @ SymbolNode (location: (10...12))
+            │           │       ├── opening_loc: (10...11) = ":"
+            │           │       ├── value_loc: (11...12) = "c"
+            │           │       ├── closing_loc: ∅
+            │           │       └── unescaped: "c"
+            │           ├── opening_loc: (5...6) = "["
+            │           └── closing_loc: (12...13) = "]"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "=="
diff --git a/test/yarp/snapshots/seattlerb/call_array_block_call.txt b/test/yarp/snapshots/seattlerb/call_array_block_call.txt
index 460621a131..ce9ced7e30 100644
--- a/test/yarp/snapshots/seattlerb/call_array_block_call.txt
+++ b/test/yarp/snapshots/seattlerb/call_array_block_call.txt
@@ -1,33 +1,38 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [CallNode(0...19)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...19)(
-         [ArrayNode(2...19)(
-            [NilNode(4...7)(),
-             CallNode(9...17)(
-               nil,
-               nil,
-               (9...10),
-               nil,
-               nil,
-               nil,
-               BlockNode(11...17)([], nil, nil, (11...13), (14...17)),
-               0,
-               "b"
-             )],
-            (2...3),
-            (18...19)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...19))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...19))
+            │   └── arguments: (length: 1)
+            │       └── @ ArrayNode (location: (2...19))
+            │           ├── elements: (length: 2)
+            │           │   ├── @ NilNode (location: (4...7))
+            │           │   └── @ CallNode (location: (9...17))
+            │           │       ├── receiver: ∅
+            │           │       ├── call_operator_loc: ∅
+            │           │       ├── message_loc: (9...10) = "b"
+            │           │       ├── opening_loc: ∅
+            │           │       ├── arguments: ∅
+            │           │       ├── closing_loc: ∅
+            │           │       ├── block:
+            │           │       │   @ BlockNode (location: (11...17))
+            │           │       │   ├── locals: []
+            │           │       │   ├── parameters: ∅
+            │           │       │   ├── body: ∅
+            │           │       │   ├── opening_loc: (11...13) = "do"
+            │           │       │   └── closing_loc: (14...17) = "end"
+            │           │       ├── flags: 
+            │           │       └── name: "b"
+            │           ├── opening_loc: (2...3) = "["
+            │           └── closing_loc: (18...19) = "]"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/call_array_lambda_block_call.txt b/test/yarp/snapshots/seattlerb/call_array_lambda_block_call.txt
index c83adb235f..cb4f241661 100644
--- a/test/yarp/snapshots/seattlerb/call_array_lambda_block_call.txt
+++ b/test/yarp/snapshots/seattlerb/call_array_lambda_block_call.txt
@@ -1,29 +1,39 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...11)(
-         [ArrayNode(2...11)(
-            [LambdaNode(3...10)(
-               [],
-               (3...5),
-               (8...9),
-               (9...10),
-               BlockParametersNode(5...7)(nil, [], (5...6), (6...7)),
-               nil
-             )],
-            (2...3),
-            (10...11)
-          )]
-       ),
-       nil,
-       BlockNode(12...18)([], nil, nil, (12...14), (15...18)),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...18))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...11))
+            │   └── arguments: (length: 1)
+            │       └── @ ArrayNode (location: (2...11))
+            │           ├── elements: (length: 1)
+            │           │   └── @ LambdaNode (location: (3...10))
+            │           │       ├── locals: []
+            │           │       ├── operator_loc: (3...5) = "->"
+            │           │       ├── opening_loc: (8...9) = "{"
+            │           │       ├── closing_loc: (9...10) = "}"
+            │           │       ├── parameters:
+            │           │       │   @ BlockParametersNode (location: (5...7))
+            │           │       │   ├── parameters: ∅
+            │           │       │   ├── locals: (length: 0)
+            │           │       │   ├── opening_loc: (5...6) = "("
+            │           │       │   └── closing_loc: (6...7) = ")"
+            │           │       └── body: ∅
+            │           ├── opening_loc: (2...3) = "["
+            │           └── closing_loc: (10...11) = "]"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (12...18))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (12...14) = "do"
+            │   └── closing_loc: (15...18) = "end"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/call_array_lit_inline_hash.txt b/test/yarp/snapshots/seattlerb/call_array_lit_inline_hash.txt
index ef336c5a15..b8dd0eb928 100644
--- a/test/yarp/snapshots/seattlerb/call_array_lit_inline_hash.txt
+++ b/test/yarp/snapshots/seattlerb/call_array_lit_inline_hash.txt
@@ -1,29 +1,38 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...16)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...15)(
-         [ArrayNode(2...15)(
-            [SymbolNode(3...5)((3...4), (4...5), nil, "b"),
-             KeywordHashNode(7...14)(
-               [AssocNode(7...14)(
-                  SymbolNode(7...9)((7...8), (8...9), nil, "c"),
-                  IntegerNode(13...14)(),
-                  (10...12)
-                )]
-             )],
-            (2...3),
-            (14...15)
-          )]
-       ),
-       (15...16),
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...16))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...15))
+            │   └── arguments: (length: 1)
+            │       └── @ ArrayNode (location: (2...15))
+            │           ├── elements: (length: 2)
+            │           │   ├── @ SymbolNode (location: (3...5))
+            │           │   │   ├── opening_loc: (3...4) = ":"
+            │           │   │   ├── value_loc: (4...5) = "b"
+            │           │   │   ├── closing_loc: ∅
+            │           │   │   └── unescaped: "b"
+            │           │   └── @ KeywordHashNode (location: (7...14))
+            │           │       └── elements: (length: 1)
+            │           │           └── @ AssocNode (location: (7...14))
+            │           │               ├── key:
+            │           │               │   @ SymbolNode (location: (7...9))
+            │           │               │   ├── opening_loc: (7...8) = ":"
+            │           │               │   ├── value_loc: (8...9) = "c"
+            │           │               │   ├── closing_loc: ∅
+            │           │               │   └── unescaped: "c"
+            │           │               ├── value:
+            │           │               │   @ IntegerNode (location: (13...14))
+            │           │               └── operator_loc: (10...12) = "=>"
+            │           ├── opening_loc: (2...3) = "["
+            │           └── closing_loc: (14...15) = "]"
+            ├── closing_loc: (15...16) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/call_assoc.txt b/test/yarp/snapshots/seattlerb/call_assoc.txt
index bd6a6e286c..666a2560b8 100644
--- a/test/yarp/snapshots/seattlerb/call_assoc.txt
+++ b/test/yarp/snapshots/seattlerb/call_assoc.txt
@@ -1,24 +1,25 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...6)(
-         [KeywordHashNode(2...6)(
-            [AssocNode(2...6)(
-               IntegerNode(2...3)(),
-               IntegerNode(5...6)(),
-               (3...5)
-             )]
-          )]
-       ),
-       (6...7),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...6))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (2...6))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (2...6))
+            │                   ├── key:
+            │                   │   @ IntegerNode (location: (2...3))
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (5...6))
+            │                   └── operator_loc: (3...5) = "=>"
+            ├── closing_loc: (6...7) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/call_assoc_new.txt b/test/yarp/snapshots/seattlerb/call_assoc_new.txt
index 525b3b1472..03b2c2d5c8 100644
--- a/test/yarp/snapshots/seattlerb/call_assoc_new.txt
+++ b/test/yarp/snapshots/seattlerb/call_assoc_new.txt
@@ -1,24 +1,29 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...5)(
-         [KeywordHashNode(2...5)(
-            [AssocNode(2...5)(
-               SymbolNode(2...4)(nil, (2...3), (3...4), "a"),
-               IntegerNode(4...5)(),
-               nil
-             )]
-          )]
-       ),
-       (5...6),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...5))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (2...5))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (2...5))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (2...4))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (2...3) = "a"
+            │                   │   ├── closing_loc: (3...4) = ":"
+            │                   │   └── unescaped: "a"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (4...5))
+            │                   └── operator_loc: ∅
+            ├── closing_loc: (5...6) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/call_assoc_new_if_multiline.txt b/test/yarp/snapshots/seattlerb/call_assoc_new_if_multiline.txt
index 5bfb5a0887..dd397655ca 100644
--- a/test/yarp/snapshots/seattlerb/call_assoc_new_if_multiline.txt
+++ b/test/yarp/snapshots/seattlerb/call_assoc_new_if_multiline.txt
@@ -1,34 +1,49 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [CallNode(0...24)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...23)(
-         [KeywordHashNode(2...23)(
-            [AssocNode(2...23)(
-               SymbolNode(2...4)(nil, (2...3), (3...4), "b"),
-               IfNode(5...23)(
-                 (5...7),
-                 SymbolNode(8...10)((8...9), (9...10), nil, "c"),
-                 StatementsNode(11...12)([IntegerNode(11...12)()]),
-                 ElseNode(13...23)(
-                   (13...17),
-                   StatementsNode(18...19)([IntegerNode(18...19)()]),
-                   (20...23)
-                 ),
-                 (20...23)
-               ),
-               nil
-             )]
-          )]
-       ),
-       (23...24),
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...24))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...23))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (2...23))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (2...23))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (2...4))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (2...3) = "b"
+            │                   │   ├── closing_loc: (3...4) = ":"
+            │                   │   └── unescaped: "b"
+            │                   ├── value:
+            │                   │   @ IfNode (location: (5...23))
+            │                   │   ├── if_keyword_loc: (5...7) = "if"
+            │                   │   ├── predicate:
+            │                   │   │   @ SymbolNode (location: (8...10))
+            │                   │   │   ├── opening_loc: (8...9) = ":"
+            │                   │   │   ├── value_loc: (9...10) = "c"
+            │                   │   │   ├── closing_loc: ∅
+            │                   │   │   └── unescaped: "c"
+            │                   │   ├── statements:
+            │                   │   │   @ StatementsNode (location: (11...12))
+            │                   │   │   └── body: (length: 1)
+            │                   │   │       └── @ IntegerNode (location: (11...12))
+            │                   │   ├── consequent:
+            │                   │   │   @ ElseNode (location: (13...23))
+            │                   │   │   ├── else_keyword_loc: (13...17) = "else"
+            │                   │   │   ├── statements:
+            │                   │   │   │   @ StatementsNode (location: (18...19))
+            │                   │   │   │   └── body: (length: 1)
+            │                   │   │   │       └── @ IntegerNode (location: (18...19))
+            │                   │   │   └── end_keyword_loc: (20...23) = "end"
+            │                   │   └── end_keyword_loc: (20...23) = "end"
+            │                   └── operator_loc: ∅
+            ├── closing_loc: (23...24) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/call_assoc_trailing_comma.txt b/test/yarp/snapshots/seattlerb/call_assoc_trailing_comma.txt
index 0f68852c19..8822b5a948 100644
--- a/test/yarp/snapshots/seattlerb/call_assoc_trailing_comma.txt
+++ b/test/yarp/snapshots/seattlerb/call_assoc_trailing_comma.txt
@@ -1,24 +1,25 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...8)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...6)(
-         [KeywordHashNode(2...6)(
-            [AssocNode(2...6)(
-               IntegerNode(2...3)(),
-               IntegerNode(5...6)(),
-               (3...5)
-             )]
-          )]
-       ),
-       (7...8),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...8))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...6))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (2...6))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (2...6))
+            │                   ├── key:
+            │                   │   @ IntegerNode (location: (2...3))
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (5...6))
+            │                   └── operator_loc: (3...5) = "=>"
+            ├── closing_loc: (7...8) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/call_bang_command_call.txt b/test/yarp/snapshots/seattlerb/call_bang_command_call.txt
index 104d90d1c2..b0981f5492 100644
--- a/test/yarp/snapshots/seattlerb/call_bang_command_call.txt
+++ b/test/yarp/snapshots/seattlerb/call_bang_command_call.txt
@@ -1,26 +1,38 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       CallNode(2...7)(
-         CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "a"),
-         (3...4),
-         (4...5),
-         nil,
-         ArgumentsNode(6...7)([IntegerNode(6...7)()]),
-         nil,
-         nil,
-         0,
-         "b"
-       ),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ CallNode (location: (2...7))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (2...3))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (2...3) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (3...4) = "."
+            │   ├── message_loc: (4...5) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (6...7))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ IntegerNode (location: (6...7))
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "b"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "!"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/seattlerb/call_bang_squiggle.txt b/test/yarp/snapshots/seattlerb/call_bang_squiggle.txt
index 5614695771..08f73d350c 100644
--- a/test/yarp/snapshots/seattlerb/call_bang_squiggle.txt
+++ b/test/yarp/snapshots/seattlerb/call_bang_squiggle.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...4),
-       nil,
-       ArgumentsNode(5...6)([IntegerNode(5...6)()]),
-       nil,
-       nil,
-       0,
-       "!~"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...4) = "!~"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...6))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (5...6))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!~"
diff --git a/test/yarp/snapshots/seattlerb/call_begin_call_block_call.txt b/test/yarp/snapshots/seattlerb/call_begin_call_block_call.txt
index 9b60d515f0..defd0ecd81 100644
--- a/test/yarp/snapshots/seattlerb/call_begin_call_block_call.txt
+++ b/test/yarp/snapshots/seattlerb/call_begin_call_block_call.txt
@@ -1,47 +1,52 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [CallNode(0...22)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...22)(
-         [BeginNode(2...22)(
-            (2...7),
-            StatementsNode(8...18)(
-              [CallNode(8...18)(
-                 CallNode(8...9)(
-                   nil,
-                   nil,
-                   (8...9),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "b"
-                 ),
-                 (9...10),
-                 (10...11),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(12...18)([], nil, nil, (12...14), (15...18)),
-                 0,
-                 "c"
-               )]
-            ),
-            nil,
-            nil,
-            nil,
-            (19...22)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...22))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...22))
+            │   └── arguments: (length: 1)
+            │       └── @ BeginNode (location: (2...22))
+            │           ├── begin_keyword_loc: (2...7) = "begin"
+            │           ├── statements:
+            │           │   @ StatementsNode (location: (8...18))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (8...18))
+            │           │           ├── receiver:
+            │           │           │   @ CallNode (location: (8...9))
+            │           │           │   ├── receiver: ∅
+            │           │           │   ├── call_operator_loc: ∅
+            │           │           │   ├── message_loc: (8...9) = "b"
+            │           │           │   ├── opening_loc: ∅
+            │           │           │   ├── arguments: ∅
+            │           │           │   ├── closing_loc: ∅
+            │           │           │   ├── block: ∅
+            │           │           │   ├── flags: variable_call
+            │           │           │   └── name: "b"
+            │           │           ├── call_operator_loc: (9...10) = "."
+            │           │           ├── message_loc: (10...11) = "c"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block:
+            │           │           │   @ BlockNode (location: (12...18))
+            │           │           │   ├── locals: []
+            │           │           │   ├── parameters: ∅
+            │           │           │   ├── body: ∅
+            │           │           │   ├── opening_loc: (12...14) = "do"
+            │           │           │   └── closing_loc: (15...18) = "end"
+            │           │           ├── flags: 
+            │           │           └── name: "c"
+            │           ├── rescue_clause: ∅
+            │           ├── else_clause: ∅
+            │           ├── ensure_clause: ∅
+            │           └── end_keyword_loc: (19...22) = "end"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/call_block_arg_named.txt b/test/yarp/snapshots/seattlerb/call_block_arg_named.txt
index f24da1bcd5..4739365aca 100644
--- a/test/yarp/snapshots/seattlerb/call_block_arg_named.txt
+++ b/test/yarp/snapshots/seattlerb/call_block_arg_named.txt
@@ -1,21 +1,30 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...6)(
-         [BlockArgumentNode(2...6)(
-            CallNode(3...6)(nil, nil, (3...6), nil, nil, nil, nil, 2, "blk"),
-            (2...3)
-          )]
-       ),
-       (6...7),
-       nil,
-       0,
-       "x"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "x"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...6))
+            │   └── arguments: (length: 1)
+            │       └── @ BlockArgumentNode (location: (2...6))
+            │           ├── expression:
+            │           │   @ CallNode (location: (3...6))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (3...6) = "blk"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "blk"
+            │           └── operator_loc: (2...3) = "&"
+            ├── closing_loc: (6...7) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/call_carat.txt b/test/yarp/snapshots/seattlerb/call_carat.txt
index bea1ff7c68..485ba51cb0 100644
--- a/test/yarp/snapshots/seattlerb/call_carat.txt
+++ b/test/yarp/snapshots/seattlerb/call_carat.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...3),
-       nil,
-       ArgumentsNode(4...5)([IntegerNode(4...5)()]),
-       nil,
-       nil,
-       0,
-       "^"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...3) = "^"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...5))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (4...5))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "^"
diff --git a/test/yarp/snapshots/seattlerb/call_colon2.txt b/test/yarp/snapshots/seattlerb/call_colon2.txt
index 66b8a4a017..7f8eaf55bc 100644
--- a/test/yarp/snapshots/seattlerb/call_colon2.txt
+++ b/test/yarp/snapshots/seattlerb/call_colon2.txt
@@ -1,16 +1,17 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [CallNode(0...4)(
-       ConstantReadNode(0...1)(:A),
-       (1...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...4))
+            ├── receiver:
+            │   @ ConstantReadNode (location: (0...1))
+            │   └── name: :A
+            ├── call_operator_loc: (1...3) = "::"
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/call_colon_parens.txt b/test/yarp/snapshots/seattlerb/call_colon_parens.txt
index 14c7247bcd..f6b39e38a4 100644
--- a/test/yarp/snapshots/seattlerb/call_colon_parens.txt
+++ b/test/yarp/snapshots/seattlerb/call_colon_parens.txt
@@ -1,16 +1,16 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       IntegerNode(0...1)(),
-       (1...3),
-       nil,
-       (3...4),
-       nil,
-       (4...5),
-       nil,
-       0,
-       "call"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: (1...3) = "::"
+            ├── message_loc: ∅
+            ├── opening_loc: (3...4) = "("
+            ├── arguments: ∅
+            ├── closing_loc: (4...5) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "call"
diff --git a/test/yarp/snapshots/seattlerb/call_div.txt b/test/yarp/snapshots/seattlerb/call_div.txt
index f7caf10414..eeeda0dc00 100644
--- a/test/yarp/snapshots/seattlerb/call_div.txt
+++ b/test/yarp/snapshots/seattlerb/call_div.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...3),
-       nil,
-       ArgumentsNode(4...5)([IntegerNode(4...5)()]),
-       nil,
-       nil,
-       0,
-       "/"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...3) = "/"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...5))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (4...5))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "/"
diff --git a/test/yarp/snapshots/seattlerb/call_dot_parens.txt b/test/yarp/snapshots/seattlerb/call_dot_parens.txt
index 073336ed48..a8d917c0b6 100644
--- a/test/yarp/snapshots/seattlerb/call_dot_parens.txt
+++ b/test/yarp/snapshots/seattlerb/call_dot_parens.txt
@@ -1,16 +1,16 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [CallNode(0...4)(
-       IntegerNode(0...1)(),
-       (1...2),
-       nil,
-       (2...3),
-       nil,
-       (3...4),
-       nil,
-       0,
-       "call"
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...4))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: ∅
+            ├── opening_loc: (2...3) = "("
+            ├── arguments: ∅
+            ├── closing_loc: (3...4) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "call"
diff --git a/test/yarp/snapshots/seattlerb/call_env.txt b/test/yarp/snapshots/seattlerb/call_env.txt
index 8af975cdce..69e3bf23bf 100644
--- a/test/yarp/snapshots/seattlerb/call_env.txt
+++ b/test/yarp/snapshots/seattlerb/call_env.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...7),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "happy"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...7) = "happy"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "happy"
diff --git a/test/yarp/snapshots/seattlerb/call_eq3.txt b/test/yarp/snapshots/seattlerb/call_eq3.txt
index 192a3c97c5..144c8a55f1 100644
--- a/test/yarp/snapshots/seattlerb/call_eq3.txt
+++ b/test/yarp/snapshots/seattlerb/call_eq3.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...5),
-       nil,
-       ArgumentsNode(6...7)([IntegerNode(6...7)()]),
-       nil,
-       nil,
-       0,
-       "==="
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...5) = "==="
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (6...7))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (6...7))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "==="
diff --git a/test/yarp/snapshots/seattlerb/call_gt.txt b/test/yarp/snapshots/seattlerb/call_gt.txt
index 9eadb5ee2f..92cdd04aa4 100644
--- a/test/yarp/snapshots/seattlerb/call_gt.txt
+++ b/test/yarp/snapshots/seattlerb/call_gt.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...3),
-       nil,
-       ArgumentsNode(4...5)([IntegerNode(4...5)()]),
-       nil,
-       nil,
-       0,
-       ">"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...3) = ">"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...5))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (4...5))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: ">"
diff --git a/test/yarp/snapshots/seattlerb/call_kwsplat.txt b/test/yarp/snapshots/seattlerb/call_kwsplat.txt
index c5b45b9cb2..e6f4ae5236 100644
--- a/test/yarp/snapshots/seattlerb/call_kwsplat.txt
+++ b/test/yarp/snapshots/seattlerb/call_kwsplat.txt
@@ -1,20 +1,23 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...5)(
-         [KeywordHashNode(2...5)(
-            [AssocSplatNode(2...5)(IntegerNode(4...5)(), (2...4))]
-          )]
-       ),
-       (5...6),
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...5))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (2...5))
+            │           └── elements: (length: 1)
+            │               └── @ AssocSplatNode (location: (2...5))
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (4...5))
+            │                   └── operator_loc: (2...4) = "**"
+            ├── closing_loc: (5...6) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/call_leading_dots.txt b/test/yarp/snapshots/seattlerb/call_leading_dots.txt
index bc418635a1..ba97ea9f08 100644
--- a/test/yarp/snapshots/seattlerb/call_leading_dots.txt
+++ b/test/yarp/snapshots/seattlerb/call_leading_dots.txt
@@ -1,26 +1,35 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       CallNode(0...4)(
-         CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-         (2...3),
-         (3...4),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "b"
-       ),
-       (5...6),
-       (6...7),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "c"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ CallNode (location: (0...4))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (0...1))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (0...1) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (2...3) = "."
+            │   ├── message_loc: (3...4) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "b"
+            ├── call_operator_loc: (5...6) = "."
+            ├── message_loc: (6...7) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/call_leading_dots_comment.txt b/test/yarp/snapshots/seattlerb/call_leading_dots_comment.txt
index e9a88d05d4..30cc0df938 100644
--- a/test/yarp/snapshots/seattlerb/call_leading_dots_comment.txt
+++ b/test/yarp/snapshots/seattlerb/call_leading_dots_comment.txt
@@ -1,26 +1,35 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallNode(0...11)(
-       CallNode(0...4)(
-         CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-         (2...3),
-         (3...4),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "b"
-       ),
-       (9...10),
-       (10...11),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "d"
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...11))
+            ├── receiver:
+            │   @ CallNode (location: (0...4))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (0...1))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (0...1) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (2...3) = "."
+            │   ├── message_loc: (3...4) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "b"
+            ├── call_operator_loc: (9...10) = "."
+            ├── message_loc: (10...11) = "d"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/call_lt.txt b/test/yarp/snapshots/seattlerb/call_lt.txt
index 11fcd8c44f..4113ca6ef5 100644
--- a/test/yarp/snapshots/seattlerb/call_lt.txt
+++ b/test/yarp/snapshots/seattlerb/call_lt.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...3),
-       nil,
-       ArgumentsNode(4...5)([IntegerNode(4...5)()]),
-       nil,
-       nil,
-       0,
-       "<"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...3) = "<"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...5))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (4...5))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "<"
diff --git a/test/yarp/snapshots/seattlerb/call_lte.txt b/test/yarp/snapshots/seattlerb/call_lte.txt
index 5ad45cbf0e..875b8e6f5b 100644
--- a/test/yarp/snapshots/seattlerb/call_lte.txt
+++ b/test/yarp/snapshots/seattlerb/call_lte.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...4),
-       nil,
-       ArgumentsNode(5...6)([IntegerNode(5...6)()]),
-       nil,
-       nil,
-       0,
-       "<="
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...4) = "<="
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...6))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (5...6))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "<="
diff --git a/test/yarp/snapshots/seattlerb/call_not.txt b/test/yarp/snapshots/seattlerb/call_not.txt
index d42b852ead..ec19618f30 100644
--- a/test/yarp/snapshots/seattlerb/call_not.txt
+++ b/test/yarp/snapshots/seattlerb/call_not.txt
@@ -1,16 +1,16 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       IntegerNode(4...6)(),
-       nil,
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver:
+            │   @ IntegerNode (location: (4...6))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "not"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/seattlerb/call_pipe.txt b/test/yarp/snapshots/seattlerb/call_pipe.txt
index e372fce6e5..8124f2adb6 100644
--- a/test/yarp/snapshots/seattlerb/call_pipe.txt
+++ b/test/yarp/snapshots/seattlerb/call_pipe.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...3),
-       nil,
-       ArgumentsNode(4...5)([IntegerNode(4...5)()]),
-       nil,
-       nil,
-       0,
-       "|"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...3) = "|"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...5))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (4...5))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "|"
diff --git a/test/yarp/snapshots/seattlerb/call_rshift.txt b/test/yarp/snapshots/seattlerb/call_rshift.txt
index 9a523669eb..ff9b3d1410 100644
--- a/test/yarp/snapshots/seattlerb/call_rshift.txt
+++ b/test/yarp/snapshots/seattlerb/call_rshift.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...4),
-       nil,
-       ArgumentsNode(5...6)([IntegerNode(5...6)()]),
-       nil,
-       nil,
-       0,
-       ">>"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...4) = ">>"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...6))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (5...6))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: ">>"
diff --git a/test/yarp/snapshots/seattlerb/call_self_brackets.txt b/test/yarp/snapshots/seattlerb/call_self_brackets.txt
index 7dfe5a50be..c165f618bd 100644
--- a/test/yarp/snapshots/seattlerb/call_self_brackets.txt
+++ b/test/yarp/snapshots/seattlerb/call_self_brackets.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       SelfNode(0...4)(),
-       nil,
-       (4...7),
-       (4...5),
-       ArgumentsNode(5...6)([IntegerNode(5...6)()]),
-       (6...7),
-       nil,
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ SelfNode (location: (0...4))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (4...7) = "[1]"
+            ├── opening_loc: (4...5) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...6))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (5...6))
+            ├── closing_loc: (6...7) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/seattlerb/call_spaceship.txt b/test/yarp/snapshots/seattlerb/call_spaceship.txt
index a7ee865978..4305f8c384 100644
--- a/test/yarp/snapshots/seattlerb/call_spaceship.txt
+++ b/test/yarp/snapshots/seattlerb/call_spaceship.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...5),
-       nil,
-       ArgumentsNode(6...7)([IntegerNode(6...7)()]),
-       nil,
-       nil,
-       0,
-       "<=>"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...5) = "<=>"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (6...7))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (6...7))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "<=>"
diff --git a/test/yarp/snapshots/seattlerb/call_stabby_do_end_with_block.txt b/test/yarp/snapshots/seattlerb/call_stabby_do_end_with_block.txt
index f541c52985..d8ae32bd5a 100644
--- a/test/yarp/snapshots/seattlerb/call_stabby_do_end_with_block.txt
+++ b/test/yarp/snapshots/seattlerb/call_stabby_do_end_with_block.txt
@@ -1,31 +1,36 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [CallNode(0...22)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...13)(
-         [LambdaNode(2...13)(
-            [],
-            (2...4),
-            (5...7),
-            (10...13),
-            nil,
-            StatementsNode(8...9)([IntegerNode(8...9)()])
-          )]
-       ),
-       nil,
-       BlockNode(14...22)(
-         [],
-         nil,
-         StatementsNode(17...18)([IntegerNode(17...18)()]),
-         (14...16),
-         (19...22)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...22))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...13))
+            │   └── arguments: (length: 1)
+            │       └── @ LambdaNode (location: (2...13))
+            │           ├── locals: []
+            │           ├── operator_loc: (2...4) = "->"
+            │           ├── opening_loc: (5...7) = "do"
+            │           ├── closing_loc: (10...13) = "end"
+            │           ├── parameters: ∅
+            │           └── body:
+            │               @ StatementsNode (location: (8...9))
+            │               └── body: (length: 1)
+            │                   └── @ IntegerNode (location: (8...9))
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (14...22))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (17...18))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (17...18))
+            │   ├── opening_loc: (14...16) = "do"
+            │   └── closing_loc: (19...22) = "end"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/call_stabby_with_braces_block.txt b/test/yarp/snapshots/seattlerb/call_stabby_with_braces_block.txt
index 83c62571fd..5b2014c7d5 100644
--- a/test/yarp/snapshots/seattlerb/call_stabby_with_braces_block.txt
+++ b/test/yarp/snapshots/seattlerb/call_stabby_with_braces_block.txt
@@ -1,31 +1,36 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [CallNode(0...19)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...10)(
-         [LambdaNode(2...10)(
-            [],
-            (2...4),
-            (5...6),
-            (9...10),
-            nil,
-            StatementsNode(7...8)([IntegerNode(7...8)()])
-          )]
-       ),
-       nil,
-       BlockNode(11...19)(
-         [],
-         nil,
-         StatementsNode(14...15)([IntegerNode(14...15)()]),
-         (11...13),
-         (16...19)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...19))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...10))
+            │   └── arguments: (length: 1)
+            │       └── @ LambdaNode (location: (2...10))
+            │           ├── locals: []
+            │           ├── operator_loc: (2...4) = "->"
+            │           ├── opening_loc: (5...6) = "{"
+            │           ├── closing_loc: (9...10) = "}"
+            │           ├── parameters: ∅
+            │           └── body:
+            │               @ StatementsNode (location: (7...8))
+            │               └── body: (length: 1)
+            │                   └── @ IntegerNode (location: (7...8))
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (11...19))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (14...15))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (14...15))
+            │   ├── opening_loc: (11...13) = "do"
+            │   └── closing_loc: (16...19) = "end"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/call_star.txt b/test/yarp/snapshots/seattlerb/call_star.txt
index 1e4683a882..0c4b61df90 100644
--- a/test/yarp/snapshots/seattlerb/call_star.txt
+++ b/test/yarp/snapshots/seattlerb/call_star.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...3),
-       nil,
-       ArgumentsNode(4...5)([IntegerNode(4...5)()]),
-       nil,
-       nil,
-       0,
-       "*"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...3) = "*"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...5))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (4...5))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "*"
diff --git a/test/yarp/snapshots/seattlerb/call_star2.txt b/test/yarp/snapshots/seattlerb/call_star2.txt
index d051c4a313..65132bda70 100644
--- a/test/yarp/snapshots/seattlerb/call_star2.txt
+++ b/test/yarp/snapshots/seattlerb/call_star2.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       IntegerNode(0...1)(),
-       nil,
-       (2...4),
-       nil,
-       ArgumentsNode(5...6)([IntegerNode(5...6)()]),
-       nil,
-       nil,
-       0,
-       "**"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (2...4) = "**"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...6))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (5...6))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "**"
diff --git a/test/yarp/snapshots/seattlerb/call_trailing_comma.txt b/test/yarp/snapshots/seattlerb/call_trailing_comma.txt
index da971880af..f562aee8c2 100644
--- a/test/yarp/snapshots/seattlerb/call_trailing_comma.txt
+++ b/test/yarp/snapshots/seattlerb/call_trailing_comma.txt
@@ -1,16 +1,18 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...3)([IntegerNode(2...3)()]),
-       (4...5),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...3))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (2...3))
+            ├── closing_loc: (4...5) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/call_trailing_dots.txt b/test/yarp/snapshots/seattlerb/call_trailing_dots.txt
index a2ccf8addd..0f0a6ac5e8 100644
--- a/test/yarp/snapshots/seattlerb/call_trailing_dots.txt
+++ b/test/yarp/snapshots/seattlerb/call_trailing_dots.txt
@@ -1,26 +1,35 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       CallNode(0...4)(
-         CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-         (1...2),
-         (3...4),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "b"
-       ),
-       (4...5),
-       (6...7),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "c"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ CallNode (location: (0...4))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (0...1))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (0...1) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (1...2) = "."
+            │   ├── message_loc: (3...4) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "b"
+            ├── call_operator_loc: (4...5) = "."
+            ├── message_loc: (6...7) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/call_unary_bang.txt b/test/yarp/snapshots/seattlerb/call_unary_bang.txt
index e0de2a924f..17f05cbe0c 100644
--- a/test/yarp/snapshots/seattlerb/call_unary_bang.txt
+++ b/test/yarp/snapshots/seattlerb/call_unary_bang.txt
@@ -1,16 +1,16 @@
-ProgramNode(0...2)(
-  [],
-  StatementsNode(0...2)(
-    [CallNode(0...2)(
-       IntegerNode(1...2)(),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...2))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...2))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...2))
+            ├── receiver:
+            │   @ IntegerNode (location: (1...2))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "!"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/seattlerb/case_in.txt b/test/yarp/snapshots/seattlerb/case_in.txt
index a1e2641013..c133b6e292 100644
--- a/test/yarp/snapshots/seattlerb/case_in.txt
+++ b/test/yarp/snapshots/seattlerb/case_in.txt
@@ -1,597 +1,882 @@
-ProgramNode(0...747)(
-  [:b, :_, :lhs, :x, :rhs, :c, :e],
-  StatementsNode(0...747)(
-    [CaseNode(0...21)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...16)(
-          HashPatternNode(12...16)(
-            nil,
-            [AssocNode(12...16)(
-               SymbolNode(12...16)((12...13), (13...14), (14...16), "b"),
-               nil,
-               nil
-             )],
-            nil,
-            nil,
-            nil
-          ),
-          nil,
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (18...21)
-     ),
-     CaseNode(23...45)(
-       SymbolNode(28...30)((28...29), (29...30), nil, "a"),
-       [InNode(31...41)(
-          ArrayNode(34...41)(
-            [SymbolNode(37...38)(nil, (37...38), nil, "a"),
-             SymbolNode(39...40)(nil, (39...40), nil, "b")],
-            (34...37),
-            (40...41)
-          ),
-          nil,
-          (31...33),
-          nil
-        )],
-       nil,
-       (23...27),
-       (42...45)
-     ),
-     CaseNode(47...69)(
-       SymbolNode(52...54)((52...53), (53...54), nil, "a"),
-       [InNode(55...65)(
-          ArrayNode(58...65)(
-            [StringNode(61...62)(nil, (61...62), nil, "a"),
-             StringNode(63...64)(nil, (63...64), nil, "b")],
-            (58...61),
-            (64...65)
-          ),
-          nil,
-          (55...57),
-          nil
-        )],
-       nil,
-       (47...51),
-       (66...69)
-     ),
-     CaseNode(71...93)(
-       SymbolNode(76...78)((76...77), (77...78), nil, "a"),
-       [InNode(79...89)(
-          ArrayNode(82...89)(
-            [SymbolNode(85...86)(nil, (85...86), nil, "a"),
-             SymbolNode(87...88)(nil, (87...88), nil, "b")],
-            (82...85),
-            (88...89)
-          ),
-          nil,
-          (79...81),
-          nil
-        )],
-       nil,
-       (71...75),
-       (90...93)
-     ),
-     CaseNode(95...117)(
-       SymbolNode(100...102)((100...101), (101...102), nil, "a"),
-       [InNode(103...113)(
-          ArrayNode(106...113)(
-            [StringNode(109...110)(nil, (109...110), nil, "a"),
-             StringNode(111...112)(nil, (111...112), nil, "b")],
-            (106...109),
-            (112...113)
-          ),
-          nil,
-          (103...105),
-          nil
-        )],
-       nil,
-       (95...99),
-       (114...117)
-     ),
-     CaseNode(119...141)(
-       SymbolNode(124...126)((124...125), (125...126), nil, "a"),
-       [InNode(127...136)(
-          RangeNode(131...136)(nil, IntegerNode(134...136)(), (131...134), 1),
-          nil,
-          (127...129),
-          nil
-        )],
-       nil,
-       (119...123),
-       (138...141)
-     ),
-     CaseNode(143...164)(
-       SymbolNode(148...150)((148...149), (149...150), nil, "a"),
-       [InNode(151...159)(
-          RangeNode(155...159)(nil, IntegerNode(157...159)(), (155...157), 0),
-          nil,
-          (151...153),
-          nil
-        )],
-       nil,
-       (143...147),
-       (161...164)
-     ),
-     CaseNode(166...187)(
-       SymbolNode(171...173)((171...172), (172...173), nil, "a"),
-       [InNode(174...182)(
-          RangeNode(178...182)(IntegerNode(178...179)(), nil, (179...182), 1),
-          nil,
-          (174...176),
-          nil
-        )],
-       nil,
-       (166...170),
-       (184...187)
-     ),
-     CaseNode(189...211)(
-       SymbolNode(194...196)((194...195), (195...196), nil, "a"),
-       [InNode(197...206)(
-          RangeNode(201...206)(
-            IntegerNode(201...202)(),
-            IntegerNode(205...206)(),
-            (202...205),
-            1
-          ),
-          nil,
-          (197...199),
-          nil
-        )],
-       nil,
-       (189...193),
-       (208...211)
-     ),
-     CaseNode(213...232)(
-       SymbolNode(218...220)((218...219), (219...220), nil, "a"),
-       [InNode(221...227)(IntegerNode(225...227)(), nil, (221...223), nil)],
-       nil,
-       (213...217),
-       (229...232)
-     ),
-     CaseNode(234...254)(
-       SymbolNode(239...241)((239...240), (240...241), nil, "a"),
-       [InNode(242...250)(
-          HashPatternNode(245...250)(
-            nil,
-            [NoKeywordsParameterNode(245...250)((245...247), (247...250))],
-            nil,
-            nil,
-            nil
-          ),
-          nil,
-          (242...244),
-          nil
-        )],
-       nil,
-       (234...238),
-       (251...254)
-     ),
-     CaseNode(256...279)(
-       SymbolNode(261...263)((261...262), (262...263), nil, "a"),
-       [InNode(264...275)(
-          RegularExpressionNode(267...275)(
-            (267...268),
-            (268...274),
-            (274...275),
-            "regexp",
-            0
-          ),
-          nil,
-          (264...266),
-          nil
-        )],
-       nil,
-       (256...260),
-       (276...279)
-     ),
-     CaseNode(281...306)(
-       SymbolNode(286...288)((286...287), (287...288), nil, "a"),
-       [InNode(289...302)(
-          ArrayPatternNode(292...302)(
-            nil,
-            [SymbolNode(292...294)((292...293), (293...294), nil, "b")],
-            SplatNode(296...298)(
-              (296...297),
-              LocalVariableTargetNode(297...298)(:_, 0)
-            ),
-            [SymbolNode(300...302)((300...301), (301...302), nil, "c")],
-            nil,
-            nil
-          ),
-          nil,
-          (289...291),
-          nil
-        )],
-       nil,
-       (281...285),
-       (303...306)
-     ),
-     CaseNode(308...331)(
-       SymbolNode(313...315)((313...314), (314...315), nil, "a"),
-       [InNode(316...327)(
-          ArrayPatternNode(319...327)(
-            nil,
-            [SymbolNode(319...321)((319...320), (320...321), nil, "b"),
-             ArrayPatternNode(323...327)(
-               nil,
-               [SymbolNode(324...326)((324...325), (325...326), nil, "c")],
-               nil,
-               [],
-               (323...324),
-               (326...327)
-             )],
-            nil,
-            [],
-            nil,
-            nil
-          ),
-          nil,
-          (316...318),
-          nil
-        )],
-       nil,
-       (308...312),
-       (328...331)
-     ),
-     CaseNode(333...356)(
-       SymbolNode(338...340)((338...339), (339...340), nil, "a"),
-       [InNode(341...352)(
-          ArrayPatternNode(344...352)(
-            ConstantReadNode(344...350)(:Symbol),
-            [],
-            nil,
-            [],
-            (350...351),
-            (351...352)
-          ),
-          nil,
-          (341...343),
-          nil
-        )],
-       nil,
-       (333...337),
-       (353...356)
-     ),
-     CaseNode(358...394)(
-       SymbolNode(363...365)((363...364), (364...365), nil, "a"),
-       [InNode(366...390)(
-          FindPatternNode(369...390)(
-            ConstantReadNode(369...375)(:Symbol),
-            SplatNode(376...380)(
-              (376...377),
-              LocalVariableTargetNode(377...380)(:lhs, 0)
-            ),
-            [LocalVariableTargetNode(382...383)(:x, 0)],
-            SplatNode(385...389)(
-              (385...386),
-              LocalVariableTargetNode(386...389)(:rhs, 0)
-            ),
-            (375...376),
-            (389...390)
-          ),
-          nil,
-          (366...368),
-          nil
-        )],
-       nil,
-       (358...362),
-       (391...394)
-     ),
-     CaseNode(396...432)(
-       SymbolNode(401...403)((401...402), (402...403), nil, "a"),
-       [InNode(404...428)(
-          FindPatternNode(407...428)(
-            ConstantReadNode(407...413)(:Symbol),
-            SplatNode(414...418)(
-              (414...415),
-              LocalVariableTargetNode(415...418)(:lhs, 0)
-            ),
-            [LocalVariableTargetNode(420...421)(:x, 0)],
-            SplatNode(423...427)(
-              (423...424),
-              LocalVariableTargetNode(424...427)(:rhs, 0)
-            ),
-            (413...414),
-            (427...428)
-          ),
-          nil,
-          (404...406),
-          nil
-        )],
-       nil,
-       (396...400),
-       (429...432)
-     ),
-     CaseNode(434...468)(
-       SymbolNode(439...441)((439...440), (440...441), nil, "a"),
-       [InNode(442...464)(
-          ArrayPatternNode(445...464)(
-            nil,
-            [LambdaNode(446...460)(
-               [:b],
-               (446...448),
-               (452...453),
-               (459...460),
-               BlockParametersNode(448...451)(
-                 ParametersNode(449...450)(
-                   [RequiredParameterNode(449...450)(:b)],
-                   [],
-                   [],
-                   nil,
-                   [],
-                   nil,
-                   nil
-                 ),
-                 [],
-                 (448...449),
-                 (450...451)
-               ),
-               StatementsNode(454...458)([TrueNode(454...458)()])
-             ),
-             LocalVariableTargetNode(462...463)(:c, 0)],
-            nil,
-            [],
-            (445...446),
-            (463...464)
-          ),
-          nil,
-          (442...444),
-          nil
-        )],
-       nil,
-       (434...438),
-       (465...468)
-     ),
-     CaseNode(470...510)(
-       SymbolNode(475...477)((475...476), (476...477), nil, "a"),
-       [InNode(478...506)(
-          ArrayPatternNode(481...506)(
-            nil,
-            [SymbolNode(482...484)((482...483), (483...484), nil, "a"),
-             LocalVariableTargetNode(486...487)(:b, 0),
-             LocalVariableTargetNode(489...490)(:c, 0),
-             ArrayPatternNode(492...505)(
-               nil,
-               [SymbolNode(493...495)((493...494), (494...495), nil, "d")],
-               SplatNode(497...499)(
-                 (497...498),
-                 LocalVariableTargetNode(498...499)(:e, 0)
-               ),
-               [NilNode(501...504)()],
-               (492...493),
-               (504...505)
-             )],
-            nil,
-            [],
-            (481...482),
-            (505...506)
-          ),
-          nil,
-          (478...480),
-          nil
-        )],
-       nil,
-       (470...474),
-       (507...510)
-     ),
-     CaseNode(512...536)(
-       SymbolNode(517...519)((517...518), (518...519), nil, "a"),
-       [InNode(520...532)(
-          ArrayPatternNode(523...532)(
-            nil,
-            [ConstantReadNode(524...525)(:A)],
-            SplatNode(527...528)((527...528), nil),
-            [ConstantReadNode(530...531)(:B)],
-            (523...524),
-            (531...532)
-          ),
-          nil,
-          (520...522),
-          nil
-        )],
-       nil,
-       (512...516),
-       (533...536)
-     ),
-     CaseNode(538...572)(
-       SymbolNode(543...545)((543...544), (544...545), nil, "a"),
-       [InNode(546...568)(
-          ArrayPatternNode(549...568)(
-            nil,
-            [ArrayPatternNode(550...557)(
-               nil,
-               [SymbolNode(551...553)((551...552), (552...553), nil, "b"),
-                LocalVariableTargetNode(555...556)(:c, 0)],
-               nil,
-               [],
-               (550...551),
-               (556...557)
-             ),
-             ArrayPatternNode(559...567)(
-               nil,
-               [SymbolNode(560...562)((560...561), (561...562), nil, "d"),
-                PinnedVariableNode(564...566)(
-                  LocalVariableReadNode(565...566)(:e, 0),
-                  (564...565)
-                )],
-               nil,
-               [],
-               (559...560),
-               (566...567)
-             )],
-            nil,
-            [],
-            (549...550),
-            (567...568)
-          ),
-          nil,
-          (546...548),
-          nil
-        )],
-       nil,
-       (538...542),
-       (569...572)
-     ),
-     CaseNode(574...591)(
-       SymbolNode(579...581)((579...580), (580...581), nil, "a"),
-       [InNode(582...587)(
-          ArrayPatternNode(585...587)(
-            nil,
-            [],
-            nil,
-            [],
-            (585...586),
-            (586...587)
-          ),
-          nil,
-          (582...584),
-          nil
-        )],
-       nil,
-       (574...578),
-       (588...591)
-     ),
-     CaseNode(593...614)(
-       SymbolNode(598...600)((598...599), (599...600), nil, "a"),
-       [InNode(601...610)(
-          ArrayPatternNode(604...610)(
-            nil,
-            [PinnedExpressionNode(605...609)(
-               CallNode(607...608)(
-                 nil,
-                 nil,
-                 (607...608),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "a"
-               ),
-               (605...606),
-               (606...607),
-               (608...609)
-             )],
-            nil,
-            [],
-            (604...605),
-            (609...610)
-          ),
-          nil,
-          (601...603),
-          nil
-        )],
-       nil,
-       (593...597),
-       (611...614)
-     ),
-     CaseNode(616...647)(
-       SymbolNode(621...623)((621...622), (622...623), nil, "a"),
-       [InNode(624...643)(
-          ArrayPatternNode(627...643)(
-            nil,
-            [PinnedVariableNode(628...631)(
-               InstanceVariableReadNode(629...631)(:@a),
-               (628...629)
-             ),
-             PinnedVariableNode(633...636)(
-               GlobalVariableReadNode(634...636)(:$b),
-               (633...634)
-             ),
-             PinnedVariableNode(638...642)(
-               ClassVariableReadNode(639...642)(:@@c),
-               (638...639)
-             )],
-            nil,
-            [],
-            (627...628),
-            (642...643)
-          ),
-          nil,
-          (624...626),
-          nil
-        )],
-       nil,
-       (616...620),
-       (644...647)
-     ),
-     CaseNode(649...673)(
-       SymbolNode(654...656)((654...655), (655...656), nil, "a"),
-       [InNode(657...669)(
-          XStringNode(660...669)(
-            (660...661),
-            (661...668),
-            (668...669),
-            "echo hi"
-          ),
-          nil,
-          (657...659),
-          nil
-        )],
-       nil,
-       (649...653),
-       (670...673)
-     ),
-     CaseNode(675...703)(
-       SymbolNode(680...682)((680...681), (681...682), nil, "a"),
-       [InNode(683...699)(
-          ArrayPatternNode(686...699)(
-            nil,
-            [NilNode(686...689)(), NilNode(691...694)(), NilNode(696...699)()],
-            nil,
-            [],
-            nil,
-            nil
-          ),
-          nil,
-          (683...685),
-          nil
-        )],
-       nil,
-       (675...679),
-       (700...703)
-     ),
-     CaseNode(705...728)(
-       SymbolNode(710...712)((710...711), (711...712), nil, "a"),
-       [InNode(713...724)(
-          HashPatternNode(716...724)(
-            nil,
-            [AssocNode(718...722)(
-               SymbolNode(718...722)(
-                 (718...719),
-                 (719...720),
-                 (720...722),
-                 "b"
-               ),
-               nil,
-               nil
-             )],
-            nil,
-            (716...717),
-            (723...724)
-          ),
-          nil,
-          (713...715),
-          nil
-        )],
-       nil,
-       (705...709),
-       (725...728)
-     ),
-     CaseNode(730...747)(
-       SymbolNode(735...737)((735...736), (736...737), nil, "a"),
-       [InNode(738...743)(
-          HashPatternNode(741...743)(nil, [], nil, (741...742), (742...743)),
-          nil,
-          (738...740),
-          nil
-        )],
-       nil,
-       (730...734),
-       (744...747)
-     )]
-  )
-)
+@ ProgramNode (location: (0...747))
+├── locals: [:b, :_, :lhs, :x, :rhs, :c, :e]
+└── statements:
+    @ StatementsNode (location: (0...747))
+    └── body: (length: 28)
+        ├── @ CaseNode (location: (0...21))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (5...7))
+        │   │   ├── opening_loc: (5...6) = ":"
+        │   │   ├── value_loc: (6...7) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (8...16))
+        │   │       ├── pattern:
+        │   │       │   @ HashPatternNode (location: (12...16))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── assocs: (length: 1)
+        │   │       │   │   └── @ AssocNode (location: (12...16))
+        │   │       │   │       ├── key:
+        │   │       │   │       │   @ SymbolNode (location: (12...16))
+        │   │       │   │       │   ├── opening_loc: (12...13) = "\""
+        │   │       │   │       │   ├── value_loc: (13...14) = "b"
+        │   │       │   │       │   ├── closing_loc: (14...16) = "\":"
+        │   │       │   │       │   └── unescaped: "b"
+        │   │       │   │       ├── value: ∅
+        │   │       │   │       └── operator_loc: ∅
+        │   │       │   ├── kwrest: ∅
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   └── closing_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (8...10) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (0...4) = "case"
+        │   └── end_keyword_loc: (18...21) = "end"
+        ├── @ CaseNode (location: (23...45))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (28...30))
+        │   │   ├── opening_loc: (28...29) = ":"
+        │   │   ├── value_loc: (29...30) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (31...41))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayNode (location: (34...41))
+        │   │       │   ├── elements: (length: 2)
+        │   │       │   │   ├── @ SymbolNode (location: (37...38))
+        │   │       │   │   │   ├── opening_loc: ∅
+        │   │       │   │   │   ├── value_loc: (37...38) = "a"
+        │   │       │   │   │   ├── closing_loc: ∅
+        │   │       │   │   │   └── unescaped: "a"
+        │   │       │   │   └── @ SymbolNode (location: (39...40))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── value_loc: (39...40) = "b"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "b"
+        │   │       │   ├── opening_loc: (34...37) = "%I["
+        │   │       │   └── closing_loc: (40...41) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (31...33) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (23...27) = "case"
+        │   └── end_keyword_loc: (42...45) = "end"
+        ├── @ CaseNode (location: (47...69))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (52...54))
+        │   │   ├── opening_loc: (52...53) = ":"
+        │   │   ├── value_loc: (53...54) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (55...65))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayNode (location: (58...65))
+        │   │       │   ├── elements: (length: 2)
+        │   │       │   │   ├── @ StringNode (location: (61...62))
+        │   │       │   │   │   ├── opening_loc: ∅
+        │   │       │   │   │   ├── content_loc: (61...62) = "a"
+        │   │       │   │   │   ├── closing_loc: ∅
+        │   │       │   │   │   └── unescaped: "a"
+        │   │       │   │   └── @ StringNode (location: (63...64))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (63...64) = "b"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "b"
+        │   │       │   ├── opening_loc: (58...61) = "%W["
+        │   │       │   └── closing_loc: (64...65) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (55...57) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (47...51) = "case"
+        │   └── end_keyword_loc: (66...69) = "end"
+        ├── @ CaseNode (location: (71...93))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (76...78))
+        │   │   ├── opening_loc: (76...77) = ":"
+        │   │   ├── value_loc: (77...78) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (79...89))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayNode (location: (82...89))
+        │   │       │   ├── elements: (length: 2)
+        │   │       │   │   ├── @ SymbolNode (location: (85...86))
+        │   │       │   │   │   ├── opening_loc: ∅
+        │   │       │   │   │   ├── value_loc: (85...86) = "a"
+        │   │       │   │   │   ├── closing_loc: ∅
+        │   │       │   │   │   └── unescaped: "a"
+        │   │       │   │   └── @ SymbolNode (location: (87...88))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── value_loc: (87...88) = "b"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "b"
+        │   │       │   ├── opening_loc: (82...85) = "%i["
+        │   │       │   └── closing_loc: (88...89) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (79...81) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (71...75) = "case"
+        │   └── end_keyword_loc: (90...93) = "end"
+        ├── @ CaseNode (location: (95...117))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (100...102))
+        │   │   ├── opening_loc: (100...101) = ":"
+        │   │   ├── value_loc: (101...102) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (103...113))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayNode (location: (106...113))
+        │   │       │   ├── elements: (length: 2)
+        │   │       │   │   ├── @ StringNode (location: (109...110))
+        │   │       │   │   │   ├── opening_loc: ∅
+        │   │       │   │   │   ├── content_loc: (109...110) = "a"
+        │   │       │   │   │   ├── closing_loc: ∅
+        │   │       │   │   │   └── unescaped: "a"
+        │   │       │   │   └── @ StringNode (location: (111...112))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (111...112) = "b"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "b"
+        │   │       │   ├── opening_loc: (106...109) = "%w["
+        │   │       │   └── closing_loc: (112...113) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (103...105) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (95...99) = "case"
+        │   └── end_keyword_loc: (114...117) = "end"
+        ├── @ CaseNode (location: (119...141))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (124...126))
+        │   │   ├── opening_loc: (124...125) = ":"
+        │   │   ├── value_loc: (125...126) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (127...136))
+        │   │       ├── pattern:
+        │   │       │   @ RangeNode (location: (131...136))
+        │   │       │   ├── left: ∅
+        │   │       │   ├── right:
+        │   │       │   │   @ IntegerNode (location: (134...136))
+        │   │       │   ├── operator_loc: (131...134) = "..."
+        │   │       │   └── flags: exclude_end
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (127...129) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (119...123) = "case"
+        │   └── end_keyword_loc: (138...141) = "end"
+        ├── @ CaseNode (location: (143...164))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (148...150))
+        │   │   ├── opening_loc: (148...149) = ":"
+        │   │   ├── value_loc: (149...150) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (151...159))
+        │   │       ├── pattern:
+        │   │       │   @ RangeNode (location: (155...159))
+        │   │       │   ├── left: ∅
+        │   │       │   ├── right:
+        │   │       │   │   @ IntegerNode (location: (157...159))
+        │   │       │   ├── operator_loc: (155...157) = ".."
+        │   │       │   └── flags: 
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (151...153) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (143...147) = "case"
+        │   └── end_keyword_loc: (161...164) = "end"
+        ├── @ CaseNode (location: (166...187))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (171...173))
+        │   │   ├── opening_loc: (171...172) = ":"
+        │   │   ├── value_loc: (172...173) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (174...182))
+        │   │       ├── pattern:
+        │   │       │   @ RangeNode (location: (178...182))
+        │   │       │   ├── left:
+        │   │       │   │   @ IntegerNode (location: (178...179))
+        │   │       │   ├── right: ∅
+        │   │       │   ├── operator_loc: (179...182) = "..."
+        │   │       │   └── flags: exclude_end
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (174...176) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (166...170) = "case"
+        │   └── end_keyword_loc: (184...187) = "end"
+        ├── @ CaseNode (location: (189...211))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (194...196))
+        │   │   ├── opening_loc: (194...195) = ":"
+        │   │   ├── value_loc: (195...196) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (197...206))
+        │   │       ├── pattern:
+        │   │       │   @ RangeNode (location: (201...206))
+        │   │       │   ├── left:
+        │   │       │   │   @ IntegerNode (location: (201...202))
+        │   │       │   ├── right:
+        │   │       │   │   @ IntegerNode (location: (205...206))
+        │   │       │   ├── operator_loc: (202...205) = "..."
+        │   │       │   └── flags: exclude_end
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (197...199) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (189...193) = "case"
+        │   └── end_keyword_loc: (208...211) = "end"
+        ├── @ CaseNode (location: (213...232))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (218...220))
+        │   │   ├── opening_loc: (218...219) = ":"
+        │   │   ├── value_loc: (219...220) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (221...227))
+        │   │       ├── pattern:
+        │   │       │   @ IntegerNode (location: (225...227))
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (221...223) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (213...217) = "case"
+        │   └── end_keyword_loc: (229...232) = "end"
+        ├── @ CaseNode (location: (234...254))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (239...241))
+        │   │   ├── opening_loc: (239...240) = ":"
+        │   │   ├── value_loc: (240...241) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (242...250))
+        │   │       ├── pattern:
+        │   │       │   @ HashPatternNode (location: (245...250))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── assocs: (length: 1)
+        │   │       │   │   └── @ NoKeywordsParameterNode (location: (245...250))
+        │   │       │   │       ├── operator_loc: (245...247) = "**"
+        │   │       │   │       └── keyword_loc: (247...250) = "nil"
+        │   │       │   ├── kwrest: ∅
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   └── closing_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (242...244) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (234...238) = "case"
+        │   └── end_keyword_loc: (251...254) = "end"
+        ├── @ CaseNode (location: (256...279))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (261...263))
+        │   │   ├── opening_loc: (261...262) = ":"
+        │   │   ├── value_loc: (262...263) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (264...275))
+        │   │       ├── pattern:
+        │   │       │   @ RegularExpressionNode (location: (267...275))
+        │   │       │   ├── opening_loc: (267...268) = "/"
+        │   │       │   ├── content_loc: (268...274) = "regexp"
+        │   │       │   ├── closing_loc: (274...275) = "/"
+        │   │       │   ├── unescaped: "regexp"
+        │   │       │   └── flags: 
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (264...266) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (256...260) = "case"
+        │   └── end_keyword_loc: (276...279) = "end"
+        ├── @ CaseNode (location: (281...306))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (286...288))
+        │   │   ├── opening_loc: (286...287) = ":"
+        │   │   ├── value_loc: (287...288) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (289...302))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (292...302))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 1)
+        │   │       │   │   └── @ SymbolNode (location: (292...294))
+        │   │       │   │       ├── opening_loc: (292...293) = ":"
+        │   │       │   │       ├── value_loc: (293...294) = "b"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "b"
+        │   │       │   ├── rest:
+        │   │       │   │   @ SplatNode (location: (296...298))
+        │   │       │   │   ├── operator_loc: (296...297) = "*"
+        │   │       │   │   └── expression:
+        │   │       │   │       @ LocalVariableTargetNode (location: (297...298))
+        │   │       │   │       ├── name: :_
+        │   │       │   │       └── depth: 0
+        │   │       │   ├── posts: (length: 1)
+        │   │       │   │   └── @ SymbolNode (location: (300...302))
+        │   │       │   │       ├── opening_loc: (300...301) = ":"
+        │   │       │   │       ├── value_loc: (301...302) = "c"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "c"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   └── closing_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (289...291) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (281...285) = "case"
+        │   └── end_keyword_loc: (303...306) = "end"
+        ├── @ CaseNode (location: (308...331))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (313...315))
+        │   │   ├── opening_loc: (313...314) = ":"
+        │   │   ├── value_loc: (314...315) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (316...327))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (319...327))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 2)
+        │   │       │   │   ├── @ SymbolNode (location: (319...321))
+        │   │       │   │   │   ├── opening_loc: (319...320) = ":"
+        │   │       │   │   │   ├── value_loc: (320...321) = "b"
+        │   │       │   │   │   ├── closing_loc: ∅
+        │   │       │   │   │   └── unescaped: "b"
+        │   │       │   │   └── @ ArrayPatternNode (location: (323...327))
+        │   │       │   │       ├── constant: ∅
+        │   │       │   │       ├── requireds: (length: 1)
+        │   │       │   │       │   └── @ SymbolNode (location: (324...326))
+        │   │       │   │       │       ├── opening_loc: (324...325) = ":"
+        │   │       │   │       │       ├── value_loc: (325...326) = "c"
+        │   │       │   │       │       ├── closing_loc: ∅
+        │   │       │   │       │       └── unescaped: "c"
+        │   │       │   │       ├── rest: ∅
+        │   │       │   │       ├── posts: (length: 0)
+        │   │       │   │       ├── opening_loc: (323...324) = "["
+        │   │       │   │       └── closing_loc: (326...327) = "]"
+        │   │       │   ├── rest: ∅
+        │   │       │   ├── posts: (length: 0)
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   └── closing_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (316...318) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (308...312) = "case"
+        │   └── end_keyword_loc: (328...331) = "end"
+        ├── @ CaseNode (location: (333...356))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (338...340))
+        │   │   ├── opening_loc: (338...339) = ":"
+        │   │   ├── value_loc: (339...340) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (341...352))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (344...352))
+        │   │       │   ├── constant:
+        │   │       │   │   @ ConstantReadNode (location: (344...350))
+        │   │       │   │   └── name: :Symbol
+        │   │       │   ├── requireds: (length: 0)
+        │   │       │   ├── rest: ∅
+        │   │       │   ├── posts: (length: 0)
+        │   │       │   ├── opening_loc: (350...351) = "("
+        │   │       │   └── closing_loc: (351...352) = ")"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (341...343) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (333...337) = "case"
+        │   └── end_keyword_loc: (353...356) = "end"
+        ├── @ CaseNode (location: (358...394))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (363...365))
+        │   │   ├── opening_loc: (363...364) = ":"
+        │   │   ├── value_loc: (364...365) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (366...390))
+        │   │       ├── pattern:
+        │   │       │   @ FindPatternNode (location: (369...390))
+        │   │       │   ├── constant:
+        │   │       │   │   @ ConstantReadNode (location: (369...375))
+        │   │       │   │   └── name: :Symbol
+        │   │       │   ├── left:
+        │   │       │   │   @ SplatNode (location: (376...380))
+        │   │       │   │   ├── operator_loc: (376...377) = "*"
+        │   │       │   │   └── expression:
+        │   │       │   │       @ LocalVariableTargetNode (location: (377...380))
+        │   │       │   │       ├── name: :lhs
+        │   │       │   │       └── depth: 0
+        │   │       │   ├── requireds: (length: 1)
+        │   │       │   │   └── @ LocalVariableTargetNode (location: (382...383))
+        │   │       │   │       ├── name: :x
+        │   │       │   │       └── depth: 0
+        │   │       │   ├── right:
+        │   │       │   │   @ SplatNode (location: (385...389))
+        │   │       │   │   ├── operator_loc: (385...386) = "*"
+        │   │       │   │   └── expression:
+        │   │       │   │       @ LocalVariableTargetNode (location: (386...389))
+        │   │       │   │       ├── name: :rhs
+        │   │       │   │       └── depth: 0
+        │   │       │   ├── opening_loc: (375...376) = "("
+        │   │       │   └── closing_loc: (389...390) = ")"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (366...368) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (358...362) = "case"
+        │   └── end_keyword_loc: (391...394) = "end"
+        ├── @ CaseNode (location: (396...432))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (401...403))
+        │   │   ├── opening_loc: (401...402) = ":"
+        │   │   ├── value_loc: (402...403) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (404...428))
+        │   │       ├── pattern:
+        │   │       │   @ FindPatternNode (location: (407...428))
+        │   │       │   ├── constant:
+        │   │       │   │   @ ConstantReadNode (location: (407...413))
+        │   │       │   │   └── name: :Symbol
+        │   │       │   ├── left:
+        │   │       │   │   @ SplatNode (location: (414...418))
+        │   │       │   │   ├── operator_loc: (414...415) = "*"
+        │   │       │   │   └── expression:
+        │   │       │   │       @ LocalVariableTargetNode (location: (415...418))
+        │   │       │   │       ├── name: :lhs
+        │   │       │   │       └── depth: 0
+        │   │       │   ├── requireds: (length: 1)
+        │   │       │   │   └── @ LocalVariableTargetNode (location: (420...421))
+        │   │       │   │       ├── name: :x
+        │   │       │   │       └── depth: 0
+        │   │       │   ├── right:
+        │   │       │   │   @ SplatNode (location: (423...427))
+        │   │       │   │   ├── operator_loc: (423...424) = "*"
+        │   │       │   │   └── expression:
+        │   │       │   │       @ LocalVariableTargetNode (location: (424...427))
+        │   │       │   │       ├── name: :rhs
+        │   │       │   │       └── depth: 0
+        │   │       │   ├── opening_loc: (413...414) = "["
+        │   │       │   └── closing_loc: (427...428) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (404...406) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (396...400) = "case"
+        │   └── end_keyword_loc: (429...432) = "end"
+        ├── @ CaseNode (location: (434...468))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (439...441))
+        │   │   ├── opening_loc: (439...440) = ":"
+        │   │   ├── value_loc: (440...441) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (442...464))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (445...464))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 2)
+        │   │       │   │   ├── @ LambdaNode (location: (446...460))
+        │   │       │   │   │   ├── locals: [:b]
+        │   │       │   │   │   ├── operator_loc: (446...448) = "->"
+        │   │       │   │   │   ├── opening_loc: (452...453) = "{"
+        │   │       │   │   │   ├── closing_loc: (459...460) = "}"
+        │   │       │   │   │   ├── parameters:
+        │   │       │   │   │   │   @ BlockParametersNode (location: (448...451))
+        │   │       │   │   │   │   ├── parameters:
+        │   │       │   │   │   │   │   @ ParametersNode (location: (449...450))
+        │   │       │   │   │   │   │   ├── requireds: (length: 1)
+        │   │       │   │   │   │   │   │   └── @ RequiredParameterNode (location: (449...450))
+        │   │       │   │   │   │   │   │       └── name: :b
+        │   │       │   │   │   │   │   ├── optionals: (length: 0)
+        │   │       │   │   │   │   │   ├── posts: (length: 0)
+        │   │       │   │   │   │   │   ├── rest: ∅
+        │   │       │   │   │   │   │   ├── keywords: (length: 0)
+        │   │       │   │   │   │   │   ├── keyword_rest: ∅
+        │   │       │   │   │   │   │   └── block: ∅
+        │   │       │   │   │   │   ├── locals: (length: 0)
+        │   │       │   │   │   │   ├── opening_loc: (448...449) = "("
+        │   │       │   │   │   │   └── closing_loc: (450...451) = ")"
+        │   │       │   │   │   └── body:
+        │   │       │   │   │       @ StatementsNode (location: (454...458))
+        │   │       │   │   │       └── body: (length: 1)
+        │   │       │   │   │           └── @ TrueNode (location: (454...458))
+        │   │       │   │   └── @ LocalVariableTargetNode (location: (462...463))
+        │   │       │   │       ├── name: :c
+        │   │       │   │       └── depth: 0
+        │   │       │   ├── rest: ∅
+        │   │       │   ├── posts: (length: 0)
+        │   │       │   ├── opening_loc: (445...446) = "["
+        │   │       │   └── closing_loc: (463...464) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (442...444) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (434...438) = "case"
+        │   └── end_keyword_loc: (465...468) = "end"
+        ├── @ CaseNode (location: (470...510))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (475...477))
+        │   │   ├── opening_loc: (475...476) = ":"
+        │   │   ├── value_loc: (476...477) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (478...506))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (481...506))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 4)
+        │   │       │   │   ├── @ SymbolNode (location: (482...484))
+        │   │       │   │   │   ├── opening_loc: (482...483) = ":"
+        │   │       │   │   │   ├── value_loc: (483...484) = "a"
+        │   │       │   │   │   ├── closing_loc: ∅
+        │   │       │   │   │   └── unescaped: "a"
+        │   │       │   │   ├── @ LocalVariableTargetNode (location: (486...487))
+        │   │       │   │   │   ├── name: :b
+        │   │       │   │   │   └── depth: 0
+        │   │       │   │   ├── @ LocalVariableTargetNode (location: (489...490))
+        │   │       │   │   │   ├── name: :c
+        │   │       │   │   │   └── depth: 0
+        │   │       │   │   └── @ ArrayPatternNode (location: (492...505))
+        │   │       │   │       ├── constant: ∅
+        │   │       │   │       ├── requireds: (length: 1)
+        │   │       │   │       │   └── @ SymbolNode (location: (493...495))
+        │   │       │   │       │       ├── opening_loc: (493...494) = ":"
+        │   │       │   │       │       ├── value_loc: (494...495) = "d"
+        │   │       │   │       │       ├── closing_loc: ∅
+        │   │       │   │       │       └── unescaped: "d"
+        │   │       │   │       ├── rest:
+        │   │       │   │       │   @ SplatNode (location: (497...499))
+        │   │       │   │       │   ├── operator_loc: (497...498) = "*"
+        │   │       │   │       │   └── expression:
+        │   │       │   │       │       @ LocalVariableTargetNode (location: (498...499))
+        │   │       │   │       │       ├── name: :e
+        │   │       │   │       │       └── depth: 0
+        │   │       │   │       ├── posts: (length: 1)
+        │   │       │   │       │   └── @ NilNode (location: (501...504))
+        │   │       │   │       ├── opening_loc: (492...493) = "["
+        │   │       │   │       └── closing_loc: (504...505) = "]"
+        │   │       │   ├── rest: ∅
+        │   │       │   ├── posts: (length: 0)
+        │   │       │   ├── opening_loc: (481...482) = "["
+        │   │       │   └── closing_loc: (505...506) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (478...480) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (470...474) = "case"
+        │   └── end_keyword_loc: (507...510) = "end"
+        ├── @ CaseNode (location: (512...536))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (517...519))
+        │   │   ├── opening_loc: (517...518) = ":"
+        │   │   ├── value_loc: (518...519) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (520...532))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (523...532))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 1)
+        │   │       │   │   └── @ ConstantReadNode (location: (524...525))
+        │   │       │   │       └── name: :A
+        │   │       │   ├── rest:
+        │   │       │   │   @ SplatNode (location: (527...528))
+        │   │       │   │   ├── operator_loc: (527...528) = "*"
+        │   │       │   │   └── expression: ∅
+        │   │       │   ├── posts: (length: 1)
+        │   │       │   │   └── @ ConstantReadNode (location: (530...531))
+        │   │       │   │       └── name: :B
+        │   │       │   ├── opening_loc: (523...524) = "["
+        │   │       │   └── closing_loc: (531...532) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (520...522) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (512...516) = "case"
+        │   └── end_keyword_loc: (533...536) = "end"
+        ├── @ CaseNode (location: (538...572))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (543...545))
+        │   │   ├── opening_loc: (543...544) = ":"
+        │   │   ├── value_loc: (544...545) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (546...568))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (549...568))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 2)
+        │   │       │   │   ├── @ ArrayPatternNode (location: (550...557))
+        │   │       │   │   │   ├── constant: ∅
+        │   │       │   │   │   ├── requireds: (length: 2)
+        │   │       │   │   │   │   ├── @ SymbolNode (location: (551...553))
+        │   │       │   │   │   │   │   ├── opening_loc: (551...552) = ":"
+        │   │       │   │   │   │   │   ├── value_loc: (552...553) = "b"
+        │   │       │   │   │   │   │   ├── closing_loc: ∅
+        │   │       │   │   │   │   │   └── unescaped: "b"
+        │   │       │   │   │   │   └── @ LocalVariableTargetNode (location: (555...556))
+        │   │       │   │   │   │       ├── name: :c
+        │   │       │   │   │   │       └── depth: 0
+        │   │       │   │   │   ├── rest: ∅
+        │   │       │   │   │   ├── posts: (length: 0)
+        │   │       │   │   │   ├── opening_loc: (550...551) = "["
+        │   │       │   │   │   └── closing_loc: (556...557) = "]"
+        │   │       │   │   └── @ ArrayPatternNode (location: (559...567))
+        │   │       │   │       ├── constant: ∅
+        │   │       │   │       ├── requireds: (length: 2)
+        │   │       │   │       │   ├── @ SymbolNode (location: (560...562))
+        │   │       │   │       │   │   ├── opening_loc: (560...561) = ":"
+        │   │       │   │       │   │   ├── value_loc: (561...562) = "d"
+        │   │       │   │       │   │   ├── closing_loc: ∅
+        │   │       │   │       │   │   └── unescaped: "d"
+        │   │       │   │       │   └── @ PinnedVariableNode (location: (564...566))
+        │   │       │   │       │       ├── variable:
+        │   │       │   │       │       │   @ LocalVariableReadNode (location: (565...566))
+        │   │       │   │       │       │   ├── name: :e
+        │   │       │   │       │       │   └── depth: 0
+        │   │       │   │       │       └── operator_loc: (564...565) = "^"
+        │   │       │   │       ├── rest: ∅
+        │   │       │   │       ├── posts: (length: 0)
+        │   │       │   │       ├── opening_loc: (559...560) = "["
+        │   │       │   │       └── closing_loc: (566...567) = "]"
+        │   │       │   ├── rest: ∅
+        │   │       │   ├── posts: (length: 0)
+        │   │       │   ├── opening_loc: (549...550) = "["
+        │   │       │   └── closing_loc: (567...568) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (546...548) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (538...542) = "case"
+        │   └── end_keyword_loc: (569...572) = "end"
+        ├── @ CaseNode (location: (574...591))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (579...581))
+        │   │   ├── opening_loc: (579...580) = ":"
+        │   │   ├── value_loc: (580...581) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (582...587))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (585...587))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 0)
+        │   │       │   ├── rest: ∅
+        │   │       │   ├── posts: (length: 0)
+        │   │       │   ├── opening_loc: (585...586) = "["
+        │   │       │   └── closing_loc: (586...587) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (582...584) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (574...578) = "case"
+        │   └── end_keyword_loc: (588...591) = "end"
+        ├── @ CaseNode (location: (593...614))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (598...600))
+        │   │   ├── opening_loc: (598...599) = ":"
+        │   │   ├── value_loc: (599...600) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (601...610))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (604...610))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 1)
+        │   │       │   │   └── @ PinnedExpressionNode (location: (605...609))
+        │   │       │   │       ├── expression:
+        │   │       │   │       │   @ CallNode (location: (607...608))
+        │   │       │   │       │   ├── receiver: ∅
+        │   │       │   │       │   ├── call_operator_loc: ∅
+        │   │       │   │       │   ├── message_loc: (607...608) = "a"
+        │   │       │   │       │   ├── opening_loc: ∅
+        │   │       │   │       │   ├── arguments: ∅
+        │   │       │   │       │   ├── closing_loc: ∅
+        │   │       │   │       │   ├── block: ∅
+        │   │       │   │       │   ├── flags: variable_call
+        │   │       │   │       │   └── name: "a"
+        │   │       │   │       ├── operator_loc: (605...606) = "^"
+        │   │       │   │       ├── lparen_loc: (606...607) = "("
+        │   │       │   │       └── rparen_loc: (608...609) = ")"
+        │   │       │   ├── rest: ∅
+        │   │       │   ├── posts: (length: 0)
+        │   │       │   ├── opening_loc: (604...605) = "["
+        │   │       │   └── closing_loc: (609...610) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (601...603) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (593...597) = "case"
+        │   └── end_keyword_loc: (611...614) = "end"
+        ├── @ CaseNode (location: (616...647))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (621...623))
+        │   │   ├── opening_loc: (621...622) = ":"
+        │   │   ├── value_loc: (622...623) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (624...643))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (627...643))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 3)
+        │   │       │   │   ├── @ PinnedVariableNode (location: (628...631))
+        │   │       │   │   │   ├── variable:
+        │   │       │   │   │   │   @ InstanceVariableReadNode (location: (629...631))
+        │   │       │   │   │   │   └── name: :@a
+        │   │       │   │   │   └── operator_loc: (628...629) = "^"
+        │   │       │   │   ├── @ PinnedVariableNode (location: (633...636))
+        │   │       │   │   │   ├── variable:
+        │   │       │   │   │   │   @ GlobalVariableReadNode (location: (634...636))
+        │   │       │   │   │   │   └── name: :$b
+        │   │       │   │   │   └── operator_loc: (633...634) = "^"
+        │   │       │   │   └── @ PinnedVariableNode (location: (638...642))
+        │   │       │   │       ├── variable:
+        │   │       │   │       │   @ ClassVariableReadNode (location: (639...642))
+        │   │       │   │       │   └── name: :@@c
+        │   │       │   │       └── operator_loc: (638...639) = "^"
+        │   │       │   ├── rest: ∅
+        │   │       │   ├── posts: (length: 0)
+        │   │       │   ├── opening_loc: (627...628) = "["
+        │   │       │   └── closing_loc: (642...643) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (624...626) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (616...620) = "case"
+        │   └── end_keyword_loc: (644...647) = "end"
+        ├── @ CaseNode (location: (649...673))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (654...656))
+        │   │   ├── opening_loc: (654...655) = ":"
+        │   │   ├── value_loc: (655...656) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (657...669))
+        │   │       ├── pattern:
+        │   │       │   @ XStringNode (location: (660...669))
+        │   │       │   ├── opening_loc: (660...661) = "`"
+        │   │       │   ├── content_loc: (661...668) = "echo hi"
+        │   │       │   ├── closing_loc: (668...669) = "`"
+        │   │       │   └── unescaped: "echo hi"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (657...659) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (649...653) = "case"
+        │   └── end_keyword_loc: (670...673) = "end"
+        ├── @ CaseNode (location: (675...703))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (680...682))
+        │   │   ├── opening_loc: (680...681) = ":"
+        │   │   ├── value_loc: (681...682) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (683...699))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (686...699))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── requireds: (length: 3)
+        │   │       │   │   ├── @ NilNode (location: (686...689))
+        │   │       │   │   ├── @ NilNode (location: (691...694))
+        │   │       │   │   └── @ NilNode (location: (696...699))
+        │   │       │   ├── rest: ∅
+        │   │       │   ├── posts: (length: 0)
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   └── closing_loc: ∅
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (683...685) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (675...679) = "case"
+        │   └── end_keyword_loc: (700...703) = "end"
+        ├── @ CaseNode (location: (705...728))
+        │   ├── predicate:
+        │   │   @ SymbolNode (location: (710...712))
+        │   │   ├── opening_loc: (710...711) = ":"
+        │   │   ├── value_loc: (711...712) = "a"
+        │   │   ├── closing_loc: ∅
+        │   │   └── unescaped: "a"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (713...724))
+        │   │       ├── pattern:
+        │   │       │   @ HashPatternNode (location: (716...724))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── assocs: (length: 1)
+        │   │       │   │   └── @ AssocNode (location: (718...722))
+        │   │       │   │       ├── key:
+        │   │       │   │       │   @ SymbolNode (location: (718...722))
+        │   │       │   │       │   ├── opening_loc: (718...719) = "\""
+        │   │       │   │       │   ├── value_loc: (719...720) = "b"
+        │   │       │   │       │   ├── closing_loc: (720...722) = "\":"
+        │   │       │   │       │   └── unescaped: "b"
+        │   │       │   │       ├── value: ∅
+        │   │       │   │       └── operator_loc: ∅
+        │   │       │   ├── kwrest: ∅
+        │   │       │   ├── opening_loc: (716...717) = "{"
+        │   │       │   └── closing_loc: (723...724) = "}"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (713...715) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (705...709) = "case"
+        │   └── end_keyword_loc: (725...728) = "end"
+        └── @ CaseNode (location: (730...747))
+            ├── predicate:
+            │   @ SymbolNode (location: (735...737))
+            │   ├── opening_loc: (735...736) = ":"
+            │   ├── value_loc: (736...737) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (738...743))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (741...743))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 0)
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: (741...742) = "{"
+            │       │   └── closing_loc: (742...743) = "}"
+            │       ├── statements: ∅
+            │       ├── in_loc: (738...740) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (730...734) = "case"
+            └── end_keyword_loc: (744...747) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_31.txt b/test/yarp/snapshots/seattlerb/case_in_31.txt
index c34b271b84..a60e442456 100644
--- a/test/yarp/snapshots/seattlerb/case_in_31.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_31.txt
@@ -1,29 +1,46 @@
-ProgramNode(0...28)(
-  [:c],
-  StatementsNode(0...28)(
-    [CaseNode(0...28)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...24)(
-          ArrayPatternNode(11...19)(
-            nil,
-            [SymbolNode(12...14)((12...13), (13...14), nil, "b")],
-            SplatNode(16...18)(
-              (16...17),
-              LocalVariableTargetNode(17...18)(:c, 0)
-            ),
-            [],
-            (11...12),
-            (18...19)
-          ),
-          StatementsNode(22...24)(
-            [SymbolNode(22...24)((22...23), (23...24), nil, "d")]
-          ),
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (25...28)
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: [:c]
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...28))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...24))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (11...19))
+            │       │   ├── constant: ∅
+            │       │   ├── requireds: (length: 1)
+            │       │   │   └── @ SymbolNode (location: (12...14))
+            │       │   │       ├── opening_loc: (12...13) = ":"
+            │       │   │       ├── value_loc: (13...14) = "b"
+            │       │   │       ├── closing_loc: ∅
+            │       │   │       └── unescaped: "b"
+            │       │   ├── rest:
+            │       │   │   @ SplatNode (location: (16...18))
+            │       │   │   ├── operator_loc: (16...17) = "*"
+            │       │   │   └── expression:
+            │       │   │       @ LocalVariableTargetNode (location: (17...18))
+            │       │   │       ├── name: :c
+            │       │   │       └── depth: 0
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: (11...12) = "["
+            │       │   └── closing_loc: (18...19) = "]"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (22...24))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (22...24))
+            │       │           ├── opening_loc: (22...23) = ":"
+            │       │           ├── value_loc: (23...24) = "d"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "d"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (25...28) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_37.txt b/test/yarp/snapshots/seattlerb/case_in_37.txt
index 47137d795d..a11efb2e72 100644
--- a/test/yarp/snapshots/seattlerb/case_in_37.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_37.txt
@@ -1,36 +1,55 @@
-ProgramNode(0...36)(
-  [],
-  StatementsNode(0...36)(
-    [CaseNode(0...36)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...32)(
-          HashPatternNode(11...27)(
-            nil,
-            [AssocNode(13...25)(
-               SymbolNode(13...15)(nil, (13...14), (14...15), "b"),
-               ArrayPatternNode(16...25)(
-                 nil,
-                 [ConstantReadNode(17...21)(:Hash)],
-                 SplatNode(23...24)((23...24), nil),
-                 [],
-                 (16...17),
-                 (24...25)
-               ),
-               nil
-             )],
-            nil,
-            (11...12),
-            (26...27)
-          ),
-          StatementsNode(30...32)(
-            [SymbolNode(30...32)((30...31), (31...32), nil, "c")]
-          ),
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (33...36)
-     )]
-  )
-)
+@ ProgramNode (location: (0...36))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...36))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...36))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...32))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (11...27))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 1)
+            │       │   │   └── @ AssocNode (location: (13...25))
+            │       │   │       ├── key:
+            │       │   │       │   @ SymbolNode (location: (13...15))
+            │       │   │       │   ├── opening_loc: ∅
+            │       │   │       │   ├── value_loc: (13...14) = "b"
+            │       │   │       │   ├── closing_loc: (14...15) = ":"
+            │       │   │       │   └── unescaped: "b"
+            │       │   │       ├── value:
+            │       │   │       │   @ ArrayPatternNode (location: (16...25))
+            │       │   │       │   ├── constant: ∅
+            │       │   │       │   ├── requireds: (length: 1)
+            │       │   │       │   │   └── @ ConstantReadNode (location: (17...21))
+            │       │   │       │   │       └── name: :Hash
+            │       │   │       │   ├── rest:
+            │       │   │       │   │   @ SplatNode (location: (23...24))
+            │       │   │       │   │   ├── operator_loc: (23...24) = "*"
+            │       │   │       │   │   └── expression: ∅
+            │       │   │       │   ├── posts: (length: 0)
+            │       │   │       │   ├── opening_loc: (16...17) = "["
+            │       │   │       │   └── closing_loc: (24...25) = "]"
+            │       │   │       └── operator_loc: ∅
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: (11...12) = "{"
+            │       │   └── closing_loc: (26...27) = "}"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (30...32))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (30...32))
+            │       │           ├── opening_loc: (30...31) = ":"
+            │       │           ├── value_loc: (31...32) = "c"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "c"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (33...36) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_42.txt b/test/yarp/snapshots/seattlerb/case_in_42.txt
index b98fd9f4b7..64a2ac33cc 100644
--- a/test/yarp/snapshots/seattlerb/case_in_42.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_42.txt
@@ -1,27 +1,42 @@
-ProgramNode(0...30)(
-  [:_],
-  StatementsNode(0...30)(
-    [CaseNode(0...30)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...26)(
-          ArrayPatternNode(11...17)(
-            nil,
-            [SymbolNode(11...13)((11...12), (12...13), nil, "b")],
-            SplatNode(15...17)(
-              (15...16),
-              LocalVariableTargetNode(16...17)(:_, 0)
-            ),
-            [],
-            nil,
-            nil
-          ),
-          StatementsNode(23...26)([NilNode(23...26)()]),
-          (8...10),
-          (18...22)
-        )],
-       nil,
-       (0...4),
-       (27...30)
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: [:_]
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...30))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...26))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (11...17))
+            │       │   ├── constant: ∅
+            │       │   ├── requireds: (length: 1)
+            │       │   │   └── @ SymbolNode (location: (11...13))
+            │       │   │       ├── opening_loc: (11...12) = ":"
+            │       │   │       ├── value_loc: (12...13) = "b"
+            │       │   │       ├── closing_loc: ∅
+            │       │   │       └── unescaped: "b"
+            │       │   ├── rest:
+            │       │   │   @ SplatNode (location: (15...17))
+            │       │   │   ├── operator_loc: (15...16) = "*"
+            │       │   │   └── expression:
+            │       │   │       @ LocalVariableTargetNode (location: (16...17))
+            │       │   │       ├── name: :_
+            │       │   │       └── depth: 0
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: ∅
+            │       │   └── closing_loc: ∅
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (23...26))
+            │       │   └── body: (length: 1)
+            │       │       └── @ NilNode (location: (23...26))
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: (18...22) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (27...30) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_42_2.txt b/test/yarp/snapshots/seattlerb/case_in_42_2.txt
index 5d7fc68646..184ed6013a 100644
--- a/test/yarp/snapshots/seattlerb/case_in_42_2.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_42_2.txt
@@ -1,27 +1,39 @@
-ProgramNode(0...32)(
-  [:list],
-  StatementsNode(0...32)(
-    [CaseNode(0...32)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...28)(
-          ArrayPatternNode(11...19)(
-            ConstantReadNode(11...12)(:A),
-            [],
-            SplatNode(13...18)(
-              (13...14),
-              LocalVariableTargetNode(14...18)(:list, 0)
-            ),
-            [],
-            (12...13),
-            (18...19)
-          ),
-          StatementsNode(25...28)([NilNode(25...28)()]),
-          (8...10),
-          (20...24)
-        )],
-       nil,
-       (0...4),
-       (29...32)
-     )]
-  )
-)
+@ ProgramNode (location: (0...32))
+├── locals: [:list]
+└── statements:
+    @ StatementsNode (location: (0...32))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...32))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...28))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (11...19))
+            │       │   ├── constant:
+            │       │   │   @ ConstantReadNode (location: (11...12))
+            │       │   │   └── name: :A
+            │       │   ├── requireds: (length: 0)
+            │       │   ├── rest:
+            │       │   │   @ SplatNode (location: (13...18))
+            │       │   │   ├── operator_loc: (13...14) = "*"
+            │       │   │   └── expression:
+            │       │   │       @ LocalVariableTargetNode (location: (14...18))
+            │       │   │       ├── name: :list
+            │       │   │       └── depth: 0
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: (12...13) = "("
+            │       │   └── closing_loc: (18...19) = ")"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (25...28))
+            │       │   └── body: (length: 1)
+            │       │       └── @ NilNode (location: (25...28))
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: (20...24) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (29...32) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_47.txt b/test/yarp/snapshots/seattlerb/case_in_47.txt
index 727efebdde..b757188e84 100644
--- a/test/yarp/snapshots/seattlerb/case_in_47.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_47.txt
@@ -1,27 +1,48 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)(
-    [CaseNode(0...31)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...27)(
-          ArrayPatternNode(11...22)(
-            nil,
-            [],
-            SplatNode(12...13)((12...13), nil),
-            [SymbolNode(15...17)((15...16), (16...17), nil, "b"),
-             SymbolNode(19...21)((19...20), (20...21), nil, "c")],
-            (11...12),
-            (21...22)
-          ),
-          StatementsNode(25...27)(
-            [SymbolNode(25...27)((25...26), (26...27), nil, "d")]
-          ),
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (28...31)
-     )]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...31))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...27))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (11...22))
+            │       │   ├── constant: ∅
+            │       │   ├── requireds: (length: 0)
+            │       │   ├── rest:
+            │       │   │   @ SplatNode (location: (12...13))
+            │       │   │   ├── operator_loc: (12...13) = "*"
+            │       │   │   └── expression: ∅
+            │       │   ├── posts: (length: 2)
+            │       │   │   ├── @ SymbolNode (location: (15...17))
+            │       │   │   │   ├── opening_loc: (15...16) = ":"
+            │       │   │   │   ├── value_loc: (16...17) = "b"
+            │       │   │   │   ├── closing_loc: ∅
+            │       │   │   │   └── unescaped: "b"
+            │       │   │   └── @ SymbolNode (location: (19...21))
+            │       │   │       ├── opening_loc: (19...20) = ":"
+            │       │   │       ├── value_loc: (20...21) = "c"
+            │       │   │       ├── closing_loc: ∅
+            │       │   │       └── unescaped: "c"
+            │       │   ├── opening_loc: (11...12) = "["
+            │       │   └── closing_loc: (21...22) = "]"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (25...27))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (25...27))
+            │       │           ├── opening_loc: (25...26) = ":"
+            │       │           ├── value_loc: (26...27) = "d"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "d"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (28...31) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_67.txt b/test/yarp/snapshots/seattlerb/case_in_67.txt
index 094d6711aa..3991a6c695 100644
--- a/test/yarp/snapshots/seattlerb/case_in_67.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_67.txt
@@ -1,17 +1,30 @@
-ProgramNode(0...27)(
-  [],
-  StatementsNode(0...27)(
-    [CaseNode(0...27)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...23)(
-          RangeNode(11...14)(IntegerNode(11...12)(), nil, (12...14), 0),
-          StatementsNode(20...23)([NilNode(20...23)()]),
-          (8...10),
-          (15...19)
-        )],
-       nil,
-       (0...4),
-       (24...27)
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...27))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...23))
+            │       ├── pattern:
+            │       │   @ RangeNode (location: (11...14))
+            │       │   ├── left:
+            │       │   │   @ IntegerNode (location: (11...12))
+            │       │   ├── right: ∅
+            │       │   ├── operator_loc: (12...14) = ".."
+            │       │   └── flags: 
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (20...23))
+            │       │   └── body: (length: 1)
+            │       │       └── @ NilNode (location: (20...23))
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: (15...19) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (24...27) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_86.txt b/test/yarp/snapshots/seattlerb/case_in_86.txt
index c6287b9c3e..e7d7f7bd78 100644
--- a/test/yarp/snapshots/seattlerb/case_in_86.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_86.txt
@@ -1,33 +1,49 @@
-ProgramNode(0...43)(
-  [],
-  StatementsNode(0...43)(
-    [CaseNode(0...43)(
-       ArrayNode(5...13)(
-         [SymbolNode(6...8)((6...7), (7...8), nil, "a"),
-          SymbolNode(10...12)((10...11), (11...12), nil, "b")],
-         (5...6),
-         (12...13)
-       ),
-       [InNode(14...39)(
-          ArrayPatternNode(17...30)(
-            nil,
-            [ConstantPathNode(17...27)(
-               nil,
-               ConstantReadNode(19...27)(:NilClass),
-               (17...19)
-             )],
-            SplatNode(29...30)((29...30), nil),
-            [],
-            nil,
-            nil
-          ),
-          StatementsNode(36...39)([NilNode(36...39)()]),
-          (14...16),
-          (31...35)
-        )],
-       nil,
-       (0...4),
-       (40...43)
-     )]
-  )
-)
+@ ProgramNode (location: (0...43))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...43))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...43))
+            ├── predicate:
+            │   @ ArrayNode (location: (5...13))
+            │   ├── elements: (length: 2)
+            │   │   ├── @ SymbolNode (location: (6...8))
+            │   │   │   ├── opening_loc: (6...7) = ":"
+            │   │   │   ├── value_loc: (7...8) = "a"
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   └── unescaped: "a"
+            │   │   └── @ SymbolNode (location: (10...12))
+            │   │       ├── opening_loc: (10...11) = ":"
+            │   │       ├── value_loc: (11...12) = "b"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "b"
+            │   ├── opening_loc: (5...6) = "["
+            │   └── closing_loc: (12...13) = "]"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (14...39))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (17...30))
+            │       │   ├── constant: ∅
+            │       │   ├── requireds: (length: 1)
+            │       │   │   └── @ ConstantPathNode (location: (17...27))
+            │       │   │       ├── parent: ∅
+            │       │   │       ├── child:
+            │       │   │       │   @ ConstantReadNode (location: (19...27))
+            │       │   │       │   └── name: :NilClass
+            │       │   │       └── delimiter_loc: (17...19) = "::"
+            │       │   ├── rest:
+            │       │   │   @ SplatNode (location: (29...30))
+            │       │   │   ├── operator_loc: (29...30) = "*"
+            │       │   │   └── expression: ∅
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: ∅
+            │       │   └── closing_loc: ∅
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (36...39))
+            │       │   └── body: (length: 1)
+            │       │       └── @ NilNode (location: (36...39))
+            │       ├── in_loc: (14...16) = "in"
+            │       └── then_loc: (31...35) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (40...43) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_86_2.txt b/test/yarp/snapshots/seattlerb/case_in_86_2.txt
index 16fdad3d3c..4d1332a48f 100644
--- a/test/yarp/snapshots/seattlerb/case_in_86_2.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_86_2.txt
@@ -1,33 +1,49 @@
-ProgramNode(0...43)(
-  [],
-  StatementsNode(0...43)(
-    [CaseNode(0...43)(
-       ArrayNode(5...13)(
-         [SymbolNode(6...8)((6...7), (7...8), nil, "a"),
-          SymbolNode(10...12)((10...11), (11...12), nil, "b")],
-         (5...6),
-         (12...13)
-       ),
-       [InNode(14...39)(
-          ArrayPatternNode(17...30)(
-            nil,
-            [],
-            SplatNode(17...18)((17...18), nil),
-            [ConstantPathNode(20...30)(
-               nil,
-               ConstantReadNode(22...30)(:NilClass),
-               (20...22)
-             )],
-            nil,
-            nil
-          ),
-          StatementsNode(36...39)([NilNode(36...39)()]),
-          (14...16),
-          (31...35)
-        )],
-       nil,
-       (0...4),
-       (40...43)
-     )]
-  )
-)
+@ ProgramNode (location: (0...43))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...43))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...43))
+            ├── predicate:
+            │   @ ArrayNode (location: (5...13))
+            │   ├── elements: (length: 2)
+            │   │   ├── @ SymbolNode (location: (6...8))
+            │   │   │   ├── opening_loc: (6...7) = ":"
+            │   │   │   ├── value_loc: (7...8) = "a"
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   └── unescaped: "a"
+            │   │   └── @ SymbolNode (location: (10...12))
+            │   │       ├── opening_loc: (10...11) = ":"
+            │   │       ├── value_loc: (11...12) = "b"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "b"
+            │   ├── opening_loc: (5...6) = "["
+            │   └── closing_loc: (12...13) = "]"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (14...39))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (17...30))
+            │       │   ├── constant: ∅
+            │       │   ├── requireds: (length: 0)
+            │       │   ├── rest:
+            │       │   │   @ SplatNode (location: (17...18))
+            │       │   │   ├── operator_loc: (17...18) = "*"
+            │       │   │   └── expression: ∅
+            │       │   ├── posts: (length: 1)
+            │       │   │   └── @ ConstantPathNode (location: (20...30))
+            │       │   │       ├── parent: ∅
+            │       │   │       ├── child:
+            │       │   │       │   @ ConstantReadNode (location: (22...30))
+            │       │   │       │   └── name: :NilClass
+            │       │   │       └── delimiter_loc: (20...22) = "::"
+            │       │   ├── opening_loc: ∅
+            │       │   └── closing_loc: ∅
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (36...39))
+            │       │   └── body: (length: 1)
+            │       │       └── @ NilNode (location: (36...39))
+            │       ├── in_loc: (14...16) = "in"
+            │       └── then_loc: (31...35) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (40...43) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_array_pat_const.txt b/test/yarp/snapshots/seattlerb/case_in_array_pat_const.txt
index bf332c3d5d..b7408b12e5 100644
--- a/test/yarp/snapshots/seattlerb/case_in_array_pat_const.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_array_pat_const.txt
@@ -1,26 +1,40 @@
-ProgramNode(0...24)(
-  [:c],
-  StatementsNode(0...24)(
-    [CaseNode(0...24)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...20)(
-          ArrayPatternNode(11...15)(
-            ConstantReadNode(11...12)(:B),
-            [LocalVariableTargetNode(13...14)(:c, 0)],
-            nil,
-            [],
-            (12...13),
-            (14...15)
-          ),
-          StatementsNode(18...20)(
-            [SymbolNode(18...20)((18...19), (19...20), nil, "d")]
-          ),
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (21...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: [:c]
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...24))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...20))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (11...15))
+            │       │   ├── constant:
+            │       │   │   @ ConstantReadNode (location: (11...12))
+            │       │   │   └── name: :B
+            │       │   ├── requireds: (length: 1)
+            │       │   │   └── @ LocalVariableTargetNode (location: (13...14))
+            │       │   │       ├── name: :c
+            │       │   │       └── depth: 0
+            │       │   ├── rest: ∅
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: (12...13) = "["
+            │       │   └── closing_loc: (14...15) = "]"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (18...20))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (18...20))
+            │       │           ├── opening_loc: (18...19) = ":"
+            │       │           ├── value_loc: (19...20) = "d"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "d"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (21...24) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_array_pat_const2.txt b/test/yarp/snapshots/seattlerb/case_in_array_pat_const2.txt
index 382db335d5..986e5f02fc 100644
--- a/test/yarp/snapshots/seattlerb/case_in_array_pat_const2.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_array_pat_const2.txt
@@ -1,30 +1,46 @@
-ProgramNode(0...27)(
-  [:d],
-  StatementsNode(0...27)(
-    [CaseNode(0...27)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...23)(
-          ArrayPatternNode(11...18)(
-            ConstantPathNode(11...15)(
-              ConstantReadNode(11...12)(:B),
-              ConstantReadNode(14...15)(:C),
-              (12...14)
-            ),
-            [LocalVariableTargetNode(16...17)(:d, 0)],
-            nil,
-            [],
-            (15...16),
-            (17...18)
-          ),
-          StatementsNode(21...23)(
-            [SymbolNode(21...23)((21...22), (22...23), nil, "e")]
-          ),
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (24...27)
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: [:d]
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...27))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...23))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (11...18))
+            │       │   ├── constant:
+            │       │   │   @ ConstantPathNode (location: (11...15))
+            │       │   │   ├── parent:
+            │       │   │   │   @ ConstantReadNode (location: (11...12))
+            │       │   │   │   └── name: :B
+            │       │   │   ├── child:
+            │       │   │   │   @ ConstantReadNode (location: (14...15))
+            │       │   │   │   └── name: :C
+            │       │   │   └── delimiter_loc: (12...14) = "::"
+            │       │   ├── requireds: (length: 1)
+            │       │   │   └── @ LocalVariableTargetNode (location: (16...17))
+            │       │   │       ├── name: :d
+            │       │   │       └── depth: 0
+            │       │   ├── rest: ∅
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: (15...16) = "["
+            │       │   └── closing_loc: (17...18) = "]"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (21...23))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (21...23))
+            │       │           ├── opening_loc: (21...22) = ":"
+            │       │           ├── value_loc: (22...23) = "e"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "e"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (24...27) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_array_pat_paren_assign.txt b/test/yarp/snapshots/seattlerb/case_in_array_pat_paren_assign.txt
index c2a74beaab..b158ab5a7f 100644
--- a/test/yarp/snapshots/seattlerb/case_in_array_pat_paren_assign.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_array_pat_paren_assign.txt
@@ -1,30 +1,46 @@
-ProgramNode(0...29)(
-  [:d],
-  StatementsNode(0...29)(
-    [CaseNode(0...29)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...25)(
-          ArrayPatternNode(11...20)(
-            ConstantReadNode(11...12)(:B),
-            [CapturePatternNode(13...19)(
-               ConstantReadNode(13...14)(:C),
-               LocalVariableTargetNode(18...19)(:d, 0),
-               (15...17)
-             )],
-            nil,
-            [],
-            (12...13),
-            (19...20)
-          ),
-          StatementsNode(23...25)(
-            [SymbolNode(23...25)((23...24), (24...25), nil, "d")]
-          ),
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (26...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: [:d]
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...29))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...25))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (11...20))
+            │       │   ├── constant:
+            │       │   │   @ ConstantReadNode (location: (11...12))
+            │       │   │   └── name: :B
+            │       │   ├── requireds: (length: 1)
+            │       │   │   └── @ CapturePatternNode (location: (13...19))
+            │       │   │       ├── value:
+            │       │   │       │   @ ConstantReadNode (location: (13...14))
+            │       │   │       │   └── name: :C
+            │       │   │       ├── target:
+            │       │   │       │   @ LocalVariableTargetNode (location: (18...19))
+            │       │   │       │   ├── name: :d
+            │       │   │       │   └── depth: 0
+            │       │   │       └── operator_loc: (15...17) = "=>"
+            │       │   ├── rest: ∅
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: (12...13) = "("
+            │       │   └── closing_loc: (19...20) = ")"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (23...25))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (23...25))
+            │       │           ├── opening_loc: (23...24) = ":"
+            │       │           ├── value_loc: (24...25) = "d"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "d"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (26...29) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_const.txt b/test/yarp/snapshots/seattlerb/case_in_const.txt
index b2312a5d7a..a38aaa4d54 100644
--- a/test/yarp/snapshots/seattlerb/case_in_const.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_const.txt
@@ -1,19 +1,27 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CaseNode(0...28)(
-       ConstantReadNode(5...10)(:Array),
-       [InNode(11...24)(
-          ConstantReadNode(14...19)(:Class),
-          StatementsNode(22...24)(
-            [SymbolNode(22...24)((22...23), (23...24), nil, "b")]
-          ),
-          (11...13),
-          nil
-        )],
-       nil,
-       (0...4),
-       (25...28)
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...28))
+            ├── predicate:
+            │   @ ConstantReadNode (location: (5...10))
+            │   └── name: :Array
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (11...24))
+            │       ├── pattern:
+            │       │   @ ConstantReadNode (location: (14...19))
+            │       │   └── name: :Class
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (22...24))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (22...24))
+            │       │           ├── opening_loc: (22...23) = ":"
+            │       │           ├── value_loc: (23...24) = "b"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "b"
+            │       ├── in_loc: (11...13) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (25...28) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_else.txt b/test/yarp/snapshots/seattlerb/case_in_else.txt
index edbcff9af8..8a0afbeb16 100644
--- a/test/yarp/snapshots/seattlerb/case_in_else.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_else.txt
@@ -1,25 +1,38 @@
-ProgramNode(0...38)(
-  [],
-  StatementsNode(0...38)(
-    [CaseNode(0...38)(
-       ConstantReadNode(5...10)(:Array),
-       [InNode(11...24)(
-          ConstantReadNode(14...19)(:Class),
-          StatementsNode(22...24)(
-            [SymbolNode(22...24)((22...23), (23...24), nil, "b")]
-          ),
-          (11...13),
-          nil
-        )],
-       ElseNode(25...38)(
-         (25...29),
-         StatementsNode(32...34)(
-           [SymbolNode(32...34)((32...33), (33...34), nil, "c")]
-         ),
-         (35...38)
-       ),
-       (0...4),
-       (35...38)
-     )]
-  )
-)
+@ ProgramNode (location: (0...38))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...38))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...38))
+            ├── predicate:
+            │   @ ConstantReadNode (location: (5...10))
+            │   └── name: :Array
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (11...24))
+            │       ├── pattern:
+            │       │   @ ConstantReadNode (location: (14...19))
+            │       │   └── name: :Class
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (22...24))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (22...24))
+            │       │           ├── opening_loc: (22...23) = ":"
+            │       │           ├── value_loc: (23...24) = "b"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "b"
+            │       ├── in_loc: (11...13) = "in"
+            │       └── then_loc: ∅
+            ├── consequent:
+            │   @ ElseNode (location: (25...38))
+            │   ├── else_keyword_loc: (25...29) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (32...34))
+            │   │   └── body: (length: 1)
+            │   │       └── @ SymbolNode (location: (32...34))
+            │   │           ├── opening_loc: (32...33) = ":"
+            │   │           ├── value_loc: (33...34) = "c"
+            │   │           ├── closing_loc: ∅
+            │   │           └── unescaped: "c"
+            │   └── end_keyword_loc: (35...38) = "end"
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (35...38) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_find.txt b/test/yarp/snapshots/seattlerb/case_in_find.txt
index 3c8e644244..b533dba4aa 100644
--- a/test/yarp/snapshots/seattlerb/case_in_find.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_find.txt
@@ -1,30 +1,45 @@
-ProgramNode(0...27)(
-  [:a, :b],
-  StatementsNode(0...27)(
-    [CaseNode(0...27)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(10...23)(
-          FindPatternNode(13...23)(
-            nil,
-            SplatNode(13...15)(
-              (13...14),
-              LocalVariableTargetNode(14...15)(:a, 0)
-            ),
-            [SymbolNode(17...19)((17...18), (18...19), nil, "+")],
-            SplatNode(21...23)(
-              (21...22),
-              LocalVariableTargetNode(22...23)(:b, 0)
-            ),
-            nil,
-            nil
-          ),
-          nil,
-          (10...12),
-          nil
-        )],
-       nil,
-       (0...4),
-       (24...27)
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...27))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (10...23))
+            │       ├── pattern:
+            │       │   @ FindPatternNode (location: (13...23))
+            │       │   ├── constant: ∅
+            │       │   ├── left:
+            │       │   │   @ SplatNode (location: (13...15))
+            │       │   │   ├── operator_loc: (13...14) = "*"
+            │       │   │   └── expression:
+            │       │   │       @ LocalVariableTargetNode (location: (14...15))
+            │       │   │       ├── name: :a
+            │       │   │       └── depth: 0
+            │       │   ├── requireds: (length: 1)
+            │       │   │   └── @ SymbolNode (location: (17...19))
+            │       │   │       ├── opening_loc: (17...18) = ":"
+            │       │   │       ├── value_loc: (18...19) = "+"
+            │       │   │       ├── closing_loc: ∅
+            │       │   │       └── unescaped: "+"
+            │       │   ├── right:
+            │       │   │   @ SplatNode (location: (21...23))
+            │       │   │   ├── operator_loc: (21...22) = "*"
+            │       │   │   └── expression:
+            │       │   │       @ LocalVariableTargetNode (location: (22...23))
+            │       │   │       ├── name: :b
+            │       │   │       └── depth: 0
+            │       │   ├── opening_loc: ∅
+            │       │   └── closing_loc: ∅
+            │       ├── statements: ∅
+            │       ├── in_loc: (10...12) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (24...27) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_find_array.txt b/test/yarp/snapshots/seattlerb/case_in_find_array.txt
index 616c8f864b..7f7939b366 100644
--- a/test/yarp/snapshots/seattlerb/case_in_find_array.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_find_array.txt
@@ -1,25 +1,42 @@
-ProgramNode(0...28)(
-  [:c],
-  StatementsNode(0...28)(
-    [CaseNode(0...28)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...24)(
-          FindPatternNode(11...24)(
-            nil,
-            SplatNode(12...13)((12...13), nil),
-            [SymbolNode(15...17)((15...16), (16...17), nil, "b"),
-             LocalVariableTargetNode(19...20)(:c, 0)],
-            SplatNode(22...23)((22...23), nil),
-            (11...12),
-            (23...24)
-          ),
-          nil,
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (25...28)
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: [:c]
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...28))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...24))
+            │       ├── pattern:
+            │       │   @ FindPatternNode (location: (11...24))
+            │       │   ├── constant: ∅
+            │       │   ├── left:
+            │       │   │   @ SplatNode (location: (12...13))
+            │       │   │   ├── operator_loc: (12...13) = "*"
+            │       │   │   └── expression: ∅
+            │       │   ├── requireds: (length: 2)
+            │       │   │   ├── @ SymbolNode (location: (15...17))
+            │       │   │   │   ├── opening_loc: (15...16) = ":"
+            │       │   │   │   ├── value_loc: (16...17) = "b"
+            │       │   │   │   ├── closing_loc: ∅
+            │       │   │   │   └── unescaped: "b"
+            │       │   │   └── @ LocalVariableTargetNode (location: (19...20))
+            │       │   │       ├── name: :c
+            │       │   │       └── depth: 0
+            │       │   ├── right:
+            │       │   │   @ SplatNode (location: (22...23))
+            │       │   │   ├── operator_loc: (22...23) = "*"
+            │       │   │   └── expression: ∅
+            │       │   ├── opening_loc: (11...12) = "["
+            │       │   └── closing_loc: (23...24) = "]"
+            │       ├── statements: ∅
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (25...28) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_hash_pat.txt b/test/yarp/snapshots/seattlerb/case_in_hash_pat.txt
index b7c8e7eb82..a6853f9cae 100644
--- a/test/yarp/snapshots/seattlerb/case_in_hash_pat.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_hash_pat.txt
@@ -1,34 +1,62 @@
-ProgramNode(0...43)(
-  [],
-  StatementsNode(0...43)(
-    [CaseNode(0...43)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...39)(
-          HashPatternNode(11...29)(
-            nil,
-            [AssocNode(13...19)(
-               SymbolNode(13...15)(nil, (13...14), (14...15), "b"),
-               StringNode(16...19)((16...17), (17...18), (18...19), "c"),
-               nil
-             ),
-             AssocNode(21...27)(
-               SymbolNode(21...23)(nil, (21...22), (22...23), "d"),
-               StringNode(24...27)((24...25), (25...26), (26...27), "e"),
-               nil
-             )],
-            nil,
-            (11...12),
-            (28...29)
-          ),
-          StatementsNode(37...39)(
-            [SymbolNode(37...39)((37...38), (38...39), nil, "f")]
-          ),
-          (8...10),
-          (30...34)
-        )],
-       nil,
-       (0...4),
-       (40...43)
-     )]
-  )
-)
+@ ProgramNode (location: (0...43))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...43))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...43))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...39))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (11...29))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 2)
+            │       │   │   ├── @ AssocNode (location: (13...19))
+            │       │   │   │   ├── key:
+            │       │   │   │   │   @ SymbolNode (location: (13...15))
+            │       │   │   │   │   ├── opening_loc: ∅
+            │       │   │   │   │   ├── value_loc: (13...14) = "b"
+            │       │   │   │   │   ├── closing_loc: (14...15) = ":"
+            │       │   │   │   │   └── unescaped: "b"
+            │       │   │   │   ├── value:
+            │       │   │   │   │   @ StringNode (location: (16...19))
+            │       │   │   │   │   ├── opening_loc: (16...17) = "'"
+            │       │   │   │   │   ├── content_loc: (17...18) = "c"
+            │       │   │   │   │   ├── closing_loc: (18...19) = "'"
+            │       │   │   │   │   └── unescaped: "c"
+            │       │   │   │   └── operator_loc: ∅
+            │       │   │   └── @ AssocNode (location: (21...27))
+            │       │   │       ├── key:
+            │       │   │       │   @ SymbolNode (location: (21...23))
+            │       │   │       │   ├── opening_loc: ∅
+            │       │   │       │   ├── value_loc: (21...22) = "d"
+            │       │   │       │   ├── closing_loc: (22...23) = ":"
+            │       │   │       │   └── unescaped: "d"
+            │       │   │       ├── value:
+            │       │   │       │   @ StringNode (location: (24...27))
+            │       │   │       │   ├── opening_loc: (24...25) = "\""
+            │       │   │       │   ├── content_loc: (25...26) = "e"
+            │       │   │       │   ├── closing_loc: (26...27) = "\""
+            │       │   │       │   └── unescaped: "e"
+            │       │   │       └── operator_loc: ∅
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: (11...12) = "{"
+            │       │   └── closing_loc: (28...29) = "}"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (37...39))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (37...39))
+            │       │           ├── opening_loc: (37...38) = ":"
+            │       │           ├── value_loc: (38...39) = "f"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "f"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: (30...34) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (40...43) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_hash_pat_assign.txt b/test/yarp/snapshots/seattlerb/case_in_hash_pat_assign.txt
index bac4076d27..5a14af2366 100644
--- a/test/yarp/snapshots/seattlerb/case_in_hash_pat_assign.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_hash_pat_assign.txt
@@ -1,43 +1,75 @@
-ProgramNode(0...56)(
-  [:x, :f],
-  StatementsNode(0...56)(
-    [CaseNode(0...56)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...52)(
-          HashPatternNode(11...42)(
-            nil,
-            [AssocNode(13...28)(
-               SymbolNode(13...15)(nil, (13...14), (14...15), "b"),
-               CapturePatternNode(16...28)(
-                 ConstantReadNode(16...23)(:Integer),
-                 LocalVariableTargetNode(27...28)(:x, 0),
-                 (24...26)
-               ),
-               nil
-             ),
-             AssocNode(30...36)(
-               SymbolNode(30...32)(nil, (30...31), (31...32), "d"),
-               StringNode(33...36)((33...34), (34...35), (35...36), "e"),
-               nil
-             ),
-             AssocNode(38...40)(
-               SymbolNode(38...40)(nil, (38...39), (39...40), "f"),
-               nil,
-               nil
-             )],
-            nil,
-            (11...12),
-            (41...42)
-          ),
-          StatementsNode(50...52)(
-            [SymbolNode(50...52)((50...51), (51...52), nil, "g")]
-          ),
-          (8...10),
-          (43...47)
-        )],
-       nil,
-       (0...4),
-       (53...56)
-     )]
-  )
-)
+@ ProgramNode (location: (0...56))
+├── locals: [:x, :f]
+└── statements:
+    @ StatementsNode (location: (0...56))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...56))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...52))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (11...42))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 3)
+            │       │   │   ├── @ AssocNode (location: (13...28))
+            │       │   │   │   ├── key:
+            │       │   │   │   │   @ SymbolNode (location: (13...15))
+            │       │   │   │   │   ├── opening_loc: ∅
+            │       │   │   │   │   ├── value_loc: (13...14) = "b"
+            │       │   │   │   │   ├── closing_loc: (14...15) = ":"
+            │       │   │   │   │   └── unescaped: "b"
+            │       │   │   │   ├── value:
+            │       │   │   │   │   @ CapturePatternNode (location: (16...28))
+            │       │   │   │   │   ├── value:
+            │       │   │   │   │   │   @ ConstantReadNode (location: (16...23))
+            │       │   │   │   │   │   └── name: :Integer
+            │       │   │   │   │   ├── target:
+            │       │   │   │   │   │   @ LocalVariableTargetNode (location: (27...28))
+            │       │   │   │   │   │   ├── name: :x
+            │       │   │   │   │   │   └── depth: 0
+            │       │   │   │   │   └── operator_loc: (24...26) = "=>"
+            │       │   │   │   └── operator_loc: ∅
+            │       │   │   ├── @ AssocNode (location: (30...36))
+            │       │   │   │   ├── key:
+            │       │   │   │   │   @ SymbolNode (location: (30...32))
+            │       │   │   │   │   ├── opening_loc: ∅
+            │       │   │   │   │   ├── value_loc: (30...31) = "d"
+            │       │   │   │   │   ├── closing_loc: (31...32) = ":"
+            │       │   │   │   │   └── unescaped: "d"
+            │       │   │   │   ├── value:
+            │       │   │   │   │   @ StringNode (location: (33...36))
+            │       │   │   │   │   ├── opening_loc: (33...34) = "\""
+            │       │   │   │   │   ├── content_loc: (34...35) = "e"
+            │       │   │   │   │   ├── closing_loc: (35...36) = "\""
+            │       │   │   │   │   └── unescaped: "e"
+            │       │   │   │   └── operator_loc: ∅
+            │       │   │   └── @ AssocNode (location: (38...40))
+            │       │   │       ├── key:
+            │       │   │       │   @ SymbolNode (location: (38...40))
+            │       │   │       │   ├── opening_loc: ∅
+            │       │   │       │   ├── value_loc: (38...39) = "f"
+            │       │   │       │   ├── closing_loc: (39...40) = ":"
+            │       │   │       │   └── unescaped: "f"
+            │       │   │       ├── value: ∅
+            │       │   │       └── operator_loc: ∅
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: (11...12) = "{"
+            │       │   └── closing_loc: (41...42) = "}"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (50...52))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (50...52))
+            │       │           ├── opening_loc: (50...51) = ":"
+            │       │           ├── value_loc: (51...52) = "g"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "g"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: (43...47) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (53...56) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt b/test/yarp/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt
index 352da8ab8b..9d72150eaf 100644
--- a/test/yarp/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt
@@ -1,29 +1,46 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CaseNode(0...28)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...24)(
-          HashPatternNode(11...19)(
-            ConstantReadNode(11...12)(:B),
-            [AssocNode(13...18)(
-               SymbolNode(13...15)(nil, (13...14), (14...15), "a"),
-               IntegerNode(16...18)(),
-               nil
-             )],
-            nil,
-            (12...13),
-            (18...19)
-          ),
-          StatementsNode(22...24)(
-            [SymbolNode(22...24)((22...23), (23...24), nil, "d")]
-          ),
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (25...28)
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...28))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...24))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (11...19))
+            │       │   ├── constant:
+            │       │   │   @ ConstantReadNode (location: (11...12))
+            │       │   │   └── name: :B
+            │       │   ├── assocs: (length: 1)
+            │       │   │   └── @ AssocNode (location: (13...18))
+            │       │   │       ├── key:
+            │       │   │       │   @ SymbolNode (location: (13...15))
+            │       │   │       │   ├── opening_loc: ∅
+            │       │   │       │   ├── value_loc: (13...14) = "a"
+            │       │   │       │   ├── closing_loc: (14...15) = ":"
+            │       │   │       │   └── unescaped: "a"
+            │       │   │       ├── value:
+            │       │   │       │   @ IntegerNode (location: (16...18))
+            │       │   │       └── operator_loc: ∅
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: (12...13) = "("
+            │       │   └── closing_loc: (18...19) = ")"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (22...24))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (22...24))
+            │       │           ├── opening_loc: (22...23) = ":"
+            │       │           ├── value_loc: (23...24) = "d"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "d"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (25...28) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_hash_pat_paren_true.txt b/test/yarp/snapshots/seattlerb/case_in_hash_pat_paren_true.txt
index c1bc104eff..4aef57e4af 100644
--- a/test/yarp/snapshots/seattlerb/case_in_hash_pat_paren_true.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_hash_pat_paren_true.txt
@@ -1,29 +1,44 @@
-ProgramNode(0...32)(
-  [],
-  StatementsNode(0...32)(
-    [CaseNode(0...32)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...28)(
-          HashPatternNode(11...18)(
-            nil,
-            [AssocNode(11...18)(
-               SymbolNode(11...13)(nil, (11...12), (12...13), "b"),
-               TrueNode(14...18)(),
-               nil
-             )],
-            nil,
-            nil,
-            nil
-          ),
-          StatementsNode(26...28)(
-            [SymbolNode(26...28)((26...27), (27...28), nil, "c")]
-          ),
-          (8...10),
-          (19...23)
-        )],
-       nil,
-       (0...4),
-       (29...32)
-     )]
-  )
-)
+@ ProgramNode (location: (0...32))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...32))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...32))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...28))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (11...18))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 1)
+            │       │   │   └── @ AssocNode (location: (11...18))
+            │       │   │       ├── key:
+            │       │   │       │   @ SymbolNode (location: (11...13))
+            │       │   │       │   ├── opening_loc: ∅
+            │       │   │       │   ├── value_loc: (11...12) = "b"
+            │       │   │       │   ├── closing_loc: (12...13) = ":"
+            │       │   │       │   └── unescaped: "b"
+            │       │   │       ├── value:
+            │       │   │       │   @ TrueNode (location: (14...18))
+            │       │   │       └── operator_loc: ∅
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: ∅
+            │       │   └── closing_loc: ∅
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (26...28))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (26...28))
+            │       │           ├── opening_loc: (26...27) = ":"
+            │       │           ├── value_loc: (27...28) = "c"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "c"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: (19...23) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (29...32) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_hash_pat_rest.txt b/test/yarp/snapshots/seattlerb/case_in_hash_pat_rest.txt
index 9998de3cfe..ae83bb4be8 100644
--- a/test/yarp/snapshots/seattlerb/case_in_hash_pat_rest.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_hash_pat_rest.txt
@@ -1,33 +1,52 @@
-ProgramNode(0...35)(
-  [:c, :rest],
-  StatementsNode(0...35)(
-    [CaseNode(0...35)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...31)(
-          HashPatternNode(11...23)(
-            nil,
-            [AssocNode(11...15)(
-               SymbolNode(11...13)(nil, (11...12), (12...13), "b"),
-               LocalVariableTargetNode(14...15)(:c, 0),
-               nil
-             ),
-             AssocSplatNode(17...23)(
-               LocalVariableTargetNode(19...23)(:rest, 0),
-               (17...19)
-             )],
-            nil,
-            nil,
-            nil
-          ),
-          StatementsNode(29...31)(
-            [SymbolNode(29...31)((29...30), (30...31), nil, "d")]
-          ),
-          (8...10),
-          (24...28)
-        )],
-       nil,
-       (0...4),
-       (32...35)
-     )]
-  )
-)
+@ ProgramNode (location: (0...35))
+├── locals: [:c, :rest]
+└── statements:
+    @ StatementsNode (location: (0...35))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...35))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...31))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (11...23))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 2)
+            │       │   │   ├── @ AssocNode (location: (11...15))
+            │       │   │   │   ├── key:
+            │       │   │   │   │   @ SymbolNode (location: (11...13))
+            │       │   │   │   │   ├── opening_loc: ∅
+            │       │   │   │   │   ├── value_loc: (11...12) = "b"
+            │       │   │   │   │   ├── closing_loc: (12...13) = ":"
+            │       │   │   │   │   └── unescaped: "b"
+            │       │   │   │   ├── value:
+            │       │   │   │   │   @ LocalVariableTargetNode (location: (14...15))
+            │       │   │   │   │   ├── name: :c
+            │       │   │   │   │   └── depth: 0
+            │       │   │   │   └── operator_loc: ∅
+            │       │   │   └── @ AssocSplatNode (location: (17...23))
+            │       │   │       ├── value:
+            │       │   │       │   @ LocalVariableTargetNode (location: (19...23))
+            │       │   │       │   ├── name: :rest
+            │       │   │       │   └── depth: 0
+            │       │   │       └── operator_loc: (17...19) = "**"
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: ∅
+            │       │   └── closing_loc: ∅
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (29...31))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (29...31))
+            │       │           ├── opening_loc: (29...30) = ":"
+            │       │           ├── value_loc: (30...31) = "d"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "d"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: (24...28) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (32...35) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt b/test/yarp/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt
index 7d6634c7f8..bdb727dad3 100644
--- a/test/yarp/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt
@@ -1,28 +1,40 @@
-ProgramNode(0...29)(
-  [:rest],
-  StatementsNode(0...29)(
-    [CaseNode(0...29)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...25)(
-          HashPatternNode(11...17)(
-            nil,
-            [AssocSplatNode(11...17)(
-               LocalVariableTargetNode(13...17)(:rest, 0),
-               (11...13)
-             )],
-            nil,
-            nil,
-            nil
-          ),
-          StatementsNode(23...25)(
-            [SymbolNode(23...25)((23...24), (24...25), nil, "d")]
-          ),
-          (8...10),
-          (18...22)
-        )],
-       nil,
-       (0...4),
-       (26...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: [:rest]
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...29))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...25))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (11...17))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 1)
+            │       │   │   └── @ AssocSplatNode (location: (11...17))
+            │       │   │       ├── value:
+            │       │   │       │   @ LocalVariableTargetNode (location: (13...17))
+            │       │   │       │   ├── name: :rest
+            │       │   │       │   └── depth: 0
+            │       │   │       └── operator_loc: (11...13) = "**"
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: ∅
+            │       │   └── closing_loc: ∅
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (23...25))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (23...25))
+            │       │           ├── opening_loc: (23...24) = ":"
+            │       │           ├── value_loc: (24...25) = "d"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "d"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: (18...22) = "then"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (26...29) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_if_unless_post_mod.txt b/test/yarp/snapshots/seattlerb/case_in_if_unless_post_mod.txt
index d4869db8ed..2acc2bcdf4 100644
--- a/test/yarp/snapshots/seattlerb/case_in_if_unless_post_mod.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_if_unless_post_mod.txt
@@ -1,39 +1,62 @@
-ProgramNode(0...52)(
-  [],
-  StatementsNode(0...52)(
-    [CaseNode(0...52)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...25)(
-          IfNode(11...20)(
-            (13...15),
-            TrueNode(16...20)(),
-            StatementsNode(11...12)([ConstantReadNode(11...12)(:A)]),
-            nil,
-            nil
-          ),
-          StatementsNode(23...25)(
-            [SymbolNode(23...25)((23...24), (24...25), nil, "C")]
-          ),
-          (8...10),
-          nil
-        ),
-        InNode(26...48)(
-          UnlessNode(29...43)(
-            (31...37),
-            FalseNode(38...43)(),
-            StatementsNode(29...30)([ConstantReadNode(29...30)(:D)]),
-            nil,
-            nil
-          ),
-          StatementsNode(46...48)(
-            [SymbolNode(46...48)((46...47), (47...48), nil, "E")]
-          ),
-          (26...28),
-          nil
-        )],
-       nil,
-       (0...4),
-       (49...52)
-     )]
-  )
-)
+@ ProgramNode (location: (0...52))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...52))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...52))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 2)
+            │   ├── @ InNode (location: (8...25))
+            │   │   ├── pattern:
+            │   │   │   @ IfNode (location: (11...20))
+            │   │   │   ├── if_keyword_loc: (13...15) = "if"
+            │   │   │   ├── predicate:
+            │   │   │   │   @ TrueNode (location: (16...20))
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (11...12))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ ConstantReadNode (location: (11...12))
+            │   │   │   │           └── name: :A
+            │   │   │   ├── consequent: ∅
+            │   │   │   └── end_keyword_loc: ∅
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (23...25))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ SymbolNode (location: (23...25))
+            │   │   │           ├── opening_loc: (23...24) = ":"
+            │   │   │           ├── value_loc: (24...25) = "C"
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           └── unescaped: "C"
+            │   │   ├── in_loc: (8...10) = "in"
+            │   │   └── then_loc: ∅
+            │   └── @ InNode (location: (26...48))
+            │       ├── pattern:
+            │       │   @ UnlessNode (location: (29...43))
+            │       │   ├── keyword_loc: (31...37) = "unless"
+            │       │   ├── predicate:
+            │       │   │   @ FalseNode (location: (38...43))
+            │       │   ├── statements:
+            │       │   │   @ StatementsNode (location: (29...30))
+            │       │   │   └── body: (length: 1)
+            │       │   │       └── @ ConstantReadNode (location: (29...30))
+            │       │   │           └── name: :D
+            │       │   ├── consequent: ∅
+            │       │   └── end_keyword_loc: ∅
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (46...48))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (46...48))
+            │       │           ├── opening_loc: (46...47) = ":"
+            │       │           ├── value_loc: (47...48) = "E"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "E"
+            │       ├── in_loc: (26...28) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (49...52) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_multiple.txt b/test/yarp/snapshots/seattlerb/case_in_multiple.txt
index 2210570cb9..06dbf3b213 100644
--- a/test/yarp/snapshots/seattlerb/case_in_multiple.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_multiple.txt
@@ -1,35 +1,56 @@
-ProgramNode(0...37)(
-  [],
-  StatementsNode(0...37)(
-    [CaseNode(0...37)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...20)(
-          ConstantPathNode(11...15)(
-            ConstantReadNode(11...12)(:A),
-            ConstantReadNode(14...15)(:B),
-            (12...14)
-          ),
-          StatementsNode(18...20)(
-            [SymbolNode(18...20)((18...19), (19...20), nil, "C")]
-          ),
-          (8...10),
-          nil
-        ),
-        InNode(21...33)(
-          ConstantPathNode(24...28)(
-            ConstantReadNode(24...25)(:D),
-            ConstantReadNode(27...28)(:E),
-            (25...27)
-          ),
-          StatementsNode(31...33)(
-            [SymbolNode(31...33)((31...32), (32...33), nil, "F")]
-          ),
-          (21...23),
-          nil
-        )],
-       nil,
-       (0...4),
-       (34...37)
-     )]
-  )
-)
+@ ProgramNode (location: (0...37))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...37))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...37))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 2)
+            │   ├── @ InNode (location: (8...20))
+            │   │   ├── pattern:
+            │   │   │   @ ConstantPathNode (location: (11...15))
+            │   │   │   ├── parent:
+            │   │   │   │   @ ConstantReadNode (location: (11...12))
+            │   │   │   │   └── name: :A
+            │   │   │   ├── child:
+            │   │   │   │   @ ConstantReadNode (location: (14...15))
+            │   │   │   │   └── name: :B
+            │   │   │   └── delimiter_loc: (12...14) = "::"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (18...20))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ SymbolNode (location: (18...20))
+            │   │   │           ├── opening_loc: (18...19) = ":"
+            │   │   │           ├── value_loc: (19...20) = "C"
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           └── unescaped: "C"
+            │   │   ├── in_loc: (8...10) = "in"
+            │   │   └── then_loc: ∅
+            │   └── @ InNode (location: (21...33))
+            │       ├── pattern:
+            │       │   @ ConstantPathNode (location: (24...28))
+            │       │   ├── parent:
+            │       │   │   @ ConstantReadNode (location: (24...25))
+            │       │   │   └── name: :D
+            │       │   ├── child:
+            │       │   │   @ ConstantReadNode (location: (27...28))
+            │       │   │   └── name: :E
+            │       │   └── delimiter_loc: (25...27) = "::"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (31...33))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (31...33))
+            │       │           ├── opening_loc: (31...32) = ":"
+            │       │           ├── value_loc: (32...33) = "F"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "F"
+            │       ├── in_loc: (21...23) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (34...37) = "end"
diff --git a/test/yarp/snapshots/seattlerb/case_in_or.txt b/test/yarp/snapshots/seattlerb/case_in_or.txt
index 2a5ec39441..20993f40aa 100644
--- a/test/yarp/snapshots/seattlerb/case_in_or.txt
+++ b/test/yarp/snapshots/seattlerb/case_in_or.txt
@@ -1,23 +1,36 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [CaseNode(0...25)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...21)(
-          AlternationPatternNode(11...16)(
-            ConstantReadNode(11...12)(:B),
-            ConstantReadNode(15...16)(:C),
-            (13...14)
-          ),
-          StatementsNode(19...21)(
-            [SymbolNode(19...21)((19...20), (20...21), nil, "d")]
-          ),
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (22...25)
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...25))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...21))
+            │       ├── pattern:
+            │       │   @ AlternationPatternNode (location: (11...16))
+            │       │   ├── left:
+            │       │   │   @ ConstantReadNode (location: (11...12))
+            │       │   │   └── name: :B
+            │       │   ├── right:
+            │       │   │   @ ConstantReadNode (location: (15...16))
+            │       │   │   └── name: :C
+            │       │   └── operator_loc: (13...14) = "|"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (19...21))
+            │       │   └── body: (length: 1)
+            │       │       └── @ SymbolNode (location: (19...21))
+            │       │           ├── opening_loc: (19...20) = ":"
+            │       │           ├── value_loc: (20...21) = "d"
+            │       │           ├── closing_loc: ∅
+            │       │           └── unescaped: "d"
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (22...25) = "end"
diff --git a/test/yarp/snapshots/seattlerb/class_comments.txt b/test/yarp/snapshots/seattlerb/class_comments.txt
index 5314c70cc4..5eb521e1f2 100644
--- a/test/yarp/snapshots/seattlerb/class_comments.txt
+++ b/test/yarp/snapshots/seattlerb/class_comments.txt
@@ -1,30 +1,31 @@
-ProgramNode(19...71)(
-  [],
-  StatementsNode(19...71)(
-    [ClassNode(19...71)(
-       [],
-       (19...24),
-       ConstantReadNode(25...26)(:X),
-       nil,
-       nil,
-       StatementsNode(40...67)(
-         [DefNode(40...67)(
-            :blah,
-            (44...48),
-            nil,
-            nil,
-            nil,
-            [],
-            (40...43),
-            nil,
-            nil,
-            nil,
-            nil,
-            (64...67)
-          )]
-       ),
-       (68...71),
-       :X
-     )]
-  )
-)
+@ ProgramNode (location: (19...71))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (19...71))
+    └── body: (length: 1)
+        └── @ ClassNode (location: (19...71))
+            ├── locals: []
+            ├── class_keyword_loc: (19...24) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (25...26))
+            │   └── name: :X
+            ├── inheritance_operator_loc: ∅
+            ├── superclass: ∅
+            ├── body:
+            │   @ StatementsNode (location: (40...67))
+            │   └── body: (length: 1)
+            │       └── @ DefNode (location: (40...67))
+            │           ├── name: :blah
+            │           ├── name_loc: (44...48) = "blah"
+            │           ├── receiver: ∅
+            │           ├── parameters: ∅
+            │           ├── body: ∅
+            │           ├── locals: []
+            │           ├── def_keyword_loc: (40...43) = "def"
+            │           ├── operator_loc: ∅
+            │           ├── lparen_loc: ∅
+            │           ├── rparen_loc: ∅
+            │           ├── equal_loc: ∅
+            │           └── end_keyword_loc: (64...67) = "end"
+            ├── end_keyword_loc: (68...71) = "end"
+            └── name: :X
diff --git a/test/yarp/snapshots/seattlerb/cond_unary_minus.txt b/test/yarp/snapshots/seattlerb/cond_unary_minus.txt
index d445306674..1f289e96f3 100644
--- a/test/yarp/snapshots/seattlerb/cond_unary_minus.txt
+++ b/test/yarp/snapshots/seattlerb/cond_unary_minus.txt
@@ -1,6 +1,12 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [IfNode(0...10)((0...2), IntegerNode(3...5)(), nil, nil, (7...10))]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...10))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ IntegerNode (location: (3...5))
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (7...10) = "end"
diff --git a/test/yarp/snapshots/seattlerb/const_2_op_asgn_or2.txt b/test/yarp/snapshots/seattlerb/const_2_op_asgn_or2.txt
index ea0d0bc196..fb201a5737 100644
--- a/test/yarp/snapshots/seattlerb/const_2_op_asgn_or2.txt
+++ b/test/yarp/snapshots/seattlerb/const_2_op_asgn_or2.txt
@@ -1,14 +1,22 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [ConstantPathOrWriteNode(0...12)(
-       ConstantPathNode(0...6)(
-         ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(:X), (0...2)),
-         ConstantReadNode(5...6)(:Y),
-         (3...5)
-       ),
-       (7...10),
-       IntegerNode(11...12)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ ConstantPathOrWriteNode (location: (0...12))
+            ├── target:
+            │   @ ConstantPathNode (location: (0...6))
+            │   ├── parent:
+            │   │   @ ConstantPathNode (location: (0...3))
+            │   │   ├── parent: ∅
+            │   │   ├── child:
+            │   │   │   @ ConstantReadNode (location: (2...3))
+            │   │   │   └── name: :X
+            │   │   └── delimiter_loc: (0...2) = "::"
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (5...6))
+            │   │   └── name: :Y
+            │   └── delimiter_loc: (3...5) = "::"
+            ├── operator_loc: (7...10) = "||="
+            └── value:
+                @ IntegerNode (location: (11...12))
diff --git a/test/yarp/snapshots/seattlerb/const_3_op_asgn_or.txt b/test/yarp/snapshots/seattlerb/const_3_op_asgn_or.txt
index 99bbb930cf..61a67ae950 100644
--- a/test/yarp/snapshots/seattlerb/const_3_op_asgn_or.txt
+++ b/test/yarp/snapshots/seattlerb/const_3_op_asgn_or.txt
@@ -1,10 +1,16 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [ConstantPathOrWriteNode(0...9)(
-       ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(:X), (0...2)),
-       (4...7),
-       IntegerNode(8...9)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ ConstantPathOrWriteNode (location: (0...9))
+            ├── target:
+            │   @ ConstantPathNode (location: (0...3))
+            │   ├── parent: ∅
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (2...3))
+            │   │   └── name: :X
+            │   └── delimiter_loc: (0...2) = "::"
+            ├── operator_loc: (4...7) = "||="
+            └── value:
+                @ IntegerNode (location: (8...9))
diff --git a/test/yarp/snapshots/seattlerb/const_op_asgn_and1.txt b/test/yarp/snapshots/seattlerb/const_op_asgn_and1.txt
index 53fed283e1..4254f4bd21 100644
--- a/test/yarp/snapshots/seattlerb/const_op_asgn_and1.txt
+++ b/test/yarp/snapshots/seattlerb/const_op_asgn_and1.txt
@@ -1,11 +1,17 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [ConstantPathOperatorWriteNode(0...8)(
-       ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(:X), (0...2)),
-       (4...6),
-       IntegerNode(7...8)(),
-       :&
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ ConstantPathOperatorWriteNode (location: (0...8))
+            ├── target:
+            │   @ ConstantPathNode (location: (0...3))
+            │   ├── parent: ∅
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (2...3))
+            │   │   └── name: :X
+            │   └── delimiter_loc: (0...2) = "::"
+            ├── operator_loc: (4...6) = "&="
+            ├── value:
+            │   @ IntegerNode (location: (7...8))
+            └── operator: :&
diff --git a/test/yarp/snapshots/seattlerb/const_op_asgn_and2.txt b/test/yarp/snapshots/seattlerb/const_op_asgn_and2.txt
index cd13c1f5a7..1fd0829df1 100644
--- a/test/yarp/snapshots/seattlerb/const_op_asgn_and2.txt
+++ b/test/yarp/snapshots/seattlerb/const_op_asgn_and2.txt
@@ -1,10 +1,16 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [ConstantPathAndWriteNode(0...9)(
-       ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(:X), (0...2)),
-       (4...7),
-       IntegerNode(8...9)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ ConstantPathAndWriteNode (location: (0...9))
+            ├── target:
+            │   @ ConstantPathNode (location: (0...3))
+            │   ├── parent: ∅
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (2...3))
+            │   │   └── name: :X
+            │   └── delimiter_loc: (0...2) = "::"
+            ├── operator_loc: (4...7) = "&&="
+            └── value:
+                @ IntegerNode (location: (8...9))
diff --git a/test/yarp/snapshots/seattlerb/const_op_asgn_or.txt b/test/yarp/snapshots/seattlerb/const_op_asgn_or.txt
index 1b8fdf986e..e39682b3ea 100644
--- a/test/yarp/snapshots/seattlerb/const_op_asgn_or.txt
+++ b/test/yarp/snapshots/seattlerb/const_op_asgn_or.txt
@@ -1,14 +1,18 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [ConstantPathOrWriteNode(0...10)(
-       ConstantPathNode(0...4)(
-         ConstantReadNode(0...1)(:X),
-         ConstantReadNode(3...4)(:Y),
-         (1...3)
-       ),
-       (5...8),
-       IntegerNode(9...10)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ ConstantPathOrWriteNode (location: (0...10))
+            ├── target:
+            │   @ ConstantPathNode (location: (0...4))
+            │   ├── parent:
+            │   │   @ ConstantReadNode (location: (0...1))
+            │   │   └── name: :X
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (3...4))
+            │   │   └── name: :Y
+            │   └── delimiter_loc: (1...3) = "::"
+            ├── operator_loc: (5...8) = "||="
+            └── value:
+                @ IntegerNode (location: (9...10))
diff --git a/test/yarp/snapshots/seattlerb/dasgn_icky2.txt b/test/yarp/snapshots/seattlerb/dasgn_icky2.txt
index d37ac900b2..33a8beaad1 100644
--- a/test/yarp/snapshots/seattlerb/dasgn_icky2.txt
+++ b/test/yarp/snapshots/seattlerb/dasgn_icky2.txt
@@ -1,47 +1,61 @@
-ProgramNode(0...76)(
-  [],
-  StatementsNode(0...76)(
-    [CallNode(0...76)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...76)(
-         [:v],
-         nil,
-         StatementsNode(7...72)(
-           [LocalVariableWriteNode(7...14)(
-              :v,
-              0,
-              (7...8),
-              NilNode(11...14)(),
-              (9...10)
-            ),
-            BeginNode(17...72)(
-              (17...22),
-              StatementsNode(27...32)(
-                [YieldNode(27...32)((27...32), nil, nil, nil)]
-              ),
-              RescueNode(35...66)(
-                (35...41),
-                [ConstantReadNode(42...51)(:Exception)],
-                (52...54),
-                LocalVariableTargetNode(55...56)(:v, 0),
-                StatementsNode(61...66)([BreakNode(61...66)(nil, (61...66))]),
-                nil
-              ),
-              nil,
-              nil,
-              (69...72)
-            )]
-         ),
-         (2...4),
-         (73...76)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...76))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...76))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...76))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...76))
+            │   ├── locals: [:v]
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (7...72))
+            │   │   └── body: (length: 2)
+            │   │       ├── @ LocalVariableWriteNode (location: (7...14))
+            │   │       │   ├── name: :v
+            │   │       │   ├── depth: 0
+            │   │       │   ├── name_loc: (7...8) = "v"
+            │   │       │   ├── value:
+            │   │       │   │   @ NilNode (location: (11...14))
+            │   │       │   └── operator_loc: (9...10) = "="
+            │   │       └── @ BeginNode (location: (17...72))
+            │   │           ├── begin_keyword_loc: (17...22) = "begin"
+            │   │           ├── statements:
+            │   │           │   @ StatementsNode (location: (27...32))
+            │   │           │   └── body: (length: 1)
+            │   │           │       └── @ YieldNode (location: (27...32))
+            │   │           │           ├── keyword_loc: (27...32) = "yield"
+            │   │           │           ├── lparen_loc: ∅
+            │   │           │           ├── arguments: ∅
+            │   │           │           └── rparen_loc: ∅
+            │   │           ├── rescue_clause:
+            │   │           │   @ RescueNode (location: (35...66))
+            │   │           │   ├── keyword_loc: (35...41) = "rescue"
+            │   │           │   ├── exceptions: (length: 1)
+            │   │           │   │   └── @ ConstantReadNode (location: (42...51))
+            │   │           │   │       └── name: :Exception
+            │   │           │   ├── operator_loc: (52...54) = "=>"
+            │   │           │   ├── reference:
+            │   │           │   │   @ LocalVariableTargetNode (location: (55...56))
+            │   │           │   │   ├── name: :v
+            │   │           │   │   └── depth: 0
+            │   │           │   ├── statements:
+            │   │           │   │   @ StatementsNode (location: (61...66))
+            │   │           │   │   └── body: (length: 1)
+            │   │           │   │       └── @ BreakNode (location: (61...66))
+            │   │           │   │           ├── arguments: ∅
+            │   │           │   │           └── keyword_loc: (61...66) = "break"
+            │   │           │   └── consequent: ∅
+            │   │           ├── else_clause: ∅
+            │   │           ├── ensure_clause: ∅
+            │   │           └── end_keyword_loc: (69...72) = "end"
+            │   ├── opening_loc: (2...4) = "do"
+            │   └── closing_loc: (73...76) = "end"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/defined_eh_parens.txt b/test/yarp/snapshots/seattlerb/defined_eh_parens.txt
index 5aedca1fbb..87ca88d5e8 100644
--- a/test/yarp/snapshots/seattlerb/defined_eh_parens.txt
+++ b/test/yarp/snapshots/seattlerb/defined_eh_parens.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [DefinedNode(0...12)((8...9), IntegerNode(9...11)(), (11...12), (0...8))]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ DefinedNode (location: (0...12))
+            ├── lparen_loc: (8...9) = "("
+            ├── value:
+            │   @ IntegerNode (location: (9...11))
+            ├── rparen_loc: (11...12) = ")"
+            └── keyword_loc: (0...8) = "defined?"
diff --git a/test/yarp/snapshots/seattlerb/defn_arg_asplat_arg.txt b/test/yarp/snapshots/seattlerb/defn_arg_asplat_arg.txt
index 207e45aab9..5961b86ed4 100644
--- a/test/yarp/snapshots/seattlerb/defn_arg_asplat_arg.txt
+++ b/test/yarp/snapshots/seattlerb/defn_arg_asplat_arg.txt
@@ -1,27 +1,34 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [DefNode(0...29)(
-       :call,
-       (4...8),
-       nil,
-       ParametersNode(9...24)(
-         [RequiredParameterNode(9...15)(:interp)],
-         [],
-         [RequiredParameterNode(20...24)(:args)],
-         RestParameterNode(17...18)(nil, nil, (17...18)),
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:interp, :*, :args],
-       (0...3),
-       nil,
-       (8...9),
-       (24...25),
-       nil,
-       (26...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...29))
+            ├── name: :call
+            ├── name_loc: (4...8) = "call"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (9...24))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (9...15))
+            │   │       └── name: :interp
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (20...24))
+            │   │       └── name: :args
+            │   ├── rest:
+            │   │   @ RestParameterNode (location: (17...18))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (17...18) = "*"
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:interp, :*, :args]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (8...9) = "("
+            ├── rparen_loc: (24...25) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (26...29) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_arg_forward_args.txt b/test/yarp/snapshots/seattlerb/defn_arg_forward_args.txt
index 908be09337..1c79d23d62 100644
--- a/test/yarp/snapshots/seattlerb/defn_arg_forward_args.txt
+++ b/test/yarp/snapshots/seattlerb/defn_arg_forward_args.txt
@@ -1,42 +1,47 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [DefNode(0...29)(
-       :a,
-       (4...5),
-       nil,
-       ParametersNode(6...12)(
-         [RequiredParameterNode(6...7)(:x)],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(9...12)(),
-         nil
-       ),
-       StatementsNode(15...24)(
-         [CallNode(15...24)(
-            nil,
-            nil,
-            (15...16),
-            (16...17),
-            ArgumentsNode(17...23)(
-              [LocalVariableReadNode(17...18)(:x, 0),
-               ForwardingArgumentsNode(20...23)()]
-            ),
-            (23...24),
-            nil,
-            0,
-            "b"
-          )]
-       ),
-       [:x, :"..."],
-       (0...3),
-       nil,
-       (5...6),
-       (12...13),
-       nil,
-       (26...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...29))
+            ├── name: :a
+            ├── name_loc: (4...5) = "a"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...12))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (6...7))
+            │   │       └── name: :x
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ ForwardingParameterNode (location: (9...12))
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (15...24))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (15...24))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (15...16) = "b"
+            │           ├── opening_loc: (16...17) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (17...23))
+            │           │   └── arguments: (length: 2)
+            │           │       ├── @ LocalVariableReadNode (location: (17...18))
+            │           │       │   ├── name: :x
+            │           │       │   └── depth: 0
+            │           │       └── @ ForwardingArgumentsNode (location: (20...23))
+            │           ├── closing_loc: (23...24) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "b"
+            ├── locals: [:x, :"..."]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (12...13) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (26...29) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_args_forward_args.txt b/test/yarp/snapshots/seattlerb/defn_args_forward_args.txt
index bdb721f2d2..e07ef6434c 100644
--- a/test/yarp/snapshots/seattlerb/defn_args_forward_args.txt
+++ b/test/yarp/snapshots/seattlerb/defn_args_forward_args.txt
@@ -1,45 +1,56 @@
-ProgramNode(0...41)(
-  [],
-  StatementsNode(0...41)(
-    [DefNode(0...41)(
-       :a,
-       (4...5),
-       nil,
-       ParametersNode(6...18)(
-         [RequiredParameterNode(6...7)(:x),
-          RequiredParameterNode(9...10)(:y),
-          RequiredParameterNode(12...13)(:z)],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(15...18)(),
-         nil
-       ),
-       StatementsNode(21...36)(
-         [CallNode(21...36)(
-            nil,
-            nil,
-            (21...22),
-            (22...23),
-            ArgumentsNode(23...35)(
-              [SymbolNode(23...27)((23...24), (24...27), nil, "get"),
-               LocalVariableReadNode(29...30)(:z, 0),
-               ForwardingArgumentsNode(32...35)()]
-            ),
-            (35...36),
-            nil,
-            0,
-            "b"
-          )]
-       ),
-       [:x, :y, :z, :"..."],
-       (0...3),
-       nil,
-       (5...6),
-       (18...19),
-       nil,
-       (38...41)
-     )]
-  )
-)
+@ ProgramNode (location: (0...41))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...41))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...41))
+            ├── name: :a
+            ├── name_loc: (4...5) = "a"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...18))
+            │   ├── requireds: (length: 3)
+            │   │   ├── @ RequiredParameterNode (location: (6...7))
+            │   │   │   └── name: :x
+            │   │   ├── @ RequiredParameterNode (location: (9...10))
+            │   │   │   └── name: :y
+            │   │   └── @ RequiredParameterNode (location: (12...13))
+            │   │       └── name: :z
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ ForwardingParameterNode (location: (15...18))
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (21...36))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (21...36))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (21...22) = "b"
+            │           ├── opening_loc: (22...23) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (23...35))
+            │           │   └── arguments: (length: 3)
+            │           │       ├── @ SymbolNode (location: (23...27))
+            │           │       │   ├── opening_loc: (23...24) = ":"
+            │           │       │   ├── value_loc: (24...27) = "get"
+            │           │       │   ├── closing_loc: ∅
+            │           │       │   └── unescaped: "get"
+            │           │       ├── @ LocalVariableReadNode (location: (29...30))
+            │           │       │   ├── name: :z
+            │           │       │   └── depth: 0
+            │           │       └── @ ForwardingArgumentsNode (location: (32...35))
+            │           ├── closing_loc: (35...36) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "b"
+            ├── locals: [:x, :y, :z, :"..."]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (18...19) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (38...41) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_comments.txt b/test/yarp/snapshots/seattlerb/defn_comments.txt
index a9b5501204..9ce9116597 100644
--- a/test/yarp/snapshots/seattlerb/defn_comments.txt
+++ b/test/yarp/snapshots/seattlerb/defn_comments.txt
@@ -1,19 +1,18 @@
-ProgramNode(19...31)(
-  [],
-  StatementsNode(19...31)(
-    [DefNode(19...31)(
-       :blah,
-       (23...27),
-       nil,
-       nil,
-       nil,
-       [],
-       (19...22),
-       nil,
-       nil,
-       nil,
-       nil,
-       (28...31)
-     )]
-  )
-)
+@ ProgramNode (location: (19...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (19...31))
+    └── body: (length: 1)
+        └── @ DefNode (location: (19...31))
+            ├── name: :blah
+            ├── name_loc: (23...27) = "blah"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (19...22) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (28...31) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_endless_command.txt b/test/yarp/snapshots/seattlerb/defn_endless_command.txt
index 4e88338080..6a1d54a67a 100644
--- a/test/yarp/snapshots/seattlerb/defn_endless_command.txt
+++ b/test/yarp/snapshots/seattlerb/defn_endless_command.txt
@@ -1,31 +1,33 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [DefNode(0...33)(
-       :some_method,
-       (4...15),
-       nil,
-       nil,
-       StatementsNode(18...33)(
-         [CallNode(18...33)(
-            nil,
-            nil,
-            (18...30),
-            nil,
-            ArgumentsNode(31...33)([IntegerNode(31...33)()]),
-            nil,
-            nil,
-            0,
-            "other_method"
-          )]
-       ),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       (16...17),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...33))
+            ├── name: :some_method
+            ├── name_loc: (4...15) = "some_method"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (18...33))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (18...33))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (18...30) = "other_method"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (31...33))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ IntegerNode (location: (31...33))
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "other_method"
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: (16...17) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/defn_endless_command_rescue.txt b/test/yarp/snapshots/seattlerb/defn_endless_command_rescue.txt
index 30e99d44fe..e287f417c0 100644
--- a/test/yarp/snapshots/seattlerb/defn_endless_command_rescue.txt
+++ b/test/yarp/snapshots/seattlerb/defn_endless_command_rescue.txt
@@ -1,37 +1,38 @@
-ProgramNode(0...43)(
-  [],
-  StatementsNode(0...43)(
-    [DefNode(0...43)(
-       :some_method,
-       (4...15),
-       nil,
-       nil,
-       StatementsNode(18...43)(
-         [CallNode(18...43)(
-            nil,
-            nil,
-            (18...30),
-            nil,
-            ArgumentsNode(31...43)(
-              [RescueModifierNode(31...43)(
-                 IntegerNode(31...33)(),
-                 (34...40),
-                 IntegerNode(41...43)()
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "other_method"
-          )]
-       ),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       (16...17),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...43))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...43))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...43))
+            ├── name: :some_method
+            ├── name_loc: (4...15) = "some_method"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (18...43))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (18...43))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (18...30) = "other_method"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (31...43))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ RescueModifierNode (location: (31...43))
+            │           │           ├── expression:
+            │           │           │   @ IntegerNode (location: (31...33))
+            │           │           ├── keyword_loc: (34...40) = "rescue"
+            │           │           └── rescue_expression:
+            │           │               @ IntegerNode (location: (41...43))
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "other_method"
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: (16...17) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/defn_forward_args.txt b/test/yarp/snapshots/seattlerb/defn_forward_args.txt
index 6b06726352..62e0019de7 100644
--- a/test/yarp/snapshots/seattlerb/defn_forward_args.txt
+++ b/test/yarp/snapshots/seattlerb/defn_forward_args.txt
@@ -1,39 +1,42 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [DefNode(0...23)(
-       :a,
-       (4...5),
-       nil,
-       ParametersNode(6...9)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(6...9)(),
-         nil
-       ),
-       StatementsNode(12...18)(
-         [CallNode(12...18)(
-            nil,
-            nil,
-            (12...13),
-            (13...14),
-            ArgumentsNode(14...17)([ForwardingArgumentsNode(14...17)()]),
-            (17...18),
-            nil,
-            0,
-            "b"
-          )]
-       ),
-       [:"..."],
-       (0...3),
-       nil,
-       (5...6),
-       (9...10),
-       nil,
-       (20...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...23))
+            ├── name: :a
+            ├── name_loc: (4...5) = "a"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...9))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ ForwardingParameterNode (location: (6...9))
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (12...18))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (12...18))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (12...13) = "b"
+            │           ├── opening_loc: (13...14) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (14...17))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ ForwardingArgumentsNode (location: (14...17))
+            │           ├── closing_loc: (17...18) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "b"
+            ├── locals: [:"..."]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (9...10) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (20...23) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_forward_args__no_parens.txt b/test/yarp/snapshots/seattlerb/defn_forward_args__no_parens.txt
index b0a199c7bd..09d7a2434b 100644
--- a/test/yarp/snapshots/seattlerb/defn_forward_args__no_parens.txt
+++ b/test/yarp/snapshots/seattlerb/defn_forward_args__no_parens.txt
@@ -1,39 +1,42 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [DefNode(0...22)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...9)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(6...9)(),
-         nil
-       ),
-       StatementsNode(12...18)(
-         [CallNode(12...18)(
-            nil,
-            nil,
-            (12...13),
-            (13...14),
-            ArgumentsNode(14...17)([ForwardingArgumentsNode(14...17)()]),
-            (17...18),
-            nil,
-            0,
-            "m"
-          )]
-       ),
-       [:"..."],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (19...22)
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...22))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...9))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ ForwardingParameterNode (location: (6...9))
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (12...18))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (12...18))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (12...13) = "m"
+            │           ├── opening_loc: (13...14) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (14...17))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ ForwardingArgumentsNode (location: (14...17))
+            │           ├── closing_loc: (17...18) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "m"
+            ├── locals: [:"..."]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (19...22) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_kwarg_env.txt b/test/yarp/snapshots/seattlerb/defn_kwarg_env.txt
index ec45e1790b..3def0b466a 100644
--- a/test/yarp/snapshots/seattlerb/defn_kwarg_env.txt
+++ b/test/yarp/snapshots/seattlerb/defn_kwarg_env.txt
@@ -1,46 +1,52 @@
-ProgramNode(0...45)(
-  [],
-  StatementsNode(0...45)(
-    [DefNode(0...45)(
-       :test,
-       (4...8),
-       nil,
-       ParametersNode(9...18)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(9...18)(:testing, (11...18), (9...11)),
-         nil
-       ),
-       StatementsNode(20...41)(
-         [CallNode(20...41)(
-            nil,
-            nil,
-            (20...30),
-            (30...31),
-            ArgumentsNode(31...40)(
-              [KeywordHashNode(31...40)(
-                 [AssocSplatNode(31...40)(
-                    LocalVariableReadNode(33...40)(:testing, 0),
-                    (31...33)
-                  )]
-               )]
-            ),
-            (40...41),
-            nil,
-            0,
-            "test_splat"
-          )]
-       ),
-       [:testing],
-       (0...3),
-       nil,
-       (8...9),
-       (18...19),
-       nil,
-       (42...45)
-     )]
-  )
-)
+@ ProgramNode (location: (0...45))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...45))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...45))
+            ├── name: :test
+            ├── name_loc: (4...8) = "test"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (9...18))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (9...18))
+            │   │   ├── name: :testing
+            │   │   ├── name_loc: (11...18) = "testing"
+            │   │   └── operator_loc: (9...11) = "**"
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (20...41))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (20...41))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (20...30) = "test_splat"
+            │           ├── opening_loc: (30...31) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (31...40))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ KeywordHashNode (location: (31...40))
+            │           │           └── elements: (length: 1)
+            │           │               └── @ AssocSplatNode (location: (31...40))
+            │           │                   ├── value:
+            │           │                   │   @ LocalVariableReadNode (location: (33...40))
+            │           │                   │   ├── name: :testing
+            │           │                   │   └── depth: 0
+            │           │                   └── operator_loc: (31...33) = "**"
+            │           ├── closing_loc: (40...41) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "test_splat"
+            ├── locals: [:testing]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (8...9) = "("
+            ├── rparen_loc: (18...19) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (42...45) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_kwarg_kwarg.txt b/test/yarp/snapshots/seattlerb/defn_kwarg_kwarg.txt
index aa90849328..5ca38fd860 100644
--- a/test/yarp/snapshots/seattlerb/defn_kwarg_kwarg.txt
+++ b/test/yarp/snapshots/seattlerb/defn_kwarg_kwarg.txt
@@ -1,32 +1,38 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [DefNode(0...24)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...19)(
-         [RequiredParameterNode(6...7)(:a)],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(9...13)(:b, (9...11), IntegerNode(12...13)()),
-          KeywordParameterNode(15...19)(
-            :c,
-            (15...17),
-            IntegerNode(18...19)()
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :b, :c],
-       (0...3),
-       nil,
-       (5...6),
-       (19...20),
-       nil,
-       (21...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...24))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...19))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (6...7))
+            │   │       └── name: :a
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 2)
+            │   │   ├── @ KeywordParameterNode (location: (9...13))
+            │   │   │   ├── name: :b
+            │   │   │   ├── name_loc: (9...11) = "b:"
+            │   │   │   └── value:
+            │   │   │       @ IntegerNode (location: (12...13))
+            │   │   └── @ KeywordParameterNode (location: (15...19))
+            │   │       ├── name: :c
+            │   │       ├── name_loc: (15...17) = "c:"
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (18...19))
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:a, :b, :c]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (19...20) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (21...24) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_kwarg_kwsplat.txt b/test/yarp/snapshots/seattlerb/defn_kwarg_kwsplat.txt
index 83e1bc2f23..45491e8a94 100644
--- a/test/yarp/snapshots/seattlerb/defn_kwarg_kwsplat.txt
+++ b/test/yarp/snapshots/seattlerb/defn_kwarg_kwsplat.txt
@@ -1,27 +1,35 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [DefNode(0...20)(
-       :a,
-       (4...5),
-       nil,
-       ParametersNode(6...15)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...10)(:b, (6...8), IntegerNode(9...10)())],
-         KeywordRestParameterNode(12...15)(:c, (14...15), (12...14)),
-         nil
-       ),
-       nil,
-       [:b, :c],
-       (0...3),
-       nil,
-       (5...6),
-       (15...16),
-       nil,
-       (17...20)
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...20))
+            ├── name: :a
+            ├── name_loc: (4...5) = "a"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...15))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (6...10))
+            │   │       ├── name: :b
+            │   │       ├── name_loc: (6...8) = "b:"
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (9...10))
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (12...15))
+            │   │   ├── name: :c
+            │   │   ├── name_loc: (14...15) = "c"
+            │   │   └── operator_loc: (12...14) = "**"
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:b, :c]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (15...16) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (17...20) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_kwarg_kwsplat_anon.txt b/test/yarp/snapshots/seattlerb/defn_kwarg_kwsplat_anon.txt
index 58930bb847..e8a837d11b 100644
--- a/test/yarp/snapshots/seattlerb/defn_kwarg_kwsplat_anon.txt
+++ b/test/yarp/snapshots/seattlerb/defn_kwarg_kwsplat_anon.txt
@@ -1,27 +1,35 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [DefNode(0...19)(
-       :a,
-       (4...5),
-       nil,
-       ParametersNode(6...14)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...10)(:b, (6...8), IntegerNode(9...10)())],
-         KeywordRestParameterNode(12...14)(nil, nil, (12...14)),
-         nil
-       ),
-       nil,
-       [:b, :**],
-       (0...3),
-       nil,
-       (5...6),
-       (14...15),
-       nil,
-       (16...19)
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...19))
+            ├── name: :a
+            ├── name_loc: (4...5) = "a"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...14))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (6...10))
+            │   │       ├── name: :b
+            │   │       ├── name_loc: (6...8) = "b:"
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (9...10))
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (12...14))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (12...14) = "**"
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:b, :**]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (14...15) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (16...19) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_kwarg_lvar.txt b/test/yarp/snapshots/seattlerb/defn_kwarg_lvar.txt
index 2e1afdea71..e56ff5b6b2 100644
--- a/test/yarp/snapshots/seattlerb/defn_kwarg_lvar.txt
+++ b/test/yarp/snapshots/seattlerb/defn_kwarg_lvar.txt
@@ -1,31 +1,40 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [DefNode(0...26)(
-       :fun,
-       (4...7),
-       nil,
-       ParametersNode(8...16)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(8...16)(
-            :kw,
-            (8...11),
-            SymbolNode(12...16)((12...13), (13...16), nil, "val")
-          )],
-         nil,
-         nil
-       ),
-       StatementsNode(19...21)([LocalVariableReadNode(19...21)(:kw, 0)]),
-       [:kw],
-       (0...3),
-       nil,
-       (7...8),
-       (16...17),
-       nil,
-       (23...26)
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...26))
+            ├── name: :fun
+            ├── name_loc: (4...7) = "fun"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...16))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (8...16))
+            │   │       ├── name: :kw
+            │   │       ├── name_loc: (8...11) = "kw:"
+            │   │       └── value:
+            │   │           @ SymbolNode (location: (12...16))
+            │   │           ├── opening_loc: (12...13) = ":"
+            │   │           ├── value_loc: (13...16) = "val"
+            │   │           ├── closing_loc: ∅
+            │   │           └── unescaped: "val"
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (19...21))
+            │   └── body: (length: 1)
+            │       └── @ LocalVariableReadNode (location: (19...21))
+            │           ├── name: :kw
+            │           └── depth: 0
+            ├── locals: [:kw]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (16...17) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (23...26) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_kwarg_no_parens.txt b/test/yarp/snapshots/seattlerb/defn_kwarg_no_parens.txt
index c98e8317b6..6652805a77 100644
--- a/test/yarp/snapshots/seattlerb/defn_kwarg_no_parens.txt
+++ b/test/yarp/snapshots/seattlerb/defn_kwarg_no_parens.txt
@@ -1,27 +1,31 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [DefNode(0...14)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...10)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...10)(:a, (6...8), IntegerNode(9...10)())],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (11...14)
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...14))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...10))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (6...10))
+            │   │       ├── name: :a
+            │   │       ├── name_loc: (6...8) = "a:"
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (9...10))
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:a]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (11...14) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_kwarg_val.txt b/test/yarp/snapshots/seattlerb/defn_kwarg_val.txt
index 8a0be77d22..6fc5d62dcf 100644
--- a/test/yarp/snapshots/seattlerb/defn_kwarg_val.txt
+++ b/test/yarp/snapshots/seattlerb/defn_kwarg_val.txt
@@ -1,27 +1,33 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [DefNode(0...17)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...12)(
-         [RequiredParameterNode(6...7)(:a)],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(9...12)(:b, (9...11), IntegerNode(11...12)())],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :b],
-       (0...3),
-       nil,
-       (5...6),
-       (12...13),
-       nil,
-       (14...17)
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...17))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...12))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (6...7))
+            │   │       └── name: :a
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (9...12))
+            │   │       ├── name: :b
+            │   │       ├── name_loc: (9...11) = "b:"
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (11...12))
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:a, :b]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (12...13) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (14...17) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_no_kwargs.txt b/test/yarp/snapshots/seattlerb/defn_no_kwargs.txt
index a810609fbc..85cc2e92b6 100644
--- a/test/yarp/snapshots/seattlerb/defn_no_kwargs.txt
+++ b/test/yarp/snapshots/seattlerb/defn_no_kwargs.txt
@@ -1,27 +1,29 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [DefNode(0...17)(
-       :x,
-       (4...5),
-       nil,
-       ParametersNode(6...11)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         NoKeywordsParameterNode(6...11)((6...8), (8...11)),
-         nil
-       ),
-       nil,
-       [],
-       (0...3),
-       nil,
-       (5...6),
-       (11...12),
-       nil,
-       (14...17)
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...17))
+            ├── name: :x
+            ├── name_loc: (4...5) = "x"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...11))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ NoKeywordsParameterNode (location: (6...11))
+            │   │   ├── operator_loc: (6...8) = "**"
+            │   │   └── keyword_loc: (8...11) = "nil"
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (11...12) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (14...17) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_oneliner.txt b/test/yarp/snapshots/seattlerb/defn_oneliner.txt
index 1b1600dfed..3308de7fd9 100644
--- a/test/yarp/snapshots/seattlerb/defn_oneliner.txt
+++ b/test/yarp/snapshots/seattlerb/defn_oneliner.txt
@@ -1,39 +1,45 @@
-ProgramNode(0...27)(
-  [],
-  StatementsNode(0...27)(
-    [DefNode(0...27)(
-       :exec,
-       (4...8),
-       nil,
-       ParametersNode(9...12)(
-         [RequiredParameterNode(9...12)(:cmd)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(16...27)(
-         [CallNode(16...27)(
-            nil,
-            nil,
-            (16...22),
-            (22...23),
-            ArgumentsNode(23...26)([LocalVariableReadNode(23...26)(:cmd, 0)]),
-            (26...27),
-            nil,
-            0,
-            "system"
-          )]
-       ),
-       [:cmd],
-       (0...3),
-       nil,
-       (8...9),
-       (12...13),
-       (14...15),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...27))
+            ├── name: :exec
+            ├── name_loc: (4...8) = "exec"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (9...12))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (9...12))
+            │   │       └── name: :cmd
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (16...27))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (16...27))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (16...22) = "system"
+            │           ├── opening_loc: (22...23) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (23...26))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ LocalVariableReadNode (location: (23...26))
+            │           │           ├── name: :cmd
+            │           │           └── depth: 0
+            │           ├── closing_loc: (26...27) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "system"
+            ├── locals: [:cmd]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (8...9) = "("
+            ├── rparen_loc: (12...13) = ")"
+            ├── equal_loc: (14...15) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/defn_oneliner_eq2.txt b/test/yarp/snapshots/seattlerb/defn_oneliner_eq2.txt
index db923d773e..76cef0767f 100644
--- a/test/yarp/snapshots/seattlerb/defn_oneliner_eq2.txt
+++ b/test/yarp/snapshots/seattlerb/defn_oneliner_eq2.txt
@@ -1,38 +1,44 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [ClassNode(0...28)(
-       [],
-       (0...5),
-       ConstantReadNode(6...7)(:X),
-       nil,
-       nil,
-       StatementsNode(10...24)(
-         [DefNode(10...24)(
-            :==,
-            (14...16),
-            nil,
-            ParametersNode(17...18)(
-              [RequiredParameterNode(17...18)(:o)],
-              [],
-              [],
-              nil,
-              [],
-              nil,
-              nil
-            ),
-            StatementsNode(22...24)([IntegerNode(22...24)()]),
-            [:o],
-            (10...13),
-            nil,
-            (16...17),
-            (18...19),
-            (20...21),
-            nil
-          )]
-       ),
-       (25...28),
-       :X
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ ClassNode (location: (0...28))
+            ├── locals: []
+            ├── class_keyword_loc: (0...5) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (6...7))
+            │   └── name: :X
+            ├── inheritance_operator_loc: ∅
+            ├── superclass: ∅
+            ├── body:
+            │   @ StatementsNode (location: (10...24))
+            │   └── body: (length: 1)
+            │       └── @ DefNode (location: (10...24))
+            │           ├── name: :==
+            │           ├── name_loc: (14...16) = "=="
+            │           ├── receiver: ∅
+            │           ├── parameters:
+            │           │   @ ParametersNode (location: (17...18))
+            │           │   ├── requireds: (length: 1)
+            │           │   │   └── @ RequiredParameterNode (location: (17...18))
+            │           │   │       └── name: :o
+            │           │   ├── optionals: (length: 0)
+            │           │   ├── posts: (length: 0)
+            │           │   ├── rest: ∅
+            │           │   ├── keywords: (length: 0)
+            │           │   ├── keyword_rest: ∅
+            │           │   └── block: ∅
+            │           ├── body:
+            │           │   @ StatementsNode (location: (22...24))
+            │           │   └── body: (length: 1)
+            │           │       └── @ IntegerNode (location: (22...24))
+            │           ├── locals: [:o]
+            │           ├── def_keyword_loc: (10...13) = "def"
+            │           ├── operator_loc: ∅
+            │           ├── lparen_loc: (16...17) = "("
+            │           ├── rparen_loc: (18...19) = ")"
+            │           ├── equal_loc: (20...21) = "="
+            │           └── end_keyword_loc: ∅
+            ├── end_keyword_loc: (25...28) = "end"
+            └── name: :X
diff --git a/test/yarp/snapshots/seattlerb/defn_oneliner_noargs.txt b/test/yarp/snapshots/seattlerb/defn_oneliner_noargs.txt
index 2da92bf559..64572b8386 100644
--- a/test/yarp/snapshots/seattlerb/defn_oneliner_noargs.txt
+++ b/test/yarp/snapshots/seattlerb/defn_oneliner_noargs.txt
@@ -1,31 +1,30 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [DefNode(0...17)(
-       :exec,
-       (4...8),
-       nil,
-       nil,
-       StatementsNode(11...17)(
-         [CallNode(11...17)(
-            nil,
-            nil,
-            (11...17),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "system"
-          )]
-       ),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       (9...10),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...17))
+            ├── name: :exec
+            ├── name_loc: (4...8) = "exec"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (11...17))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (11...17))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (11...17) = "system"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "system"
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: (9...10) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/defn_oneliner_noargs_parentheses.txt b/test/yarp/snapshots/seattlerb/defn_oneliner_noargs_parentheses.txt
index b416121718..3be79555bf 100644
--- a/test/yarp/snapshots/seattlerb/defn_oneliner_noargs_parentheses.txt
+++ b/test/yarp/snapshots/seattlerb/defn_oneliner_noargs_parentheses.txt
@@ -1,31 +1,30 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [DefNode(0...19)(
-       :exec,
-       (4...8),
-       nil,
-       nil,
-       StatementsNode(13...19)(
-         [CallNode(13...19)(
-            nil,
-            nil,
-            (13...19),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "system"
-          )]
-       ),
-       [],
-       (0...3),
-       nil,
-       (8...9),
-       (9...10),
-       (11...12),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...19))
+            ├── name: :exec
+            ├── name_loc: (4...8) = "exec"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (13...19))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (13...19))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (13...19) = "system"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "system"
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (8...9) = "("
+            ├── rparen_loc: (9...10) = ")"
+            ├── equal_loc: (11...12) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/defn_oneliner_rescue.txt b/test/yarp/snapshots/seattlerb/defn_oneliner_rescue.txt
index 0a1f6cbd93..f6cfcc908a 100644
--- a/test/yarp/snapshots/seattlerb/defn_oneliner_rescue.txt
+++ b/test/yarp/snapshots/seattlerb/defn_oneliner_rescue.txt
@@ -1,135 +1,152 @@
-ProgramNode(0...130)(
-  [],
-  StatementsNode(0...130)(
-    [DefNode(0...44)(
-       :exec,
-       (4...8),
-       nil,
-       ParametersNode(9...12)(
-         [RequiredParameterNode(9...12)(:cmd)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       BeginNode(16...44)(
-         nil,
-         StatementsNode(16...27)(
-           [CallNode(16...27)(
-              nil,
-              nil,
-              (16...22),
-              (22...23),
-              ArgumentsNode(23...26)(
-                [LocalVariableReadNode(23...26)(:cmd, 0)]
-              ),
-              (26...27),
-              nil,
-              0,
-              "system"
-            )]
-         ),
-         RescueNode(28...40)(
-           (28...34),
-           [],
-           nil,
-           nil,
-           StatementsNode(37...40)([NilNode(37...40)()]),
-           nil
-         ),
-         nil,
-         nil,
-         (41...44)
-       ),
-       [:cmd],
-       (0...3),
-       nil,
-       (8...9),
-       (12...13),
-       nil,
-       (41...44)
-     ),
-     DefNode(47...89)(
-       :exec,
-       (51...55),
-       nil,
-       ParametersNode(56...59)(
-         [RequiredParameterNode(56...59)(:cmd)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(63...85)(
-         [RescueModifierNode(63...85)(
-            CallNode(63...74)(
-              nil,
-              nil,
-              (63...69),
-              (69...70),
-              ArgumentsNode(70...73)(
-                [LocalVariableReadNode(70...73)(:cmd, 0)]
-              ),
-              (73...74),
-              nil,
-              0,
-              "system"
-            ),
-            (75...81),
-            NilNode(82...85)()
-          )]
-       ),
-       [:cmd],
-       (47...50),
-       nil,
-       (55...56),
-       (59...60),
-       nil,
-       (86...89)
-     ),
-     DefNode(92...130)(
-       :exec,
-       (96...100),
-       nil,
-       ParametersNode(101...104)(
-         [RequiredParameterNode(101...104)(:cmd)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(108...130)(
-         [RescueModifierNode(108...130)(
-            CallNode(108...119)(
-              nil,
-              nil,
-              (108...114),
-              (114...115),
-              ArgumentsNode(115...118)(
-                [LocalVariableReadNode(115...118)(:cmd, 0)]
-              ),
-              (118...119),
-              nil,
-              0,
-              "system"
-            ),
-            (120...126),
-            NilNode(127...130)()
-          )]
-       ),
-       [:cmd],
-       (92...95),
-       nil,
-       (100...101),
-       (104...105),
-       (106...107),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...130))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...130))
+    └── body: (length: 3)
+        ├── @ DefNode (location: (0...44))
+        │   ├── name: :exec
+        │   ├── name_loc: (4...8) = "exec"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (9...12))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (9...12))
+        │   │   │       └── name: :cmd
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (16...44))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (16...27))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (16...27))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (16...22) = "system"
+        │   │   │           ├── opening_loc: (22...23) = "("
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (23...26))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ LocalVariableReadNode (location: (23...26))
+        │   │   │           │           ├── name: :cmd
+        │   │   │           │           └── depth: 0
+        │   │   │           ├── closing_loc: (26...27) = ")"
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "system"
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (28...40))
+        │   │   │   ├── keyword_loc: (28...34) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (37...40))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ NilNode (location: (37...40))
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause: ∅
+        │   │   ├── ensure_clause: ∅
+        │   │   └── end_keyword_loc: (41...44) = "end"
+        │   ├── locals: [:cmd]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (8...9) = "("
+        │   ├── rparen_loc: (12...13) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (41...44) = "end"
+        ├── @ DefNode (location: (47...89))
+        │   ├── name: :exec
+        │   ├── name_loc: (51...55) = "exec"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (56...59))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (56...59))
+        │   │   │       └── name: :cmd
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (63...85))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RescueModifierNode (location: (63...85))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (63...74))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (63...69) = "system"
+        │   │           │   ├── opening_loc: (69...70) = "("
+        │   │           │   ├── arguments:
+        │   │           │   │   @ ArgumentsNode (location: (70...73))
+        │   │           │   │   └── arguments: (length: 1)
+        │   │           │   │       └── @ LocalVariableReadNode (location: (70...73))
+        │   │           │   │           ├── name: :cmd
+        │   │           │   │           └── depth: 0
+        │   │           │   ├── closing_loc: (73...74) = ")"
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: 
+        │   │           │   └── name: "system"
+        │   │           ├── keyword_loc: (75...81) = "rescue"
+        │   │           └── rescue_expression:
+        │   │               @ NilNode (location: (82...85))
+        │   ├── locals: [:cmd]
+        │   ├── def_keyword_loc: (47...50) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (55...56) = "("
+        │   ├── rparen_loc: (59...60) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (86...89) = "end"
+        └── @ DefNode (location: (92...130))
+            ├── name: :exec
+            ├── name_loc: (96...100) = "exec"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (101...104))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (101...104))
+            │   │       └── name: :cmd
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (108...130))
+            │   └── body: (length: 1)
+            │       └── @ RescueModifierNode (location: (108...130))
+            │           ├── expression:
+            │           │   @ CallNode (location: (108...119))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (108...114) = "system"
+            │           │   ├── opening_loc: (114...115) = "("
+            │           │   ├── arguments:
+            │           │   │   @ ArgumentsNode (location: (115...118))
+            │           │   │   └── arguments: (length: 1)
+            │           │   │       └── @ LocalVariableReadNode (location: (115...118))
+            │           │   │           ├── name: :cmd
+            │           │   │           └── depth: 0
+            │           │   ├── closing_loc: (118...119) = ")"
+            │           │   ├── block: ∅
+            │           │   ├── flags: 
+            │           │   └── name: "system"
+            │           ├── keyword_loc: (120...126) = "rescue"
+            │           └── rescue_expression:
+            │               @ NilNode (location: (127...130))
+            ├── locals: [:cmd]
+            ├── def_keyword_loc: (92...95) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (100...101) = "("
+            ├── rparen_loc: (104...105) = ")"
+            ├── equal_loc: (106...107) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/defn_opt_last_arg.txt b/test/yarp/snapshots/seattlerb/defn_opt_last_arg.txt
index b9fe1dcf52..a70cd123a5 100644
--- a/test/yarp/snapshots/seattlerb/defn_opt_last_arg.txt
+++ b/test/yarp/snapshots/seattlerb/defn_opt_last_arg.txt
@@ -1,32 +1,32 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [DefNode(0...21)(
-       :m,
-       (4...5),
-       nil,
-       ParametersNode(6...17)(
-         [],
-         [OptionalParameterNode(6...17)(
-            :arg,
-            (6...9),
-            (10...11),
-            FalseNode(12...17)()
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:arg],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (18...21)
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...21))
+            ├── name: :m
+            ├── name_loc: (4...5) = "m"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...17))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 1)
+            │   │   └── @ OptionalParameterNode (location: (6...17))
+            │   │       ├── name: :arg
+            │   │       ├── name_loc: (6...9) = "arg"
+            │   │       ├── operator_loc: (10...11) = "="
+            │   │       └── value:
+            │   │           @ FalseNode (location: (12...17))
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:arg]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (18...21) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_opt_reg.txt b/test/yarp/snapshots/seattlerb/defn_opt_reg.txt
index 0ae5037d59..8d0e098db7 100644
--- a/test/yarp/snapshots/seattlerb/defn_opt_reg.txt
+++ b/test/yarp/snapshots/seattlerb/defn_opt_reg.txt
@@ -1,32 +1,34 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [DefNode(0...19)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...14)(
-         [],
-         [OptionalParameterNode(6...11)(
-            :a,
-            (6...7),
-            (7...8),
-            NilNode(8...11)()
-          )],
-         [RequiredParameterNode(13...14)(:b)],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :b],
-       (0...3),
-       nil,
-       (5...6),
-       (14...15),
-       nil,
-       (16...19)
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...19))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...14))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 1)
+            │   │   └── @ OptionalParameterNode (location: (6...11))
+            │   │       ├── name: :a
+            │   │       ├── name_loc: (6...7) = "a"
+            │   │       ├── operator_loc: (7...8) = "="
+            │   │       └── value:
+            │   │           @ NilNode (location: (8...11))
+            │   ├── posts: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (13...14))
+            │   │       └── name: :b
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:a, :b]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (14...15) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (16...19) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_opt_splat_arg.txt b/test/yarp/snapshots/seattlerb/defn_opt_splat_arg.txt
index 2148a93df5..b74f9390dc 100644
--- a/test/yarp/snapshots/seattlerb/defn_opt_splat_arg.txt
+++ b/test/yarp/snapshots/seattlerb/defn_opt_splat_arg.txt
@@ -1,32 +1,38 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [DefNode(0...24)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(7...19)(
-         [],
-         [OptionalParameterNode(7...12)(
-            :a,
-            (7...8),
-            (9...10),
-            IntegerNode(11...12)()
-          )],
-         [RequiredParameterNode(18...19)(:c)],
-         RestParameterNode(14...16)(:b, (15...16), (14...15)),
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :b, :c],
-       (0...3),
-       nil,
-       (6...7),
-       (19...20),
-       nil,
-       (21...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...24))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (7...19))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 1)
+            │   │   └── @ OptionalParameterNode (location: (7...12))
+            │   │       ├── name: :a
+            │   │       ├── name_loc: (7...8) = "a"
+            │   │       ├── operator_loc: (9...10) = "="
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (11...12))
+            │   ├── posts: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (18...19))
+            │   │       └── name: :c
+            │   ├── rest:
+            │   │   @ RestParameterNode (location: (14...16))
+            │   │   ├── name: :b
+            │   │   ├── name_loc: (15...16) = "b"
+            │   │   └── operator_loc: (14...15) = "*"
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:a, :b, :c]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (6...7) = "("
+            ├── rparen_loc: (19...20) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (21...24) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_powarg.txt b/test/yarp/snapshots/seattlerb/defn_powarg.txt
index b57aa3c9c7..64ef8743d4 100644
--- a/test/yarp/snapshots/seattlerb/defn_powarg.txt
+++ b/test/yarp/snapshots/seattlerb/defn_powarg.txt
@@ -1,27 +1,30 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [DefNode(0...17)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...12)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(6...12)(:opts, (8...12), (6...8)),
-         nil
-       ),
-       nil,
-       [:opts],
-       (0...3),
-       nil,
-       (5...6),
-       (12...13),
-       nil,
-       (14...17)
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...17))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...12))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (6...12))
+            │   │   ├── name: :opts
+            │   │   ├── name_loc: (8...12) = "opts"
+            │   │   └── operator_loc: (6...8) = "**"
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:opts]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (12...13) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (14...17) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_reg_opt_reg.txt b/test/yarp/snapshots/seattlerb/defn_reg_opt_reg.txt
index ee789ca0ae..46c6cfb8ac 100644
--- a/test/yarp/snapshots/seattlerb/defn_reg_opt_reg.txt
+++ b/test/yarp/snapshots/seattlerb/defn_reg_opt_reg.txt
@@ -1,32 +1,40 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [DefNode(0...23)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...18)(
-         [RequiredParameterNode(6...7)(:a)],
-         [OptionalParameterNode(9...15)(
-            :b,
-            (9...10),
-            (11...12),
-            SymbolNode(13...15)((13...14), (14...15), nil, "c")
-          )],
-         [RequiredParameterNode(17...18)(:d)],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :b, :d],
-       (0...3),
-       nil,
-       (5...6),
-       (18...19),
-       nil,
-       (20...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...23))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...18))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (6...7))
+            │   │       └── name: :a
+            │   ├── optionals: (length: 1)
+            │   │   └── @ OptionalParameterNode (location: (9...15))
+            │   │       ├── name: :b
+            │   │       ├── name_loc: (9...10) = "b"
+            │   │       ├── operator_loc: (11...12) = "="
+            │   │       └── value:
+            │   │           @ SymbolNode (location: (13...15))
+            │   │           ├── opening_loc: (13...14) = ":"
+            │   │           ├── value_loc: (14...15) = "c"
+            │   │           ├── closing_loc: ∅
+            │   │           └── unescaped: "c"
+            │   ├── posts: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (17...18))
+            │   │       └── name: :d
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:a, :b, :d]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (18...19) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (20...23) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_splat_arg.txt b/test/yarp/snapshots/seattlerb/defn_splat_arg.txt
index 95a16a11b5..3b316d642f 100644
--- a/test/yarp/snapshots/seattlerb/defn_splat_arg.txt
+++ b/test/yarp/snapshots/seattlerb/defn_splat_arg.txt
@@ -1,27 +1,32 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [DefNode(0...15)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...10)(
-         [],
-         [],
-         [RequiredParameterNode(9...10)(:a)],
-         RestParameterNode(6...7)(nil, nil, (6...7)),
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:*, :a],
-       (0...3),
-       nil,
-       (5...6),
-       (10...11),
-       nil,
-       (12...15)
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...15))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...10))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (9...10))
+            │   │       └── name: :a
+            │   ├── rest:
+            │   │   @ RestParameterNode (location: (6...7))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (6...7) = "*"
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:*, :a]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (10...11) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (12...15) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defn_unary_not.txt b/test/yarp/snapshots/seattlerb/defn_unary_not.txt
index e167c2aee9..cda6aa71c3 100644
--- a/test/yarp/snapshots/seattlerb/defn_unary_not.txt
+++ b/test/yarp/snapshots/seattlerb/defn_unary_not.txt
@@ -1,19 +1,21 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [DefNode(0...17)(
-       :"!@",
-       (4...6),
-       nil,
-       nil,
-       StatementsNode(8...12)([TrueNode(8...12)()]),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (14...17)
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...17))
+            ├── name: :"!@"
+            ├── name_loc: (4...6) = "!@"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (8...12))
+            │   └── body: (length: 1)
+            │       └── @ TrueNode (location: (8...12))
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (14...17) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defns_reserved.txt b/test/yarp/snapshots/seattlerb/defns_reserved.txt
index 7d12edeb9b..a8c0e13843 100644
--- a/test/yarp/snapshots/seattlerb/defns_reserved.txt
+++ b/test/yarp/snapshots/seattlerb/defns_reserved.txt
@@ -1,19 +1,19 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [DefNode(0...20)(
-       :return,
-       (9...15),
-       SelfNode(4...8)(),
-       nil,
-       nil,
-       [],
-       (0...3),
-       (8...9),
-       nil,
-       nil,
-       nil,
-       (17...20)
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...20))
+            ├── name: :return
+            ├── name_loc: (9...15) = "return"
+            ├── receiver:
+            │   @ SelfNode (location: (4...8))
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: (8...9) = "."
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (17...20) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defs_as_arg_with_do_block_inside.txt b/test/yarp/snapshots/seattlerb/defs_as_arg_with_do_block_inside.txt
index 5474d1e825..988048e511 100644
--- a/test/yarp/snapshots/seattlerb/defs_as_arg_with_do_block_inside.txt
+++ b/test/yarp/snapshots/seattlerb/defs_as_arg_with_do_block_inside.txt
@@ -1,53 +1,59 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [CallNode(0...30)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...30)(
-         [DefNode(2...30)(
-            :b,
-            (11...12),
-            SelfNode(6...10)(),
-            nil,
-            StatementsNode(14...25)(
-              [CallNode(14...25)(
-                 CallNode(14...15)(
-                   nil,
-                   nil,
-                   (14...15),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "x"
-                 ),
-                 (15...16),
-                 (16...17),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(18...25)([], nil, nil, (18...20), (22...25)),
-                 0,
-                 "y"
-               )]
-            ),
-            [],
-            (2...5),
-            (10...11),
-            nil,
-            nil,
-            nil,
-            (27...30)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...30))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...30))
+            │   └── arguments: (length: 1)
+            │       └── @ DefNode (location: (2...30))
+            │           ├── name: :b
+            │           ├── name_loc: (11...12) = "b"
+            │           ├── receiver:
+            │           │   @ SelfNode (location: (6...10))
+            │           ├── parameters: ∅
+            │           ├── body:
+            │           │   @ StatementsNode (location: (14...25))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (14...25))
+            │           │           ├── receiver:
+            │           │           │   @ CallNode (location: (14...15))
+            │           │           │   ├── receiver: ∅
+            │           │           │   ├── call_operator_loc: ∅
+            │           │           │   ├── message_loc: (14...15) = "x"
+            │           │           │   ├── opening_loc: ∅
+            │           │           │   ├── arguments: ∅
+            │           │           │   ├── closing_loc: ∅
+            │           │           │   ├── block: ∅
+            │           │           │   ├── flags: variable_call
+            │           │           │   └── name: "x"
+            │           │           ├── call_operator_loc: (15...16) = "."
+            │           │           ├── message_loc: (16...17) = "y"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block:
+            │           │           │   @ BlockNode (location: (18...25))
+            │           │           │   ├── locals: []
+            │           │           │   ├── parameters: ∅
+            │           │           │   ├── body: ∅
+            │           │           │   ├── opening_loc: (18...20) = "do"
+            │           │           │   └── closing_loc: (22...25) = "end"
+            │           │           ├── flags: 
+            │           │           └── name: "y"
+            │           ├── locals: []
+            │           ├── def_keyword_loc: (2...5) = "def"
+            │           ├── operator_loc: (10...11) = "."
+            │           ├── lparen_loc: ∅
+            │           ├── rparen_loc: ∅
+            │           ├── equal_loc: ∅
+            │           └── end_keyword_loc: (27...30) = "end"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/seattlerb/defs_comments.txt b/test/yarp/snapshots/seattlerb/defs_comments.txt
index 640576684b..6387b61ad7 100644
--- a/test/yarp/snapshots/seattlerb/defs_comments.txt
+++ b/test/yarp/snapshots/seattlerb/defs_comments.txt
@@ -1,19 +1,19 @@
-ProgramNode(19...36)(
-  [],
-  StatementsNode(19...36)(
-    [DefNode(19...36)(
-       :blah,
-       (28...32),
-       SelfNode(23...27)(),
-       nil,
-       nil,
-       [],
-       (19...22),
-       (27...28),
-       nil,
-       nil,
-       nil,
-       (33...36)
-     )]
-  )
-)
+@ ProgramNode (location: (19...36))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (19...36))
+    └── body: (length: 1)
+        └── @ DefNode (location: (19...36))
+            ├── name: :blah
+            ├── name_loc: (28...32) = "blah"
+            ├── receiver:
+            │   @ SelfNode (location: (23...27))
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (19...22) = "def"
+            ├── operator_loc: (27...28) = "."
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (33...36) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defs_endless_command.txt b/test/yarp/snapshots/seattlerb/defs_endless_command.txt
index 068e7de9b3..9fafb43e08 100644
--- a/test/yarp/snapshots/seattlerb/defs_endless_command.txt
+++ b/test/yarp/snapshots/seattlerb/defs_endless_command.txt
@@ -1,31 +1,43 @@
-ProgramNode(0...35)(
-  [],
-  StatementsNode(0...35)(
-    [DefNode(0...35)(
-       :some_method,
-       (6...17),
-       CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "x"),
-       nil,
-       StatementsNode(20...35)(
-         [CallNode(20...35)(
-            nil,
-            nil,
-            (20...32),
-            nil,
-            ArgumentsNode(33...35)([IntegerNode(33...35)()]),
-            nil,
-            nil,
-            0,
-            "other_method"
-          )]
-       ),
-       [],
-       (0...3),
-       (5...6),
-       nil,
-       nil,
-       (18...19),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...35))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...35))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...35))
+            ├── name: :some_method
+            ├── name_loc: (6...17) = "some_method"
+            ├── receiver:
+            │   @ CallNode (location: (4...5))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (4...5) = "x"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "x"
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (20...35))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (20...35))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (20...32) = "other_method"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (33...35))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ IntegerNode (location: (33...35))
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "other_method"
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: (5...6) = "."
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: (18...19) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/defs_endless_command_rescue.txt b/test/yarp/snapshots/seattlerb/defs_endless_command_rescue.txt
index 00b4472689..9fcfcd15bb 100644
--- a/test/yarp/snapshots/seattlerb/defs_endless_command_rescue.txt
+++ b/test/yarp/snapshots/seattlerb/defs_endless_command_rescue.txt
@@ -1,37 +1,48 @@
-ProgramNode(0...45)(
-  [],
-  StatementsNode(0...45)(
-    [DefNode(0...45)(
-       :some_method,
-       (6...17),
-       CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "x"),
-       nil,
-       StatementsNode(20...45)(
-         [CallNode(20...45)(
-            nil,
-            nil,
-            (20...32),
-            nil,
-            ArgumentsNode(33...45)(
-              [RescueModifierNode(33...45)(
-                 IntegerNode(33...35)(),
-                 (36...42),
-                 IntegerNode(43...45)()
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "other_method"
-          )]
-       ),
-       [],
-       (0...3),
-       (5...6),
-       nil,
-       nil,
-       (18...19),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...45))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...45))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...45))
+            ├── name: :some_method
+            ├── name_loc: (6...17) = "some_method"
+            ├── receiver:
+            │   @ CallNode (location: (4...5))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (4...5) = "x"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "x"
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (20...45))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (20...45))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (20...32) = "other_method"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (33...45))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ RescueModifierNode (location: (33...45))
+            │           │           ├── expression:
+            │           │           │   @ IntegerNode (location: (33...35))
+            │           │           ├── keyword_loc: (36...42) = "rescue"
+            │           │           └── rescue_expression:
+            │           │               @ IntegerNode (location: (43...45))
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "other_method"
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: (5...6) = "."
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: (18...19) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/defs_kwarg.txt b/test/yarp/snapshots/seattlerb/defs_kwarg.txt
index 6b1e60d602..2ad17321e8 100644
--- a/test/yarp/snapshots/seattlerb/defs_kwarg.txt
+++ b/test/yarp/snapshots/seattlerb/defs_kwarg.txt
@@ -1,31 +1,32 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [DefNode(0...19)(
-       :a,
-       (9...10),
-       SelfNode(4...8)(),
-       ParametersNode(11...15)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(11...15)(
-            :b,
-            (11...13),
-            IntegerNode(14...15)()
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:b],
-       (0...3),
-       (8...9),
-       nil,
-       nil,
-       nil,
-       (16...19)
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...19))
+            ├── name: :a
+            ├── name_loc: (9...10) = "a"
+            ├── receiver:
+            │   @ SelfNode (location: (4...8))
+            ├── parameters:
+            │   @ ParametersNode (location: (11...15))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (11...15))
+            │   │       ├── name: :b
+            │   │       ├── name_loc: (11...13) = "b:"
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (14...15))
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:b]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: (8...9) = "."
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (16...19) = "end"
diff --git a/test/yarp/snapshots/seattlerb/defs_oneliner.txt b/test/yarp/snapshots/seattlerb/defs_oneliner.txt
index f8214ef3f6..c1b53833e4 100644
--- a/test/yarp/snapshots/seattlerb/defs_oneliner.txt
+++ b/test/yarp/snapshots/seattlerb/defs_oneliner.txt
@@ -1,39 +1,46 @@
-ProgramNode(0...32)(
-  [],
-  StatementsNode(0...32)(
-    [DefNode(0...32)(
-       :exec,
-       (9...13),
-       SelfNode(4...8)(),
-       ParametersNode(14...17)(
-         [RequiredParameterNode(14...17)(:cmd)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(21...32)(
-         [CallNode(21...32)(
-            nil,
-            nil,
-            (21...27),
-            (27...28),
-            ArgumentsNode(28...31)([LocalVariableReadNode(28...31)(:cmd, 0)]),
-            (31...32),
-            nil,
-            0,
-            "system"
-          )]
-       ),
-       [:cmd],
-       (0...3),
-       (8...9),
-       (13...14),
-       (17...18),
-       (19...20),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...32))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...32))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...32))
+            ├── name: :exec
+            ├── name_loc: (9...13) = "exec"
+            ├── receiver:
+            │   @ SelfNode (location: (4...8))
+            ├── parameters:
+            │   @ ParametersNode (location: (14...17))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (14...17))
+            │   │       └── name: :cmd
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (21...32))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (21...32))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (21...27) = "system"
+            │           ├── opening_loc: (27...28) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (28...31))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ LocalVariableReadNode (location: (28...31))
+            │           │           ├── name: :cmd
+            │           │           └── depth: 0
+            │           ├── closing_loc: (31...32) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "system"
+            ├── locals: [:cmd]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: (8...9) = "."
+            ├── lparen_loc: (13...14) = "("
+            ├── rparen_loc: (17...18) = ")"
+            ├── equal_loc: (19...20) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/defs_oneliner_eq2.txt b/test/yarp/snapshots/seattlerb/defs_oneliner_eq2.txt
index ee69fa0752..5bfafc6c86 100644
--- a/test/yarp/snapshots/seattlerb/defs_oneliner_eq2.txt
+++ b/test/yarp/snapshots/seattlerb/defs_oneliner_eq2.txt
@@ -1,38 +1,45 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [ClassNode(0...33)(
-       [],
-       (0...5),
-       ConstantReadNode(6...7)(:X),
-       nil,
-       nil,
-       StatementsNode(10...29)(
-         [DefNode(10...29)(
-            :==,
-            (19...21),
-            SelfNode(14...18)(),
-            ParametersNode(22...23)(
-              [RequiredParameterNode(22...23)(:o)],
-              [],
-              [],
-              nil,
-              [],
-              nil,
-              nil
-            ),
-            StatementsNode(27...29)([IntegerNode(27...29)()]),
-            [:o],
-            (10...13),
-            (18...19),
-            (21...22),
-            (23...24),
-            (25...26),
-            nil
-          )]
-       ),
-       (30...33),
-       :X
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 1)
+        └── @ ClassNode (location: (0...33))
+            ├── locals: []
+            ├── class_keyword_loc: (0...5) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (6...7))
+            │   └── name: :X
+            ├── inheritance_operator_loc: ∅
+            ├── superclass: ∅
+            ├── body:
+            │   @ StatementsNode (location: (10...29))
+            │   └── body: (length: 1)
+            │       └── @ DefNode (location: (10...29))
+            │           ├── name: :==
+            │           ├── name_loc: (19...21) = "=="
+            │           ├── receiver:
+            │           │   @ SelfNode (location: (14...18))
+            │           ├── parameters:
+            │           │   @ ParametersNode (location: (22...23))
+            │           │   ├── requireds: (length: 1)
+            │           │   │   └── @ RequiredParameterNode (location: (22...23))
+            │           │   │       └── name: :o
+            │           │   ├── optionals: (length: 0)
+            │           │   ├── posts: (length: 0)
+            │           │   ├── rest: ∅
+            │           │   ├── keywords: (length: 0)
+            │           │   ├── keyword_rest: ∅
+            │           │   └── block: ∅
+            │           ├── body:
+            │           │   @ StatementsNode (location: (27...29))
+            │           │   └── body: (length: 1)
+            │           │       └── @ IntegerNode (location: (27...29))
+            │           ├── locals: [:o]
+            │           ├── def_keyword_loc: (10...13) = "def"
+            │           ├── operator_loc: (18...19) = "."
+            │           ├── lparen_loc: (21...22) = "("
+            │           ├── rparen_loc: (23...24) = ")"
+            │           ├── equal_loc: (25...26) = "="
+            │           └── end_keyword_loc: ∅
+            ├── end_keyword_loc: (30...33) = "end"
+            └── name: :X
diff --git a/test/yarp/snapshots/seattlerb/defs_oneliner_rescue.txt b/test/yarp/snapshots/seattlerb/defs_oneliner_rescue.txt
index 9f510cdb72..5939649c53 100644
--- a/test/yarp/snapshots/seattlerb/defs_oneliner_rescue.txt
+++ b/test/yarp/snapshots/seattlerb/defs_oneliner_rescue.txt
@@ -1,135 +1,155 @@
-ProgramNode(0...145)(
-  [],
-  StatementsNode(0...145)(
-    [DefNode(0...49)(
-       :exec,
-       (9...13),
-       SelfNode(4...8)(),
-       ParametersNode(14...17)(
-         [RequiredParameterNode(14...17)(:cmd)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       BeginNode(21...49)(
-         nil,
-         StatementsNode(21...32)(
-           [CallNode(21...32)(
-              nil,
-              nil,
-              (21...27),
-              (27...28),
-              ArgumentsNode(28...31)(
-                [LocalVariableReadNode(28...31)(:cmd, 0)]
-              ),
-              (31...32),
-              nil,
-              0,
-              "system"
-            )]
-         ),
-         RescueNode(33...45)(
-           (33...39),
-           [],
-           nil,
-           nil,
-           StatementsNode(42...45)([NilNode(42...45)()]),
-           nil
-         ),
-         nil,
-         nil,
-         (46...49)
-       ),
-       [:cmd],
-       (0...3),
-       (8...9),
-       (13...14),
-       (17...18),
-       nil,
-       (46...49)
-     ),
-     DefNode(52...99)(
-       :exec,
-       (61...65),
-       SelfNode(56...60)(),
-       ParametersNode(66...69)(
-         [RequiredParameterNode(66...69)(:cmd)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(73...95)(
-         [RescueModifierNode(73...95)(
-            CallNode(73...84)(
-              nil,
-              nil,
-              (73...79),
-              (79...80),
-              ArgumentsNode(80...83)(
-                [LocalVariableReadNode(80...83)(:cmd, 0)]
-              ),
-              (83...84),
-              nil,
-              0,
-              "system"
-            ),
-            (85...91),
-            NilNode(92...95)()
-          )]
-       ),
-       [:cmd],
-       (52...55),
-       (60...61),
-       (65...66),
-       (69...70),
-       nil,
-       (96...99)
-     ),
-     DefNode(102...145)(
-       :exec,
-       (111...115),
-       SelfNode(106...110)(),
-       ParametersNode(116...119)(
-         [RequiredParameterNode(116...119)(:cmd)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(123...145)(
-         [RescueModifierNode(123...145)(
-            CallNode(123...134)(
-              nil,
-              nil,
-              (123...129),
-              (129...130),
-              ArgumentsNode(130...133)(
-                [LocalVariableReadNode(130...133)(:cmd, 0)]
-              ),
-              (133...134),
-              nil,
-              0,
-              "system"
-            ),
-            (135...141),
-            NilNode(142...145)()
-          )]
-       ),
-       [:cmd],
-       (102...105),
-       (110...111),
-       (115...116),
-       (119...120),
-       (121...122),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...145))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...145))
+    └── body: (length: 3)
+        ├── @ DefNode (location: (0...49))
+        │   ├── name: :exec
+        │   ├── name_loc: (9...13) = "exec"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (4...8))
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (14...17))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (14...17))
+        │   │   │       └── name: :cmd
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (21...49))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (21...32))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (21...32))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (21...27) = "system"
+        │   │   │           ├── opening_loc: (27...28) = "("
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (28...31))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ LocalVariableReadNode (location: (28...31))
+        │   │   │           │           ├── name: :cmd
+        │   │   │           │           └── depth: 0
+        │   │   │           ├── closing_loc: (31...32) = ")"
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "system"
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (33...45))
+        │   │   │   ├── keyword_loc: (33...39) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (42...45))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ NilNode (location: (42...45))
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause: ∅
+        │   │   ├── ensure_clause: ∅
+        │   │   └── end_keyword_loc: (46...49) = "end"
+        │   ├── locals: [:cmd]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: (8...9) = "."
+        │   ├── lparen_loc: (13...14) = "("
+        │   ├── rparen_loc: (17...18) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (46...49) = "end"
+        ├── @ DefNode (location: (52...99))
+        │   ├── name: :exec
+        │   ├── name_loc: (61...65) = "exec"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (56...60))
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (66...69))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (66...69))
+        │   │   │       └── name: :cmd
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (73...95))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RescueModifierNode (location: (73...95))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (73...84))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (73...79) = "system"
+        │   │           │   ├── opening_loc: (79...80) = "("
+        │   │           │   ├── arguments:
+        │   │           │   │   @ ArgumentsNode (location: (80...83))
+        │   │           │   │   └── arguments: (length: 1)
+        │   │           │   │       └── @ LocalVariableReadNode (location: (80...83))
+        │   │           │   │           ├── name: :cmd
+        │   │           │   │           └── depth: 0
+        │   │           │   ├── closing_loc: (83...84) = ")"
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: 
+        │   │           │   └── name: "system"
+        │   │           ├── keyword_loc: (85...91) = "rescue"
+        │   │           └── rescue_expression:
+        │   │               @ NilNode (location: (92...95))
+        │   ├── locals: [:cmd]
+        │   ├── def_keyword_loc: (52...55) = "def"
+        │   ├── operator_loc: (60...61) = "."
+        │   ├── lparen_loc: (65...66) = "("
+        │   ├── rparen_loc: (69...70) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (96...99) = "end"
+        └── @ DefNode (location: (102...145))
+            ├── name: :exec
+            ├── name_loc: (111...115) = "exec"
+            ├── receiver:
+            │   @ SelfNode (location: (106...110))
+            ├── parameters:
+            │   @ ParametersNode (location: (116...119))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (116...119))
+            │   │       └── name: :cmd
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (123...145))
+            │   └── body: (length: 1)
+            │       └── @ RescueModifierNode (location: (123...145))
+            │           ├── expression:
+            │           │   @ CallNode (location: (123...134))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (123...129) = "system"
+            │           │   ├── opening_loc: (129...130) = "("
+            │           │   ├── arguments:
+            │           │   │   @ ArgumentsNode (location: (130...133))
+            │           │   │   └── arguments: (length: 1)
+            │           │   │       └── @ LocalVariableReadNode (location: (130...133))
+            │           │   │           ├── name: :cmd
+            │           │   │           └── depth: 0
+            │           │   ├── closing_loc: (133...134) = ")"
+            │           │   ├── block: ∅
+            │           │   ├── flags: 
+            │           │   └── name: "system"
+            │           ├── keyword_loc: (135...141) = "rescue"
+            │           └── rescue_expression:
+            │               @ NilNode (location: (142...145))
+            ├── locals: [:cmd]
+            ├── def_keyword_loc: (102...105) = "def"
+            ├── operator_loc: (110...111) = "."
+            ├── lparen_loc: (115...116) = "("
+            ├── rparen_loc: (119...120) = ")"
+            ├── equal_loc: (121...122) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/difficult0_.txt b/test/yarp/snapshots/seattlerb/difficult0_.txt
index c68a126eb0..b763d090b9 100644
--- a/test/yarp/snapshots/seattlerb/difficult0_.txt
+++ b/test/yarp/snapshots/seattlerb/difficult0_.txt
@@ -1,51 +1,69 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [CallNode(0...30)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...30)(
-         [CallNode(2...30)(
-            CallNode(2...26)(
-              InterpolatedStringNode(2...8)(
-                (2...8),
-                [StringNode(12...16)(nil, (12...16), nil, "  a\n")],
-                (16...22)
-              ),
-              nil,
-              (8...9),
-              nil,
-              ArgumentsNode(9...26)(
-                [InterpolatedStringNode(9...26)(
-                   (9...10),
-                   [StringNode(10...12)(nil, (10...12), nil, "b\n"),
-                    StringNode(22...25)(nil, (22...25), nil, "  c")],
-                   (25...26)
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "+"
-            ),
-            nil,
-            (26...27),
-            nil,
-            ArgumentsNode(27...30)(
-              [StringNode(27...30)((27...28), (28...29), (29...30), "d")]
-            ),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...30))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...30))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (2...30))
+            │           ├── receiver:
+            │           │   @ CallNode (location: (2...26))
+            │           │   ├── receiver:
+            │           │   │   @ InterpolatedStringNode (location: (2...8))
+            │           │   │   ├── opening_loc: (2...8) = "<<-END"
+            │           │   │   ├── parts: (length: 1)
+            │           │   │   │   └── @ StringNode (location: (12...16))
+            │           │   │   │       ├── opening_loc: ∅
+            │           │   │   │       ├── content_loc: (12...16) = "  a\n"
+            │           │   │   │       ├── closing_loc: ∅
+            │           │   │   │       └── unescaped: "  a\n"
+            │           │   │   └── closing_loc: (16...22) = "  END\n"
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (8...9) = "+"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments:
+            │           │   │   @ ArgumentsNode (location: (9...26))
+            │           │   │   └── arguments: (length: 1)
+            │           │   │       └── @ InterpolatedStringNode (location: (9...26))
+            │           │   │           ├── opening_loc: (9...10) = "'"
+            │           │   │           ├── parts: (length: 2)
+            │           │   │           │   ├── @ StringNode (location: (10...12))
+            │           │   │           │   │   ├── opening_loc: ∅
+            │           │   │           │   │   ├── content_loc: (10...12) = "b\n"
+            │           │   │           │   │   ├── closing_loc: ∅
+            │           │   │           │   │   └── unescaped: "b\n"
+            │           │   │           │   └── @ StringNode (location: (22...25))
+            │           │   │           │       ├── opening_loc: ∅
+            │           │   │           │       ├── content_loc: (22...25) = "  c"
+            │           │   │           │       ├── closing_loc: ∅
+            │           │   │           │       └── unescaped: "  c"
+            │           │   │           └── closing_loc: (25...26) = "'"
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: 
+            │           │   └── name: "+"
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (26...27) = "+"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (27...30))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ StringNode (location: (27...30))
+            │           │           ├── opening_loc: (27...28) = "'"
+            │           │           ├── content_loc: (28...29) = "d"
+            │           │           ├── closing_loc: (29...30) = "'"
+            │           │           └── unescaped: "d"
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "+"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/seattlerb/difficult1_line_numbers.txt b/test/yarp/snapshots/seattlerb/difficult1_line_numbers.txt
index 6973697641..7be70a823d 100644
--- a/test/yarp/snapshots/seattlerb/difficult1_line_numbers.txt
+++ b/test/yarp/snapshots/seattlerb/difficult1_line_numbers.txt
@@ -1,131 +1,228 @@
-ProgramNode(0...104)(
-  [],
-  StatementsNode(0...104)(
-    [IfNode(0...104)(
-       (0...2),
-       TrueNode(3...7)(),
-       StatementsNode(10...100)(
-         [CallNode(10...13)(
-            nil,
-            nil,
-            (10...11),
-            nil,
-            ArgumentsNode(12...13)([IntegerNode(12...13)()]),
-            nil,
-            nil,
-            0,
-            "p"
-          ),
-          CallNode(16...21)(
-            CallNode(16...17)(nil, nil, (16...17), nil, nil, nil, nil, 2, "a"),
-            (17...18),
-            (18...19),
-            nil,
-            ArgumentsNode(20...21)([IntegerNode(20...21)()]),
-            nil,
-            nil,
-            0,
-            "b"
-          ),
-          CallNode(24...32)(
-            CallNode(24...25)(nil, nil, (24...25), nil, nil, nil, nil, 2, "c"),
-            (25...26),
-            (26...27),
-            nil,
-            ArgumentsNode(28...32)(
-              [IntegerNode(28...29)(), IntegerNode(31...32)()]
-            ),
-            nil,
-            nil,
-            0,
-            "d"
-          ),
-          CallNode(35...40)(
-            CallNode(35...36)(nil, nil, (35...36), nil, nil, nil, nil, 2, "e"),
-            (36...37),
-            (37...38),
-            nil,
-            ArgumentsNode(39...40)([IntegerNode(39...40)()]),
-            nil,
-            nil,
-            0,
-            "f"
-          ),
-          CallNode(43...51)(
-            CallNode(43...44)(nil, nil, (43...44), nil, nil, nil, nil, 2, "g"),
-            (44...45),
-            (45...46),
-            nil,
-            ArgumentsNode(47...51)(
-              [IntegerNode(47...48)(), IntegerNode(50...51)()]
-            ),
-            nil,
-            nil,
-            0,
-            "h"
-          ),
-          CallNode(54...58)(
-            nil,
-            nil,
-            (54...55),
-            (55...56),
-            ArgumentsNode(56...57)([IntegerNode(56...57)()]),
-            (57...58),
-            nil,
-            0,
-            "p"
-          ),
-          CallNode(61...67)(
-            CallNode(61...62)(nil, nil, (61...62), nil, nil, nil, nil, 2, "a"),
-            (62...63),
-            (63...64),
-            (64...65),
-            ArgumentsNode(65...66)([IntegerNode(65...66)()]),
-            (66...67),
-            nil,
-            0,
-            "b"
-          ),
-          CallNode(70...79)(
-            CallNode(70...71)(nil, nil, (70...71), nil, nil, nil, nil, 2, "c"),
-            (71...72),
-            (72...73),
-            (73...74),
-            ArgumentsNode(74...78)(
-              [IntegerNode(74...75)(), IntegerNode(77...78)()]
-            ),
-            (78...79),
-            nil,
-            0,
-            "d"
-          ),
-          CallNode(82...88)(
-            CallNode(82...83)(nil, nil, (82...83), nil, nil, nil, nil, 2, "e"),
-            (83...84),
-            (84...85),
-            (85...86),
-            ArgumentsNode(86...87)([IntegerNode(86...87)()]),
-            (87...88),
-            nil,
-            0,
-            "f"
-          ),
-          CallNode(91...100)(
-            CallNode(91...92)(nil, nil, (91...92), nil, nil, nil, nil, 2, "g"),
-            (92...93),
-            (93...94),
-            (94...95),
-            ArgumentsNode(95...99)(
-              [IntegerNode(95...96)(), IntegerNode(98...99)()]
-            ),
-            (99...100),
-            nil,
-            0,
-            "h"
-          )]
-       ),
-       nil,
-       (101...104)
-     )]
-  )
-)
+@ ProgramNode (location: (0...104))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...104))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...104))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ TrueNode (location: (3...7))
+            ├── statements:
+            │   @ StatementsNode (location: (10...100))
+            │   └── body: (length: 10)
+            │       ├── @ CallNode (location: (10...13))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (10...11) = "p"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (12...13))
+            │       │   │   └── arguments: (length: 1)
+            │       │   │       └── @ IntegerNode (location: (12...13))
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "p"
+            │       ├── @ CallNode (location: (16...21))
+            │       │   ├── receiver:
+            │       │   │   @ CallNode (location: (16...17))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (16...17) = "a"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "a"
+            │       │   ├── call_operator_loc: (17...18) = "."
+            │       │   ├── message_loc: (18...19) = "b"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (20...21))
+            │       │   │   └── arguments: (length: 1)
+            │       │   │       └── @ IntegerNode (location: (20...21))
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "b"
+            │       ├── @ CallNode (location: (24...32))
+            │       │   ├── receiver:
+            │       │   │   @ CallNode (location: (24...25))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (24...25) = "c"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "c"
+            │       │   ├── call_operator_loc: (25...26) = "."
+            │       │   ├── message_loc: (26...27) = "d"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (28...32))
+            │       │   │   └── arguments: (length: 2)
+            │       │   │       ├── @ IntegerNode (location: (28...29))
+            │       │   │       └── @ IntegerNode (location: (31...32))
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "d"
+            │       ├── @ CallNode (location: (35...40))
+            │       │   ├── receiver:
+            │       │   │   @ CallNode (location: (35...36))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (35...36) = "e"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "e"
+            │       │   ├── call_operator_loc: (36...37) = "."
+            │       │   ├── message_loc: (37...38) = "f"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (39...40))
+            │       │   │   └── arguments: (length: 1)
+            │       │   │       └── @ IntegerNode (location: (39...40))
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "f"
+            │       ├── @ CallNode (location: (43...51))
+            │       │   ├── receiver:
+            │       │   │   @ CallNode (location: (43...44))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (43...44) = "g"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "g"
+            │       │   ├── call_operator_loc: (44...45) = "."
+            │       │   ├── message_loc: (45...46) = "h"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (47...51))
+            │       │   │   └── arguments: (length: 2)
+            │       │   │       ├── @ IntegerNode (location: (47...48))
+            │       │   │       └── @ IntegerNode (location: (50...51))
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "h"
+            │       ├── @ CallNode (location: (54...58))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (54...55) = "p"
+            │       │   ├── opening_loc: (55...56) = "("
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (56...57))
+            │       │   │   └── arguments: (length: 1)
+            │       │   │       └── @ IntegerNode (location: (56...57))
+            │       │   ├── closing_loc: (57...58) = ")"
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "p"
+            │       ├── @ CallNode (location: (61...67))
+            │       │   ├── receiver:
+            │       │   │   @ CallNode (location: (61...62))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (61...62) = "a"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "a"
+            │       │   ├── call_operator_loc: (62...63) = "."
+            │       │   ├── message_loc: (63...64) = "b"
+            │       │   ├── opening_loc: (64...65) = "("
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (65...66))
+            │       │   │   └── arguments: (length: 1)
+            │       │   │       └── @ IntegerNode (location: (65...66))
+            │       │   ├── closing_loc: (66...67) = ")"
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "b"
+            │       ├── @ CallNode (location: (70...79))
+            │       │   ├── receiver:
+            │       │   │   @ CallNode (location: (70...71))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (70...71) = "c"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "c"
+            │       │   ├── call_operator_loc: (71...72) = "."
+            │       │   ├── message_loc: (72...73) = "d"
+            │       │   ├── opening_loc: (73...74) = "("
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (74...78))
+            │       │   │   └── arguments: (length: 2)
+            │       │   │       ├── @ IntegerNode (location: (74...75))
+            │       │   │       └── @ IntegerNode (location: (77...78))
+            │       │   ├── closing_loc: (78...79) = ")"
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "d"
+            │       ├── @ CallNode (location: (82...88))
+            │       │   ├── receiver:
+            │       │   │   @ CallNode (location: (82...83))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (82...83) = "e"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "e"
+            │       │   ├── call_operator_loc: (83...84) = "."
+            │       │   ├── message_loc: (84...85) = "f"
+            │       │   ├── opening_loc: (85...86) = "("
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (86...87))
+            │       │   │   └── arguments: (length: 1)
+            │       │   │       └── @ IntegerNode (location: (86...87))
+            │       │   ├── closing_loc: (87...88) = ")"
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "f"
+            │       └── @ CallNode (location: (91...100))
+            │           ├── receiver:
+            │           │   @ CallNode (location: (91...92))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (91...92) = "g"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "g"
+            │           ├── call_operator_loc: (92...93) = "."
+            │           ├── message_loc: (93...94) = "h"
+            │           ├── opening_loc: (94...95) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (95...99))
+            │           │   └── arguments: (length: 2)
+            │           │       ├── @ IntegerNode (location: (95...96))
+            │           │       └── @ IntegerNode (location: (98...99))
+            │           ├── closing_loc: (99...100) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "h"
+            ├── consequent: ∅
+            └── end_keyword_loc: (101...104) = "end"
diff --git a/test/yarp/snapshots/seattlerb/difficult1_line_numbers2.txt b/test/yarp/snapshots/seattlerb/difficult1_line_numbers2.txt
index d19d6d817b..9a5887484c 100644
--- a/test/yarp/snapshots/seattlerb/difficult1_line_numbers2.txt
+++ b/test/yarp/snapshots/seattlerb/difficult1_line_numbers2.txt
@@ -1,52 +1,70 @@
-ProgramNode(0...48)(
-  [:b, :c],
-  StatementsNode(0...48)(
-    [IfNode(0...46)(
-       (0...2),
-       TrueNode(3...7)(),
-       StatementsNode(15...42)(
-         [CallNode(15...21)(
-            nil,
-            nil,
-            (15...16),
-            (16...17),
-            ArgumentsNode(17...20)(
-              [StringNode(17...20)((17...18), (18...19), (19...20), "a")]
-            ),
-            (20...21),
-            nil,
-            0,
-            "p"
-          ),
-          LocalVariableWriteNode(24...29)(
-            :b,
-            0,
-            (24...25),
-            IntegerNode(28...29)(),
-            (26...27)
-          ),
-          CallNode(32...35)(
-            nil,
-            nil,
-            (32...33),
-            nil,
-            ArgumentsNode(34...35)([LocalVariableReadNode(34...35)(:b, 0)]),
-            nil,
-            nil,
-            0,
-            "p"
-          ),
-          LocalVariableWriteNode(38...42)(
-            :c,
-            0,
-            (38...39),
-            IntegerNode(41...42)(),
-            (40...41)
-          )]
-       ),
-       nil,
-       (43...46)
-     ),
-     CallNode(47...48)(nil, nil, (47...48), nil, nil, nil, nil, 2, "a")]
-  )
-)
+@ ProgramNode (location: (0...48))
+├── locals: [:b, :c]
+└── statements:
+    @ StatementsNode (location: (0...48))
+    └── body: (length: 2)
+        ├── @ IfNode (location: (0...46))
+        │   ├── if_keyword_loc: (0...2) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (3...7))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (15...42))
+        │   │   └── body: (length: 4)
+        │   │       ├── @ CallNode (location: (15...21))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (15...16) = "p"
+        │   │       │   ├── opening_loc: (16...17) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (17...20))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ StringNode (location: (17...20))
+        │   │       │   │           ├── opening_loc: (17...18) = "\""
+        │   │       │   │           ├── content_loc: (18...19) = "a"
+        │   │       │   │           ├── closing_loc: (19...20) = "\""
+        │   │       │   │           └── unescaped: "a"
+        │   │       │   ├── closing_loc: (20...21) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "p"
+        │   │       ├── @ LocalVariableWriteNode (location: (24...29))
+        │   │       │   ├── name: :b
+        │   │       │   ├── depth: 0
+        │   │       │   ├── name_loc: (24...25) = "b"
+        │   │       │   ├── value:
+        │   │       │   │   @ IntegerNode (location: (28...29))
+        │   │       │   └── operator_loc: (26...27) = "="
+        │   │       ├── @ CallNode (location: (32...35))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (32...33) = "p"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (34...35))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ LocalVariableReadNode (location: (34...35))
+        │   │       │   │           ├── name: :b
+        │   │       │   │           └── depth: 0
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "p"
+        │   │       └── @ LocalVariableWriteNode (location: (38...42))
+        │   │           ├── name: :c
+        │   │           ├── depth: 0
+        │   │           ├── name_loc: (38...39) = "c"
+        │   │           ├── value:
+        │   │           │   @ IntegerNode (location: (41...42))
+        │   │           └── operator_loc: (40...41) = "="
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (43...46) = "end"
+        └── @ CallNode (location: (47...48))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (47...48) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/difficult2_.txt b/test/yarp/snapshots/seattlerb/difficult2_.txt
index 78772ca20d..6a609126c9 100644
--- a/test/yarp/snapshots/seattlerb/difficult2_.txt
+++ b/test/yarp/snapshots/seattlerb/difficult2_.txt
@@ -1,49 +1,62 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [IfNode(0...13)(
-       nil,
-       IntegerNode(0...1)(),
-       StatementsNode(4...9)(
-         [CallNode(4...9)(
-            nil,
-            nil,
-            (4...5),
-            (5...6),
-            ArgumentsNode(6...8)(
-              [StringNode(6...8)((6...7), (7...7), (7...8), "")]
-            ),
-            (8...9),
-            nil,
-            0,
-            "b"
-          )]
-       ),
-       ElseNode(10...13)(
-         (10...11),
-         StatementsNode(12...13)([IntegerNode(12...13)()]),
-         nil
-       ),
-       nil
-     ),
-     CallNode(14...20)(
-       nil,
-       nil,
-       (14...15),
-       nil,
-       ArgumentsNode(16...20)(
-         [KeywordHashNode(16...20)(
-            [AssocNode(16...20)(
-               SymbolNode(16...18)(nil, (16...17), (17...18), "d"),
-               IntegerNode(19...20)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 2)
+        ├── @ IfNode (location: (0...13))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ IntegerNode (location: (0...1))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (4...9))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (4...9))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (4...5) = "b"
+        │   │           ├── opening_loc: (5...6) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (6...8))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ StringNode (location: (6...8))
+        │   │           │           ├── opening_loc: (6...7) = "'"
+        │   │           │           ├── content_loc: (7...7) = ""
+        │   │           │           ├── closing_loc: (7...8) = "'"
+        │   │           │           └── unescaped: ""
+        │   │           ├── closing_loc: (8...9) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "b"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (10...13))
+        │   │   ├── else_keyword_loc: (10...11) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (12...13))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (12...13))
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        └── @ CallNode (location: (14...20))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (14...15) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (16...20))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (16...20))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (16...20))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (16...18))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (16...17) = "d"
+            │                   │   ├── closing_loc: (17...18) = ":"
+            │                   │   └── unescaped: "d"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (19...20))
+            │                   └── operator_loc: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/difficult3_.txt b/test/yarp/snapshots/seattlerb/difficult3_.txt
index ba5d6c3aed..ef58921ec9 100644
--- a/test/yarp/snapshots/seattlerb/difficult3_.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3_.txt
@@ -1,44 +1,47 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...18)(
-         [:a, :b, :c],
-         BlockParametersNode(4...16)(
-           ParametersNode(5...15)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...15)(
-                [RequiredParameterNode(9...10)(:b),
-                 SplatNode(12...14)(
-                   (12...13),
-                   RequiredParameterNode(13...14)(:c)
-                 )],
-                (8...9),
-                (14...15)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (15...16)
-         ),
-         nil,
-         (2...3),
-         (17...18)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...18))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...18))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...16))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...15))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...15))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       │   │   └── name: :b
+            │   │   │   │       │   └── @ SplatNode (location: (12...14))
+            │   │   │   │       │       ├── operator_loc: (12...13) = "*"
+            │   │   │   │       │       └── expression:
+            │   │   │   │       │           @ RequiredParameterNode (location: (13...14))
+            │   │   │   │       │           └── name: :c
+            │   │   │   │       ├── opening_loc: (8...9) = "("
+            │   │   │   │       └── closing_loc: (14...15) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (15...16) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (17...18) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3_2.txt b/test/yarp/snapshots/seattlerb/difficult3_2.txt
index fffcbac8be..fc867265ec 100644
--- a/test/yarp/snapshots/seattlerb/difficult3_2.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3_2.txt
@@ -1,35 +1,40 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...13)(
-         [:a, :b],
-         BlockParametersNode(4...11)(
-           ParametersNode(5...10)(
-             [],
-             [],
-             [RequiredParameterNode(9...10)(:b)],
-             RestParameterNode(5...7)(:a, (6...7), (5...6)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (10...11)
-         ),
-         nil,
-         (2...3),
-         (12...13)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...13))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...11))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...10))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (5...7))
+            │   │   │   │   ├── name: :a
+            │   │   │   │   ├── name_loc: (6...7) = "a"
+            │   │   │   │   └── operator_loc: (5...6) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (10...11) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (12...13) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3_3.txt b/test/yarp/snapshots/seattlerb/difficult3_3.txt
index 700f53cb67..f077b4a025 100644
--- a/test/yarp/snapshots/seattlerb/difficult3_3.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3_3.txt
@@ -1,35 +1,44 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...17)(
-         [:a, :b, :c],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [],
-             [],
-             [RequiredParameterNode(9...10)(:b)],
-             RestParameterNode(5...7)(:a, (6...7), (5...6)),
-             [],
-             nil,
-             BlockParameterNode(12...14)(:c, (13...14), (12...13))
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         nil,
-         (2...3),
-         (16...17)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...17))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (5...7))
+            │   │   │   │   ├── name: :a
+            │   │   │   │   ├── name_loc: (6...7) = "a"
+            │   │   │   │   └── operator_loc: (5...6) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (12...14))
+            │   │   │       ├── name: :c
+            │   │   │       ├── name_loc: (13...14) = "c"
+            │   │   │       └── operator_loc: (12...13) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (16...17) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3_4.txt b/test/yarp/snapshots/seattlerb/difficult3_4.txt
index 40ebfca661..ca07b60783 100644
--- a/test/yarp/snapshots/seattlerb/difficult3_4.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3_4.txt
@@ -1,22 +1,37 @@
-ProgramNode(0...17)(
-  [:a],
-  StatementsNode(0...17)(
-    [LocalVariableWriteNode(0...17)(
-       :a,
-       0,
-       (0...1),
-       IfNode(2...17)(
-         nil,
-         CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "b"),
-         StatementsNode(6...10)([TrueNode(6...10)()]),
-         ElseNode(10...17)(
-           (10...11),
-           StatementsNode(12...17)([FalseNode(12...17)()]),
-           nil
-         ),
-         nil
-       ),
-       (1...2)
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...17))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ IfNode (location: (2...17))
+            │   ├── if_keyword_loc: ∅
+            │   ├── predicate:
+            │   │   @ CallNode (location: (2...3))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (2...3) = "b"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "b"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (6...10))
+            │   │   └── body: (length: 1)
+            │   │       └── @ TrueNode (location: (6...10))
+            │   ├── consequent:
+            │   │   @ ElseNode (location: (10...17))
+            │   │   ├── else_keyword_loc: (10...11) = ":"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (12...17))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ FalseNode (location: (12...17))
+            │   │   └── end_keyword_loc: ∅
+            │   └── end_keyword_loc: ∅
+            └── operator_loc: (1...2) = "="
diff --git a/test/yarp/snapshots/seattlerb/difficult3_5.txt b/test/yarp/snapshots/seattlerb/difficult3_5.txt
index 746786b8a5..8859389448 100644
--- a/test/yarp/snapshots/seattlerb/difficult3_5.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3_5.txt
@@ -1,37 +1,47 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [CallNode(0...19)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...19)(
-         [LambdaNode(2...19)(
-            [],
-            (2...4),
-            (7...8),
-            (18...19),
-            BlockParametersNode(4...6)(nil, [], (4...5), (5...6)),
-            StatementsNode(9...17)(
-              [CallNode(9...17)(
-                 nil,
-                 nil,
-                 (9...10),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(11...17)([], nil, nil, (11...13), (14...17)),
-                 0,
-                 "g"
-               )]
-            )
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...19))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...19))
+            │   └── arguments: (length: 1)
+            │       └── @ LambdaNode (location: (2...19))
+            │           ├── locals: []
+            │           ├── operator_loc: (2...4) = "->"
+            │           ├── opening_loc: (7...8) = "{"
+            │           ├── closing_loc: (18...19) = "}"
+            │           ├── parameters:
+            │           │   @ BlockParametersNode (location: (4...6))
+            │           │   ├── parameters: ∅
+            │           │   ├── locals: (length: 0)
+            │           │   ├── opening_loc: (4...5) = "("
+            │           │   └── closing_loc: (5...6) = ")"
+            │           └── body:
+            │               @ StatementsNode (location: (9...17))
+            │               └── body: (length: 1)
+            │                   └── @ CallNode (location: (9...17))
+            │                       ├── receiver: ∅
+            │                       ├── call_operator_loc: ∅
+            │                       ├── message_loc: (9...10) = "g"
+            │                       ├── opening_loc: ∅
+            │                       ├── arguments: ∅
+            │                       ├── closing_loc: ∅
+            │                       ├── block:
+            │                       │   @ BlockNode (location: (11...17))
+            │                       │   ├── locals: []
+            │                       │   ├── parameters: ∅
+            │                       │   ├── body: ∅
+            │                       │   ├── opening_loc: (11...13) = "do"
+            │                       │   └── closing_loc: (14...17) = "end"
+            │                       ├── flags: 
+            │                       └── name: "g"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3__10.txt b/test/yarp/snapshots/seattlerb/difficult3__10.txt
index 7b7dc6f41b..e401090819 100644
--- a/test/yarp/snapshots/seattlerb/difficult3__10.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3__10.txt
@@ -1,44 +1,47 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...18)(
-         [:a, :b, :c],
-         BlockParametersNode(4...16)(
-           ParametersNode(5...15)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...15)(
-                [SplatNode(9...11)(
-                   (9...10),
-                   RequiredParameterNode(10...11)(:b)
-                 ),
-                 RequiredParameterNode(13...14)(:c)],
-                (8...9),
-                (14...15)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (15...16)
-         ),
-         nil,
-         (2...3),
-         (17...18)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...18))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...18))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...16))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...15))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...15))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ SplatNode (location: (9...11))
+            │   │   │   │       │   │   ├── operator_loc: (9...10) = "*"
+            │   │   │   │       │   │   └── expression:
+            │   │   │   │       │   │       @ RequiredParameterNode (location: (10...11))
+            │   │   │   │       │   │       └── name: :b
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (13...14))
+            │   │   │   │       │       └── name: :c
+            │   │   │   │       ├── opening_loc: (8...9) = "("
+            │   │   │   │       └── closing_loc: (14...15) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (15...16) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (17...18) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3__11.txt b/test/yarp/snapshots/seattlerb/difficult3__11.txt
index c5b8b81b18..d2343207bb 100644
--- a/test/yarp/snapshots/seattlerb/difficult3__11.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3__11.txt
@@ -1,40 +1,43 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...14)(
-         [:a],
-         BlockParametersNode(4...12)(
-           ParametersNode(5...11)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...11)(
-                [SplatNode(9...10)((9...10), nil)],
-                (8...9),
-                (10...11)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (11...12)
-         ),
-         nil,
-         (2...3),
-         (13...14)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...14))
+            │   ├── locals: [:a]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...11))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...11))
+            │   │   │   │       ├── parameters: (length: 1)
+            │   │   │   │       │   └── @ SplatNode (location: (9...10))
+            │   │   │   │       │       ├── operator_loc: (9...10) = "*"
+            │   │   │   │       │       └── expression: ∅
+            │   │   │   │       ├── opening_loc: (8...9) = "("
+            │   │   │   │       └── closing_loc: (10...11) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (11...12) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (13...14) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3__12.txt b/test/yarp/snapshots/seattlerb/difficult3__12.txt
index 87dd280a9e..8223e440ca 100644
--- a/test/yarp/snapshots/seattlerb/difficult3__12.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3__12.txt
@@ -1,41 +1,45 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...17)(
-         [:a, :b],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...14)(
-                [SplatNode(9...10)((9...10), nil),
-                 RequiredParameterNode(12...13)(:b)],
-                (8...9),
-                (13...14)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         nil,
-         (2...3),
-         (16...17)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...17))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...14))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ SplatNode (location: (9...10))
+            │   │   │   │       │   │   ├── operator_loc: (9...10) = "*"
+            │   │   │   │       │   │   └── expression: ∅
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (12...13))
+            │   │   │   │       │       └── name: :b
+            │   │   │   │       ├── opening_loc: (8...9) = "("
+            │   │   │   │       └── closing_loc: (13...14) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (16...17) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3__6.txt b/test/yarp/snapshots/seattlerb/difficult3__6.txt
index 578a22e843..b5b9ca334a 100644
--- a/test/yarp/snapshots/seattlerb/difficult3__6.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3__6.txt
@@ -1,45 +1,49 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [CallNode(0...21)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...21)(
-         [:a, :b, :c, :d],
-         BlockParametersNode(4...19)(
-           ParametersNode(5...18)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...18)(
-                [RequiredParameterNode(9...10)(:b),
-                 SplatNode(12...14)(
-                   (12...13),
-                   RequiredParameterNode(13...14)(:c)
-                 ),
-                 RequiredParameterNode(16...17)(:d)],
-                (8...9),
-                (17...18)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (18...19)
-         ),
-         nil,
-         (2...3),
-         (20...21)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...21))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...21))
+            │   ├── locals: [:a, :b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...19))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...18))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...18))
+            │   │   │   │       ├── parameters: (length: 3)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       │   │   └── name: :b
+            │   │   │   │       │   ├── @ SplatNode (location: (12...14))
+            │   │   │   │       │   │   ├── operator_loc: (12...13) = "*"
+            │   │   │   │       │   │   └── expression:
+            │   │   │   │       │   │       @ RequiredParameterNode (location: (13...14))
+            │   │   │   │       │   │       └── name: :c
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (16...17))
+            │   │   │   │       │       └── name: :d
+            │   │   │   │       ├── opening_loc: (8...9) = "("
+            │   │   │   │       └── closing_loc: (17...18) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (18...19) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (20...21) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3__7.txt b/test/yarp/snapshots/seattlerb/difficult3__7.txt
index a306b1f895..507a777916 100644
--- a/test/yarp/snapshots/seattlerb/difficult3__7.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3__7.txt
@@ -1,41 +1,45 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...17)(
-         [:a, :b],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...14)(
-                [RequiredParameterNode(9...10)(:b),
-                 SplatNode(12...13)((12...13), nil)],
-                (8...9),
-                (13...14)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         nil,
-         (2...3),
-         (16...17)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...17))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...14))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       │   │   └── name: :b
+            │   │   │   │       │   └── @ SplatNode (location: (12...13))
+            │   │   │   │       │       ├── operator_loc: (12...13) = "*"
+            │   │   │   │       │       └── expression: ∅
+            │   │   │   │       ├── opening_loc: (8...9) = "("
+            │   │   │   │       └── closing_loc: (13...14) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (16...17) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3__8.txt b/test/yarp/snapshots/seattlerb/difficult3__8.txt
index 9d0eb81357..f14db9e0f6 100644
--- a/test/yarp/snapshots/seattlerb/difficult3__8.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3__8.txt
@@ -1,42 +1,47 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [CallNode(0...20)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...20)(
-         [:a, :b, :c],
-         BlockParametersNode(4...18)(
-           ParametersNode(5...17)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...17)(
-                [RequiredParameterNode(9...10)(:b),
-                 SplatNode(12...13)((12...13), nil),
-                 RequiredParameterNode(15...16)(:c)],
-                (8...9),
-                (16...17)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (17...18)
-         ),
-         nil,
-         (2...3),
-         (19...20)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...20))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...20))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...18))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...17))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...17))
+            │   │   │   │       ├── parameters: (length: 3)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       │   │   └── name: :b
+            │   │   │   │       │   ├── @ SplatNode (location: (12...13))
+            │   │   │   │       │   │   ├── operator_loc: (12...13) = "*"
+            │   │   │   │       │   │   └── expression: ∅
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (15...16))
+            │   │   │   │       │       └── name: :c
+            │   │   │   │       ├── opening_loc: (8...9) = "("
+            │   │   │   │       └── closing_loc: (16...17) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (17...18) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (19...20) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult3__9.txt b/test/yarp/snapshots/seattlerb/difficult3__9.txt
index a3a5ccd89d..0adeec368d 100644
--- a/test/yarp/snapshots/seattlerb/difficult3__9.txt
+++ b/test/yarp/snapshots/seattlerb/difficult3__9.txt
@@ -1,43 +1,45 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...15)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...15)(
-         [:a, :b],
-         BlockParametersNode(4...13)(
-           ParametersNode(5...12)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...12)(
-                [SplatNode(9...11)(
-                   (9...10),
-                   RequiredParameterNode(10...11)(:b)
-                 )],
-                (8...9),
-                (11...12)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (12...13)
-         ),
-         nil,
-         (2...3),
-         (14...15)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...15))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...15))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...13))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...12))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (8...12))
+            │   │   │   │       ├── parameters: (length: 1)
+            │   │   │   │       │   └── @ SplatNode (location: (9...11))
+            │   │   │   │       │       ├── operator_loc: (9...10) = "*"
+            │   │   │   │       │       └── expression:
+            │   │   │   │       │           @ RequiredParameterNode (location: (10...11))
+            │   │   │   │       │           └── name: :b
+            │   │   │   │       ├── opening_loc: (8...9) = "("
+            │   │   │   │       └── closing_loc: (11...12) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (12...13) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (14...15) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/difficult4__leading_dots.txt b/test/yarp/snapshots/seattlerb/difficult4__leading_dots.txt
index 881cc6d5a8..8daf7a20ca 100644
--- a/test/yarp/snapshots/seattlerb/difficult4__leading_dots.txt
+++ b/test/yarp/snapshots/seattlerb/difficult4__leading_dots.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [CallNode(0...4)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (2...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...4))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (2...3) = "."
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/difficult4__leading_dots2.txt b/test/yarp/snapshots/seattlerb/difficult4__leading_dots2.txt
index 8a246f5827..5e72abfe5e 100644
--- a/test/yarp/snapshots/seattlerb/difficult4__leading_dots2.txt
+++ b/test/yarp/snapshots/seattlerb/difficult4__leading_dots2.txt
@@ -1,7 +1,12 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [IntegerNode(0...1)(),
-     RangeNode(2...5)(nil, IntegerNode(4...5)(), (2...4), 0)]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 2)
+        ├── @ IntegerNode (location: (0...1))
+        └── @ RangeNode (location: (2...5))
+            ├── left: ∅
+            ├── right:
+            │   @ IntegerNode (location: (4...5))
+            ├── operator_loc: (2...4) = ".."
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/difficult6_.txt b/test/yarp/snapshots/seattlerb/difficult6_.txt
index 2d1677e108..8a8bc9e344 100644
--- a/test/yarp/snapshots/seattlerb/difficult6_.txt
+++ b/test/yarp/snapshots/seattlerb/difficult6_.txt
@@ -1,50 +1,57 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [LambdaNode(0...25)(
-       [:a, :b],
-       (0...2),
-       (13...14),
-       (24...25),
-       BlockParametersNode(2...12)(
-         ParametersNode(3...11)(
-           [RequiredParameterNode(3...4)(:a)],
-           [OptionalParameterNode(6...11)(
-              :b,
-              (6...7),
-              (7...8),
-              NilNode(8...11)()
-            )],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (2...3),
-         (11...12)
-       ),
-       StatementsNode(15...23)(
-         [CallNode(15...23)(
-            nil,
-            nil,
-            (15...16),
-            nil,
-            ArgumentsNode(17...23)(
-              [ArrayNode(17...23)(
-                 [LocalVariableReadNode(18...19)(:a, 0),
-                  LocalVariableReadNode(21...22)(:b, 0)],
-                 (17...18),
-                 (22...23)
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "p"
-          )]
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...25))
+            ├── locals: [:a, :b]
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (13...14) = "{"
+            ├── closing_loc: (24...25) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (2...12))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (3...11))
+            │   │   ├── requireds: (length: 1)
+            │   │   │   └── @ RequiredParameterNode (location: (3...4))
+            │   │   │       └── name: :a
+            │   │   ├── optionals: (length: 1)
+            │   │   │   └── @ OptionalParameterNode (location: (6...11))
+            │   │   │       ├── name: :b
+            │   │   │       ├── name_loc: (6...7) = "b"
+            │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │       └── value:
+            │   │   │           @ NilNode (location: (8...11))
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 0)
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: (2...3) = "("
+            │   └── closing_loc: (11...12) = ")"
+            └── body:
+                @ StatementsNode (location: (15...23))
+                └── body: (length: 1)
+                    └── @ CallNode (location: (15...23))
+                        ├── receiver: ∅
+                        ├── call_operator_loc: ∅
+                        ├── message_loc: (15...16) = "p"
+                        ├── opening_loc: ∅
+                        ├── arguments:
+                        │   @ ArgumentsNode (location: (17...23))
+                        │   └── arguments: (length: 1)
+                        │       └── @ ArrayNode (location: (17...23))
+                        │           ├── elements: (length: 2)
+                        │           │   ├── @ LocalVariableReadNode (location: (18...19))
+                        │           │   │   ├── name: :a
+                        │           │   │   └── depth: 0
+                        │           │   └── @ LocalVariableReadNode (location: (21...22))
+                        │           │       ├── name: :b
+                        │           │       └── depth: 0
+                        │           ├── opening_loc: (17...18) = "["
+                        │           └── closing_loc: (22...23) = "]"
+                        ├── closing_loc: ∅
+                        ├── block: ∅
+                        ├── flags: 
+                        └── name: "p"
diff --git a/test/yarp/snapshots/seattlerb/difficult6__7.txt b/test/yarp/snapshots/seattlerb/difficult6__7.txt
index 60b902f4d2..331435a0b6 100644
--- a/test/yarp/snapshots/seattlerb/difficult6__7.txt
+++ b/test/yarp/snapshots/seattlerb/difficult6__7.txt
@@ -1,30 +1,52 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallNode(0...11)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...3),
-       nil,
-       ArgumentsNode(4...7)(
-         [ParenthesesNode(4...7)(
-            StatementsNode(5...6)([IntegerNode(5...6)()]),
-            (4...5),
-            (6...7)
-          )]
-       ),
-       nil,
-       BlockNode(8...11)(
-         [],
-         nil,
-         StatementsNode(9...10)(
-           [CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "c")]
-         ),
-         (8...9),
-         (10...11)
-       ),
-       0,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...11))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...3) = "b"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...7))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (4...7))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (5...6))
+            │           │   └── body: (length: 1)
+            │           │       └── @ IntegerNode (location: (5...6))
+            │           ├── opening_loc: (4...5) = "("
+            │           └── closing_loc: (6...7) = ")"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (8...11))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (9...10))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (9...10))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (9...10) = "c"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "c"
+            │   ├── opening_loc: (8...9) = "{"
+            │   └── closing_loc: (10...11) = "}"
+            ├── flags: 
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/difficult6__8.txt b/test/yarp/snapshots/seattlerb/difficult6__8.txt
index ed7a53a89a..d21dfbe4bf 100644
--- a/test/yarp/snapshots/seattlerb/difficult6__8.txt
+++ b/test/yarp/snapshots/seattlerb/difficult6__8.txt
@@ -1,30 +1,52 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...12)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       ArgumentsNode(5...8)(
-         [ParenthesesNode(5...8)(
-            StatementsNode(6...7)([IntegerNode(6...7)()]),
-            (5...6),
-            (7...8)
-          )]
-       ),
-       nil,
-       BlockNode(9...12)(
-         [],
-         nil,
-         StatementsNode(10...11)(
-           [CallNode(10...11)(nil, nil, (10...11), nil, nil, nil, nil, 2, "c")]
-         ),
-         (9...10),
-         (11...12)
-       ),
-       0,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...12))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "::"
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...8))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (5...8))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (6...7))
+            │           │   └── body: (length: 1)
+            │           │       └── @ IntegerNode (location: (6...7))
+            │           ├── opening_loc: (5...6) = "("
+            │           └── closing_loc: (7...8) = ")"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (9...12))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (10...11))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (10...11))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (10...11) = "c"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "c"
+            │   ├── opening_loc: (9...10) = "{"
+            │   └── closing_loc: (11...12) = "}"
+            ├── flags: 
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/difficult7_.txt b/test/yarp/snapshots/seattlerb/difficult7_.txt
index 44a67b3377..7d95285b85 100644
--- a/test/yarp/snapshots/seattlerb/difficult7_.txt
+++ b/test/yarp/snapshots/seattlerb/difficult7_.txt
@@ -1,81 +1,90 @@
-ProgramNode(6...66)(
-  [],
-  StatementsNode(6...66)(
-    [HashNode(6...66)(
-       (6...7),
-       [AssocNode(16...41)(
-          SymbolNode(16...18)(nil, (16...17), (17...18), "a"),
-          CallNode(19...41)(
-            nil,
-            nil,
-            (19...25),
-            nil,
-            nil,
-            nil,
-            BlockNode(26...41)(
-              [],
-              nil,
-              StatementsNode(28...39)(
-                [IfNode(28...39)(
-                   nil,
-                   CallNode(28...29)(
-                     nil,
-                     nil,
-                     (28...29),
-                     nil,
-                     nil,
-                     nil,
-                     nil,
-                     2,
-                     "b"
-                   ),
-                   StatementsNode(32...35)(
-                     [CallNode(32...35)(
-                        nil,
-                        nil,
-                        (32...33),
-                        (33...34),
-                        nil,
-                        (34...35),
-                        nil,
-                        0,
-                        "c"
-                      )]
-                   ),
-                   ElseNode(36...39)(
-                     (36...37),
-                     StatementsNode(38...39)(
-                       [CallNode(38...39)(
-                          nil,
-                          nil,
-                          (38...39),
-                          nil,
-                          nil,
-                          nil,
-                          nil,
-                          2,
-                          "d"
-                        )]
-                     ),
-                     nil
-                   ),
-                   nil
-                 )]
-              ),
-              (26...27),
-              (40...41)
-            ),
-            0,
-            "lambda"
-          ),
-          nil
-        ),
-        AssocNode(51...57)(
-          SymbolNode(51...53)(nil, (51...52), (52...53), "e"),
-          NilNode(54...57)(),
-          nil
-        )],
-       (65...66)
-     )]
-  )
-)
+@ ProgramNode (location: (6...66))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (6...66))
+    └── body: (length: 1)
+        └── @ HashNode (location: (6...66))
+            ├── opening_loc: (6...7) = "{"
+            ├── elements: (length: 2)
+            │   ├── @ AssocNode (location: (16...41))
+            │   │   ├── key:
+            │   │   │   @ SymbolNode (location: (16...18))
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── value_loc: (16...17) = "a"
+            │   │   │   ├── closing_loc: (17...18) = ":"
+            │   │   │   └── unescaped: "a"
+            │   │   ├── value:
+            │   │   │   @ CallNode (location: (19...41))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (19...25) = "lambda"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block:
+            │   │   │   │   @ BlockNode (location: (26...41))
+            │   │   │   │   ├── locals: []
+            │   │   │   │   ├── parameters: ∅
+            │   │   │   │   ├── body:
+            │   │   │   │   │   @ StatementsNode (location: (28...39))
+            │   │   │   │   │   └── body: (length: 1)
+            │   │   │   │   │       └── @ IfNode (location: (28...39))
+            │   │   │   │   │           ├── if_keyword_loc: ∅
+            │   │   │   │   │           ├── predicate:
+            │   │   │   │   │           │   @ CallNode (location: (28...29))
+            │   │   │   │   │           │   ├── receiver: ∅
+            │   │   │   │   │           │   ├── call_operator_loc: ∅
+            │   │   │   │   │           │   ├── message_loc: (28...29) = "b"
+            │   │   │   │   │           │   ├── opening_loc: ∅
+            │   │   │   │   │           │   ├── arguments: ∅
+            │   │   │   │   │           │   ├── closing_loc: ∅
+            │   │   │   │   │           │   ├── block: ∅
+            │   │   │   │   │           │   ├── flags: variable_call
+            │   │   │   │   │           │   └── name: "b"
+            │   │   │   │   │           ├── statements:
+            │   │   │   │   │           │   @ StatementsNode (location: (32...35))
+            │   │   │   │   │           │   └── body: (length: 1)
+            │   │   │   │   │           │       └── @ CallNode (location: (32...35))
+            │   │   │   │   │           │           ├── receiver: ∅
+            │   │   │   │   │           │           ├── call_operator_loc: ∅
+            │   │   │   │   │           │           ├── message_loc: (32...33) = "c"
+            │   │   │   │   │           │           ├── opening_loc: (33...34) = "("
+            │   │   │   │   │           │           ├── arguments: ∅
+            │   │   │   │   │           │           ├── closing_loc: (34...35) = ")"
+            │   │   │   │   │           │           ├── block: ∅
+            │   │   │   │   │           │           ├── flags: 
+            │   │   │   │   │           │           └── name: "c"
+            │   │   │   │   │           ├── consequent:
+            │   │   │   │   │           │   @ ElseNode (location: (36...39))
+            │   │   │   │   │           │   ├── else_keyword_loc: (36...37) = ":"
+            │   │   │   │   │           │   ├── statements:
+            │   │   │   │   │           │   │   @ StatementsNode (location: (38...39))
+            │   │   │   │   │           │   │   └── body: (length: 1)
+            │   │   │   │   │           │   │       └── @ CallNode (location: (38...39))
+            │   │   │   │   │           │   │           ├── receiver: ∅
+            │   │   │   │   │           │   │           ├── call_operator_loc: ∅
+            │   │   │   │   │           │   │           ├── message_loc: (38...39) = "d"
+            │   │   │   │   │           │   │           ├── opening_loc: ∅
+            │   │   │   │   │           │   │           ├── arguments: ∅
+            │   │   │   │   │           │   │           ├── closing_loc: ∅
+            │   │   │   │   │           │   │           ├── block: ∅
+            │   │   │   │   │           │   │           ├── flags: variable_call
+            │   │   │   │   │           │   │           └── name: "d"
+            │   │   │   │   │           │   └── end_keyword_loc: ∅
+            │   │   │   │   │           └── end_keyword_loc: ∅
+            │   │   │   │   ├── opening_loc: (26...27) = "{"
+            │   │   │   │   └── closing_loc: (40...41) = "}"
+            │   │   │   ├── flags: 
+            │   │   │   └── name: "lambda"
+            │   │   └── operator_loc: ∅
+            │   └── @ AssocNode (location: (51...57))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (51...53))
+            │       │   ├── opening_loc: ∅
+            │       │   ├── value_loc: (51...52) = "e"
+            │       │   ├── closing_loc: (52...53) = ":"
+            │       │   └── unescaped: "e"
+            │       ├── value:
+            │       │   @ NilNode (location: (54...57))
+            │       └── operator_loc: ∅
+            └── closing_loc: (65...66) = "}"
diff --git a/test/yarp/snapshots/seattlerb/do_bug.txt b/test/yarp/snapshots/seattlerb/do_bug.txt
index 269d349519..74734bbb96 100644
--- a/test/yarp/snapshots/seattlerb/do_bug.txt
+++ b/test/yarp/snapshots/seattlerb/do_bug.txt
@@ -1,46 +1,59 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [CallNode(0...3)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...3)([IntegerNode(2...3)()]),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(4...33)(
-       CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "a"),
-       (5...6),
-       (6...7),
-       nil,
-       nil,
-       nil,
-       BlockNode(8...33)(
-         [:c],
-         BlockParametersNode(11...14)(
-           ParametersNode(12...13)(
-             [RequiredParameterNode(12...13)(:c)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (11...12),
-           (13...14)
-         ),
-         nil,
-         (8...10),
-         (30...33)
-       ),
-       0,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...3))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...3))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (2...3))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (4...33))
+            ├── receiver:
+            │   @ CallNode (location: (4...5))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (4...5) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (5...6) = "."
+            ├── message_loc: (6...7) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (8...33))
+            │   ├── locals: [:c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (11...14))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (12...13))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (12...13))
+            │   │   │   │       └── name: :c
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (11...12) = "|"
+            │   │   └── closing_loc: (13...14) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (8...10) = "do"
+            │   └── closing_loc: (30...33) = "end"
+            ├── flags: 
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/do_lambda.txt b/test/yarp/snapshots/seattlerb/do_lambda.txt
index a7eb211623..99e9ac7074 100644
--- a/test/yarp/snapshots/seattlerb/do_lambda.txt
+++ b/test/yarp/snapshots/seattlerb/do_lambda.txt
@@ -1,13 +1,17 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [LambdaNode(0...11)(
-       [],
-       (0...2),
-       (5...7),
-       (8...11),
-       BlockParametersNode(2...4)(nil, [], (2...3), (3...4)),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...11))
+            ├── locals: []
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (5...7) = "do"
+            ├── closing_loc: (8...11) = "end"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (2...4))
+            │   ├── parameters: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: (2...3) = "("
+            │   └── closing_loc: (3...4) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/seattlerb/dot2_nil__26.txt b/test/yarp/snapshots/seattlerb/dot2_nil__26.txt
index 38e8dfd9c0..0d5706be91 100644
--- a/test/yarp/snapshots/seattlerb/dot2_nil__26.txt
+++ b/test/yarp/snapshots/seattlerb/dot2_nil__26.txt
@@ -1,11 +1,20 @@
-ProgramNode(0...3)(
-  [],
-  StatementsNode(0...3)(
-    [RangeNode(0...3)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (1...3),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ RangeNode (location: (0...3))
+            ├── left:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── right: ∅
+            ├── operator_loc: (1...3) = ".."
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/dot3_nil__26.txt b/test/yarp/snapshots/seattlerb/dot3_nil__26.txt
index 91cf903a9a..7fee58b4c4 100644
--- a/test/yarp/snapshots/seattlerb/dot3_nil__26.txt
+++ b/test/yarp/snapshots/seattlerb/dot3_nil__26.txt
@@ -1,11 +1,20 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [RangeNode(0...4)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (1...4),
-       1
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ RangeNode (location: (0...4))
+            ├── left:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── right: ∅
+            ├── operator_loc: (1...4) = "..."
+            └── flags: exclude_end
diff --git a/test/yarp/snapshots/seattlerb/dstr_evstr.txt b/test/yarp/snapshots/seattlerb/dstr_evstr.txt
index 75377e9c7f..70e4b2a7e7 100644
--- a/test/yarp/snapshots/seattlerb/dstr_evstr.txt
+++ b/test/yarp/snapshots/seattlerb/dstr_evstr.txt
@@ -1,23 +1,36 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [InterpolatedStringNode(0...12)(
-       (0...1),
-       [EmbeddedStatementsNode(1...7)(
-          (1...3),
-          StatementsNode(3...6)(
-            [StringNode(3...6)((3...4), (4...5), (5...6), "a")]
-          ),
-          (6...7)
-        ),
-        EmbeddedStatementsNode(7...11)(
-          (7...9),
-          StatementsNode(9...10)(
-            [CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "b")]
-          ),
-          (10...11)
-        )],
-       (11...12)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...12))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 2)
+            │   ├── @ EmbeddedStatementsNode (location: (1...7))
+            │   │   ├── opening_loc: (1...3) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (3...6))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ StringNode (location: (3...6))
+            │   │   │           ├── opening_loc: (3...4) = "'"
+            │   │   │           ├── content_loc: (4...5) = "a"
+            │   │   │           ├── closing_loc: (5...6) = "'"
+            │   │   │           └── unescaped: "a"
+            │   │   └── closing_loc: (6...7) = "}"
+            │   └── @ EmbeddedStatementsNode (location: (7...11))
+            │       ├── opening_loc: (7...9) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (9...10))
+            │       │   └── body: (length: 1)
+            │       │       └── @ CallNode (location: (9...10))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (9...10) = "b"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments: ∅
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: variable_call
+            │       │           └── name: "b"
+            │       └── closing_loc: (10...11) = "}"
+            └── closing_loc: (11...12) = "\""
diff --git a/test/yarp/snapshots/seattlerb/dstr_evstr_empty_end.txt b/test/yarp/snapshots/seattlerb/dstr_evstr_empty_end.txt
index e4a9c81b88..9a43e6fe4f 100644
--- a/test/yarp/snapshots/seattlerb/dstr_evstr_empty_end.txt
+++ b/test/yarp/snapshots/seattlerb/dstr_evstr_empty_end.txt
@@ -1,26 +1,25 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [InterpolatedSymbolNode(0...11)(
-       (0...2),
-       [EmbeddedStatementsNode(2...10)(
-          (2...4),
-          StatementsNode(4...9)(
-            [CallNode(4...9)(
-               nil,
-               nil,
-               (4...9),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "field"
-             )]
-          ),
-          (9...10)
-        )],
-       (10...11)
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ InterpolatedSymbolNode (location: (0...11))
+            ├── opening_loc: (0...2) = ":\""
+            ├── parts: (length: 1)
+            │   └── @ EmbeddedStatementsNode (location: (2...10))
+            │       ├── opening_loc: (2...4) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (4...9))
+            │       │   └── body: (length: 1)
+            │       │       └── @ CallNode (location: (4...9))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (4...9) = "field"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments: ∅
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: variable_call
+            │       │           └── name: "field"
+            │       └── closing_loc: (9...10) = "}"
+            └── closing_loc: (10...11) = "\""
diff --git a/test/yarp/snapshots/seattlerb/dstr_lex_state.txt b/test/yarp/snapshots/seattlerb/dstr_lex_state.txt
index 50e327ab9c..21b7cb0117 100644
--- a/test/yarp/snapshots/seattlerb/dstr_lex_state.txt
+++ b/test/yarp/snapshots/seattlerb/dstr_lex_state.txt
@@ -1,28 +1,32 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [InterpolatedStringNode(0...8)(
-       (0...1),
-       [EmbeddedStatementsNode(1...7)(
-          (1...3),
-          StatementsNode(3...6)(
-            [CallNode(3...6)(
-               nil,
-               nil,
-               (3...4),
-               nil,
-               ArgumentsNode(4...6)(
-                 [SymbolNode(4...6)((4...5), (5...6), nil, "a")]
-               ),
-               nil,
-               nil,
-               0,
-               "p"
-             )]
-          ),
-          (6...7)
-        )],
-       (7...8)
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...8))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 1)
+            │   └── @ EmbeddedStatementsNode (location: (1...7))
+            │       ├── opening_loc: (1...3) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (3...6))
+            │       │   └── body: (length: 1)
+            │       │       └── @ CallNode (location: (3...6))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (3...4) = "p"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments:
+            │       │           │   @ ArgumentsNode (location: (4...6))
+            │       │           │   └── arguments: (length: 1)
+            │       │           │       └── @ SymbolNode (location: (4...6))
+            │       │           │           ├── opening_loc: (4...5) = ":"
+            │       │           │           ├── value_loc: (5...6) = "a"
+            │       │           │           ├── closing_loc: ∅
+            │       │           │           └── unescaped: "a"
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: 
+            │       │           └── name: "p"
+            │       └── closing_loc: (6...7) = "}"
+            └── closing_loc: (7...8) = "\""
diff --git a/test/yarp/snapshots/seattlerb/dstr_str.txt b/test/yarp/snapshots/seattlerb/dstr_str.txt
index e17b035d2f..1693c51f85 100644
--- a/test/yarp/snapshots/seattlerb/dstr_str.txt
+++ b/test/yarp/snapshots/seattlerb/dstr_str.txt
@@ -1,17 +1,25 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [InterpolatedStringNode(0...10)(
-       (0...1),
-       [EmbeddedStatementsNode(1...7)(
-          (1...3),
-          StatementsNode(3...6)(
-            [StringNode(3...6)((3...4), (4...5), (5...6), "a")]
-          ),
-          (6...7)
-        ),
-        StringNode(7...9)(nil, (7...9), nil, " b")],
-       (9...10)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...10))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 2)
+            │   ├── @ EmbeddedStatementsNode (location: (1...7))
+            │   │   ├── opening_loc: (1...3) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (3...6))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ StringNode (location: (3...6))
+            │   │   │           ├── opening_loc: (3...4) = "'"
+            │   │   │           ├── content_loc: (4...5) = "a"
+            │   │   │           ├── closing_loc: (5...6) = "'"
+            │   │   │           └── unescaped: "a"
+            │   │   └── closing_loc: (6...7) = "}"
+            │   └── @ StringNode (location: (7...9))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (7...9) = " b"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: " b"
+            └── closing_loc: (9...10) = "\""
diff --git a/test/yarp/snapshots/seattlerb/dsym_esc_to_sym.txt b/test/yarp/snapshots/seattlerb/dsym_esc_to_sym.txt
index 4f6697237b..15e1ec2b16 100644
--- a/test/yarp/snapshots/seattlerb/dsym_esc_to_sym.txt
+++ b/test/yarp/snapshots/seattlerb/dsym_esc_to_sym.txt
@@ -1,6 +1,10 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [SymbolNode(0...17)((0...2), (2...16), (16...17), "Varietà")]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ SymbolNode (location: (0...17))
+            ├── opening_loc: (0...2) = ":\""
+            ├── value_loc: (2...16) = "Variet\\303\\240"
+            ├── closing_loc: (16...17) = "\""
+            └── unescaped: "Varietà"
diff --git a/test/yarp/snapshots/seattlerb/dsym_to_sym.txt b/test/yarp/snapshots/seattlerb/dsym_to_sym.txt
index d383b67184..8c79a29d15 100644
--- a/test/yarp/snapshots/seattlerb/dsym_to_sym.txt
+++ b/test/yarp/snapshots/seattlerb/dsym_to_sym.txt
@@ -1,15 +1,33 @@
-ProgramNode(0...32)(
-  [],
-  StatementsNode(0...32)(
-    [AliasNode(0...17)(
-       SymbolNode(6...11)((6...8), (8...10), (10...11), "<<"),
-       SymbolNode(12...17)((12...14), (14...16), (16...17), ">>"),
-       (0...5)
-     ),
-     AliasNode(19...32)(
-       SymbolNode(25...28)((25...26), (26...28), nil, "<<"),
-       SymbolNode(29...32)((29...30), (30...32), nil, ">>"),
-       (19...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...32))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...32))
+    └── body: (length: 2)
+        ├── @ AliasNode (location: (0...17))
+        │   ├── new_name:
+        │   │   @ SymbolNode (location: (6...11))
+        │   │   ├── opening_loc: (6...8) = ":\""
+        │   │   ├── value_loc: (8...10) = "<<"
+        │   │   ├── closing_loc: (10...11) = "\""
+        │   │   └── unescaped: "<<"
+        │   ├── old_name:
+        │   │   @ SymbolNode (location: (12...17))
+        │   │   ├── opening_loc: (12...14) = ":\""
+        │   │   ├── value_loc: (14...16) = ">>"
+        │   │   ├── closing_loc: (16...17) = "\""
+        │   │   └── unescaped: ">>"
+        │   └── keyword_loc: (0...5) = "alias"
+        └── @ AliasNode (location: (19...32))
+            ├── new_name:
+            │   @ SymbolNode (location: (25...28))
+            │   ├── opening_loc: (25...26) = ":"
+            │   ├── value_loc: (26...28) = "<<"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "<<"
+            ├── old_name:
+            │   @ SymbolNode (location: (29...32))
+            │   ├── opening_loc: (29...30) = ":"
+            │   ├── value_loc: (30...32) = ">>"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: ">>"
+            └── keyword_loc: (19...24) = "alias"
diff --git a/test/yarp/snapshots/seattlerb/eq_begin_line_numbers.txt b/test/yarp/snapshots/seattlerb/eq_begin_line_numbers.txt
index 46a167a8de..58c3312980 100644
--- a/test/yarp/snapshots/seattlerb/eq_begin_line_numbers.txt
+++ b/test/yarp/snapshots/seattlerb/eq_begin_line_numbers.txt
@@ -1,4 +1,7 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)([IntegerNode(0...1)(), IntegerNode(30...31)()])
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 2)
+        ├── @ IntegerNode (location: (0...1))
+        └── @ IntegerNode (location: (30...31))
diff --git a/test/yarp/snapshots/seattlerb/eq_begin_why_wont_people_use_their_spacebar.txt b/test/yarp/snapshots/seattlerb/eq_begin_why_wont_people_use_their_spacebar.txt
index e277d15a34..238fa48188 100644
--- a/test/yarp/snapshots/seattlerb/eq_begin_why_wont_people_use_their_spacebar.txt
+++ b/test/yarp/snapshots/seattlerb/eq_begin_why_wont_people_use_their_spacebar.txt
@@ -1,26 +1,47 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [CallNode(0...29)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "h"),
-       nil,
-       (1...4),
-       (1...2),
-       ArgumentsNode(2...29)(
-         [CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "k"),
-          BeginNode(5...29)(
-            (5...10),
-            StatementsNode(18...20)([IntegerNode(18...20)()]),
-            nil,
-            nil,
-            nil,
-            (26...29)
-          )]
-       ),
-       (3...4),
-       nil,
-       0,
-       "[]="
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...29))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "h"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "h"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (1...4) = "[k]"
+            ├── opening_loc: (1...2) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...29))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (2...3))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (2...3) = "k"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "k"
+            │       └── @ BeginNode (location: (5...29))
+            │           ├── begin_keyword_loc: (5...10) = "begin"
+            │           ├── statements:
+            │           │   @ StatementsNode (location: (18...20))
+            │           │   └── body: (length: 1)
+            │           │       └── @ IntegerNode (location: (18...20))
+            │           ├── rescue_clause: ∅
+            │           ├── else_clause: ∅
+            │           ├── ensure_clause: ∅
+            │           └── end_keyword_loc: (26...29) = "end"
+            ├── closing_loc: (3...4) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]="
diff --git a/test/yarp/snapshots/seattlerb/evstr_evstr.txt b/test/yarp/snapshots/seattlerb/evstr_evstr.txt
index f194b1b94a..eed8b0f72a 100644
--- a/test/yarp/snapshots/seattlerb/evstr_evstr.txt
+++ b/test/yarp/snapshots/seattlerb/evstr_evstr.txt
@@ -1,23 +1,41 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [InterpolatedStringNode(0...10)(
-       (0...1),
-       [EmbeddedStatementsNode(1...5)(
-          (1...3),
-          StatementsNode(3...4)(
-            [CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "a")]
-          ),
-          (4...5)
-        ),
-        EmbeddedStatementsNode(5...9)(
-          (5...7),
-          StatementsNode(7...8)(
-            [CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "b")]
-          ),
-          (8...9)
-        )],
-       (9...10)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...10))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 2)
+            │   ├── @ EmbeddedStatementsNode (location: (1...5))
+            │   │   ├── opening_loc: (1...3) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (3...4))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (3...4))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (3...4) = "a"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "a"
+            │   │   └── closing_loc: (4...5) = "}"
+            │   └── @ EmbeddedStatementsNode (location: (5...9))
+            │       ├── opening_loc: (5...7) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (7...8))
+            │       │   └── body: (length: 1)
+            │       │       └── @ CallNode (location: (7...8))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (7...8) = "b"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments: ∅
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: variable_call
+            │       │           └── name: "b"
+            │       └── closing_loc: (8...9) = "}"
+            └── closing_loc: (9...10) = "\""
diff --git a/test/yarp/snapshots/seattlerb/evstr_str.txt b/test/yarp/snapshots/seattlerb/evstr_str.txt
index 2ebd4e4639..00efb71c6e 100644
--- a/test/yarp/snapshots/seattlerb/evstr_str.txt
+++ b/test/yarp/snapshots/seattlerb/evstr_str.txt
@@ -1,17 +1,30 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [InterpolatedStringNode(0...8)(
-       (0...1),
-       [EmbeddedStatementsNode(1...5)(
-          (1...3),
-          StatementsNode(3...4)(
-            [CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "a")]
-          ),
-          (4...5)
-        ),
-        StringNode(5...7)(nil, (5...7), nil, " b")],
-       (7...8)
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...8))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 2)
+            │   ├── @ EmbeddedStatementsNode (location: (1...5))
+            │   │   ├── opening_loc: (1...3) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (3...4))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (3...4))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (3...4) = "a"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "a"
+            │   │   └── closing_loc: (4...5) = "}"
+            │   └── @ StringNode (location: (5...7))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (5...7) = " b"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: " b"
+            └── closing_loc: (7...8) = "\""
diff --git a/test/yarp/snapshots/seattlerb/expr_not_bang.txt b/test/yarp/snapshots/seattlerb/expr_not_bang.txt
index 43e47cb03b..9ff96c83d2 100644
--- a/test/yarp/snapshots/seattlerb/expr_not_bang.txt
+++ b/test/yarp/snapshots/seattlerb/expr_not_bang.txt
@@ -1,28 +1,37 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       CallNode(2...5)(
-         nil,
-         nil,
-         (2...3),
-         nil,
-         ArgumentsNode(4...5)(
-           [CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "b")]
-         ),
-         nil,
-         nil,
-         0,
-         "a"
-       ),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ CallNode (location: (2...5))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (2...3) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (4...5))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (4...5))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (4...5) = "b"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "b"
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "!"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/seattlerb/f_kw.txt b/test/yarp/snapshots/seattlerb/f_kw.txt
index 053e093303..1ad3cfa8b2 100644
--- a/test/yarp/snapshots/seattlerb/f_kw.txt
+++ b/test/yarp/snapshots/seattlerb/f_kw.txt
@@ -1,27 +1,31 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [DefNode(0...15)(
-       :x,
-       (4...5),
-       nil,
-       ParametersNode(6...10)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...10)(:k, (6...8), IntegerNode(8...10)())],
-         nil,
-         nil
-       ),
-       nil,
-       [:k],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (12...15)
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...15))
+            ├── name: :x
+            ├── name_loc: (4...5) = "x"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...10))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (6...10))
+            │   │       ├── name: :k
+            │   │       ├── name_loc: (6...8) = "k:"
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (8...10))
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:k]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (12...15) = "end"
diff --git a/test/yarp/snapshots/seattlerb/f_kw__required.txt b/test/yarp/snapshots/seattlerb/f_kw__required.txt
index 8f29a7a9c9..4a1a554037 100644
--- a/test/yarp/snapshots/seattlerb/f_kw__required.txt
+++ b/test/yarp/snapshots/seattlerb/f_kw__required.txt
@@ -1,27 +1,30 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [DefNode(0...13)(
-       :x,
-       (4...5),
-       nil,
-       ParametersNode(6...8)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...8)(:k, (6...8), nil)],
-         nil,
-         nil
-       ),
-       nil,
-       [:k],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (10...13)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...13))
+            ├── name: :x
+            ├── name_loc: (4...5) = "x"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...8))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (6...8))
+            │   │       ├── name: :k
+            │   │       ├── name_loc: (6...8) = "k:"
+            │   │       └── value: ∅
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:k]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (10...13) = "end"
diff --git a/test/yarp/snapshots/seattlerb/flip2_env_lvar.txt b/test/yarp/snapshots/seattlerb/flip2_env_lvar.txt
index bca1426fc1..c6cb48f693 100644
--- a/test/yarp/snapshots/seattlerb/flip2_env_lvar.txt
+++ b/test/yarp/snapshots/seattlerb/flip2_env_lvar.txt
@@ -1,17 +1,36 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [IfNode(0...16)(
-       (0...2),
-       FlipFlopNode(3...7)(
-         CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "a"),
-         CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b"),
-         (4...6),
-         0
-       ),
-       nil,
-       nil,
-       (13...16)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...16))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ FlipFlopNode (location: (3...7))
+            │   ├── left:
+            │   │   @ CallNode (location: (3...4))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (3...4) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── right:
+            │   │   @ CallNode (location: (6...7))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (6...7) = "b"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "b"
+            │   ├── operator_loc: (4...6) = ".."
+            │   └── flags: 
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (13...16) = "end"
diff --git a/test/yarp/snapshots/seattlerb/float_with_if_modifier.txt b/test/yarp/snapshots/seattlerb/float_with_if_modifier.txt
index c27a5bfe3b..f2be371163 100644
--- a/test/yarp/snapshots/seattlerb/float_with_if_modifier.txt
+++ b/test/yarp/snapshots/seattlerb/float_with_if_modifier.txt
@@ -1,12 +1,15 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [IfNode(0...10)(
-       (3...5),
-       TrueNode(6...10)(),
-       StatementsNode(0...3)([FloatNode(0...3)()]),
-       nil,
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...10))
+            ├── if_keyword_loc: (3...5) = "if"
+            ├── predicate:
+            │   @ TrueNode (location: (6...10))
+            ├── statements:
+            │   @ StatementsNode (location: (0...3))
+            │   └── body: (length: 1)
+            │       └── @ FloatNode (location: (0...3))
+            ├── consequent: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/heredoc__backslash_dos_format.txt b/test/yarp/snapshots/seattlerb/heredoc__backslash_dos_format.txt
index befdff81ee..656cfdcdc6 100644
--- a/test/yarp/snapshots/seattlerb/heredoc__backslash_dos_format.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc__backslash_dos_format.txt
@@ -1,16 +1,20 @@
-ProgramNode(0...12)(
-  [:str],
-  StatementsNode(0...12)(
-    [LocalVariableWriteNode(0...12)(
-       :str,
-       0,
-       (0...3),
-       InterpolatedStringNode(6...12)(
-         (6...12),
-         [StringNode(14...30)(nil, (14...30), nil, "beforeafter\r\n")],
-         (30...35)
-       ),
-       (4...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:str]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...12))
+            ├── name: :str
+            ├── depth: 0
+            ├── name_loc: (0...3) = "str"
+            ├── value:
+            │   @ InterpolatedStringNode (location: (6...12))
+            │   ├── opening_loc: (6...12) = "<<-XXX"
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (14...30))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (14...30) = "before\\\r\nafter\r\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "beforeafter\r\n"
+            │   └── closing_loc: (30...35) = "XXX\r\n"
+            └── operator_loc: (4...5) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_backslash_nl.txt b/test/yarp/snapshots/seattlerb/heredoc_backslash_nl.txt
index 532b1fe9e7..4bb11c4811 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_backslash_nl.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_backslash_nl.txt
@@ -1,21 +1,19 @@
-ProgramNode(0...49)(
-  [],
-  StatementsNode(0...49)(
-    [StringNode(0...40)(
-       (0...1),
-       (1...39),
-       (39...40),
-       "  why would someone do this?   blah\n"
-     ),
-     InterpolatedStringNode(42...49)(
-       (42...49),
-       [StringNode(50...88)(
-          nil,
-          (50...88),
-          nil,
-          "  why would someone do this?   blah\n"
-        )],
-       (88...93)
-     )]
-  )
-)
+@ ProgramNode (location: (0...49))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...49))
+    └── body: (length: 2)
+        ├── @ StringNode (location: (0...40))
+        │   ├── opening_loc: (0...1) = "\""
+        │   ├── content_loc: (1...39) = "  why would someone do this? \\\n  blah\n"
+        │   ├── closing_loc: (39...40) = "\""
+        │   └── unescaped: "  why would someone do this?   blah\n"
+        └── @ InterpolatedStringNode (location: (42...49))
+            ├── opening_loc: (42...49) = "<<-DESC"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (50...88))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (50...88) = "  why would someone do this? \\\n  blah\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "  why would someone do this?   blah\n"
+            └── closing_loc: (88...93) = "DESC\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_bad_hex_escape.txt b/test/yarp/snapshots/seattlerb/heredoc_bad_hex_escape.txt
index 842da16d1d..c0af63a657 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_bad_hex_escape.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_bad_hex_escape.txt
@@ -1,16 +1,20 @@
-ProgramNode(0...9)(
-  [:s],
-  StatementsNode(0...9)(
-    [LocalVariableWriteNode(0...9)(
-       :s,
-       0,
-       (0...1),
-       InterpolatedStringNode(4...9)(
-         (4...9),
-         [StringNode(10...17)(nil, (10...17), nil, "a\xE9b\n")],
-         (17...21)
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: [:s]
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...9))
+            ├── name: :s
+            ├── depth: 0
+            ├── name_loc: (0...1) = "s"
+            ├── value:
+            │   @ InterpolatedStringNode (location: (4...9))
+            │   ├── opening_loc: (4...9) = "<<eos"
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (10...17))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (10...17) = "a\\xE9b\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "a\xE9b\n"
+            │   └── closing_loc: (17...21) = "eos\n"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_bad_oct_escape.txt b/test/yarp/snapshots/seattlerb/heredoc_bad_oct_escape.txt
index 14c02bdfb3..aba1212f38 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_bad_oct_escape.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_bad_oct_escape.txt
@@ -1,16 +1,20 @@
-ProgramNode(0...10)(
-  [:s],
-  StatementsNode(0...10)(
-    [LocalVariableWriteNode(0...10)(
-       :s,
-       0,
-       (0...1),
-       InterpolatedStringNode(4...10)(
-         (4...10),
-         [StringNode(11...23)(nil, (11...23), nil, "a\xA7b\n" + "cöd\n")],
-         (23...27)
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: [:s]
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...10))
+            ├── name: :s
+            ├── depth: 0
+            ├── name_loc: (0...1) = "s"
+            ├── value:
+            │   @ InterpolatedStringNode (location: (4...10))
+            │   ├── opening_loc: (4...10) = "<<-EOS"
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (11...23))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (11...23) = "a\\247b\ncöd\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "a\xA7b\ncöd\n"
+            │   └── closing_loc: (23...27) = "EOS\n"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_comma_arg.txt b/test/yarp/snapshots/seattlerb/heredoc_comma_arg.txt
index bbded2484e..c4e52e17f4 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_comma_arg.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_comma_arg.txt
@@ -1,19 +1,27 @@
-ProgramNode(0...47)(
-  [],
-  StatementsNode(0...47)(
-    [ArrayNode(0...17)(
-       [StringNode(1...15)((1...2), (2...14), (14...15), "  some text\n")],
-       (0...1),
-       (16...17)
-     ),
-     ArrayNode(19...47)(
-       [InterpolatedStringNode(20...27)(
-          (20...27),
-          [StringNode(29...41)(nil, (29...41), nil, "  some text\n")],
-          (41...46)
-        )],
-       (19...20),
-       (46...47)
-     )]
-  )
-)
+@ ProgramNode (location: (0...47))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...47))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...17))
+        │   ├── elements: (length: 1)
+        │   │   └── @ StringNode (location: (1...15))
+        │   │       ├── opening_loc: (1...2) = "\""
+        │   │       ├── content_loc: (2...14) = "  some text\n"
+        │   │       ├── closing_loc: (14...15) = "\""
+        │   │       └── unescaped: "  some text\n"
+        │   ├── opening_loc: (0...1) = "["
+        │   └── closing_loc: (16...17) = "]"
+        └── @ ArrayNode (location: (19...47))
+            ├── elements: (length: 1)
+            │   └── @ InterpolatedStringNode (location: (20...27))
+            │       ├── opening_loc: (20...27) = "<<-FILE"
+            │       ├── parts: (length: 1)
+            │       │   └── @ StringNode (location: (29...41))
+            │       │       ├── opening_loc: ∅
+            │       │       ├── content_loc: (29...41) = "  some text\n"
+            │       │       ├── closing_loc: ∅
+            │       │       └── unescaped: "  some text\n"
+            │       └── closing_loc: (41...46) = "FILE\n"
+            ├── opening_loc: (19...20) = "["
+            └── closing_loc: (46...47) = "]"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_lineno.txt b/test/yarp/snapshots/seattlerb/heredoc_lineno.txt
index 9bbc817c20..bf84cc6bc1 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_lineno.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_lineno.txt
@@ -1,28 +1,27 @@
-ProgramNode(0...41)(
-  [:c, :d],
-  StatementsNode(0...41)(
-    [LocalVariableWriteNode(0...11)(
-       :c,
-       0,
-       (0...1),
-       InterpolatedStringNode(4...11)(
-         (4...11),
-         [StringNode(12...30)(
-            nil,
-            (12...30),
-            nil,
-            "line2\n" + "line3\n" + "line4\n"
-          )],
-         (30...34)
-       ),
-       (2...3)
-     ),
-     LocalVariableWriteNode(35...41)(
-       :d,
-       0,
-       (35...36),
-       IntegerNode(39...41)(),
-       (37...38)
-     )]
-  )
-)
+@ ProgramNode (location: (0...41))
+├── locals: [:c, :d]
+└── statements:
+    @ StatementsNode (location: (0...41))
+    └── body: (length: 2)
+        ├── @ LocalVariableWriteNode (location: (0...11))
+        │   ├── name: :c
+        │   ├── depth: 0
+        │   ├── name_loc: (0...1) = "c"
+        │   ├── value:
+        │   │   @ InterpolatedStringNode (location: (4...11))
+        │   │   ├── opening_loc: (4...11) = "<<'CCC'"
+        │   │   ├── parts: (length: 1)
+        │   │   │   └── @ StringNode (location: (12...30))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (12...30) = "line2\nline3\nline4\n"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "line2\nline3\nline4\n"
+        │   │   └── closing_loc: (30...34) = "CCC\n"
+        │   └── operator_loc: (2...3) = "="
+        └── @ LocalVariableWriteNode (location: (35...41))
+            ├── name: :d
+            ├── depth: 0
+            ├── name_loc: (35...36) = "d"
+            ├── value:
+            │   @ IntegerNode (location: (39...41))
+            └── operator_loc: (37...38) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_nested.txt b/test/yarp/snapshots/seattlerb/heredoc_nested.txt
index 3c3d30d958..85287b6141 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_nested.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_nested.txt
@@ -1,27 +1,39 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [ArrayNode(0...23)(
-       [InterpolatedStringNode(1...4)(
-          (1...4),
-          [EmbeddedStatementsNode(6...12)(
-             (6...8),
-             StatementsNode(8...11)(
-               [InterpolatedStringNode(8...11)(
-                  (8...11),
-                  [StringNode(13...15)(nil, (13...15), nil, "b\n")],
-                  (15...17)
-                )]
-             ),
-             (11...12)
-           ),
-           StringNode(12...13)(nil, (12...13), nil, "\n"),
-           StringNode(17...19)(nil, (17...19), nil, "a\n")],
-          (19...21)
-        ),
-        IntegerNode(21...22)()],
-       (0...1),
-       (22...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...23))
+            ├── elements: (length: 2)
+            │   ├── @ InterpolatedStringNode (location: (1...4))
+            │   │   ├── opening_loc: (1...4) = "<<A"
+            │   │   ├── parts: (length: 3)
+            │   │   │   ├── @ EmbeddedStatementsNode (location: (6...12))
+            │   │   │   │   ├── opening_loc: (6...8) = "\#{"
+            │   │   │   │   ├── statements:
+            │   │   │   │   │   @ StatementsNode (location: (8...11))
+            │   │   │   │   │   └── body: (length: 1)
+            │   │   │   │   │       └── @ InterpolatedStringNode (location: (8...11))
+            │   │   │   │   │           ├── opening_loc: (8...11) = "<<B"
+            │   │   │   │   │           ├── parts: (length: 1)
+            │   │   │   │   │           │   └── @ StringNode (location: (13...15))
+            │   │   │   │   │           │       ├── opening_loc: ∅
+            │   │   │   │   │           │       ├── content_loc: (13...15) = "b\n"
+            │   │   │   │   │           │       ├── closing_loc: ∅
+            │   │   │   │   │           │       └── unescaped: "b\n"
+            │   │   │   │   │           └── closing_loc: (15...17) = "B\n"
+            │   │   │   │   └── closing_loc: (11...12) = "}"
+            │   │   │   ├── @ StringNode (location: (12...13))
+            │   │   │   │   ├── opening_loc: ∅
+            │   │   │   │   ├── content_loc: (12...13) = "\n"
+            │   │   │   │   ├── closing_loc: ∅
+            │   │   │   │   └── unescaped: "\n"
+            │   │   │   └── @ StringNode (location: (17...19))
+            │   │   │       ├── opening_loc: ∅
+            │   │   │       ├── content_loc: (17...19) = "a\n"
+            │   │   │       ├── closing_loc: ∅
+            │   │   │       └── unescaped: "a\n"
+            │   │   └── closing_loc: (19...21) = "A\n"
+            │   └── @ IntegerNode (location: (21...22))
+            ├── opening_loc: (0...1) = "["
+            └── closing_loc: (22...23) = "]"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_squiggly.txt b/test/yarp/snapshots/seattlerb/heredoc_squiggly.txt
index 6491c86c04..789e3d90a9 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_squiggly.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_squiggly.txt
@@ -1,16 +1,20 @@
-ProgramNode(0...12)(
-  [:a],
-  StatementsNode(0...12)(
-    [LocalVariableWriteNode(0...12)(
-       :a,
-       0,
-       (0...1),
-       InterpolatedStringNode(4...12)(
-         (4...12),
-         [StringNode(13...25)(nil, (13...25), nil, "x\n" + "y\n" + "z\n")],
-         (25...31)
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...12))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ InterpolatedStringNode (location: (4...12))
+            │   ├── opening_loc: (4...12) = "<<~\"EOF\""
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (13...25))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (13...25) = "  x\n  y\n  z\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "x\ny\nz\n"
+            │   └── closing_loc: (25...31) = "  EOF\n"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_squiggly_blank_line_plus_interpolation.txt b/test/yarp/snapshots/seattlerb/heredoc_squiggly_blank_line_plus_interpolation.txt
index f2c3c1b1a9..ee57f65875 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_squiggly_blank_line_plus_interpolation.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_squiggly_blank_line_plus_interpolation.txt
@@ -1,56 +1,63 @@
-ProgramNode(0...20)(
-  [:a],
-  StatementsNode(0...20)(
-    [LocalVariableWriteNode(0...20)(
-       :a,
-       0,
-       (0...1),
-       CallNode(4...20)(
-         nil,
-         nil,
-         (4...7),
-         (7...8),
-         ArgumentsNode(8...19)(
-           [CallNode(8...19)(
-              InterpolatedStringNode(8...14)(
-                (8...14),
-                [StringNode(21...26)(nil, (21...26), nil, "\n"),
-                 EmbeddedStatementsNode(26...32)(
-                   (26...28),
-                   StatementsNode(28...31)(
-                     [CallNode(28...31)(
-                        nil,
-                        nil,
-                        (28...31),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "bar"
-                      )]
-                   ),
-                   (31...32)
-                 ),
-                 StringNode(32...36)(nil, (32...36), nil, "baz\n")],
-                (36...42)
-              ),
-              (14...15),
-              (15...19),
-              nil,
-              nil,
-              nil,
-              nil,
-              0,
-              "chop"
-            )]
-         ),
-         (19...20),
-         nil,
-         0,
-         "foo"
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...20))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ CallNode (location: (4...20))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (4...7) = "foo"
+            │   ├── opening_loc: (7...8) = "("
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (8...19))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (8...19))
+            │   │           ├── receiver:
+            │   │           │   @ InterpolatedStringNode (location: (8...14))
+            │   │           │   ├── opening_loc: (8...14) = "<<~EOF"
+            │   │           │   ├── parts: (length: 3)
+            │   │           │   │   ├── @ StringNode (location: (21...26))
+            │   │           │   │   │   ├── opening_loc: ∅
+            │   │           │   │   │   ├── content_loc: (21...26) = "\n    "
+            │   │           │   │   │   ├── closing_loc: ∅
+            │   │           │   │   │   └── unescaped: "\n"
+            │   │           │   │   ├── @ EmbeddedStatementsNode (location: (26...32))
+            │   │           │   │   │   ├── opening_loc: (26...28) = "\#{"
+            │   │           │   │   │   ├── statements:
+            │   │           │   │   │   │   @ StatementsNode (location: (28...31))
+            │   │           │   │   │   │   └── body: (length: 1)
+            │   │           │   │   │   │       └── @ CallNode (location: (28...31))
+            │   │           │   │   │   │           ├── receiver: ∅
+            │   │           │   │   │   │           ├── call_operator_loc: ∅
+            │   │           │   │   │   │           ├── message_loc: (28...31) = "bar"
+            │   │           │   │   │   │           ├── opening_loc: ∅
+            │   │           │   │   │   │           ├── arguments: ∅
+            │   │           │   │   │   │           ├── closing_loc: ∅
+            │   │           │   │   │   │           ├── block: ∅
+            │   │           │   │   │   │           ├── flags: variable_call
+            │   │           │   │   │   │           └── name: "bar"
+            │   │           │   │   │   └── closing_loc: (31...32) = "}"
+            │   │           │   │   └── @ StringNode (location: (32...36))
+            │   │           │   │       ├── opening_loc: ∅
+            │   │           │   │       ├── content_loc: (32...36) = "baz\n"
+            │   │           │   │       ├── closing_loc: ∅
+            │   │           │   │       └── unescaped: "baz\n"
+            │   │           │   └── closing_loc: (36...42) = "  EOF\n"
+            │   │           ├── call_operator_loc: (14...15) = "."
+            │   │           ├── message_loc: (15...19) = "chop"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "chop"
+            │   ├── closing_loc: (19...20) = ")"
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "foo"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_squiggly_blank_lines.txt b/test/yarp/snapshots/seattlerb/heredoc_squiggly_blank_lines.txt
index 4b59c35246..fd474553d8 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_squiggly_blank_lines.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_squiggly_blank_lines.txt
@@ -1,16 +1,20 @@
-ProgramNode(0...10)(
-  [:a],
-  StatementsNode(0...10)(
-    [LocalVariableWriteNode(0...10)(
-       :a,
-       0,
-       (0...1),
-       InterpolatedStringNode(4...10)(
-         (4...10),
-         [StringNode(11...20)(nil, (11...20), nil, "x\n" + "\n" + "z\n")],
-         (20...24)
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...10))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ InterpolatedStringNode (location: (4...10))
+            │   ├── opening_loc: (4...10) = "<<~EOF"
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (11...20))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (11...20) = "  x\n\n  z\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "x\n\nz\n"
+            │   └── closing_loc: (20...24) = "EOF\n"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_squiggly_empty.txt b/test/yarp/snapshots/seattlerb/heredoc_squiggly_empty.txt
index 7303a5ee71..7769e4ca2c 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_squiggly_empty.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_squiggly_empty.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)([InterpolatedStringNode(0...4)((0...4), [], (5...7))])
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...4))
+            ├── opening_loc: (0...4) = "<<~A"
+            ├── parts: (length: 0)
+            └── closing_loc: (5...7) = "A\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_squiggly_interp.txt b/test/yarp/snapshots/seattlerb/heredoc_squiggly_interp.txt
index e03304a7d1..fbe607be7d 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_squiggly_interp.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_squiggly_interp.txt
@@ -1,22 +1,32 @@
-ProgramNode(0...10)(
-  [:a],
-  StatementsNode(0...10)(
-    [LocalVariableWriteNode(0...10)(
-       :a,
-       0,
-       (0...1),
-       InterpolatedStringNode(4...10)(
-         (4...10),
-         [StringNode(11...22)(nil, (11...22), nil, "    w\n" + "x"),
-          EmbeddedStatementsNode(22...27)(
-            (22...24),
-            StatementsNode(24...26)([IntegerNode(24...26)()]),
-            (26...27)
-          ),
-          StringNode(27...36)(nil, (27...36), nil, " y\n" + "  z\n")],
-         (36...42)
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...10))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ InterpolatedStringNode (location: (4...10))
+            │   ├── opening_loc: (4...10) = "<<~EOF"
+            │   ├── parts: (length: 3)
+            │   │   ├── @ StringNode (location: (11...22))
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── content_loc: (11...22) = "      w\n  x"
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   └── unescaped: "    w\nx"
+            │   │   ├── @ EmbeddedStatementsNode (location: (22...27))
+            │   │   │   ├── opening_loc: (22...24) = "\#{"
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (24...26))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ IntegerNode (location: (24...26))
+            │   │   │   └── closing_loc: (26...27) = "}"
+            │   │   └── @ StringNode (location: (27...36))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (27...36) = " y\n    z\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: " y\n  z\n"
+            │   └── closing_loc: (36...42) = "  EOF\n"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_squiggly_no_indent.txt b/test/yarp/snapshots/seattlerb/heredoc_squiggly_no_indent.txt
index 47a116dab2..b88a5b4af9 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_squiggly_no_indent.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_squiggly_no_indent.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [InterpolatedStringNode(0...4)(
-       (0...4),
-       [StringNode(5...7)(nil, (5...7), nil, "a\n")],
-       (7...9)
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...4))
+            ├── opening_loc: (0...4) = "<<~A"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (5...7))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (5...7) = "a\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "a\n"
+            └── closing_loc: (7...9) = "A\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_squiggly_tabs.txt b/test/yarp/snapshots/seattlerb/heredoc_squiggly_tabs.txt
index 1592d13104..b5046bcca2 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_squiggly_tabs.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_squiggly_tabs.txt
@@ -1,21 +1,20 @@
-ProgramNode(0...12)(
-  [:a],
-  StatementsNode(0...12)(
-    [LocalVariableWriteNode(0...12)(
-       :a,
-       0,
-       (0...1),
-       InterpolatedStringNode(4...12)(
-         (4...12),
-         [StringNode(13...43)(
-            nil,
-            (13...43),
-            nil,
-            "blah blah\n" + " blah blah\n"
-          )],
-         (43...49)
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...12))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ InterpolatedStringNode (location: (4...12))
+            │   ├── opening_loc: (4...12) = "<<~\"EOF\""
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (13...43))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (13...43) = "        blah blah\n\t blah blah\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "blah blah\n blah blah\n"
+            │   └── closing_loc: (43...49) = "  EOF\n"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_squiggly_tabs_extra.txt b/test/yarp/snapshots/seattlerb/heredoc_squiggly_tabs_extra.txt
index 63ff5887c9..f321ec6e5d 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_squiggly_tabs_extra.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_squiggly_tabs_extra.txt
@@ -1,21 +1,20 @@
-ProgramNode(0...12)(
-  [:a],
-  StatementsNode(0...12)(
-    [LocalVariableWriteNode(0...12)(
-       :a,
-       0,
-       (0...1),
-       InterpolatedStringNode(4...12)(
-         (4...12),
-         [StringNode(13...37)(
-            nil,
-            (13...37),
-            nil,
-            "blah blah\n" + "\tblah blah\n"
-          )],
-         (37...43)
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...12))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ InterpolatedStringNode (location: (4...12))
+            │   ├── opening_loc: (4...12) = "<<~\"EOF\""
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (13...37))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (13...37) = "  blah blah\n \tblah blah\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "blah blah\n\tblah blah\n"
+            │   └── closing_loc: (37...43) = "  EOF\n"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_squiggly_visually_blank_lines.txt b/test/yarp/snapshots/seattlerb/heredoc_squiggly_visually_blank_lines.txt
index 866c5fac08..8fbdfac6ef 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_squiggly_visually_blank_lines.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_squiggly_visually_blank_lines.txt
@@ -1,16 +1,20 @@
-ProgramNode(0...10)(
-  [:a],
-  StatementsNode(0...10)(
-    [LocalVariableWriteNode(0...10)(
-       :a,
-       0,
-       (0...1),
-       InterpolatedStringNode(4...10)(
-         (4...10),
-         [StringNode(11...21)(nil, (11...21), nil, "x\n" + "\n" + "z\n")],
-         (21...25)
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...10))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ InterpolatedStringNode (location: (4...10))
+            │   ├── opening_loc: (4...10) = "<<~EOF"
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (11...21))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (11...21) = "  x\n \n  z\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "x\n\nz\n"
+            │   └── closing_loc: (21...25) = "EOF\n"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/heredoc_trailing_slash_continued_call.txt b/test/yarp/snapshots/seattlerb/heredoc_trailing_slash_continued_call.txt
index b672fceefc..f5018d999b 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_trailing_slash_continued_call.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_trailing_slash_continued_call.txt
@@ -1,20 +1,24 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [CallNode(0...22)(
-       InterpolatedStringNode(0...5)(
-         (0...5),
-         [StringNode(7...12)(nil, (7...12), nil, "blah\n")],
-         (12...16)
-       ),
-       (16...17),
-       (17...22),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "strip"
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...22))
+            ├── receiver:
+            │   @ InterpolatedStringNode (location: (0...5))
+            │   ├── opening_loc: (0...5) = "<<END"
+            │   ├── parts: (length: 1)
+            │   │   └── @ StringNode (location: (7...12))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (7...12) = "blah\n"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "blah\n"
+            │   └── closing_loc: (12...16) = "END\n"
+            ├── call_operator_loc: (16...17) = "."
+            ├── message_loc: (17...22) = "strip"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "strip"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_unicode.txt b/test/yarp/snapshots/seattlerb/heredoc_unicode.txt
index 42e475b08a..0fc8737282 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_unicode.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_unicode.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [InterpolatedStringNode(0...9)(
-       (0...9),
-       [StringNode(10...12)(nil, (10...12), nil, ".\n")],
-       (12...20)
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...9))
+            ├── opening_loc: (0...9) = "<<OOTPÜT"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (10...12))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (10...12) = ".\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: ".\n"
+            └── closing_loc: (12...20) = "OOTPÜT\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_carriage_return_escapes.txt b/test/yarp/snapshots/seattlerb/heredoc_with_carriage_return_escapes.txt
index f3a7cdd423..b5f85f4348 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_carriage_return_escapes.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_carriage_return_escapes.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [InterpolatedStringNode(0...5)(
-       (0...5),
-       [StringNode(6...21)(nil, (6...21), nil, "foo\rbar\n" + "baz\r\n")],
-       (21...25)
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...5))
+            ├── opening_loc: (0...5) = "<<EOS"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (6...21))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (6...21) = "foo\\rbar\nbaz\\r\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "foo\rbar\nbaz\r\n"
+            └── closing_loc: (21...25) = "EOS\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_carriage_return_escapes_windows.txt b/test/yarp/snapshots/seattlerb/heredoc_with_carriage_return_escapes_windows.txt
index e206ee78a9..aed5f0465c 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_carriage_return_escapes_windows.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_carriage_return_escapes_windows.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [InterpolatedStringNode(0...5)(
-       (0...5),
-       [StringNode(7...24)(nil, (7...24), nil, "foo\rbar\r\n" + "baz\r\r\n")],
-       (24...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...5))
+            ├── opening_loc: (0...5) = "<<EOS"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (7...24))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (7...24) = "foo\\rbar\r\nbaz\\r\r\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "foo\rbar\r\nbaz\r\r\n"
+            └── closing_loc: (24...29) = "EOS\r\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_horrible_mix.txt b/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_horrible_mix.txt
index 2c5d16dcab..9c6471da76 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_horrible_mix.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_horrible_mix.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [InterpolatedStringNode(0...7)(
-       (0...7),
-       [StringNode(9...15)(nil, (9...15), nil, "body\r\n")],
-       (15...19)
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...7))
+            ├── opening_loc: (0...7) = "<<'eot'"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (9...15))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (9...15) = "body\r\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "body\r\n"
+            └── closing_loc: (15...19) = "eot\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_returns.txt b/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_returns.txt
index 35583e3289..217824be97 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_returns.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_returns.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [InterpolatedStringNode(0...5)(
-       (0...5),
-       [StringNode(6...19)(nil, (6...19), nil, "foo\rbar\r\n" + "baz\n")],
-       (19...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...5))
+            ├── opening_loc: (0...5) = "<<EOS"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (6...19))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (6...19) = "foo\rbar\r\nbaz\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "foo\rbar\r\nbaz\n"
+            └── closing_loc: (19...23) = "EOS\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_returns_windows.txt b/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_returns_windows.txt
index c36008cfce..482dc5ba15 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_returns_windows.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_extra_carriage_returns_windows.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [InterpolatedStringNode(0...5)(
-       (0...5),
-       [StringNode(7...22)(nil, (7...22), nil, "foo\rbar\r\r\n" + "baz\r\n")],
-       (22...27)
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...5))
+            ├── opening_loc: (0...5) = "<<EOS"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (7...22))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (7...22) = "foo\rbar\r\r\nbaz\r\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "foo\rbar\r\r\nbaz\r\n"
+            └── closing_loc: (22...27) = "EOS\r\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes.txt b/test/yarp/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes.txt
index 452e5b605b..331eed2824 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes.txt
@@ -1,15 +1,24 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [InterpolatedStringNode(0...5)(
-       (0...5),
-       [StringNode(6...11)(nil, (6...11), nil, "foo\r"),
-        EmbeddedVariableNode(11...16)(
-          (11...12),
-          InstanceVariableReadNode(12...16)(:@bar)
-        ),
-        StringNode(16...17)(nil, (16...17), nil, "\n")],
-       (17...21)
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...5))
+            ├── opening_loc: (0...5) = "<<EOS"
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (6...11))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (6...11) = "foo\\r"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo\r"
+            │   ├── @ EmbeddedVariableNode (location: (11...16))
+            │   │   ├── operator_loc: (11...12) = "#"
+            │   │   └── variable:
+            │   │       @ InstanceVariableReadNode (location: (12...16))
+            │   │       └── name: :@bar
+            │   └── @ StringNode (location: (16...17))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (16...17) = "\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\n"
+            └── closing_loc: (17...21) = "EOS\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes_windows.txt b/test/yarp/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes_windows.txt
index 99b42f6122..dd09d1ae09 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes_windows.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_interpolation_and_carriage_return_escapes_windows.txt
@@ -1,15 +1,24 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [InterpolatedStringNode(0...5)(
-       (0...5),
-       [StringNode(7...12)(nil, (7...12), nil, "foo\r"),
-        EmbeddedVariableNode(12...17)(
-          (12...13),
-          InstanceVariableReadNode(13...17)(:@bar)
-        ),
-        StringNode(17...19)(nil, (17...19), nil, "\r\n")],
-       (19...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...5))
+            ├── opening_loc: (0...5) = "<<EOS"
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (7...12))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (7...12) = "foo\\r"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo\r"
+            │   ├── @ EmbeddedVariableNode (location: (12...17))
+            │   │   ├── operator_loc: (12...13) = "#"
+            │   │   └── variable:
+            │   │       @ InstanceVariableReadNode (location: (13...17))
+            │   │       └── name: :@bar
+            │   └── @ StringNode (location: (17...19))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (17...19) = "\r\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\r\n"
+            └── closing_loc: (19...24) = "EOS\r\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_not_global_interpolation.txt b/test/yarp/snapshots/seattlerb/heredoc_with_not_global_interpolation.txt
index be3f48e171..4f51527b28 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_not_global_interpolation.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_not_global_interpolation.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [InterpolatedStringNode(0...10)(
-       (0...10),
-       [StringNode(11...15)(nil, (11...15), nil, "\#${\n")],
-       (15...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...10))
+            ├── opening_loc: (0...10) = "<<-HEREDOC"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (11...15))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (11...15) = "\#${\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\#${\n"
+            └── closing_loc: (15...23) = "HEREDOC\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_only_carriage_returns.txt b/test/yarp/snapshots/seattlerb/heredoc_with_only_carriage_returns.txt
index f4a65965f6..ea9bc76b2f 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_only_carriage_returns.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_only_carriage_returns.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [InterpolatedStringNode(0...5)(
-       (0...5),
-       [StringNode(6...14)(nil, (6...14), nil, "\r\n" + "\r\r\n" + "\r\n")],
-       (14...18)
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...5))
+            ├── opening_loc: (0...5) = "<<EOS"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (6...14))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (6...14) = "\r\n\r\r\n\\r\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\r\n\r\r\n\r\n"
+            └── closing_loc: (14...18) = "EOS\n"
diff --git a/test/yarp/snapshots/seattlerb/heredoc_with_only_carriage_returns_windows.txt b/test/yarp/snapshots/seattlerb/heredoc_with_only_carriage_returns_windows.txt
index e3fbb71b7f..8a57f8cff8 100644
--- a/test/yarp/snapshots/seattlerb/heredoc_with_only_carriage_returns_windows.txt
+++ b/test/yarp/snapshots/seattlerb/heredoc_with_only_carriage_returns_windows.txt
@@ -1,15 +1,14 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [InterpolatedStringNode(0...5)(
-       (0...5),
-       [StringNode(7...18)(
-          nil,
-          (7...18),
-          nil,
-          "\r\r\n" + "\r\r\r\n" + "\r\r\n"
-        )],
-       (18...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...5))
+            ├── opening_loc: (0...5) = "<<EOS"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (7...18))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (7...18) = "\r\r\n\r\r\r\n\\r\r\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\r\r\n\r\r\r\n\r\r\n"
+            └── closing_loc: (18...23) = "EOS\r\n"
diff --git a/test/yarp/snapshots/seattlerb/if_elsif.txt b/test/yarp/snapshots/seattlerb/if_elsif.txt
index 51c89a9a32..23ea223f2a 100644
--- a/test/yarp/snapshots/seattlerb/if_elsif.txt
+++ b/test/yarp/snapshots/seattlerb/if_elsif.txt
@@ -1,12 +1,19 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [IfNode(0...18)(
-       (0...2),
-       IntegerNode(3...4)(),
-       nil,
-       IfNode(6...18)((6...11), IntegerNode(12...13)(), nil, nil, (15...18)),
-       (15...18)
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...18))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ IntegerNode (location: (3...4))
+            ├── statements: ∅
+            ├── consequent:
+            │   @ IfNode (location: (6...18))
+            │   ├── if_keyword_loc: (6...11) = "elsif"
+            │   ├── predicate:
+            │   │   @ IntegerNode (location: (12...13))
+            │   ├── statements: ∅
+            │   ├── consequent: ∅
+            │   └── end_keyword_loc: (15...18) = "end"
+            └── end_keyword_loc: (15...18) = "end"
diff --git a/test/yarp/snapshots/seattlerb/if_symbol.txt b/test/yarp/snapshots/seattlerb/if_symbol.txt
index 4e4fdcefce..b8686fd668 100644
--- a/test/yarp/snapshots/seattlerb/if_symbol.txt
+++ b/test/yarp/snapshots/seattlerb/if_symbol.txt
@@ -1,22 +1,28 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [IfNode(0...12)(
-       (0...2),
-       CallNode(3...7)(
-         nil,
-         nil,
-         (3...4),
-         nil,
-         ArgumentsNode(5...7)([SymbolNode(5...7)((5...6), (6...7), nil, "x")]),
-         nil,
-         nil,
-         0,
-         "f"
-       ),
-       nil,
-       nil,
-       (9...12)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...12))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (3...7))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (3...4) = "f"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (5...7))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ SymbolNode (location: (5...7))
+            │   │           ├── opening_loc: (5...6) = ":"
+            │   │           ├── value_loc: (6...7) = "x"
+            │   │           ├── closing_loc: ∅
+            │   │           └── unescaped: "x"
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "f"
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (9...12) = "end"
diff --git a/test/yarp/snapshots/seattlerb/in_expr_no_case.txt b/test/yarp/snapshots/seattlerb/in_expr_no_case.txt
index a4249f6414..08a2a37a90 100644
--- a/test/yarp/snapshots/seattlerb/in_expr_no_case.txt
+++ b/test/yarp/snapshots/seattlerb/in_expr_no_case.txt
@@ -1,10 +1,16 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [MatchPredicateNode(0...16)(
-       StringNode(0...6)((0...1), (1...5), (5...6), "woot"),
-       ConstantReadNode(10...16)(:String),
-       (7...9)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ MatchPredicateNode (location: (0...16))
+            ├── value:
+            │   @ StringNode (location: (0...6))
+            │   ├── opening_loc: (0...1) = "'"
+            │   ├── content_loc: (1...5) = "woot"
+            │   ├── closing_loc: (5...6) = "'"
+            │   └── unescaped: "woot"
+            ├── pattern:
+            │   @ ConstantReadNode (location: (10...16))
+            │   └── name: :String
+            └── operator_loc: (7...9) = "in"
diff --git a/test/yarp/snapshots/seattlerb/index_0.txt b/test/yarp/snapshots/seattlerb/index_0.txt
index 42a7239752..d03310c8bc 100644
--- a/test/yarp/snapshots/seattlerb/index_0.txt
+++ b/test/yarp/snapshots/seattlerb/index_0.txt
@@ -1,18 +1,37 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (1...3),
-       (1...2),
-       ArgumentsNode(6...7)(
-         [CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b")]
-       ),
-       (2...3),
-       nil,
-       0,
-       "[]="
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (1...3) = "[]"
+            ├── opening_loc: (1...2) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (6...7))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (6...7))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (6...7) = "b"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "b"
+            ├── closing_loc: (2...3) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]="
diff --git a/test/yarp/snapshots/seattlerb/index_0_opasgn.txt b/test/yarp/snapshots/seattlerb/index_0_opasgn.txt
index 60c76d0d00..3c69be05b8 100644
--- a/test/yarp/snapshots/seattlerb/index_0_opasgn.txt
+++ b/test/yarp/snapshots/seattlerb/index_0_opasgn.txt
@@ -1,19 +1,38 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallOperatorWriteNode(0...8)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (1...3),
-       (1...2),
-       nil,
-       (2...3),
-       0,
-       "[]",
-       "[]=",
-       :+,
-       (4...6),
-       CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "b")
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallOperatorWriteNode (location: (0...8))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (1...3) = "[]"
+            ├── opening_loc: (1...2) = "["
+            ├── arguments: ∅
+            ├── closing_loc: (2...3) = "]"
+            ├── flags: 
+            ├── read_name: "[]"
+            ├── write_name: "[]="
+            ├── operator: :+
+            ├── operator_loc: (4...6) = "+="
+            └── value:
+                @ CallNode (location: (7...8))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (7...8) = "b"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/integer_with_if_modifier.txt b/test/yarp/snapshots/seattlerb/integer_with_if_modifier.txt
index f57ed6c422..8fc9d66a65 100644
--- a/test/yarp/snapshots/seattlerb/integer_with_if_modifier.txt
+++ b/test/yarp/snapshots/seattlerb/integer_with_if_modifier.txt
@@ -1,12 +1,15 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [IfNode(0...12)(
-       (5...7),
-       TrueNode(8...12)(),
-       StatementsNode(0...5)([IntegerNode(0...5)()]),
-       nil,
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...12))
+            ├── if_keyword_loc: (5...7) = "if"
+            ├── predicate:
+            │   @ TrueNode (location: (8...12))
+            ├── statements:
+            │   @ StatementsNode (location: (0...5))
+            │   └── body: (length: 1)
+            │       └── @ IntegerNode (location: (0...5))
+            ├── consequent: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/interpolated_symbol_array_line_breaks.txt b/test/yarp/snapshots/seattlerb/interpolated_symbol_array_line_breaks.txt
index 0a779610a6..7a561cfbf3 100644
--- a/test/yarp/snapshots/seattlerb/interpolated_symbol_array_line_breaks.txt
+++ b/test/yarp/snapshots/seattlerb/interpolated_symbol_array_line_breaks.txt
@@ -1,12 +1,20 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [ArrayNode(0...9)(
-       [SymbolNode(4...5)(nil, (4...5), nil, "a"),
-        SymbolNode(6...7)(nil, (6...7), nil, "b")],
-       (0...3),
-       (8...9)
-     ),
-     IntegerNode(10...11)()]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...9))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ SymbolNode (location: (4...5))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (4...5) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ SymbolNode (location: (6...7))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (6...7) = "b"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "b"
+        │   ├── opening_loc: (0...3) = "%I("
+        │   └── closing_loc: (8...9) = ")"
+        └── @ IntegerNode (location: (10...11))
diff --git a/test/yarp/snapshots/seattlerb/interpolated_word_array_line_breaks.txt b/test/yarp/snapshots/seattlerb/interpolated_word_array_line_breaks.txt
index 901575f9a8..5a41dafae6 100644
--- a/test/yarp/snapshots/seattlerb/interpolated_word_array_line_breaks.txt
+++ b/test/yarp/snapshots/seattlerb/interpolated_word_array_line_breaks.txt
@@ -1,12 +1,20 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [ArrayNode(0...9)(
-       [StringNode(4...5)(nil, (4...5), nil, "a"),
-        StringNode(6...7)(nil, (6...7), nil, "b")],
-       (0...3),
-       (8...9)
-     ),
-     IntegerNode(10...11)()]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...9))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ StringNode (location: (4...5))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (4...5) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ StringNode (location: (6...7))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (6...7) = "b"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "b"
+        │   ├── opening_loc: (0...3) = "%W("
+        │   └── closing_loc: (8...9) = ")"
+        └── @ IntegerNode (location: (10...11))
diff --git a/test/yarp/snapshots/seattlerb/iter_args_1.txt b/test/yarp/snapshots/seattlerb/iter_args_1.txt
index 9fdbf68818..e01eab5038 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_1.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_1.txt
@@ -1,36 +1,38 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallNode(0...11)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...11)(
-         [:a, :b],
-         BlockParametersNode(4...9)(
-           ParametersNode(5...8)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredParameterNode(7...8)(:b)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (8...9)
-         ),
-         nil,
-         (2...3),
-         (10...11)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...11))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...11))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...9))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...8))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   └── @ RequiredParameterNode (location: (7...8))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (8...9) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (10...11) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_10_1.txt b/test/yarp/snapshots/seattlerb/iter_args_10_1.txt
index 3086873b0d..d767ae4f04 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_10_1.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_10_1.txt
@@ -1,40 +1,46 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [CallNode(0...21)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...21)(
-         [:a, :b, :c],
-         BlockParametersNode(4...19)(
-           ParametersNode(5...18)(
-             [RequiredParameterNode(5...6)(:a)],
-             [OptionalParameterNode(8...14)(
-                :b,
-                (8...9),
-                (10...11),
-                IntegerNode(12...14)()
-              )],
-             [],
-             RestParameterNode(16...18)(:c, (17...18), (16...17)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (18...19)
-         ),
-         nil,
-         (2...3),
-         (20...21)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...21))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...21))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...19))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...18))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...14))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (8...9) = "b"
+            │   │   │   │       ├── operator_loc: (10...11) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (12...14))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (16...18))
+            │   │   │   │   ├── name: :c
+            │   │   │   │   ├── name_loc: (17...18) = "c"
+            │   │   │   │   └── operator_loc: (16...17) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (18...19) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (20...21) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_10_2.txt b/test/yarp/snapshots/seattlerb/iter_args_10_2.txt
index 1b6efea49f..01568b4527 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_10_2.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_10_2.txt
@@ -1,40 +1,50 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [CallNode(0...25)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...25)(
-         [:a, :b, :c, :d],
-         BlockParametersNode(4...23)(
-           ParametersNode(5...22)(
-             [RequiredParameterNode(5...6)(:a)],
-             [OptionalParameterNode(8...14)(
-                :b,
-                (8...9),
-                (10...11),
-                IntegerNode(12...14)()
-              )],
-             [],
-             RestParameterNode(16...18)(:c, (17...18), (16...17)),
-             [],
-             nil,
-             BlockParameterNode(20...22)(:d, (21...22), (20...21))
-           ),
-           [],
-           (4...5),
-           (22...23)
-         ),
-         nil,
-         (2...3),
-         (24...25)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...25))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...25))
+            │   ├── locals: [:a, :b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...23))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...22))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...14))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (8...9) = "b"
+            │   │   │   │       ├── operator_loc: (10...11) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (12...14))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (16...18))
+            │   │   │   │   ├── name: :c
+            │   │   │   │   ├── name_loc: (17...18) = "c"
+            │   │   │   │   └── operator_loc: (16...17) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (20...22))
+            │   │   │       ├── name: :d
+            │   │   │       ├── name_loc: (21...22) = "d"
+            │   │   │       └── operator_loc: (20...21) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (22...23) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (24...25) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_11_1.txt b/test/yarp/snapshots/seattlerb/iter_args_11_1.txt
index 4b2e76f116..e8e69909ce 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_11_1.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_11_1.txt
@@ -1,40 +1,48 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [CallNode(0...24)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...24)(
-         [:a, :b, :c, :d],
-         BlockParametersNode(4...22)(
-           ParametersNode(5...21)(
-             [RequiredParameterNode(5...6)(:a)],
-             [OptionalParameterNode(8...14)(
-                :b,
-                (8...9),
-                (10...11),
-                IntegerNode(12...14)()
-              )],
-             [RequiredParameterNode(20...21)(:d)],
-             RestParameterNode(16...18)(:c, (17...18), (16...17)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (21...22)
-         ),
-         nil,
-         (2...3),
-         (23...24)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...24))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...24))
+            │   ├── locals: [:a, :b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...22))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...21))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...14))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (8...9) = "b"
+            │   │   │   │       ├── operator_loc: (10...11) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (12...14))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (20...21))
+            │   │   │   │       └── name: :d
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (16...18))
+            │   │   │   │   ├── name: :c
+            │   │   │   │   ├── name_loc: (17...18) = "c"
+            │   │   │   │   └── operator_loc: (16...17) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (21...22) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (23...24) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_11_2.txt b/test/yarp/snapshots/seattlerb/iter_args_11_2.txt
index e9fa853130..27dd59624f 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_11_2.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_11_2.txt
@@ -1,40 +1,52 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CallNode(0...28)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...28)(
-         [:a, :b, :c, :d, :e],
-         BlockParametersNode(4...26)(
-           ParametersNode(5...25)(
-             [RequiredParameterNode(5...6)(:a)],
-             [OptionalParameterNode(8...14)(
-                :b,
-                (8...9),
-                (10...11),
-                IntegerNode(12...14)()
-              )],
-             [RequiredParameterNode(20...21)(:d)],
-             RestParameterNode(16...18)(:c, (17...18), (16...17)),
-             [],
-             nil,
-             BlockParameterNode(23...25)(:e, (24...25), (23...24))
-           ),
-           [],
-           (4...5),
-           (25...26)
-         ),
-         nil,
-         (2...3),
-         (27...28)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...28))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...28))
+            │   ├── locals: [:a, :b, :c, :d, :e]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...26))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...25))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...14))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (8...9) = "b"
+            │   │   │   │       ├── operator_loc: (10...11) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (12...14))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (20...21))
+            │   │   │   │       └── name: :d
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (16...18))
+            │   │   │   │   ├── name: :c
+            │   │   │   │   ├── name_loc: (17...18) = "c"
+            │   │   │   │   └── operator_loc: (16...17) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (23...25))
+            │   │   │       ├── name: :e
+            │   │   │       ├── name_loc: (24...25) = "e"
+            │   │   │       └── operator_loc: (23...24) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (25...26) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (27...28) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_2__19.txt b/test/yarp/snapshots/seattlerb/iter_args_2__19.txt
index e9e94d3d6e..85798d3258 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_2__19.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_2__19.txt
@@ -1,40 +1,42 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...14)(
-         [:a, :b],
-         BlockParametersNode(4...12)(
-           ParametersNode(5...11)(
-             [RequiredDestructuredParameterNode(5...11)(
-                [RequiredParameterNode(6...7)(:a),
-                 RequiredParameterNode(9...10)(:b)],
-                (5...6),
-                (10...11)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (11...12)
-         ),
-         nil,
-         (2...3),
-         (13...14)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...14))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...11))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (5...11))
+            │   │   │   │       ├── parameters: (length: 2)
+            │   │   │   │       │   ├── @ RequiredParameterNode (location: (6...7))
+            │   │   │   │       │   │   └── name: :a
+            │   │   │   │       │   └── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       │       └── name: :b
+            │   │   │   │       ├── opening_loc: (5...6) = "("
+            │   │   │   │       └── closing_loc: (10...11) = ")"
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (11...12) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (13...14) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_3.txt b/test/yarp/snapshots/seattlerb/iter_args_3.txt
index 8d191cc2e5..4251dd1e94 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_3.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_3.txt
@@ -1,42 +1,46 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [CallNode(0...20)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...20)(
-         [:a, :b, :c, :d],
-         BlockParametersNode(4...18)(
-           ParametersNode(5...17)(
-             [RequiredParameterNode(5...6)(:a),
-              RequiredDestructuredParameterNode(8...14)(
-                [RequiredParameterNode(9...10)(:b),
-                 RequiredParameterNode(12...13)(:c)],
-                (8...9),
-                (13...14)
-              ),
-              RequiredParameterNode(16...17)(:d)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (17...18)
-         ),
-         nil,
-         (2...3),
-         (19...20)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...20))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...20))
+            │   ├── locals: [:a, :b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...18))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...17))
+            │   │   │   ├── requireds: (length: 3)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │   │   └── name: :a
+            │   │   │   │   ├── @ RequiredDestructuredParameterNode (location: (8...14))
+            │   │   │   │   │   ├── parameters: (length: 2)
+            │   │   │   │   │   │   ├── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │   │   │   │   └── name: :b
+            │   │   │   │   │   │   └── @ RequiredParameterNode (location: (12...13))
+            │   │   │   │   │   │       └── name: :c
+            │   │   │   │   │   ├── opening_loc: (8...9) = "("
+            │   │   │   │   │   └── closing_loc: (13...14) = ")"
+            │   │   │   │   └── @ RequiredParameterNode (location: (16...17))
+            │   │   │   │       └── name: :d
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (17...18) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (19...20) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_4.txt b/test/yarp/snapshots/seattlerb/iter_args_4.txt
index 18671a1832..08a38c214f 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_4.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_4.txt
@@ -1,35 +1,42 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...16)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...16)(
-         [:a, :b, :c],
-         BlockParametersNode(4...14)(
-           ParametersNode(5...13)(
-             [RequiredParameterNode(5...6)(:a)],
-             [],
-             [RequiredParameterNode(12...13)(:c)],
-             RestParameterNode(8...10)(:b, (9...10), (8...9)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (13...14)
-         ),
-         nil,
-         (2...3),
-         (15...16)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...16))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...16))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...14))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...13))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (12...13))
+            │   │   │   │       └── name: :c
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (8...10))
+            │   │   │   │   ├── name: :b
+            │   │   │   │   ├── name_loc: (9...10) = "b"
+            │   │   │   │   └── operator_loc: (8...9) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (13...14) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (15...16) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_5.txt b/test/yarp/snapshots/seattlerb/iter_args_5.txt
index 224bdc0bf9..6754bacb32 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_5.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_5.txt
@@ -1,35 +1,40 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...13)(
-         [:a, :b],
-         BlockParametersNode(4...11)(
-           ParametersNode(5...10)(
-             [RequiredParameterNode(5...6)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(8...10)(:b, (9...10), (8...9))
-           ),
-           [],
-           (4...5),
-           (10...11)
-         ),
-         nil,
-         (2...3),
-         (12...13)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...13))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...11))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...10))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (8...10))
+            │   │   │       ├── name: :b
+            │   │   │       ├── name_loc: (9...10) = "b"
+            │   │   │       └── operator_loc: (8...9) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (10...11) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (12...13) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_6.txt b/test/yarp/snapshots/seattlerb/iter_args_6.txt
index 8a69456b62..d4cc2a52d4 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_6.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_6.txt
@@ -1,40 +1,44 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...18)(
-         [:a, :b, :c],
-         BlockParametersNode(4...16)(
-           ParametersNode(5...15)(
-             [RequiredParameterNode(5...6)(:a)],
-             [OptionalParameterNode(8...12)(
-                :b,
-                (8...9),
-                (9...10),
-                IntegerNode(10...12)()
-              )],
-             [RequiredParameterNode(14...15)(:c)],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (15...16)
-         ),
-         nil,
-         (2...3),
-         (17...18)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...18))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...18))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...16))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...15))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (5...6))
+            │   │   │   │       └── name: :a
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (8...12))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (8...9) = "b"
+            │   │   │   │       ├── operator_loc: (9...10) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (10...12))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (14...15))
+            │   │   │   │       └── name: :c
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (15...16) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (17...18) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_7_1.txt b/test/yarp/snapshots/seattlerb/iter_args_7_1.txt
index 8bfb90fc33..48f4e3c2a0 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_7_1.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_7_1.txt
@@ -1,40 +1,44 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...18)(
-         [:a, :b],
-         BlockParametersNode(4...16)(
-           ParametersNode(5...15)(
-             [],
-             [OptionalParameterNode(5...11)(
-                :a,
-                (5...6),
-                (7...8),
-                IntegerNode(9...11)()
-              )],
-             [],
-             RestParameterNode(13...15)(:b, (14...15), (13...14)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (15...16)
-         ),
-         nil,
-         (2...3),
-         (17...18)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...18))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...18))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...16))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...15))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...11))
+            │   │   │   │       ├── name: :a
+            │   │   │   │       ├── name_loc: (5...6) = "a"
+            │   │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (9...11))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (13...15))
+            │   │   │   │   ├── name: :b
+            │   │   │   │   ├── name_loc: (14...15) = "b"
+            │   │   │   │   └── operator_loc: (13...14) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (15...16) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (17...18) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_7_2.txt b/test/yarp/snapshots/seattlerb/iter_args_7_2.txt
index 21d217da22..1b5a93de65 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_7_2.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_7_2.txt
@@ -1,40 +1,48 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [CallNode(0...22)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...22)(
-         [:a, :b, :c],
-         BlockParametersNode(4...20)(
-           ParametersNode(5...19)(
-             [],
-             [OptionalParameterNode(5...11)(
-                :a,
-                (5...6),
-                (7...8),
-                IntegerNode(9...11)()
-              )],
-             [],
-             RestParameterNode(13...15)(:b, (14...15), (13...14)),
-             [],
-             nil,
-             BlockParameterNode(17...19)(:c, (18...19), (17...18))
-           ),
-           [],
-           (4...5),
-           (19...20)
-         ),
-         nil,
-         (2...3),
-         (21...22)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...22))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...22))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...20))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...19))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...11))
+            │   │   │   │       ├── name: :a
+            │   │   │   │       ├── name_loc: (5...6) = "a"
+            │   │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (9...11))
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (13...15))
+            │   │   │   │   ├── name: :b
+            │   │   │   │   ├── name_loc: (14...15) = "b"
+            │   │   │   │   └── operator_loc: (13...14) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (17...19))
+            │   │   │       ├── name: :c
+            │   │   │       ├── name_loc: (18...19) = "c"
+            │   │   │       └── operator_loc: (17...18) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (19...20) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (21...22) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_8_1.txt b/test/yarp/snapshots/seattlerb/iter_args_8_1.txt
index 6b94b67e0e..c9f3a244d3 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_8_1.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_8_1.txt
@@ -1,40 +1,46 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [CallNode(0...21)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...21)(
-         [:a, :b, :c],
-         BlockParametersNode(4...19)(
-           ParametersNode(5...18)(
-             [],
-             [OptionalParameterNode(5...11)(
-                :a,
-                (5...6),
-                (7...8),
-                IntegerNode(9...11)()
-              )],
-             [RequiredParameterNode(17...18)(:c)],
-             RestParameterNode(13...15)(:b, (14...15), (13...14)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (18...19)
-         ),
-         nil,
-         (2...3),
-         (20...21)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...21))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...21))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...19))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...18))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...11))
+            │   │   │   │       ├── name: :a
+            │   │   │   │       ├── name_loc: (5...6) = "a"
+            │   │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (9...11))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (17...18))
+            │   │   │   │       └── name: :c
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (13...15))
+            │   │   │   │   ├── name: :b
+            │   │   │   │   ├── name_loc: (14...15) = "b"
+            │   │   │   │   └── operator_loc: (13...14) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (18...19) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (20...21) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_8_2.txt b/test/yarp/snapshots/seattlerb/iter_args_8_2.txt
index f16d2fca9a..7409974f28 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_8_2.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_8_2.txt
@@ -1,40 +1,50 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [CallNode(0...25)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...25)(
-         [:a, :b, :c, :d],
-         BlockParametersNode(4...23)(
-           ParametersNode(5...22)(
-             [],
-             [OptionalParameterNode(5...11)(
-                :a,
-                (5...6),
-                (7...8),
-                IntegerNode(9...11)()
-              )],
-             [RequiredParameterNode(17...18)(:c)],
-             RestParameterNode(13...15)(:b, (14...15), (13...14)),
-             [],
-             nil,
-             BlockParameterNode(20...22)(:d, (21...22), (20...21))
-           ),
-           [],
-           (4...5),
-           (22...23)
-         ),
-         nil,
-         (2...3),
-         (24...25)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...25))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...25))
+            │   ├── locals: [:a, :b, :c, :d]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...23))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...22))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...11))
+            │   │   │   │       ├── name: :a
+            │   │   │   │       ├── name_loc: (5...6) = "a"
+            │   │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (9...11))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (17...18))
+            │   │   │   │       └── name: :c
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (13...15))
+            │   │   │   │   ├── name: :b
+            │   │   │   │   ├── name_loc: (14...15) = "b"
+            │   │   │   │   └── operator_loc: (13...14) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (20...22))
+            │   │   │       ├── name: :d
+            │   │   │       ├── name_loc: (21...22) = "d"
+            │   │   │       └── operator_loc: (20...21) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (22...23) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (24...25) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_9_1.txt b/test/yarp/snapshots/seattlerb/iter_args_9_1.txt
index 68d1fe9338..4196667c22 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_9_1.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_9_1.txt
@@ -1,40 +1,42 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...17)(
-         [:a, :b],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [],
-             [OptionalParameterNode(5...11)(
-                :a,
-                (5...6),
-                (7...8),
-                IntegerNode(9...11)()
-              )],
-             [RequiredParameterNode(13...14)(:b)],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         nil,
-         (2...3),
-         (16...17)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...17))
+            │   ├── locals: [:a, :b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...11))
+            │   │   │   │       ├── name: :a
+            │   │   │   │       ├── name_loc: (5...6) = "a"
+            │   │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (9...11))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (13...14))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (16...17) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_args_9_2.txt b/test/yarp/snapshots/seattlerb/iter_args_9_2.txt
index 904d13e7e1..a52ce05f32 100644
--- a/test/yarp/snapshots/seattlerb/iter_args_9_2.txt
+++ b/test/yarp/snapshots/seattlerb/iter_args_9_2.txt
@@ -1,40 +1,46 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [CallNode(0...21)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...21)(
-         [:a, :b, :c],
-         BlockParametersNode(4...19)(
-           ParametersNode(5...18)(
-             [],
-             [OptionalParameterNode(5...11)(
-                :a,
-                (5...6),
-                (7...8),
-                IntegerNode(9...11)()
-              )],
-             [RequiredParameterNode(13...14)(:b)],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(16...18)(:c, (17...18), (16...17))
-           ),
-           [],
-           (4...5),
-           (18...19)
-         ),
-         nil,
-         (2...3),
-         (20...21)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...21))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...21))
+            │   ├── locals: [:a, :b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...19))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...18))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 1)
+            │   │   │   │   └── @ OptionalParameterNode (location: (5...11))
+            │   │   │   │       ├── name: :a
+            │   │   │   │       ├── name_loc: (5...6) = "a"
+            │   │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (9...11))
+            │   │   │   ├── posts: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (13...14))
+            │   │   │   │       └── name: :b
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block:
+            │   │   │       @ BlockParameterNode (location: (16...18))
+            │   │   │       ├── name: :c
+            │   │   │       ├── name_loc: (17...18) = "c"
+            │   │   │       └── operator_loc: (16...17) = "&"
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (18...19) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (20...21) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/iter_kwarg.txt b/test/yarp/snapshots/seattlerb/iter_kwarg.txt
index 4dfc24209a..9ce4eb0d5e 100644
--- a/test/yarp/snapshots/seattlerb/iter_kwarg.txt
+++ b/test/yarp/snapshots/seattlerb/iter_kwarg.txt
@@ -1,35 +1,39 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...12)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...12)(
-         [:b],
-         BlockParametersNode(4...10)(
-           ParametersNode(5...9)(
-             [],
-             [],
-             [],
-             nil,
-             [KeywordParameterNode(5...9)(:b, (5...7), IntegerNode(8...9)())],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (9...10)
-         ),
-         nil,
-         (2...3),
-         (11...12)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...12))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...12))
+            │   ├── locals: [:b]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...10))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...9))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 1)
+            │   │   │   │   └── @ KeywordParameterNode (location: (5...9))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (5...7) = "b:"
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (8...9))
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (9...10) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (11...12) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/iter_kwarg_kwsplat.txt b/test/yarp/snapshots/seattlerb/iter_kwarg_kwsplat.txt
index 5ade32c483..2b4077f7d3 100644
--- a/test/yarp/snapshots/seattlerb/iter_kwarg_kwsplat.txt
+++ b/test/yarp/snapshots/seattlerb/iter_kwarg_kwsplat.txt
@@ -1,35 +1,43 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...17)(
-         [:b, :c],
-         BlockParametersNode(4...15)(
-           ParametersNode(5...14)(
-             [],
-             [],
-             [],
-             nil,
-             [KeywordParameterNode(5...9)(:b, (5...7), IntegerNode(8...9)())],
-             KeywordRestParameterNode(11...14)(:c, (13...14), (11...13)),
-             nil
-           ),
-           [],
-           (4...5),
-           (14...15)
-         ),
-         nil,
-         (2...3),
-         (16...17)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...17))
+            │   ├── locals: [:b, :c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (4...15))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (5...14))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 1)
+            │   │   │   │   └── @ KeywordParameterNode (location: (5...9))
+            │   │   │   │       ├── name: :b
+            │   │   │   │       ├── name_loc: (5...7) = "b:"
+            │   │   │   │       └── value:
+            │   │   │   │           @ IntegerNode (location: (8...9))
+            │   │   │   ├── keyword_rest:
+            │   │   │   │   @ KeywordRestParameterNode (location: (11...14))
+            │   │   │   │   ├── name: :c
+            │   │   │   │   ├── name_loc: (13...14) = "c"
+            │   │   │   │   └── operator_loc: (11...13) = "**"
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (4...5) = "|"
+            │   │   └── closing_loc: (14...15) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (2...3) = "{"
+            │   └── closing_loc: (16...17) = "}"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/label_vs_string.txt b/test/yarp/snapshots/seattlerb/label_vs_string.txt
index f647e6da0e..b6ef9d6df4 100644
--- a/test/yarp/snapshots/seattlerb/label_vs_string.txt
+++ b/test/yarp/snapshots/seattlerb/label_vs_string.txt
@@ -1,18 +1,32 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...12)(
-       CallNode(0...4)(nil, nil, (0...4), nil, nil, nil, nil, 2, "_buf"),
-       nil,
-       (5...7),
-       nil,
-       ArgumentsNode(8...12)(
-         [StringNode(8...12)((8...9), (9...11), (11...12), ":\n")]
-       ),
-       nil,
-       nil,
-       0,
-       "<<"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...12))
+            ├── receiver:
+            │   @ CallNode (location: (0...4))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...4) = "_buf"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "_buf"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (5...7) = "<<"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (8...12))
+            │   └── arguments: (length: 1)
+            │       └── @ StringNode (location: (8...12))
+            │           ├── opening_loc: (8...9) = "'"
+            │           ├── content_loc: (9...11) = ":\n"
+            │           ├── closing_loc: (11...12) = "'"
+            │           └── unescaped: ":\n"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "<<"
diff --git a/test/yarp/snapshots/seattlerb/lambda_do_vs_brace.txt b/test/yarp/snapshots/seattlerb/lambda_do_vs_brace.txt
index c7f83a9b51..cb44c27f04 100644
--- a/test/yarp/snapshots/seattlerb/lambda_do_vs_brace.txt
+++ b/test/yarp/snapshots/seattlerb/lambda_do_vs_brace.txt
@@ -1,71 +1,91 @@
-ProgramNode(0...46)(
-  [],
-  StatementsNode(0...46)(
-    [CallNode(0...11)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...11)(
-         [LambdaNode(2...11)([], (2...4), (5...7), (8...11), nil, nil)]
-       ),
-       nil,
-       nil,
-       0,
-       "f"
-     ),
-     CallNode(13...20)(
-       nil,
-       nil,
-       (13...14),
-       nil,
-       ArgumentsNode(15...20)(
-         [LambdaNode(15...20)([], (15...17), (18...19), (19...20), nil, nil)]
-       ),
-       nil,
-       nil,
-       0,
-       "f"
-     ),
-     CallNode(22...35)(
-       nil,
-       nil,
-       (22...23),
-       nil,
-       ArgumentsNode(24...35)(
-         [LambdaNode(24...35)(
-            [],
-            (24...26),
-            (29...31),
-            (32...35),
-            BlockParametersNode(26...28)(nil, [], (26...27), (27...28)),
-            nil
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "f"
-     ),
-     CallNode(37...46)(
-       nil,
-       nil,
-       (37...38),
-       nil,
-       ArgumentsNode(39...46)(
-         [LambdaNode(39...46)(
-            [],
-            (39...41),
-            (44...45),
-            (45...46),
-            BlockParametersNode(41...43)(nil, [], (41...42), (42...43)),
-            nil
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...46))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...46))
+    └── body: (length: 4)
+        ├── @ CallNode (location: (0...11))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...11))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ LambdaNode (location: (2...11))
+        │   │           ├── locals: []
+        │   │           ├── operator_loc: (2...4) = "->"
+        │   │           ├── opening_loc: (5...7) = "do"
+        │   │           ├── closing_loc: (8...11) = "end"
+        │   │           ├── parameters: ∅
+        │   │           └── body: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (13...20))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (13...14) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (15...20))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ LambdaNode (location: (15...20))
+        │   │           ├── locals: []
+        │   │           ├── operator_loc: (15...17) = "->"
+        │   │           ├── opening_loc: (18...19) = "{"
+        │   │           ├── closing_loc: (19...20) = "}"
+        │   │           ├── parameters: ∅
+        │   │           └── body: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (22...35))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (22...23) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (24...35))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ LambdaNode (location: (24...35))
+        │   │           ├── locals: []
+        │   │           ├── operator_loc: (24...26) = "->"
+        │   │           ├── opening_loc: (29...31) = "do"
+        │   │           ├── closing_loc: (32...35) = "end"
+        │   │           ├── parameters:
+        │   │           │   @ BlockParametersNode (location: (26...28))
+        │   │           │   ├── parameters: ∅
+        │   │           │   ├── locals: (length: 0)
+        │   │           │   ├── opening_loc: (26...27) = "("
+        │   │           │   └── closing_loc: (27...28) = ")"
+        │   │           └── body: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "f"
+        └── @ CallNode (location: (37...46))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (37...38) = "f"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (39...46))
+            │   └── arguments: (length: 1)
+            │       └── @ LambdaNode (location: (39...46))
+            │           ├── locals: []
+            │           ├── operator_loc: (39...41) = "->"
+            │           ├── opening_loc: (44...45) = "{"
+            │           ├── closing_loc: (45...46) = "}"
+            │           ├── parameters:
+            │           │   @ BlockParametersNode (location: (41...43))
+            │           │   ├── parameters: ∅
+            │           │   ├── locals: (length: 0)
+            │           │   ├── opening_loc: (41...42) = "("
+            │           │   └── closing_loc: (42...43) = ")"
+            │           └── body: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/lasgn_arg_rescue_arg.txt b/test/yarp/snapshots/seattlerb/lasgn_arg_rescue_arg.txt
index ad36a5edb4..9af1ea0500 100644
--- a/test/yarp/snapshots/seattlerb/lasgn_arg_rescue_arg.txt
+++ b/test/yarp/snapshots/seattlerb/lasgn_arg_rescue_arg.txt
@@ -1,16 +1,17 @@
-ProgramNode(0...14)(
-  [:a],
-  StatementsNode(0...14)(
-    [LocalVariableWriteNode(0...14)(
-       :a,
-       0,
-       (0...1),
-       RescueModifierNode(4...14)(
-         IntegerNode(4...5)(),
-         (6...12),
-         IntegerNode(13...14)()
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...14))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ RescueModifierNode (location: (4...14))
+            │   ├── expression:
+            │   │   @ IntegerNode (location: (4...5))
+            │   ├── keyword_loc: (6...12) = "rescue"
+            │   └── rescue_expression:
+            │       @ IntegerNode (location: (13...14))
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/lasgn_call_bracket_rescue_arg.txt b/test/yarp/snapshots/seattlerb/lasgn_call_bracket_rescue_arg.txt
index 86469f1c91..886cb04b1e 100644
--- a/test/yarp/snapshots/seattlerb/lasgn_call_bracket_rescue_arg.txt
+++ b/test/yarp/snapshots/seattlerb/lasgn_call_bracket_rescue_arg.txt
@@ -1,26 +1,29 @@
-ProgramNode(0...17)(
-  [:a],
-  StatementsNode(0...17)(
-    [LocalVariableWriteNode(0...17)(
-       :a,
-       0,
-       (0...1),
-       RescueModifierNode(4...17)(
-         CallNode(4...8)(
-           nil,
-           nil,
-           (4...5),
-           (5...6),
-           ArgumentsNode(6...7)([IntegerNode(6...7)()]),
-           (7...8),
-           nil,
-           0,
-           "b"
-         ),
-         (9...15),
-         IntegerNode(16...17)()
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...17))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ RescueModifierNode (location: (4...17))
+            │   ├── expression:
+            │   │   @ CallNode (location: (4...8))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (4...5) = "b"
+            │   │   ├── opening_loc: (5...6) = "("
+            │   │   ├── arguments:
+            │   │   │   @ ArgumentsNode (location: (6...7))
+            │   │   │   └── arguments: (length: 1)
+            │   │   │       └── @ IntegerNode (location: (6...7))
+            │   │   ├── closing_loc: (7...8) = ")"
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "b"
+            │   ├── keyword_loc: (9...15) = "rescue"
+            │   └── rescue_expression:
+            │       @ IntegerNode (location: (16...17))
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/lasgn_call_nobracket_rescue_arg.txt b/test/yarp/snapshots/seattlerb/lasgn_call_nobracket_rescue_arg.txt
index 72e54e0101..6d87ec10ca 100644
--- a/test/yarp/snapshots/seattlerb/lasgn_call_nobracket_rescue_arg.txt
+++ b/test/yarp/snapshots/seattlerb/lasgn_call_nobracket_rescue_arg.txt
@@ -1,28 +1,29 @@
-ProgramNode(0...16)(
-  [:a],
-  StatementsNode(0...16)(
-    [LocalVariableWriteNode(0...16)(
-       :a,
-       0,
-       (0...1),
-       CallNode(4...16)(
-         nil,
-         nil,
-         (4...5),
-         nil,
-         ArgumentsNode(6...16)(
-           [RescueModifierNode(6...16)(
-              IntegerNode(6...7)(),
-              (8...14),
-              IntegerNode(15...16)()
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "b"
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...16))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ CallNode (location: (4...16))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (4...5) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (6...16))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ RescueModifierNode (location: (6...16))
+            │   │           ├── expression:
+            │   │           │   @ IntegerNode (location: (6...7))
+            │   │           ├── keyword_loc: (8...14) = "rescue"
+            │   │           └── rescue_expression:
+            │   │               @ IntegerNode (location: (15...16))
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "b"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/lasgn_command.txt b/test/yarp/snapshots/seattlerb/lasgn_command.txt
index b1912a7c6d..2ecf1e641a 100644
--- a/test/yarp/snapshots/seattlerb/lasgn_command.txt
+++ b/test/yarp/snapshots/seattlerb/lasgn_command.txt
@@ -1,22 +1,34 @@
-ProgramNode(0...9)(
-  [:a],
-  StatementsNode(0...9)(
-    [LocalVariableWriteNode(0...9)(
-       :a,
-       0,
-       (0...1),
-       CallNode(4...9)(
-         CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "b"),
-         (5...6),
-         (6...7),
-         nil,
-         ArgumentsNode(8...9)([IntegerNode(8...9)()]),
-         nil,
-         nil,
-         0,
-         "c"
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...9))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ CallNode (location: (4...9))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (4...5))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (4...5) = "b"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "b"
+            │   ├── call_operator_loc: (5...6) = "."
+            │   ├── message_loc: (6...7) = "c"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (8...9))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ IntegerNode (location: (8...9))
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "c"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/lasgn_env.txt b/test/yarp/snapshots/seattlerb/lasgn_env.txt
index cfd276b1b2..a414d2af2b 100644
--- a/test/yarp/snapshots/seattlerb/lasgn_env.txt
+++ b/test/yarp/snapshots/seattlerb/lasgn_env.txt
@@ -1,12 +1,12 @@
-ProgramNode(0...6)(
-  [:a],
-  StatementsNode(0...6)(
-    [LocalVariableWriteNode(0...6)(
-       :a,
-       0,
-       (0...1),
-       IntegerNode(4...6)(),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...6))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ IntegerNode (location: (4...6))
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/lasgn_ivar_env.txt b/test/yarp/snapshots/seattlerb/lasgn_ivar_env.txt
index cf47f6dc7e..3cc5e65841 100644
--- a/test/yarp/snapshots/seattlerb/lasgn_ivar_env.txt
+++ b/test/yarp/snapshots/seattlerb/lasgn_ivar_env.txt
@@ -1,11 +1,11 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [InstanceVariableWriteNode(0...7)(
-       :@a,
-       (0...2),
-       IntegerNode(5...7)(),
-       (3...4)
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ InstanceVariableWriteNode (location: (0...7))
+            ├── name: :@a
+            ├── name_loc: (0...2) = "@a"
+            ├── value:
+            │   @ IntegerNode (location: (5...7))
+            └── operator_loc: (3...4) = "="
diff --git a/test/yarp/snapshots/seattlerb/lasgn_lasgn_command_call.txt b/test/yarp/snapshots/seattlerb/lasgn_lasgn_command_call.txt
index 49f22eeb43..21f02da5bf 100644
--- a/test/yarp/snapshots/seattlerb/lasgn_lasgn_command_call.txt
+++ b/test/yarp/snapshots/seattlerb/lasgn_lasgn_command_call.txt
@@ -1,28 +1,30 @@
-ProgramNode(0...11)(
-  [:a, :b],
-  StatementsNode(0...11)(
-    [LocalVariableWriteNode(0...11)(
-       :a,
-       0,
-       (0...1),
-       LocalVariableWriteNode(4...11)(
-         :b,
-         0,
-         (4...5),
-         CallNode(8...11)(
-           nil,
-           nil,
-           (8...9),
-           nil,
-           ArgumentsNode(10...11)([IntegerNode(10...11)()]),
-           nil,
-           nil,
-           0,
-           "c"
-         ),
-         (6...7)
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...11))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ LocalVariableWriteNode (location: (4...11))
+            │   ├── name: :b
+            │   ├── depth: 0
+            │   ├── name_loc: (4...5) = "b"
+            │   ├── value:
+            │   │   @ CallNode (location: (8...11))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (8...9) = "c"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments:
+            │   │   │   @ ArgumentsNode (location: (10...11))
+            │   │   │   └── arguments: (length: 1)
+            │   │   │       └── @ IntegerNode (location: (10...11))
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "c"
+            │   └── operator_loc: (6...7) = "="
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/lasgn_middle_splat.txt b/test/yarp/snapshots/seattlerb/lasgn_middle_splat.txt
index acb6c84467..9f7c7c21f4 100644
--- a/test/yarp/snapshots/seattlerb/lasgn_middle_splat.txt
+++ b/test/yarp/snapshots/seattlerb/lasgn_middle_splat.txt
@@ -1,21 +1,48 @@
-ProgramNode(0...12)(
-  [:a],
-  StatementsNode(0...12)(
-    [LocalVariableWriteNode(0...12)(
-       :a,
-       0,
-       (0...1),
-       ArrayNode(4...12)(
-         [CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "b"),
-          SplatNode(7...9)(
-            (7...8),
-            CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "c")
-          ),
-          CallNode(11...12)(nil, nil, (11...12), nil, nil, nil, nil, 2, "d")],
-         nil,
-         nil
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...12))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (0...1) = "a"
+            ├── value:
+            │   @ ArrayNode (location: (4...12))
+            │   ├── elements: (length: 3)
+            │   │   ├── @ CallNode (location: (4...5))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (4...5) = "b"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "b"
+            │   │   ├── @ SplatNode (location: (7...9))
+            │   │   │   ├── operator_loc: (7...8) = "*"
+            │   │   │   └── expression:
+            │   │   │       @ CallNode (location: (8...9))
+            │   │   │       ├── receiver: ∅
+            │   │   │       ├── call_operator_loc: ∅
+            │   │   │       ├── message_loc: (8...9) = "c"
+            │   │   │       ├── opening_loc: ∅
+            │   │   │       ├── arguments: ∅
+            │   │   │       ├── closing_loc: ∅
+            │   │   │       ├── block: ∅
+            │   │   │       ├── flags: variable_call
+            │   │   │       └── name: "c"
+            │   │   └── @ CallNode (location: (11...12))
+            │   │       ├── receiver: ∅
+            │   │       ├── call_operator_loc: ∅
+            │   │       ├── message_loc: (11...12) = "d"
+            │   │       ├── opening_loc: ∅
+            │   │       ├── arguments: ∅
+            │   │       ├── closing_loc: ∅
+            │   │       ├── block: ∅
+            │   │       ├── flags: variable_call
+            │   │       └── name: "d"
+            │   ├── opening_loc: ∅
+            │   └── closing_loc: ∅
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/magic_encoding_comment.txt b/test/yarp/snapshots/seattlerb/magic_encoding_comment.txt
index 010fe79394..3a58345e95 100644
--- a/test/yarp/snapshots/seattlerb/magic_encoding_comment.txt
+++ b/test/yarp/snapshots/seattlerb/magic_encoding_comment.txt
@@ -1,38 +1,45 @@
-ProgramNode(18...90)(
-  [],
-  StatementsNode(18...90)(
-    [ClassNode(18...90)(
-       [],
-       (18...23),
-       ConstantReadNode(24...52)(:ExampleUTF8ClassNameVarietà),
-       nil,
-       nil,
-       StatementsNode(54...86)(
-         [DefNode(54...86)(
-            :è,
-            (63...65),
-            SelfNode(58...62)(),
-            nil,
-            StatementsNode(67...81)(
-              [LocalVariableWriteNode(67...81)(
-                 :così,
-                 0,
-                 (67...72),
-                 SymbolNode(75...81)((75...76), (76...81), nil, "però"),
-                 (73...74)
-               )]
-            ),
-            [:così],
-            (54...57),
-            (62...63),
-            nil,
-            nil,
-            nil,
-            (83...86)
-          )]
-       ),
-       (87...90),
-       :ExampleUTF8ClassNameVarietà
-     )]
-  )
-)
+@ ProgramNode (location: (18...90))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (18...90))
+    └── body: (length: 1)
+        └── @ ClassNode (location: (18...90))
+            ├── locals: []
+            ├── class_keyword_loc: (18...23) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (24...52))
+            │   └── name: :ExampleUTF8ClassNameVarietà
+            ├── inheritance_operator_loc: ∅
+            ├── superclass: ∅
+            ├── body:
+            │   @ StatementsNode (location: (54...86))
+            │   └── body: (length: 1)
+            │       └── @ DefNode (location: (54...86))
+            │           ├── name: :è
+            │           ├── name_loc: (63...65) = "è"
+            │           ├── receiver:
+            │           │   @ SelfNode (location: (58...62))
+            │           ├── parameters: ∅
+            │           ├── body:
+            │           │   @ StatementsNode (location: (67...81))
+            │           │   └── body: (length: 1)
+            │           │       └── @ LocalVariableWriteNode (location: (67...81))
+            │           │           ├── name: :così
+            │           │           ├── depth: 0
+            │           │           ├── name_loc: (67...72) = "così"
+            │           │           ├── value:
+            │           │           │   @ SymbolNode (location: (75...81))
+            │           │           │   ├── opening_loc: (75...76) = ":"
+            │           │           │   ├── value_loc: (76...81) = "però"
+            │           │           │   ├── closing_loc: ∅
+            │           │           │   └── unescaped: "però"
+            │           │           └── operator_loc: (73...74) = "="
+            │           ├── locals: [:così]
+            │           ├── def_keyword_loc: (54...57) = "def"
+            │           ├── operator_loc: (62...63) = "."
+            │           ├── lparen_loc: ∅
+            │           ├── rparen_loc: ∅
+            │           ├── equal_loc: ∅
+            │           └── end_keyword_loc: (83...86) = "end"
+            ├── end_keyword_loc: (87...90) = "end"
+            └── name: :ExampleUTF8ClassNameVarietà
diff --git a/test/yarp/snapshots/seattlerb/masgn_anon_splat_arg.txt b/test/yarp/snapshots/seattlerb/masgn_anon_splat_arg.txt
index 2fb68f7b6d..bc20fb39f8 100644
--- a/test/yarp/snapshots/seattlerb/masgn_anon_splat_arg.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_anon_splat_arg.txt
@@ -1,13 +1,31 @@
-ProgramNode(0...8)(
-  [:a],
-  StatementsNode(0...8)(
-    [MultiWriteNode(0...8)(
-       [MultiTargetNode(0...1)([SplatNode(0...1)((0...1), nil)], nil, nil),
-        LocalVariableTargetNode(3...4)(:a, 0)],
-       nil,
-       nil,
-       (5...6),
-       CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "b")
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...8))
+            ├── targets: (length: 2)
+            │   ├── @ MultiTargetNode (location: (0...1))
+            │   │   ├── targets: (length: 1)
+            │   │   │   └── @ SplatNode (location: (0...1))
+            │   │   │       ├── operator_loc: (0...1) = "*"
+            │   │   │       └── expression: ∅
+            │   │   ├── lparen_loc: ∅
+            │   │   └── rparen_loc: ∅
+            │   └── @ LocalVariableTargetNode (location: (3...4))
+            │       ├── name: :a
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (5...6) = "="
+            └── value:
+                @ CallNode (location: (7...8))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (7...8) = "b"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/masgn_arg_colon_arg.txt b/test/yarp/snapshots/seattlerb/masgn_arg_colon_arg.txt
index fd2eeb213a..60d726e5d8 100644
--- a/test/yarp/snapshots/seattlerb/masgn_arg_colon_arg.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_arg_colon_arg.txt
@@ -1,23 +1,44 @@
-ProgramNode(0...11)(
-  [:a],
-  StatementsNode(0...11)(
-    [MultiWriteNode(0...11)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        CallNode(3...7)(
-          CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"),
-          (4...6),
-          (6...7),
-          nil,
-          nil,
-          nil,
-          nil,
-          0,
-          "c="
-        )],
-       nil,
-       nil,
-       (8...9),
-       CallNode(10...11)(nil, nil, (10...11), nil, nil, nil, nil, 2, "d")
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...11))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   └── @ CallNode (location: (3...7))
+            │       ├── receiver:
+            │       │   @ CallNode (location: (3...4))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (3...4) = "b"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "b"
+            │       ├── call_operator_loc: (4...6) = "::"
+            │       ├── message_loc: (6...7) = "c"
+            │       ├── opening_loc: ∅
+            │       ├── arguments: ∅
+            │       ├── closing_loc: ∅
+            │       ├── block: ∅
+            │       ├── flags: 
+            │       └── name: "c="
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (8...9) = "="
+            └── value:
+                @ CallNode (location: (10...11))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (10...11) = "d"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/masgn_arg_ident.txt b/test/yarp/snapshots/seattlerb/masgn_arg_ident.txt
index a8b17ce707..889f687616 100644
--- a/test/yarp/snapshots/seattlerb/masgn_arg_ident.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_arg_ident.txt
@@ -1,23 +1,44 @@
-ProgramNode(0...10)(
-  [:a],
-  StatementsNode(0...10)(
-    [MultiWriteNode(0...10)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        CallNode(3...6)(
-          CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"),
-          (4...5),
-          (5...6),
-          nil,
-          nil,
-          nil,
-          nil,
-          0,
-          "C="
-        )],
-       nil,
-       nil,
-       (7...8),
-       CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "d")
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...10))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   └── @ CallNode (location: (3...6))
+            │       ├── receiver:
+            │       │   @ CallNode (location: (3...4))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (3...4) = "b"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "b"
+            │       ├── call_operator_loc: (4...5) = "."
+            │       ├── message_loc: (5...6) = "C"
+            │       ├── opening_loc: ∅
+            │       ├── arguments: ∅
+            │       ├── closing_loc: ∅
+            │       ├── block: ∅
+            │       ├── flags: 
+            │       └── name: "C="
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (7...8) = "="
+            └── value:
+                @ CallNode (location: (9...10))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (9...10) = "d"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/masgn_arg_splat_arg.txt b/test/yarp/snapshots/seattlerb/masgn_arg_splat_arg.txt
index e922b3b5e8..427e49281f 100644
--- a/test/yarp/snapshots/seattlerb/masgn_arg_splat_arg.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_arg_splat_arg.txt
@@ -1,14 +1,33 @@
-ProgramNode(0...12)(
-  [:a, :b, :c],
-  StatementsNode(0...12)(
-    [MultiWriteNode(0...12)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        SplatNode(3...5)((3...4), LocalVariableTargetNode(4...5)(:b, 0)),
-        LocalVariableTargetNode(7...8)(:c, 0)],
-       nil,
-       nil,
-       (9...10),
-       CallNode(11...12)(nil, nil, (11...12), nil, nil, nil, nil, 2, "d")
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:a, :b, :c]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...12))
+            ├── targets: (length: 3)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   ├── @ SplatNode (location: (3...5))
+            │   │   ├── operator_loc: (3...4) = "*"
+            │   │   └── expression:
+            │   │       @ LocalVariableTargetNode (location: (4...5))
+            │   │       ├── name: :b
+            │   │       └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (7...8))
+            │       ├── name: :c
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (9...10) = "="
+            └── value:
+                @ CallNode (location: (11...12))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (11...12) = "d"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/masgn_colon2.txt b/test/yarp/snapshots/seattlerb/masgn_colon2.txt
index d9a2744466..746f64954c 100644
--- a/test/yarp/snapshots/seattlerb/masgn_colon2.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_colon2.txt
@@ -1,21 +1,36 @@
-ProgramNode(0...14)(
-  [:a],
-  StatementsNode(0...14)(
-    [MultiWriteNode(0...14)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        ConstantPathTargetNode(3...7)(
-          CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"),
-          ConstantReadNode(6...7)(:C),
-          (4...6)
-        )],
-       nil,
-       nil,
-       (8...9),
-       ArrayNode(10...14)(
-         [IntegerNode(10...11)(), IntegerNode(13...14)()],
-         nil,
-         nil
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...14))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   └── @ ConstantPathTargetNode (location: (3...7))
+            │       ├── parent:
+            │       │   @ CallNode (location: (3...4))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (3...4) = "b"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "b"
+            │       ├── child:
+            │       │   @ ConstantReadNode (location: (6...7))
+            │       │   └── name: :C
+            │       └── delimiter_loc: (4...6) = "::"
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (8...9) = "="
+            └── value:
+                @ ArrayNode (location: (10...14))
+                ├── elements: (length: 2)
+                │   ├── @ IntegerNode (location: (10...11))
+                │   └── @ IntegerNode (location: (13...14))
+                ├── opening_loc: ∅
+                └── closing_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/masgn_colon3.txt b/test/yarp/snapshots/seattlerb/masgn_colon3.txt
index 355f40f1cf..003420c471 100644
--- a/test/yarp/snapshots/seattlerb/masgn_colon3.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_colon3.txt
@@ -1,25 +1,29 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [MultiWriteNode(0...15)(
-       [ConstantPathTargetNode(0...3)(
-          nil,
-          ConstantReadNode(2...3)(:A),
-          (0...2)
-        ),
-        ConstantPathTargetNode(5...8)(
-          nil,
-          ConstantReadNode(7...8)(:B),
-          (5...7)
-        )],
-       nil,
-       nil,
-       (9...10),
-       ArrayNode(11...15)(
-         [IntegerNode(11...12)(), IntegerNode(14...15)()],
-         nil,
-         nil
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...15))
+            ├── targets: (length: 2)
+            │   ├── @ ConstantPathTargetNode (location: (0...3))
+            │   │   ├── parent: ∅
+            │   │   ├── child:
+            │   │   │   @ ConstantReadNode (location: (2...3))
+            │   │   │   └── name: :A
+            │   │   └── delimiter_loc: (0...2) = "::"
+            │   └── @ ConstantPathTargetNode (location: (5...8))
+            │       ├── parent: ∅
+            │       ├── child:
+            │       │   @ ConstantReadNode (location: (7...8))
+            │       │   └── name: :B
+            │       └── delimiter_loc: (5...7) = "::"
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (9...10) = "="
+            └── value:
+                @ ArrayNode (location: (11...15))
+                ├── elements: (length: 2)
+                │   ├── @ IntegerNode (location: (11...12))
+                │   └── @ IntegerNode (location: (14...15))
+                ├── opening_loc: ∅
+                └── closing_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/masgn_command_call.txt b/test/yarp/snapshots/seattlerb/masgn_command_call.txt
index 4563136c2f..6400c4b202 100644
--- a/test/yarp/snapshots/seattlerb/masgn_command_call.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_command_call.txt
@@ -1,22 +1,40 @@
-ProgramNode(0...10)(
-  [:a],
-  StatementsNode(0...10)(
-    [MultiWriteNode(0...10)(
-       [LocalVariableTargetNode(0...1)(:a, 0), SplatNode(1...2)((1...2), nil)],
-       nil,
-       nil,
-       (3...4),
-       CallNode(5...10)(
-         CallNode(5...6)(nil, nil, (5...6), nil, nil, nil, nil, 2, "b"),
-         (6...7),
-         (7...8),
-         nil,
-         ArgumentsNode(9...10)([IntegerNode(9...10)()]),
-         nil,
-         nil,
-         0,
-         "c"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...10))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   └── @ SplatNode (location: (1...2))
+            │       ├── operator_loc: (1...2) = ","
+            │       └── expression: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (3...4) = "="
+            └── value:
+                @ CallNode (location: (5...10))
+                ├── receiver:
+                │   @ CallNode (location: (5...6))
+                │   ├── receiver: ∅
+                │   ├── call_operator_loc: ∅
+                │   ├── message_loc: (5...6) = "b"
+                │   ├── opening_loc: ∅
+                │   ├── arguments: ∅
+                │   ├── closing_loc: ∅
+                │   ├── block: ∅
+                │   ├── flags: variable_call
+                │   └── name: "b"
+                ├── call_operator_loc: (6...7) = "."
+                ├── message_loc: (7...8) = "c"
+                ├── opening_loc: ∅
+                ├── arguments:
+                │   @ ArgumentsNode (location: (9...10))
+                │   └── arguments: (length: 1)
+                │       └── @ IntegerNode (location: (9...10))
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/masgn_double_paren.txt b/test/yarp/snapshots/seattlerb/masgn_double_paren.txt
index 107be851e3..3e4fc9af03 100644
--- a/test/yarp/snapshots/seattlerb/masgn_double_paren.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_double_paren.txt
@@ -1,17 +1,31 @@
-ProgramNode(1...9)(
-  [:a, :b],
-  StatementsNode(1...9)(
-    [MultiWriteNode(1...9)(
-       [MultiTargetNode(1...6)(
-          [LocalVariableTargetNode(2...3)(:a, 0),
-           LocalVariableTargetNode(4...5)(:b, 0)],
-          (1...2),
-          (5...6)
-        )],
-       nil,
-       nil,
-       (7...8),
-       CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "c")
-     )]
-  )
-)
+@ ProgramNode (location: (1...9))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (1...9))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (1...9))
+            ├── targets: (length: 1)
+            │   └── @ MultiTargetNode (location: (1...6))
+            │       ├── targets: (length: 2)
+            │       │   ├── @ LocalVariableTargetNode (location: (2...3))
+            │       │   │   ├── name: :a
+            │       │   │   └── depth: 0
+            │       │   └── @ LocalVariableTargetNode (location: (4...5))
+            │       │       ├── name: :b
+            │       │       └── depth: 0
+            │       ├── lparen_loc: (1...2) = "("
+            │       └── rparen_loc: (5...6) = ")"
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (7...8) = "="
+            └── value:
+                @ CallNode (location: (8...9))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (8...9) = "c"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/masgn_lhs_splat.txt b/test/yarp/snapshots/seattlerb/masgn_lhs_splat.txt
index 4730ed9618..0008f6ec6e 100644
--- a/test/yarp/snapshots/seattlerb/masgn_lhs_splat.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_lhs_splat.txt
@@ -1,16 +1,24 @@
-ProgramNode(0...12)(
-  [:a],
-  StatementsNode(0...12)(
-    [MultiWriteNode(0...12)(
-       [SplatNode(0...2)((0...1), LocalVariableTargetNode(1...2)(:a, 0))],
-       nil,
-       nil,
-       (3...4),
-       ArrayNode(5...12)(
-         [IntegerNode(5...6)(), IntegerNode(8...9)(), IntegerNode(11...12)()],
-         nil,
-         nil
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...12))
+            ├── targets: (length: 1)
+            │   └── @ SplatNode (location: (0...2))
+            │       ├── operator_loc: (0...1) = "*"
+            │       └── expression:
+            │           @ LocalVariableTargetNode (location: (1...2))
+            │           ├── name: :a
+            │           └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (3...4) = "="
+            └── value:
+                @ ArrayNode (location: (5...12))
+                ├── elements: (length: 3)
+                │   ├── @ IntegerNode (location: (5...6))
+                │   ├── @ IntegerNode (location: (8...9))
+                │   └── @ IntegerNode (location: (11...12))
+                ├── opening_loc: ∅
+                └── closing_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/masgn_paren.txt b/test/yarp/snapshots/seattlerb/masgn_paren.txt
index 32b4fc2989..1e4b7e5c48 100644
--- a/test/yarp/snapshots/seattlerb/masgn_paren.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_paren.txt
@@ -1,23 +1,37 @@
-ProgramNode(0...12)(
-  [:a, :b],
-  StatementsNode(0...12)(
-    [MultiWriteNode(0...12)(
-       [LocalVariableTargetNode(1...2)(:a, 0),
-        LocalVariableTargetNode(4...5)(:b, 0)],
-       (0...1),
-       (5...6),
-       (7...8),
-       CallNode(9...12)(
-         CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "c"),
-         (10...11),
-         (11...12),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "d"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...12))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (1...2))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (4...5))
+            │       ├── name: :b
+            │       └── depth: 0
+            ├── lparen_loc: (0...1) = "("
+            ├── rparen_loc: (5...6) = ")"
+            ├── operator_loc: (7...8) = "="
+            └── value:
+                @ CallNode (location: (9...12))
+                ├── receiver:
+                │   @ CallNode (location: (9...10))
+                │   ├── receiver: ∅
+                │   ├── call_operator_loc: ∅
+                │   ├── message_loc: (9...10) = "c"
+                │   ├── opening_loc: ∅
+                │   ├── arguments: ∅
+                │   ├── closing_loc: ∅
+                │   ├── block: ∅
+                │   ├── flags: variable_call
+                │   └── name: "c"
+                ├── call_operator_loc: (10...11) = "."
+                ├── message_loc: (11...12) = "d"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/masgn_splat_arg.txt b/test/yarp/snapshots/seattlerb/masgn_splat_arg.txt
index e2729a861d..7f2adb500a 100644
--- a/test/yarp/snapshots/seattlerb/masgn_splat_arg.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_splat_arg.txt
@@ -1,17 +1,34 @@
-ProgramNode(0...9)(
-  [:a, :b],
-  StatementsNode(0...9)(
-    [MultiWriteNode(0...9)(
-       [MultiTargetNode(0...2)(
-          [SplatNode(0...2)((0...1), LocalVariableTargetNode(1...2)(:a, 0))],
-          nil,
-          nil
-        ),
-        LocalVariableTargetNode(4...5)(:b, 0)],
-       nil,
-       nil,
-       (6...7),
-       CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "c")
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...9))
+            ├── targets: (length: 2)
+            │   ├── @ MultiTargetNode (location: (0...2))
+            │   │   ├── targets: (length: 1)
+            │   │   │   └── @ SplatNode (location: (0...2))
+            │   │   │       ├── operator_loc: (0...1) = "*"
+            │   │   │       └── expression:
+            │   │   │           @ LocalVariableTargetNode (location: (1...2))
+            │   │   │           ├── name: :a
+            │   │   │           └── depth: 0
+            │   │   ├── lparen_loc: ∅
+            │   │   └── rparen_loc: ∅
+            │   └── @ LocalVariableTargetNode (location: (4...5))
+            │       ├── name: :b
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (6...7) = "="
+            └── value:
+                @ CallNode (location: (8...9))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (8...9) = "c"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/masgn_splat_arg_arg.txt b/test/yarp/snapshots/seattlerb/masgn_splat_arg_arg.txt
index bd6a512614..8af251513d 100644
--- a/test/yarp/snapshots/seattlerb/masgn_splat_arg_arg.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_splat_arg_arg.txt
@@ -1,18 +1,37 @@
-ProgramNode(0...12)(
-  [:a, :b, :c],
-  StatementsNode(0...12)(
-    [MultiWriteNode(0...12)(
-       [MultiTargetNode(0...2)(
-          [SplatNode(0...2)((0...1), LocalVariableTargetNode(1...2)(:a, 0))],
-          nil,
-          nil
-        ),
-        LocalVariableTargetNode(4...5)(:b, 0),
-        LocalVariableTargetNode(7...8)(:c, 0)],
-       nil,
-       nil,
-       (9...10),
-       CallNode(11...12)(nil, nil, (11...12), nil, nil, nil, nil, 2, "d")
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:a, :b, :c]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...12))
+            ├── targets: (length: 3)
+            │   ├── @ MultiTargetNode (location: (0...2))
+            │   │   ├── targets: (length: 1)
+            │   │   │   └── @ SplatNode (location: (0...2))
+            │   │   │       ├── operator_loc: (0...1) = "*"
+            │   │   │       └── expression:
+            │   │   │           @ LocalVariableTargetNode (location: (1...2))
+            │   │   │           ├── name: :a
+            │   │   │           └── depth: 0
+            │   │   ├── lparen_loc: ∅
+            │   │   └── rparen_loc: ∅
+            │   ├── @ LocalVariableTargetNode (location: (4...5))
+            │   │   ├── name: :b
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (7...8))
+            │       ├── name: :c
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (9...10) = "="
+            └── value:
+                @ CallNode (location: (11...12))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (11...12) = "d"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/masgn_star.txt b/test/yarp/snapshots/seattlerb/masgn_star.txt
index 015e5edcc9..b17afb60d1 100644
--- a/test/yarp/snapshots/seattlerb/masgn_star.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_star.txt
@@ -1,12 +1,15 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [MultiWriteNode(0...5)(
-       [SplatNode(0...1)((0...1), nil)],
-       nil,
-       nil,
-       (2...3),
-       IntegerNode(4...5)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...5))
+            ├── targets: (length: 1)
+            │   └── @ SplatNode (location: (0...1))
+            │       ├── operator_loc: (0...1) = "*"
+            │       └── expression: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (2...3) = "="
+            └── value:
+                @ IntegerNode (location: (4...5))
diff --git a/test/yarp/snapshots/seattlerb/masgn_var_star_var.txt b/test/yarp/snapshots/seattlerb/masgn_var_star_var.txt
index f6d0136d99..06753a1e43 100644
--- a/test/yarp/snapshots/seattlerb/masgn_var_star_var.txt
+++ b/test/yarp/snapshots/seattlerb/masgn_var_star_var.txt
@@ -1,14 +1,30 @@
-ProgramNode(0...11)(
-  [:a, :b],
-  StatementsNode(0...11)(
-    [MultiWriteNode(0...11)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        SplatNode(3...4)((3...4), nil),
-        LocalVariableTargetNode(6...7)(:b, 0)],
-       nil,
-       nil,
-       (8...9),
-       CallNode(10...11)(nil, nil, (10...11), nil, nil, nil, nil, 2, "c")
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...11))
+            ├── targets: (length: 3)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   ├── @ SplatNode (location: (3...4))
+            │   │   ├── operator_loc: (3...4) = "*"
+            │   │   └── expression: ∅
+            │   └── @ LocalVariableTargetNode (location: (6...7))
+            │       ├── name: :b
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (8...9) = "="
+            └── value:
+                @ CallNode (location: (10...11))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (10...11) = "c"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/messy_op_asgn_lineno.txt b/test/yarp/snapshots/seattlerb/messy_op_asgn_lineno.txt
index 74da38dee6..dbe85e26c0 100644
--- a/test/yarp/snapshots/seattlerb/messy_op_asgn_lineno.txt
+++ b/test/yarp/snapshots/seattlerb/messy_op_asgn_lineno.txt
@@ -1,55 +1,58 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...15)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...15)(
-         [ParenthesesNode(2...15)(
-            StatementsNode(3...14)(
-              [ConstantPathOperatorWriteNode(3...14)(
-                 ConstantPathNode(3...7)(
-                   ConstantReadNode(3...4)(:B),
-                   ConstantReadNode(6...7)(:C),
-                   (4...6)
-                 ),
-                 (8...10),
-                 CallNode(11...14)(
-                   nil,
-                   nil,
-                   (11...12),
-                   nil,
-                   ArgumentsNode(13...14)(
-                     [CallNode(13...14)(
-                        nil,
-                        nil,
-                        (13...14),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "e"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "d"
-                 ),
-                 :*
-               )]
-            ),
-            (2...3),
-            (14...15)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...15))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...15))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (2...15))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (3...14))
+            │           │   └── body: (length: 1)
+            │           │       └── @ ConstantPathOperatorWriteNode (location: (3...14))
+            │           │           ├── target:
+            │           │           │   @ ConstantPathNode (location: (3...7))
+            │           │           │   ├── parent:
+            │           │           │   │   @ ConstantReadNode (location: (3...4))
+            │           │           │   │   └── name: :B
+            │           │           │   ├── child:
+            │           │           │   │   @ ConstantReadNode (location: (6...7))
+            │           │           │   │   └── name: :C
+            │           │           │   └── delimiter_loc: (4...6) = "::"
+            │           │           ├── operator_loc: (8...10) = "*="
+            │           │           ├── value:
+            │           │           │   @ CallNode (location: (11...14))
+            │           │           │   ├── receiver: ∅
+            │           │           │   ├── call_operator_loc: ∅
+            │           │           │   ├── message_loc: (11...12) = "d"
+            │           │           │   ├── opening_loc: ∅
+            │           │           │   ├── arguments:
+            │           │           │   │   @ ArgumentsNode (location: (13...14))
+            │           │           │   │   └── arguments: (length: 1)
+            │           │           │   │       └── @ CallNode (location: (13...14))
+            │           │           │   │           ├── receiver: ∅
+            │           │           │   │           ├── call_operator_loc: ∅
+            │           │           │   │           ├── message_loc: (13...14) = "e"
+            │           │           │   │           ├── opening_loc: ∅
+            │           │           │   │           ├── arguments: ∅
+            │           │           │   │           ├── closing_loc: ∅
+            │           │           │   │           ├── block: ∅
+            │           │           │   │           ├── flags: variable_call
+            │           │           │   │           └── name: "e"
+            │           │           │   ├── closing_loc: ∅
+            │           │           │   ├── block: ∅
+            │           │           │   ├── flags: 
+            │           │           │   └── name: "d"
+            │           │           └── operator: :*
+            │           ├── opening_loc: (2...3) = "("
+            │           └── closing_loc: (14...15) = ")"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/method_call_assoc_trailing_comma.txt b/test/yarp/snapshots/seattlerb/method_call_assoc_trailing_comma.txt
index 1c0c544e85..f1355e4913 100644
--- a/test/yarp/snapshots/seattlerb/method_call_assoc_trailing_comma.txt
+++ b/test/yarp/snapshots/seattlerb/method_call_assoc_trailing_comma.txt
@@ -1,24 +1,35 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [CallNode(0...10)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...3),
-       (3...4),
-       ArgumentsNode(4...8)(
-         [KeywordHashNode(4...8)(
-            [AssocNode(4...8)(
-               IntegerNode(4...5)(),
-               IntegerNode(7...8)(),
-               (5...7)
-             )]
-          )]
-       ),
-       (9...10),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...10))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...3) = "f"
+            ├── opening_loc: (3...4) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...8))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (4...8))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (4...8))
+            │                   ├── key:
+            │                   │   @ IntegerNode (location: (4...5))
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (7...8))
+            │                   └── operator_loc: (5...7) = "=>"
+            ├── closing_loc: (9...10) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/method_call_trailing_comma.txt b/test/yarp/snapshots/seattlerb/method_call_trailing_comma.txt
index 18089701db..8d80de2f48 100644
--- a/test/yarp/snapshots/seattlerb/method_call_trailing_comma.txt
+++ b/test/yarp/snapshots/seattlerb/method_call_trailing_comma.txt
@@ -1,16 +1,28 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...3),
-       (3...4),
-       ArgumentsNode(4...5)([IntegerNode(4...5)()]),
-       (6...7),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...3) = "f"
+            ├── opening_loc: (3...4) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...5))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (4...5))
+            ├── closing_loc: (6...7) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/mlhs_back_anonsplat.txt b/test/yarp/snapshots/seattlerb/mlhs_back_anonsplat.txt
index 59e954706b..d01cb219ec 100644
--- a/test/yarp/snapshots/seattlerb/mlhs_back_anonsplat.txt
+++ b/test/yarp/snapshots/seattlerb/mlhs_back_anonsplat.txt
@@ -1,15 +1,33 @@
-ProgramNode(0...14)(
-  [:a, :b, :c],
-  StatementsNode(0...14)(
-    [MultiWriteNode(0...14)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableTargetNode(3...4)(:b, 0),
-        LocalVariableTargetNode(6...7)(:c, 0),
-        SplatNode(9...10)((9...10), nil)],
-       nil,
-       nil,
-       (11...12),
-       CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "f")
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: [:a, :b, :c]
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...14))
+            ├── targets: (length: 4)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (3...4))
+            │   │   ├── name: :b
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (6...7))
+            │   │   ├── name: :c
+            │   │   └── depth: 0
+            │   └── @ SplatNode (location: (9...10))
+            │       ├── operator_loc: (9...10) = "*"
+            │       └── expression: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (11...12) = "="
+            └── value:
+                @ CallNode (location: (13...14))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (13...14) = "f"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/mlhs_back_splat.txt b/test/yarp/snapshots/seattlerb/mlhs_back_splat.txt
index 8014663bd3..12b8584ab2 100644
--- a/test/yarp/snapshots/seattlerb/mlhs_back_splat.txt
+++ b/test/yarp/snapshots/seattlerb/mlhs_back_splat.txt
@@ -1,15 +1,36 @@
-ProgramNode(0...15)(
-  [:a, :b, :c, :s],
-  StatementsNode(0...15)(
-    [MultiWriteNode(0...15)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableTargetNode(3...4)(:b, 0),
-        LocalVariableTargetNode(6...7)(:c, 0),
-        SplatNode(9...11)((9...10), LocalVariableTargetNode(10...11)(:s, 0))],
-       nil,
-       nil,
-       (12...13),
-       CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "f")
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: [:a, :b, :c, :s]
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...15))
+            ├── targets: (length: 4)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (3...4))
+            │   │   ├── name: :b
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (6...7))
+            │   │   ├── name: :c
+            │   │   └── depth: 0
+            │   └── @ SplatNode (location: (9...11))
+            │       ├── operator_loc: (9...10) = "*"
+            │       └── expression:
+            │           @ LocalVariableTargetNode (location: (10...11))
+            │           ├── name: :s
+            │           └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (12...13) = "="
+            └── value:
+                @ CallNode (location: (14...15))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (14...15) = "f"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/mlhs_front_anonsplat.txt b/test/yarp/snapshots/seattlerb/mlhs_front_anonsplat.txt
index 74a63d328b..e35ab03ae2 100644
--- a/test/yarp/snapshots/seattlerb/mlhs_front_anonsplat.txt
+++ b/test/yarp/snapshots/seattlerb/mlhs_front_anonsplat.txt
@@ -1,15 +1,37 @@
-ProgramNode(0...14)(
-  [:x, :y, :z],
-  StatementsNode(0...14)(
-    [MultiWriteNode(0...14)(
-       [MultiTargetNode(0...1)([SplatNode(0...1)((0...1), nil)], nil, nil),
-        LocalVariableTargetNode(3...4)(:x, 0),
-        LocalVariableTargetNode(6...7)(:y, 0),
-        LocalVariableTargetNode(9...10)(:z, 0)],
-       nil,
-       nil,
-       (11...12),
-       CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "f")
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: [:x, :y, :z]
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...14))
+            ├── targets: (length: 4)
+            │   ├── @ MultiTargetNode (location: (0...1))
+            │   │   ├── targets: (length: 1)
+            │   │   │   └── @ SplatNode (location: (0...1))
+            │   │   │       ├── operator_loc: (0...1) = "*"
+            │   │   │       └── expression: ∅
+            │   │   ├── lparen_loc: ∅
+            │   │   └── rparen_loc: ∅
+            │   ├── @ LocalVariableTargetNode (location: (3...4))
+            │   │   ├── name: :x
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (6...7))
+            │   │   ├── name: :y
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (9...10))
+            │       ├── name: :z
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (11...12) = "="
+            └── value:
+                @ CallNode (location: (13...14))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (13...14) = "f"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/mlhs_front_splat.txt b/test/yarp/snapshots/seattlerb/mlhs_front_splat.txt
index f3110882cc..4607908867 100644
--- a/test/yarp/snapshots/seattlerb/mlhs_front_splat.txt
+++ b/test/yarp/snapshots/seattlerb/mlhs_front_splat.txt
@@ -1,19 +1,40 @@
-ProgramNode(0...15)(
-  [:s, :x, :y, :z],
-  StatementsNode(0...15)(
-    [MultiWriteNode(0...15)(
-       [MultiTargetNode(0...2)(
-          [SplatNode(0...2)((0...1), LocalVariableTargetNode(1...2)(:s, 0))],
-          nil,
-          nil
-        ),
-        LocalVariableTargetNode(4...5)(:x, 0),
-        LocalVariableTargetNode(7...8)(:y, 0),
-        LocalVariableTargetNode(10...11)(:z, 0)],
-       nil,
-       nil,
-       (12...13),
-       CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "f")
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: [:s, :x, :y, :z]
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...15))
+            ├── targets: (length: 4)
+            │   ├── @ MultiTargetNode (location: (0...2))
+            │   │   ├── targets: (length: 1)
+            │   │   │   └── @ SplatNode (location: (0...2))
+            │   │   │       ├── operator_loc: (0...1) = "*"
+            │   │   │       └── expression:
+            │   │   │           @ LocalVariableTargetNode (location: (1...2))
+            │   │   │           ├── name: :s
+            │   │   │           └── depth: 0
+            │   │   ├── lparen_loc: ∅
+            │   │   └── rparen_loc: ∅
+            │   ├── @ LocalVariableTargetNode (location: (4...5))
+            │   │   ├── name: :x
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (7...8))
+            │   │   ├── name: :y
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (10...11))
+            │       ├── name: :z
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (12...13) = "="
+            └── value:
+                @ CallNode (location: (14...15))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (14...15) = "f"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/mlhs_keyword.txt b/test/yarp/snapshots/seattlerb/mlhs_keyword.txt
index 8910c8b5d1..1b92ceb831 100644
--- a/test/yarp/snapshots/seattlerb/mlhs_keyword.txt
+++ b/test/yarp/snapshots/seattlerb/mlhs_keyword.txt
@@ -1,16 +1,29 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...16)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...4),
-       (4...5),
-       ArgumentsNode(5...15)([TrueNode(5...9)(), TrueNode(11...15)()]),
-       (15...16),
-       nil,
-       0,
-       "!="
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...16))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...4) = "!="
+            ├── opening_loc: (4...5) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...15))
+            │   └── arguments: (length: 2)
+            │       ├── @ TrueNode (location: (5...9))
+            │       └── @ TrueNode (location: (11...15))
+            ├── closing_loc: (15...16) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!="
diff --git a/test/yarp/snapshots/seattlerb/mlhs_mid_anonsplat.txt b/test/yarp/snapshots/seattlerb/mlhs_mid_anonsplat.txt
index c0e3acc145..df73618210 100644
--- a/test/yarp/snapshots/seattlerb/mlhs_mid_anonsplat.txt
+++ b/test/yarp/snapshots/seattlerb/mlhs_mid_anonsplat.txt
@@ -1,18 +1,42 @@
-ProgramNode(0...23)(
-  [:a, :b, :c, :x, :y, :z],
-  StatementsNode(0...23)(
-    [MultiWriteNode(0...23)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableTargetNode(3...4)(:b, 0),
-        LocalVariableTargetNode(6...7)(:c, 0),
-        SplatNode(9...10)((9...10), nil),
-        LocalVariableTargetNode(12...13)(:x, 0),
-        LocalVariableTargetNode(15...16)(:y, 0),
-        LocalVariableTargetNode(18...19)(:z, 0)],
-       nil,
-       nil,
-       (20...21),
-       CallNode(22...23)(nil, nil, (22...23), nil, nil, nil, nil, 2, "f")
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: [:a, :b, :c, :x, :y, :z]
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...23))
+            ├── targets: (length: 7)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (3...4))
+            │   │   ├── name: :b
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (6...7))
+            │   │   ├── name: :c
+            │   │   └── depth: 0
+            │   ├── @ SplatNode (location: (9...10))
+            │   │   ├── operator_loc: (9...10) = "*"
+            │   │   └── expression: ∅
+            │   ├── @ LocalVariableTargetNode (location: (12...13))
+            │   │   ├── name: :x
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (15...16))
+            │   │   ├── name: :y
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (18...19))
+            │       ├── name: :z
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (20...21) = "="
+            └── value:
+                @ CallNode (location: (22...23))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (22...23) = "f"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/mlhs_mid_splat.txt b/test/yarp/snapshots/seattlerb/mlhs_mid_splat.txt
index 46d81adf64..2278b7b9bd 100644
--- a/test/yarp/snapshots/seattlerb/mlhs_mid_splat.txt
+++ b/test/yarp/snapshots/seattlerb/mlhs_mid_splat.txt
@@ -1,18 +1,45 @@
-ProgramNode(0...24)(
-  [:a, :b, :c, :s, :x, :y, :z],
-  StatementsNode(0...24)(
-    [MultiWriteNode(0...24)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableTargetNode(3...4)(:b, 0),
-        LocalVariableTargetNode(6...7)(:c, 0),
-        SplatNode(9...11)((9...10), LocalVariableTargetNode(10...11)(:s, 0)),
-        LocalVariableTargetNode(13...14)(:x, 0),
-        LocalVariableTargetNode(16...17)(:y, 0),
-        LocalVariableTargetNode(19...20)(:z, 0)],
-       nil,
-       nil,
-       (21...22),
-       CallNode(23...24)(nil, nil, (23...24), nil, nil, nil, nil, 2, "f")
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: [:a, :b, :c, :s, :x, :y, :z]
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...24))
+            ├── targets: (length: 7)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (3...4))
+            │   │   ├── name: :b
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (6...7))
+            │   │   ├── name: :c
+            │   │   └── depth: 0
+            │   ├── @ SplatNode (location: (9...11))
+            │   │   ├── operator_loc: (9...10) = "*"
+            │   │   └── expression:
+            │   │       @ LocalVariableTargetNode (location: (10...11))
+            │   │       ├── name: :s
+            │   │       └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (13...14))
+            │   │   ├── name: :x
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (16...17))
+            │   │   ├── name: :y
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (19...20))
+            │       ├── name: :z
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (21...22) = "="
+            └── value:
+                @ CallNode (location: (23...24))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (23...24) = "f"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/mlhs_rescue.txt b/test/yarp/snapshots/seattlerb/mlhs_rescue.txt
index 427c56dfea..15476af6b1 100644
--- a/test/yarp/snapshots/seattlerb/mlhs_rescue.txt
+++ b/test/yarp/snapshots/seattlerb/mlhs_rescue.txt
@@ -1,17 +1,32 @@
-ProgramNode(0...18)(
-  [:a, :b],
-  StatementsNode(0...18)(
-    [MultiWriteNode(0...18)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableTargetNode(3...4)(:b, 0)],
-       nil,
-       nil,
-       (5...6),
-       RescueModifierNode(7...18)(
-         CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "f"),
-         (9...15),
-         IntegerNode(16...18)()
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...18))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (0...1))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (3...4))
+            │       ├── name: :b
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (5...6) = "="
+            └── value:
+                @ RescueModifierNode (location: (7...18))
+                ├── expression:
+                │   @ CallNode (location: (7...8))
+                │   ├── receiver: ∅
+                │   ├── call_operator_loc: ∅
+                │   ├── message_loc: (7...8) = "f"
+                │   ├── opening_loc: ∅
+                │   ├── arguments: ∅
+                │   ├── closing_loc: ∅
+                │   ├── block: ∅
+                │   ├── flags: variable_call
+                │   └── name: "f"
+                ├── keyword_loc: (9...15) = "rescue"
+                └── rescue_expression:
+                    @ IntegerNode (location: (16...18))
diff --git a/test/yarp/snapshots/seattlerb/module_comments.txt b/test/yarp/snapshots/seattlerb/module_comments.txt
index a049665ce0..0590738ee6 100644
--- a/test/yarp/snapshots/seattlerb/module_comments.txt
+++ b/test/yarp/snapshots/seattlerb/module_comments.txt
@@ -1,28 +1,29 @@
-ProgramNode(24...77)(
-  [],
-  StatementsNode(24...77)(
-    [ModuleNode(24...77)(
-       [],
-       (24...30),
-       ConstantReadNode(31...32)(:X),
-       StatementsNode(46...73)(
-         [DefNode(46...73)(
-            :blah,
-            (50...54),
-            nil,
-            nil,
-            nil,
-            [],
-            (46...49),
-            nil,
-            nil,
-            nil,
-            nil,
-            (70...73)
-          )]
-       ),
-       (74...77),
-       :X
-     )]
-  )
-)
+@ ProgramNode (location: (24...77))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (24...77))
+    └── body: (length: 1)
+        └── @ ModuleNode (location: (24...77))
+            ├── locals: []
+            ├── module_keyword_loc: (24...30) = "module"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (31...32))
+            │   └── name: :X
+            ├── body:
+            │   @ StatementsNode (location: (46...73))
+            │   └── body: (length: 1)
+            │       └── @ DefNode (location: (46...73))
+            │           ├── name: :blah
+            │           ├── name_loc: (50...54) = "blah"
+            │           ├── receiver: ∅
+            │           ├── parameters: ∅
+            │           ├── body: ∅
+            │           ├── locals: []
+            │           ├── def_keyword_loc: (46...49) = "def"
+            │           ├── operator_loc: ∅
+            │           ├── lparen_loc: ∅
+            │           ├── rparen_loc: ∅
+            │           ├── equal_loc: ∅
+            │           └── end_keyword_loc: (70...73) = "end"
+            ├── end_keyword_loc: (74...77) = "end"
+            └── name: :X
diff --git a/test/yarp/snapshots/seattlerb/multiline_hash_declaration.txt b/test/yarp/snapshots/seattlerb/multiline_hash_declaration.txt
index e6e341fc7c..c4627472b0 100644
--- a/test/yarp/snapshots/seattlerb/multiline_hash_declaration.txt
+++ b/test/yarp/snapshots/seattlerb/multiline_hash_declaration.txt
@@ -1,62 +1,86 @@
-ProgramNode(0...43)(
-  [],
-  StatementsNode(0...43)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...13)(
-         [KeywordHashNode(2...13)(
-            [AssocNode(2...13)(
-               SymbolNode(2...8)(nil, (2...7), (7...8), "state"),
-               HashNode(10...13)((10...11), [], (12...13)),
-               nil
-             )]
-          )]
-       ),
-       (13...14),
-       nil,
-       0,
-       "f"
-     ),
-     CallNode(16...29)(
-       nil,
-       nil,
-       (16...17),
-       (17...18),
-       ArgumentsNode(18...28)(
-         [KeywordHashNode(18...28)(
-            [AssocNode(18...28)(
-               SymbolNode(18...24)(nil, (18...23), (23...24), "state"),
-               HashNode(25...28)((25...26), [], (27...28)),
-               nil
-             )]
-          )]
-       ),
-       (28...29),
-       nil,
-       0,
-       "f"
-     ),
-     CallNode(31...43)(
-       nil,
-       nil,
-       (31...32),
-       (32...33),
-       ArgumentsNode(33...42)(
-         [KeywordHashNode(33...42)(
-            [AssocNode(33...42)(
-               SymbolNode(33...39)(nil, (33...38), (38...39), "state"),
-               HashNode(40...42)((40...41), [], (41...42)),
-               nil
-             )]
-          )]
-       ),
-       (42...43),
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...43))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...43))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...14))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "f"
+        │   ├── opening_loc: (1...2) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...13))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (2...13))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (2...13))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (2...8))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (2...7) = "state"
+        │   │                   │   ├── closing_loc: (7...8) = ":"
+        │   │                   │   └── unescaped: "state"
+        │   │                   ├── value:
+        │   │                   │   @ HashNode (location: (10...13))
+        │   │                   │   ├── opening_loc: (10...11) = "{"
+        │   │                   │   ├── elements: (length: 0)
+        │   │                   │   └── closing_loc: (12...13) = "}"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: (13...14) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (16...29))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (16...17) = "f"
+        │   ├── opening_loc: (17...18) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (18...28))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (18...28))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (18...28))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (18...24))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (18...23) = "state"
+        │   │                   │   ├── closing_loc: (23...24) = ":"
+        │   │                   │   └── unescaped: "state"
+        │   │                   ├── value:
+        │   │                   │   @ HashNode (location: (25...28))
+        │   │                   │   ├── opening_loc: (25...26) = "{"
+        │   │                   │   ├── elements: (length: 0)
+        │   │                   │   └── closing_loc: (27...28) = "}"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: (28...29) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "f"
+        └── @ CallNode (location: (31...43))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (31...32) = "f"
+            ├── opening_loc: (32...33) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (33...42))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (33...42))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (33...42))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (33...39))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (33...38) = "state"
+            │                   │   ├── closing_loc: (38...39) = ":"
+            │                   │   └── unescaped: "state"
+            │                   ├── value:
+            │                   │   @ HashNode (location: (40...42))
+            │                   │   ├── opening_loc: (40...41) = "{"
+            │                   │   ├── elements: (length: 0)
+            │                   │   └── closing_loc: (41...42) = "}"
+            │                   └── operator_loc: ∅
+            ├── closing_loc: (42...43) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/non_interpolated_symbol_array_line_breaks.txt b/test/yarp/snapshots/seattlerb/non_interpolated_symbol_array_line_breaks.txt
index 0a779610a6..c0bb1fe0a2 100644
--- a/test/yarp/snapshots/seattlerb/non_interpolated_symbol_array_line_breaks.txt
+++ b/test/yarp/snapshots/seattlerb/non_interpolated_symbol_array_line_breaks.txt
@@ -1,12 +1,20 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [ArrayNode(0...9)(
-       [SymbolNode(4...5)(nil, (4...5), nil, "a"),
-        SymbolNode(6...7)(nil, (6...7), nil, "b")],
-       (0...3),
-       (8...9)
-     ),
-     IntegerNode(10...11)()]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...9))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ SymbolNode (location: (4...5))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (4...5) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ SymbolNode (location: (6...7))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (6...7) = "b"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "b"
+        │   ├── opening_loc: (0...3) = "%i("
+        │   └── closing_loc: (8...9) = ")"
+        └── @ IntegerNode (location: (10...11))
diff --git a/test/yarp/snapshots/seattlerb/non_interpolated_word_array_line_breaks.txt b/test/yarp/snapshots/seattlerb/non_interpolated_word_array_line_breaks.txt
index 901575f9a8..21a3263b86 100644
--- a/test/yarp/snapshots/seattlerb/non_interpolated_word_array_line_breaks.txt
+++ b/test/yarp/snapshots/seattlerb/non_interpolated_word_array_line_breaks.txt
@@ -1,12 +1,20 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [ArrayNode(0...9)(
-       [StringNode(4...5)(nil, (4...5), nil, "a"),
-        StringNode(6...7)(nil, (6...7), nil, "b")],
-       (0...3),
-       (8...9)
-     ),
-     IntegerNode(10...11)()]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...9))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ StringNode (location: (4...5))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (4...5) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ StringNode (location: (6...7))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (6...7) = "b"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "b"
+        │   ├── opening_loc: (0...3) = "%w("
+        │   └── closing_loc: (8...9) = ")"
+        └── @ IntegerNode (location: (10...11))
diff --git a/test/yarp/snapshots/seattlerb/op_asgn_command_call.txt b/test/yarp/snapshots/seattlerb/op_asgn_command_call.txt
index cf092dd5de..1bc0a88025 100644
--- a/test/yarp/snapshots/seattlerb/op_asgn_command_call.txt
+++ b/test/yarp/snapshots/seattlerb/op_asgn_command_call.txt
@@ -1,22 +1,34 @@
-ProgramNode(0...11)(
-  [:a],
-  StatementsNode(0...11)(
-    [LocalVariableOrWriteNode(0...11)(
-       (0...1),
-       (2...5),
-       CallNode(6...11)(
-         CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b"),
-         (7...8),
-         (8...9),
-         nil,
-         ArgumentsNode(10...11)([IntegerNode(10...11)()]),
-         nil,
-         nil,
-         0,
-         "c"
-       ),
-       :a,
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ LocalVariableOrWriteNode (location: (0...11))
+            ├── name_loc: (0...1) = "a"
+            ├── operator_loc: (2...5) = "||="
+            ├── value:
+            │   @ CallNode (location: (6...11))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (6...7))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (6...7) = "b"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "b"
+            │   ├── call_operator_loc: (7...8) = "."
+            │   ├── message_loc: (8...9) = "c"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (10...11))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ IntegerNode (location: (10...11))
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "c"
+            ├── name: :a
+            └── depth: 0
diff --git a/test/yarp/snapshots/seattlerb/op_asgn_dot_ident_command_call.txt b/test/yarp/snapshots/seattlerb/op_asgn_dot_ident_command_call.txt
index 00aa433864..ac671e90cd 100644
--- a/test/yarp/snapshots/seattlerb/op_asgn_dot_ident_command_call.txt
+++ b/test/yarp/snapshots/seattlerb/op_asgn_dot_ident_command_call.txt
@@ -1,28 +1,32 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallOrWriteNode(0...11)(
-       ConstantReadNode(0...1)(:A),
-       (1...2),
-       (2...3),
-       nil,
-       nil,
-       nil,
-       0,
-       "B",
-       "B=",
-       (4...7),
-       CallNode(8...11)(
-         nil,
-         nil,
-         (8...9),
-         nil,
-         ArgumentsNode(10...11)([IntegerNode(10...11)()]),
-         nil,
-         nil,
-         0,
-         "c"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallOrWriteNode (location: (0...11))
+            ├── receiver:
+            │   @ ConstantReadNode (location: (0...1))
+            │   └── name: :A
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...3) = "B"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: 
+            ├── read_name: "B"
+            ├── write_name: "B="
+            ├── operator_loc: (4...7) = "||="
+            └── value:
+                @ CallNode (location: (8...11))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (8...9) = "c"
+                ├── opening_loc: ∅
+                ├── arguments:
+                │   @ ArgumentsNode (location: (10...11))
+                │   └── arguments: (length: 1)
+                │       └── @ IntegerNode (location: (10...11))
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/op_asgn_index_command_call.txt b/test/yarp/snapshots/seattlerb/op_asgn_index_command_call.txt
index e166f958a4..7fa6b6e3af 100644
--- a/test/yarp/snapshots/seattlerb/op_asgn_index_command_call.txt
+++ b/test/yarp/snapshots/seattlerb/op_asgn_index_command_call.txt
@@ -1,30 +1,48 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallOrWriteNode(0...16)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (1...5),
-       (1...2),
-       ArgumentsNode(2...4)([SymbolNode(2...4)((2...3), (3...4), nil, "b")]),
-       (4...5),
-       0,
-       "[]",
-       "[]=",
-       (6...9),
-       CallNode(10...16)(
-         nil,
-         nil,
-         (10...11),
-         nil,
-         ArgumentsNode(12...16)(
-           [IntegerNode(12...13)(), IntegerNode(15...16)()]
-         ),
-         nil,
-         nil,
-         0,
-         "c"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallOrWriteNode (location: (0...16))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (1...5) = "[:b]"
+            ├── opening_loc: (1...2) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...4))
+            │   └── arguments: (length: 1)
+            │       └── @ SymbolNode (location: (2...4))
+            │           ├── opening_loc: (2...3) = ":"
+            │           ├── value_loc: (3...4) = "b"
+            │           ├── closing_loc: ∅
+            │           └── unescaped: "b"
+            ├── closing_loc: (4...5) = "]"
+            ├── flags: 
+            ├── read_name: "[]"
+            ├── write_name: "[]="
+            ├── operator_loc: (6...9) = "||="
+            └── value:
+                @ CallNode (location: (10...16))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (10...11) = "c"
+                ├── opening_loc: ∅
+                ├── arguments:
+                │   @ ArgumentsNode (location: (12...16))
+                │   └── arguments: (length: 2)
+                │       ├── @ IntegerNode (location: (12...13))
+                │       └── @ IntegerNode (location: (15...16))
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt b/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt
index 9459bf5ce5..e1aa27f08d 100644
--- a/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt
+++ b/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt
@@ -1,27 +1,40 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [ConstantPathOperatorWriteNode(0...11)(
-       ConstantPathNode(0...4)(
-         ConstantReadNode(0...1)(:A),
-         ConstantReadNode(3...4)(:B),
-         (1...3)
-       ),
-       (5...7),
-       CallNode(8...11)(
-         nil,
-         nil,
-         (8...9),
-         nil,
-         ArgumentsNode(10...11)(
-           [CallNode(10...11)(nil, nil, (10...11), nil, nil, nil, nil, 2, "d")]
-         ),
-         nil,
-         nil,
-         0,
-         "c"
-       ),
-       :*
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ ConstantPathOperatorWriteNode (location: (0...11))
+            ├── target:
+            │   @ ConstantPathNode (location: (0...4))
+            │   ├── parent:
+            │   │   @ ConstantReadNode (location: (0...1))
+            │   │   └── name: :A
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (3...4))
+            │   │   └── name: :B
+            │   └── delimiter_loc: (1...3) = "::"
+            ├── operator_loc: (5...7) = "*="
+            ├── value:
+            │   @ CallNode (location: (8...11))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (8...9) = "c"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (10...11))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (10...11))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (10...11) = "d"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "d"
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "c"
+            └── operator: :*
diff --git a/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier1.txt b/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier1.txt
index d2703a3e48..9271fa4172 100644
--- a/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier1.txt
+++ b/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier1.txt
@@ -1,19 +1,21 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallOperatorWriteNode(0...9)(
-       ConstantReadNode(0...1)(:A),
-       (1...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       :+,
-       (5...7),
-       IntegerNode(8...9)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallOperatorWriteNode (location: (0...9))
+            ├── receiver:
+            │   @ ConstantReadNode (location: (0...1))
+            │   └── name: :A
+            ├── call_operator_loc: (1...3) = "::"
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: 
+            ├── read_name: "b"
+            ├── write_name: "b="
+            ├── operator: :+
+            ├── operator_loc: (5...7) = "+="
+            └── value:
+                @ IntegerNode (location: (8...9))
diff --git a/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier_command_call.txt b/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier_command_call.txt
index 845e0c30a0..f96f0afff6 100644
--- a/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier_command_call.txt
+++ b/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier_command_call.txt
@@ -1,31 +1,42 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallOperatorWriteNode(0...11)(
-       ConstantReadNode(0...1)(:A),
-       (1...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       :*,
-       (5...7),
-       CallNode(8...11)(
-         nil,
-         nil,
-         (8...9),
-         nil,
-         ArgumentsNode(10...11)(
-           [CallNode(10...11)(nil, nil, (10...11), nil, nil, nil, nil, 2, "d")]
-         ),
-         nil,
-         nil,
-         0,
-         "c"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallOperatorWriteNode (location: (0...11))
+            ├── receiver:
+            │   @ ConstantReadNode (location: (0...1))
+            │   └── name: :A
+            ├── call_operator_loc: (1...3) = "::"
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: 
+            ├── read_name: "b"
+            ├── write_name: "b="
+            ├── operator: :*
+            ├── operator_loc: (5...7) = "*="
+            └── value:
+                @ CallNode (location: (8...11))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (8...9) = "c"
+                ├── opening_loc: ∅
+                ├── arguments:
+                │   @ ArgumentsNode (location: (10...11))
+                │   └── arguments: (length: 1)
+                │       └── @ CallNode (location: (10...11))
+                │           ├── receiver: ∅
+                │           ├── call_operator_loc: ∅
+                │           ├── message_loc: (10...11) = "d"
+                │           ├── opening_loc: ∅
+                │           ├── arguments: ∅
+                │           ├── closing_loc: ∅
+                │           ├── block: ∅
+                │           ├── flags: variable_call
+                │           └── name: "d"
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/op_asgn_val_dot_ident_command_call.txt b/test/yarp/snapshots/seattlerb/op_asgn_val_dot_ident_command_call.txt
index f075b4bb95..5b61f68ed5 100644
--- a/test/yarp/snapshots/seattlerb/op_asgn_val_dot_ident_command_call.txt
+++ b/test/yarp/snapshots/seattlerb/op_asgn_val_dot_ident_command_call.txt
@@ -1,28 +1,40 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallOrWriteNode(0...11)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...3),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       (4...7),
-       CallNode(8...11)(
-         nil,
-         nil,
-         (8...9),
-         nil,
-         ArgumentsNode(10...11)([IntegerNode(10...11)()]),
-         nil,
-         nil,
-         0,
-         "c"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallOrWriteNode (location: (0...11))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...3) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: 
+            ├── read_name: "b"
+            ├── write_name: "b="
+            ├── operator_loc: (4...7) = "||="
+            └── value:
+                @ CallNode (location: (8...11))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (8...9) = "c"
+                ├── opening_loc: ∅
+                ├── arguments:
+                │   @ ArgumentsNode (location: (10...11))
+                │   └── arguments: (length: 1)
+                │       └── @ IntegerNode (location: (10...11))
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/parse_def_special_name.txt b/test/yarp/snapshots/seattlerb/parse_def_special_name.txt
index 0b6b0eae7f..948e802d26 100644
--- a/test/yarp/snapshots/seattlerb/parse_def_special_name.txt
+++ b/test/yarp/snapshots/seattlerb/parse_def_special_name.txt
@@ -1,19 +1,18 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [DefNode(0...13)(
-       :next,
-       (4...8),
-       nil,
-       nil,
-       nil,
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (10...13)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...13))
+            ├── name: :next
+            ├── name_loc: (4...8) = "next"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (10...13) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_if_not_canonical.txt b/test/yarp/snapshots/seattlerb/parse_if_not_canonical.txt
index 223ede6af8..7e36bfdede 100644
--- a/test/yarp/snapshots/seattlerb/parse_if_not_canonical.txt
+++ b/test/yarp/snapshots/seattlerb/parse_if_not_canonical.txt
@@ -1,40 +1,59 @@
-ProgramNode(0...41)(
-  [],
-  StatementsNode(0...41)(
-    [IfNode(0...41)(
-       (0...2),
-       CallNode(3...15)(
-         CallNode(7...15)(
-           CallNode(7...10)(nil, nil, (7...10), nil, nil, nil, nil, 2, "var"),
-           (10...11),
-           (11...15),
-           nil,
-           nil,
-           nil,
-           nil,
-           0,
-           "nil?"
-         ),
-         nil,
-         (3...6),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       StatementsNode(21...26)(
-         [StringNode(21...26)((21...22), (22...25), (25...26), "foo")]
-       ),
-       ElseNode(27...41)(
-         (27...31),
-         StatementsNode(32...37)(
-           [StringNode(32...37)((32...33), (33...36), (36...37), "bar")]
-         ),
-         (38...41)
-       ),
-       (38...41)
-     )]
-  )
-)
+@ ProgramNode (location: (0...41))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...41))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...41))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (3...15))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (7...15))
+            │   │   ├── receiver:
+            │   │   │   @ CallNode (location: (7...10))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (7...10) = "var"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "var"
+            │   │   ├── call_operator_loc: (10...11) = "."
+            │   │   ├── message_loc: (11...15) = "nil?"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "nil?"
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (3...6) = "not"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "!"
+            ├── statements:
+            │   @ StatementsNode (location: (21...26))
+            │   └── body: (length: 1)
+            │       └── @ StringNode (location: (21...26))
+            │           ├── opening_loc: (21...22) = "'"
+            │           ├── content_loc: (22...25) = "foo"
+            │           ├── closing_loc: (25...26) = "'"
+            │           └── unescaped: "foo"
+            ├── consequent:
+            │   @ ElseNode (location: (27...41))
+            │   ├── else_keyword_loc: (27...31) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (32...37))
+            │   │   └── body: (length: 1)
+            │   │       └── @ StringNode (location: (32...37))
+            │   │           ├── opening_loc: (32...33) = "'"
+            │   │           ├── content_loc: (33...36) = "bar"
+            │   │           ├── closing_loc: (36...37) = "'"
+            │   │           └── unescaped: "bar"
+            │   └── end_keyword_loc: (38...41) = "end"
+            └── end_keyword_loc: (38...41) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_if_not_noncanonical.txt b/test/yarp/snapshots/seattlerb/parse_if_not_noncanonical.txt
index 223ede6af8..7e36bfdede 100644
--- a/test/yarp/snapshots/seattlerb/parse_if_not_noncanonical.txt
+++ b/test/yarp/snapshots/seattlerb/parse_if_not_noncanonical.txt
@@ -1,40 +1,59 @@
-ProgramNode(0...41)(
-  [],
-  StatementsNode(0...41)(
-    [IfNode(0...41)(
-       (0...2),
-       CallNode(3...15)(
-         CallNode(7...15)(
-           CallNode(7...10)(nil, nil, (7...10), nil, nil, nil, nil, 2, "var"),
-           (10...11),
-           (11...15),
-           nil,
-           nil,
-           nil,
-           nil,
-           0,
-           "nil?"
-         ),
-         nil,
-         (3...6),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       StatementsNode(21...26)(
-         [StringNode(21...26)((21...22), (22...25), (25...26), "foo")]
-       ),
-       ElseNode(27...41)(
-         (27...31),
-         StatementsNode(32...37)(
-           [StringNode(32...37)((32...33), (33...36), (36...37), "bar")]
-         ),
-         (38...41)
-       ),
-       (38...41)
-     )]
-  )
-)
+@ ProgramNode (location: (0...41))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...41))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...41))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (3...15))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (7...15))
+            │   │   ├── receiver:
+            │   │   │   @ CallNode (location: (7...10))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (7...10) = "var"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "var"
+            │   │   ├── call_operator_loc: (10...11) = "."
+            │   │   ├── message_loc: (11...15) = "nil?"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "nil?"
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (3...6) = "not"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "!"
+            ├── statements:
+            │   @ StatementsNode (location: (21...26))
+            │   └── body: (length: 1)
+            │       └── @ StringNode (location: (21...26))
+            │           ├── opening_loc: (21...22) = "'"
+            │           ├── content_loc: (22...25) = "foo"
+            │           ├── closing_loc: (25...26) = "'"
+            │           └── unescaped: "foo"
+            ├── consequent:
+            │   @ ElseNode (location: (27...41))
+            │   ├── else_keyword_loc: (27...31) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (32...37))
+            │   │   └── body: (length: 1)
+            │   │       └── @ StringNode (location: (32...37))
+            │   │           ├── opening_loc: (32...33) = "'"
+            │   │           ├── content_loc: (33...36) = "bar"
+            │   │           ├── closing_loc: (36...37) = "'"
+            │   │           └── unescaped: "bar"
+            │   └── end_keyword_loc: (38...41) = "end"
+            └── end_keyword_loc: (38...41) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_block.txt b/test/yarp/snapshots/seattlerb/parse_line_block.txt
index 7ca169a86b..0173a9d968 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_block.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_block.txt
@@ -1,23 +1,27 @@
-ProgramNode(0...10)(
-  [:a],
-  StatementsNode(0...10)(
-    [LocalVariableWriteNode(0...6)(
-       :a,
-       0,
-       (0...1),
-       IntegerNode(4...6)(),
-       (2...3)
-     ),
-     CallNode(7...10)(
-       nil,
-       nil,
-       (7...8),
-       nil,
-       ArgumentsNode(9...10)([LocalVariableReadNode(9...10)(:a, 0)]),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 2)
+        ├── @ LocalVariableWriteNode (location: (0...6))
+        │   ├── name: :a
+        │   ├── depth: 0
+        │   ├── name_loc: (0...1) = "a"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (4...6))
+        │   └── operator_loc: (2...3) = "="
+        └── @ CallNode (location: (7...10))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (7...8) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (9...10))
+            │   └── arguments: (length: 1)
+            │       └── @ LocalVariableReadNode (location: (9...10))
+            │           ├── name: :a
+            │           └── depth: 0
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_block_inline_comment.txt b/test/yarp/snapshots/seattlerb/parse_line_block_inline_comment.txt
index f6f0333e91..664275d982 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_block_inline_comment.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_block_inline_comment.txt
@@ -1,8 +1,35 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-     CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "b"),
-     CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "c")]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...1))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "a"
+        ├── @ CallNode (location: (2...3))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (2...3) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "b"
+        └── @ CallNode (location: (14...15))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (14...15) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_block_inline_comment_leading_newlines.txt b/test/yarp/snapshots/seattlerb/parse_line_block_inline_comment_leading_newlines.txt
index 2650fb5c12..651706d788 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_block_inline_comment_leading_newlines.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_block_inline_comment_leading_newlines.txt
@@ -1,8 +1,35 @@
-ProgramNode(3...36)(
-  [],
-  StatementsNode(3...36)(
-    [CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "a"),
-     CallNode(5...6)(nil, nil, (5...6), nil, nil, nil, nil, 2, "b"),
-     CallNode(35...36)(nil, nil, (35...36), nil, nil, nil, nil, 2, "c")]
-  )
-)
+@ ProgramNode (location: (3...36))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (3...36))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (3...4))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (3...4) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "a"
+        ├── @ CallNode (location: (5...6))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (5...6) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "b"
+        └── @ CallNode (location: (35...36))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (35...36) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_block_inline_multiline_comment.txt b/test/yarp/snapshots/seattlerb/parse_line_block_inline_multiline_comment.txt
index 0a01c627fb..878fad5a14 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_block_inline_multiline_comment.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_block_inline_multiline_comment.txt
@@ -1,8 +1,35 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-     CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "b"),
-     CallNode(32...33)(nil, nil, (32...33), nil, nil, nil, nil, 2, "c")]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...1))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "a"
+        ├── @ CallNode (location: (2...3))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (2...3) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "b"
+        └── @ CallNode (location: (32...33))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (32...33) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_call_ivar_arg_no_parens_line_break.txt b/test/yarp/snapshots/seattlerb/parse_line_call_ivar_arg_no_parens_line_break.txt
index 84ee2d450b..fdcedcb306 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_call_ivar_arg_no_parens_line_break.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_call_ivar_arg_no_parens_line_break.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [CallNode(0...4)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...4)([InstanceVariableReadNode(2...4)(:@b)]),
-       nil,
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...4))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...4))
+            │   └── arguments: (length: 1)
+            │       └── @ InstanceVariableReadNode (location: (2...4))
+            │           └── name: :@b
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_call_ivar_line_break_paren.txt b/test/yarp/snapshots/seattlerb/parse_line_call_ivar_line_break_paren.txt
index 1f9d067c76..882e039dbc 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_call_ivar_line_break_paren.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_call_ivar_line_break_paren.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...4)([InstanceVariableReadNode(2...4)(:@b)]),
-       (5...6),
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...4))
+            │   └── arguments: (length: 1)
+            │       └── @ InstanceVariableReadNode (location: (2...4))
+            │           └── name: :@b
+            ├── closing_loc: (5...6) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_call_no_args.txt b/test/yarp/snapshots/seattlerb/parse_line_call_no_args.txt
index 229bfdaa9f..042c6a97c6 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_call_no_args.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_call_no_args.txt
@@ -1,48 +1,58 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [CallNode(0...23)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...23)(
-         [:x, :y],
-         BlockParametersNode(5...11)(
-           ParametersNode(6...10)(
-             [RequiredParameterNode(6...7)(:x),
-              RequiredParameterNode(9...10)(:y)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (5...6),
-           (10...11)
-         ),
-         StatementsNode(14...19)(
-           [CallNode(14...19)(
-              LocalVariableReadNode(14...15)(:x, 0),
-              nil,
-              (16...17),
-              nil,
-              ArgumentsNode(18...19)([LocalVariableReadNode(18...19)(:y, 0)]),
-              nil,
-              nil,
-              0,
-              "+"
-            )]
-         ),
-         (2...4),
-         (20...23)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...23))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (2...23))
+            │   ├── locals: [:x, :y]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (5...11))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (6...10))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (6...7))
+            │   │   │   │   │   └── name: :x
+            │   │   │   │   └── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       └── name: :y
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (5...6) = "|"
+            │   │   └── closing_loc: (10...11) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (14...19))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (14...19))
+            │   │           ├── receiver:
+            │   │           │   @ LocalVariableReadNode (location: (14...15))
+            │   │           │   ├── name: :x
+            │   │           │   └── depth: 0
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (16...17) = "+"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments:
+            │   │           │   @ ArgumentsNode (location: (18...19))
+            │   │           │   └── arguments: (length: 1)
+            │   │           │       └── @ LocalVariableReadNode (location: (18...19))
+            │   │           │           ├── name: :y
+            │   │           │           └── depth: 0
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "+"
+            │   ├── opening_loc: (2...4) = "do"
+            │   └── closing_loc: (20...23) = "end"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_defn_complex.txt b/test/yarp/snapshots/seattlerb/parse_line_defn_complex.txt
index 7e1ea50f46..66d191aa93 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_defn_complex.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_defn_complex.txt
@@ -1,51 +1,61 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [DefNode(0...40)(
-       :x,
-       (4...5),
-       nil,
-       ParametersNode(6...7)(
-         [RequiredParameterNode(6...7)(:y)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(11...35)(
-         [CallNode(11...15)(
-            nil,
-            nil,
-            (11...12),
-            (12...13),
-            ArgumentsNode(13...14)([LocalVariableReadNode(13...14)(:y, 0)]),
-            (14...15),
-            nil,
-            0,
-            "p"
-          ),
-          LocalVariableOperatorWriteNode(18...24)(
-            (18...19),
-            (20...22),
-            IntegerNode(23...24)(),
-            :y,
-            :*,
-            0
-          ),
-          ReturnNode(27...35)(
-            (27...33),
-            ArgumentsNode(34...35)([LocalVariableReadNode(34...35)(:y, 0)])
-          )]
-       ),
-       [:y],
-       (0...3),
-       nil,
-       (5...6),
-       (7...8),
-       nil,
-       (37...40)
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...40))
+            ├── name: :x
+            ├── name_loc: (4...5) = "x"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...7))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (6...7))
+            │   │       └── name: :y
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (11...35))
+            │   └── body: (length: 3)
+            │       ├── @ CallNode (location: (11...15))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (11...12) = "p"
+            │       │   ├── opening_loc: (12...13) = "("
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (13...14))
+            │       │   │   └── arguments: (length: 1)
+            │       │   │       └── @ LocalVariableReadNode (location: (13...14))
+            │       │   │           ├── name: :y
+            │       │   │           └── depth: 0
+            │       │   ├── closing_loc: (14...15) = ")"
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "p"
+            │       ├── @ LocalVariableOperatorWriteNode (location: (18...24))
+            │       │   ├── name_loc: (18...19) = "y"
+            │       │   ├── operator_loc: (20...22) = "*="
+            │       │   ├── value:
+            │       │   │   @ IntegerNode (location: (23...24))
+            │       │   ├── name: :y
+            │       │   ├── operator: :*
+            │       │   └── depth: 0
+            │       └── @ ReturnNode (location: (27...35))
+            │           ├── keyword_loc: (27...33) = "return"
+            │           └── arguments:
+            │               @ ArgumentsNode (location: (34...35))
+            │               └── arguments: (length: 1)
+            │                   └── @ LocalVariableReadNode (location: (34...35))
+            │                       ├── name: :y
+            │                       └── depth: 0
+            ├── locals: [:y]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (7...8) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (37...40) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_defn_no_parens.txt b/test/yarp/snapshots/seattlerb/parse_line_defn_no_parens.txt
index 3bbc2bf9cd..fb057e68e0 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_defn_no_parens.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_defn_no_parens.txt
@@ -1,33 +1,31 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [DefNode(0...10)(
-       :f,
-       (4...5),
-       nil,
-       nil,
-       nil,
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (7...10)
-     ),
-     DefNode(12...21)(
-       :f,
-       (16...17),
-       nil,
-       nil,
-       nil,
-       [],
-       (12...15),
-       nil,
-       nil,
-       nil,
-       nil,
-       (18...21)
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 2)
+        ├── @ DefNode (location: (0...10))
+        │   ├── name: :f
+        │   ├── name_loc: (4...5) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (7...10) = "end"
+        └── @ DefNode (location: (12...21))
+            ├── name: :f
+            ├── name_loc: (16...17) = "f"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (12...15) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (18...21) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_defn_no_parens_args.txt b/test/yarp/snapshots/seattlerb/parse_line_defn_no_parens_args.txt
index 2040cdca68..958d09cdb8 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_defn_no_parens_args.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_defn_no_parens_args.txt
@@ -1,27 +1,28 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [DefNode(0...11)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...7)(
-         [RequiredParameterNode(6...7)(:a)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (8...11)
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...11))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...7))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (6...7))
+            │   │       └── name: :a
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:a]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (8...11) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_dot2.txt b/test/yarp/snapshots/seattlerb/parse_line_dot2.txt
index 04d53e2c51..57e8415e3f 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_dot2.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_dot2.txt
@@ -1,13 +1,47 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [RangeNode(0...5)(IntegerNode(0...1)(), IntegerNode(4...5)(), (1...3), 0),
-     RangeNode(6...11)(
-       CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "a"),
-       CallNode(10...11)(nil, nil, (10...11), nil, nil, nil, nil, 2, "b"),
-       (7...9),
-       0
-     ),
-     CallNode(12...13)(nil, nil, (12...13), nil, nil, nil, nil, 2, "c")]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 3)
+        ├── @ RangeNode (location: (0...5))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (0...1))
+        │   ├── right:
+        │   │   @ IntegerNode (location: (4...5))
+        │   ├── operator_loc: (1...3) = ".."
+        │   └── flags: 
+        ├── @ RangeNode (location: (6...11))
+        │   ├── left:
+        │   │   @ CallNode (location: (6...7))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (6...7) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── right:
+        │   │   @ CallNode (location: (10...11))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (10...11) = "b"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "b"
+        │   ├── operator_loc: (7...9) = ".."
+        │   └── flags: 
+        └── @ CallNode (location: (12...13))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (12...13) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_dot2_open.txt b/test/yarp/snapshots/seattlerb/parse_line_dot2_open.txt
index 35faa728ed..899301d988 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_dot2_open.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_dot2_open.txt
@@ -1,13 +1,36 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [RangeNode(0...3)(IntegerNode(0...1)(), nil, (1...3), 0),
-     RangeNode(6...9)(
-       CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (7...9),
-       0
-     ),
-     CallNode(12...13)(nil, nil, (12...13), nil, nil, nil, nil, 2, "c")]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 3)
+        ├── @ RangeNode (location: (0...3))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (0...1))
+        │   ├── right: ∅
+        │   ├── operator_loc: (1...3) = ".."
+        │   └── flags: 
+        ├── @ RangeNode (location: (6...9))
+        │   ├── left:
+        │   │   @ CallNode (location: (6...7))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (6...7) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── right: ∅
+        │   ├── operator_loc: (7...9) = ".."
+        │   └── flags: 
+        └── @ CallNode (location: (12...13))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (12...13) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_dot3.txt b/test/yarp/snapshots/seattlerb/parse_line_dot3.txt
index 109bbadc62..ee04437d61 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_dot3.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_dot3.txt
@@ -1,13 +1,47 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [RangeNode(0...6)(IntegerNode(0...1)(), IntegerNode(5...6)(), (1...4), 1),
-     RangeNode(7...13)(
-       CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "a"),
-       CallNode(12...13)(nil, nil, (12...13), nil, nil, nil, nil, 2, "b"),
-       (8...11),
-       1
-     ),
-     CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "c")]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 3)
+        ├── @ RangeNode (location: (0...6))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (0...1))
+        │   ├── right:
+        │   │   @ IntegerNode (location: (5...6))
+        │   ├── operator_loc: (1...4) = "..."
+        │   └── flags: exclude_end
+        ├── @ RangeNode (location: (7...13))
+        │   ├── left:
+        │   │   @ CallNode (location: (7...8))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (7...8) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── right:
+        │   │   @ CallNode (location: (12...13))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (12...13) = "b"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "b"
+        │   ├── operator_loc: (8...11) = "..."
+        │   └── flags: exclude_end
+        └── @ CallNode (location: (14...15))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (14...15) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_dot3_open.txt b/test/yarp/snapshots/seattlerb/parse_line_dot3_open.txt
index 558c430b6a..42ac66c20f 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_dot3_open.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_dot3_open.txt
@@ -1,13 +1,36 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [RangeNode(0...4)(IntegerNode(0...1)(), nil, (1...4), 1),
-     RangeNode(7...11)(
-       CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (8...11),
-       1
-     ),
-     CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "c")]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 3)
+        ├── @ RangeNode (location: (0...4))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (0...1))
+        │   ├── right: ∅
+        │   ├── operator_loc: (1...4) = "..."
+        │   └── flags: exclude_end
+        ├── @ RangeNode (location: (7...11))
+        │   ├── left:
+        │   │   @ CallNode (location: (7...8))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (7...8) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── right: ∅
+        │   ├── operator_loc: (8...11) = "..."
+        │   └── flags: exclude_end
+        └── @ CallNode (location: (14...15))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (14...15) = "c"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_dstr_escaped_newline.txt b/test/yarp/snapshots/seattlerb/parse_line_dstr_escaped_newline.txt
index b6f92191b6..34c4566c80 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_dstr_escaped_newline.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_dstr_escaped_newline.txt
@@ -1,12 +1,19 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [InterpolatedStringNode(0...9)(
-       (0...1),
-       [StringNode(1...4)(nil, (1...4), nil, "a\n"),
-        EmbeddedStatementsNode(4...8)((4...6), nil, (7...8))],
-       (8...9)
-     ),
-     TrueNode(10...14)()]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 2)
+        ├── @ InterpolatedStringNode (location: (0...9))
+        │   ├── opening_loc: (0...1) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (1...4))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (1...4) = "a\\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a\n"
+        │   │   └── @ EmbeddedStatementsNode (location: (4...8))
+        │   │       ├── opening_loc: (4...6) = "\#{"
+        │   │       ├── statements: ∅
+        │   │       └── closing_loc: (7...8) = "}"
+        │   └── closing_loc: (8...9) = "\""
+        └── @ TrueNode (location: (10...14))
diff --git a/test/yarp/snapshots/seattlerb/parse_line_dstr_soft_newline.txt b/test/yarp/snapshots/seattlerb/parse_line_dstr_soft_newline.txt
index a22199b3ac..a79c5af548 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_dstr_soft_newline.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_dstr_soft_newline.txt
@@ -1,12 +1,19 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [InterpolatedStringNode(0...8)(
-       (0...1),
-       [StringNode(1...3)(nil, (1...3), nil, "a\n"),
-        EmbeddedStatementsNode(3...7)((3...5), nil, (6...7))],
-       (7...8)
-     ),
-     TrueNode(9...13)()]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 2)
+        ├── @ InterpolatedStringNode (location: (0...8))
+        │   ├── opening_loc: (0...1) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (1...3))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (1...3) = "a\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a\n"
+        │   │   └── @ EmbeddedStatementsNode (location: (3...7))
+        │   │       ├── opening_loc: (3...5) = "\#{"
+        │   │       ├── statements: ∅
+        │   │       └── closing_loc: (6...7) = "}"
+        │   └── closing_loc: (7...8) = "\""
+        └── @ TrueNode (location: (9...13))
diff --git a/test/yarp/snapshots/seattlerb/parse_line_evstr_after_break.txt b/test/yarp/snapshots/seattlerb/parse_line_evstr_after_break.txt
index ac4be36fcc..9368b96042 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_evstr_after_break.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_evstr_after_break.txt
@@ -1,19 +1,33 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [StringConcatNode(0...11)(
-       StringNode(0...3)((0...1), (1...2), (2...3), "a"),
-       InterpolatedStringNode(5...11)(
-         (5...6),
-         [EmbeddedStatementsNode(6...10)(
-            (6...8),
-            StatementsNode(8...9)(
-              [CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "b")]
-            ),
-            (9...10)
-          )],
-         (10...11)
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ StringConcatNode (location: (0...11))
+            ├── left:
+            │   @ StringNode (location: (0...3))
+            │   ├── opening_loc: (0...1) = "\""
+            │   ├── content_loc: (1...2) = "a"
+            │   ├── closing_loc: (2...3) = "\""
+            │   └── unescaped: "a"
+            └── right:
+                @ InterpolatedStringNode (location: (5...11))
+                ├── opening_loc: (5...6) = "\""
+                ├── parts: (length: 1)
+                │   └── @ EmbeddedStatementsNode (location: (6...10))
+                │       ├── opening_loc: (6...8) = "\#{"
+                │       ├── statements:
+                │       │   @ StatementsNode (location: (8...9))
+                │       │   └── body: (length: 1)
+                │       │       └── @ CallNode (location: (8...9))
+                │       │           ├── receiver: ∅
+                │       │           ├── call_operator_loc: ∅
+                │       │           ├── message_loc: (8...9) = "b"
+                │       │           ├── opening_loc: ∅
+                │       │           ├── arguments: ∅
+                │       │           ├── closing_loc: ∅
+                │       │           ├── block: ∅
+                │       │           ├── flags: variable_call
+                │       │           └── name: "b"
+                │       └── closing_loc: (9...10) = "}"
+                └── closing_loc: (10...11) = "\""
diff --git a/test/yarp/snapshots/seattlerb/parse_line_hash_lit.txt b/test/yarp/snapshots/seattlerb/parse_line_hash_lit.txt
index a7dd5a1f7b..66b51df230 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_hash_lit.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_hash_lit.txt
@@ -1,14 +1,19 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [HashNode(0...13)(
-       (0...1),
-       [AssocNode(2...10)(
-          SymbolNode(2...5)((2...3), (3...5), nil, "s1"),
-          IntegerNode(9...10)(),
-          (6...8)
-        )],
-       (12...13)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ HashNode (location: (0...13))
+            ├── opening_loc: (0...1) = "{"
+            ├── elements: (length: 1)
+            │   └── @ AssocNode (location: (2...10))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (2...5))
+            │       │   ├── opening_loc: (2...3) = ":"
+            │       │   ├── value_loc: (3...5) = "s1"
+            │       │   ├── closing_loc: ∅
+            │       │   └── unescaped: "s1"
+            │       ├── value:
+            │       │   @ IntegerNode (location: (9...10))
+            │       └── operator_loc: (6...8) = "=>"
+            └── closing_loc: (12...13) = "}"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_heredoc.txt b/test/yarp/snapshots/seattlerb/parse_line_heredoc.txt
index 955d94e98f..4e0d5e2fe6 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_heredoc.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_heredoc.txt
@@ -1,42 +1,45 @@
-ProgramNode(6...88)(
-  [:string],
-  StatementsNode(6...88)(
-    [LocalVariableWriteNode(6...31)(
-       :string,
-       0,
-       (6...12),
-       CallNode(15...31)(
-         InterpolatedStringNode(15...25)(
-           (15...25),
-           [StringNode(32...57)(
-              nil,
-              (32...57),
-              nil,
-              "        very long string\n"
-            )],
-           (57...71)
-         ),
-         (25...26),
-         (26...31),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "strip"
-       ),
-       (13...14)
-     ),
-     CallNode(77...88)(
-       nil,
-       nil,
-       (77...81),
-       nil,
-       ArgumentsNode(82...88)([LocalVariableReadNode(82...88)(:string, 0)]),
-       nil,
-       nil,
-       0,
-       "puts"
-     )]
-  )
-)
+@ ProgramNode (location: (6...88))
+├── locals: [:string]
+└── statements:
+    @ StatementsNode (location: (6...88))
+    └── body: (length: 2)
+        ├── @ LocalVariableWriteNode (location: (6...31))
+        │   ├── name: :string
+        │   ├── depth: 0
+        │   ├── name_loc: (6...12) = "string"
+        │   ├── value:
+        │   │   @ CallNode (location: (15...31))
+        │   │   ├── receiver:
+        │   │   │   @ InterpolatedStringNode (location: (15...25))
+        │   │   │   ├── opening_loc: (15...25) = "<<-HEREDOC"
+        │   │   │   ├── parts: (length: 1)
+        │   │   │   │   └── @ StringNode (location: (32...57))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── content_loc: (32...57) = "        very long string\n"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "        very long string\n"
+        │   │   │   └── closing_loc: (57...71) = "      HEREDOC\n"
+        │   │   ├── call_operator_loc: (25...26) = "."
+        │   │   ├── message_loc: (26...31) = "strip"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "strip"
+        │   └── operator_loc: (13...14) = "="
+        └── @ CallNode (location: (77...88))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (77...81) = "puts"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (82...88))
+            │   └── arguments: (length: 1)
+            │       └── @ LocalVariableReadNode (location: (82...88))
+            │           ├── name: :string
+            │           └── depth: 0
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "puts"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_heredoc_evstr.txt b/test/yarp/snapshots/seattlerb/parse_line_heredoc_evstr.txt
index 8b95196e2d..41a8cf7274 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_heredoc_evstr.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_heredoc_evstr.txt
@@ -1,18 +1,35 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [InterpolatedStringNode(0...4)(
-       (0...4),
-       [StringNode(5...7)(nil, (5...7), nil, "a\n"),
-        EmbeddedStatementsNode(7...11)(
-          (7...9),
-          StatementsNode(9...10)(
-            [CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "b")]
-          ),
-          (10...11)
-        ),
-        StringNode(11...12)(nil, (11...12), nil, "\n")],
-       (12...14)
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...4))
+            ├── opening_loc: (0...4) = "<<-A"
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (5...7))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (5...7) = "a\n"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a\n"
+            │   ├── @ EmbeddedStatementsNode (location: (7...11))
+            │   │   ├── opening_loc: (7...9) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (9...10))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (9...10))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (9...10) = "b"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "b"
+            │   │   └── closing_loc: (10...11) = "}"
+            │   └── @ StringNode (location: (11...12))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (11...12) = "\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\n"
+            └── closing_loc: (12...14) = "A\n"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_heredoc_hardnewline.txt b/test/yarp/snapshots/seattlerb/parse_line_heredoc_hardnewline.txt
index 4d1925d56a..c264873f90 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_heredoc_hardnewline.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_heredoc_hardnewline.txt
@@ -1,25 +1,25 @@
-ProgramNode(0...48)(
-  [],
-  StatementsNode(0...48)(
-    [InterpolatedStringNode(0...8)(
-       (0...8),
-       [StringNode(9...28)(
-          nil,
-          (9...28),
-          nil,
-          "\n" + "\n" + "\n" + "\n" + "\n" + "\n" + "\n" + "\n" + "\n" + "\n"
-        )],
-       (28...34)
-     ),
-     ClassNode(35...48)(
-       [],
-       (35...40),
-       ConstantReadNode(41...44)(:Foo),
-       nil,
-       nil,
-       nil,
-       (45...48),
-       :Foo
-     )]
-  )
-)
+@ ProgramNode (location: (0...48))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...48))
+    └── body: (length: 2)
+        ├── @ InterpolatedStringNode (location: (0...8))
+        │   ├── opening_loc: (0...8) = "<<-EOFOO"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (9...28))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (9...28) = "\\n\\n\\n\\n\\n\\n\\n\\n\\n\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n\n\n\n\n\n\n\n\n\n"
+        │   └── closing_loc: (28...34) = "EOFOO\n"
+        └── @ ClassNode (location: (35...48))
+            ├── locals: []
+            ├── class_keyword_loc: (35...40) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (41...44))
+            │   └── name: :Foo
+            ├── inheritance_operator_loc: ∅
+            ├── superclass: ∅
+            ├── body: ∅
+            ├── end_keyword_loc: (45...48) = "end"
+            └── name: :Foo
diff --git a/test/yarp/snapshots/seattlerb/parse_line_heredoc_regexp_chars.txt b/test/yarp/snapshots/seattlerb/parse_line_heredoc_regexp_chars.txt
index 3d52fcbff0..8a9824181f 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_heredoc_regexp_chars.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_heredoc_regexp_chars.txt
@@ -1,32 +1,35 @@
-ProgramNode(6...74)(
-  [:string],
-  StatementsNode(6...74)(
-    [LocalVariableWriteNode(6...22)(
-       :string,
-       0,
-       (6...12),
-       InterpolatedStringNode(15...22)(
-         (15...22),
-         [StringNode(23...48)(
-            nil,
-            (23...48),
-            nil,
-            "        very long string\n"
-          )],
-         (48...57)
-       ),
-       (13...14)
-     ),
-     CallNode(63...74)(
-       nil,
-       nil,
-       (63...67),
-       nil,
-       ArgumentsNode(68...74)([LocalVariableReadNode(68...74)(:string, 0)]),
-       nil,
-       nil,
-       0,
-       "puts"
-     )]
-  )
-)
+@ ProgramNode (location: (6...74))
+├── locals: [:string]
+└── statements:
+    @ StatementsNode (location: (6...74))
+    └── body: (length: 2)
+        ├── @ LocalVariableWriteNode (location: (6...22))
+        │   ├── name: :string
+        │   ├── depth: 0
+        │   ├── name_loc: (6...12) = "string"
+        │   ├── value:
+        │   │   @ InterpolatedStringNode (location: (15...22))
+        │   │   ├── opening_loc: (15...22) = "<<-\"^D\""
+        │   │   ├── parts: (length: 1)
+        │   │   │   └── @ StringNode (location: (23...48))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (23...48) = "        very long string\n"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "        very long string\n"
+        │   │   └── closing_loc: (48...57) = "      ^D\n"
+        │   └── operator_loc: (13...14) = "="
+        └── @ CallNode (location: (63...74))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (63...67) = "puts"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (68...74))
+            │   └── arguments: (length: 1)
+            │       └── @ LocalVariableReadNode (location: (68...74))
+            │           ├── name: :string
+            │           └── depth: 0
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "puts"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_iter_call_no_parens.txt b/test/yarp/snapshots/seattlerb/parse_line_iter_call_no_parens.txt
index 82dd3ce64f..124e008689 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_iter_call_no_parens.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_iter_call_no_parens.txt
@@ -1,50 +1,70 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [CallNode(0...25)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...3)(
-         [CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "a")]
-       ),
-       nil,
-       BlockNode(4...25)(
-         [:x, :y],
-         BlockParametersNode(7...13)(
-           ParametersNode(8...12)(
-             [RequiredParameterNode(8...9)(:x),
-              RequiredParameterNode(11...12)(:y)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (7...8),
-           (12...13)
-         ),
-         StatementsNode(16...21)(
-           [CallNode(16...21)(
-              LocalVariableReadNode(16...17)(:x, 0),
-              nil,
-              (18...19),
-              nil,
-              ArgumentsNode(20...21)([LocalVariableReadNode(20...21)(:y, 0)]),
-              nil,
-              nil,
-              0,
-              "+"
-            )]
-         ),
-         (4...6),
-         (22...25)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...25))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...3))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (2...3))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (2...3) = "a"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "a"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (4...25))
+            │   ├── locals: [:x, :y]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (7...13))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (8...12))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (8...9))
+            │   │   │   │   │   └── name: :x
+            │   │   │   │   └── @ RequiredParameterNode (location: (11...12))
+            │   │   │   │       └── name: :y
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (7...8) = "|"
+            │   │   └── closing_loc: (12...13) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (16...21))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (16...21))
+            │   │           ├── receiver:
+            │   │           │   @ LocalVariableReadNode (location: (16...17))
+            │   │           │   ├── name: :x
+            │   │           │   └── depth: 0
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (18...19) = "+"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments:
+            │   │           │   @ ArgumentsNode (location: (20...21))
+            │   │           │   └── arguments: (length: 1)
+            │   │           │       └── @ LocalVariableReadNode (location: (20...21))
+            │   │           │           ├── name: :y
+            │   │           │           └── depth: 0
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "+"
+            │   ├── opening_loc: (4...6) = "do"
+            │   └── closing_loc: (22...25) = "end"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_iter_call_parens.txt b/test/yarp/snapshots/seattlerb/parse_line_iter_call_parens.txt
index db09ae12d0..4ead8a0f18 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_iter_call_parens.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_iter_call_parens.txt
@@ -1,50 +1,70 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [CallNode(0...26)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...3)(
-         [CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "a")]
-       ),
-       (3...4),
-       BlockNode(5...26)(
-         [:x, :y],
-         BlockParametersNode(8...14)(
-           ParametersNode(9...13)(
-             [RequiredParameterNode(9...10)(:x),
-              RequiredParameterNode(12...13)(:y)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (8...9),
-           (13...14)
-         ),
-         StatementsNode(17...22)(
-           [CallNode(17...22)(
-              LocalVariableReadNode(17...18)(:x, 0),
-              nil,
-              (19...20),
-              nil,
-              ArgumentsNode(21...22)([LocalVariableReadNode(21...22)(:y, 0)]),
-              nil,
-              nil,
-              0,
-              "+"
-            )]
-         ),
-         (5...7),
-         (23...26)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...26))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...3))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (2...3))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (2...3) = "a"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "a"
+            ├── closing_loc: (3...4) = ")"
+            ├── block:
+            │   @ BlockNode (location: (5...26))
+            │   ├── locals: [:x, :y]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (8...14))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (9...13))
+            │   │   │   ├── requireds: (length: 2)
+            │   │   │   │   ├── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │   │   └── name: :x
+            │   │   │   │   └── @ RequiredParameterNode (location: (12...13))
+            │   │   │   │       └── name: :y
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (8...9) = "|"
+            │   │   └── closing_loc: (13...14) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (17...22))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (17...22))
+            │   │           ├── receiver:
+            │   │           │   @ LocalVariableReadNode (location: (17...18))
+            │   │           │   ├── name: :x
+            │   │           │   └── depth: 0
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (19...20) = "+"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments:
+            │   │           │   @ ArgumentsNode (location: (21...22))
+            │   │           │   └── arguments: (length: 1)
+            │   │           │       └── @ LocalVariableReadNode (location: (21...22))
+            │   │           │           ├── name: :y
+            │   │           │           └── depth: 0
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "+"
+            │   ├── opening_loc: (5...7) = "do"
+            │   └── closing_loc: (23...26) = "end"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_multiline_str.txt b/test/yarp/snapshots/seattlerb/parse_line_multiline_str.txt
index e12f68cfb2..468d99e42e 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_multiline_str.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_multiline_str.txt
@@ -1,7 +1,11 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [StringNode(0...5)((0...1), (1...4), (4...5), "a\n" + "b"),
-     IntegerNode(6...7)()]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 2)
+        ├── @ StringNode (location: (0...5))
+        │   ├── opening_loc: (0...1) = "\""
+        │   ├── content_loc: (1...4) = "a\nb"
+        │   ├── closing_loc: (4...5) = "\""
+        │   └── unescaped: "a\nb"
+        └── @ IntegerNode (location: (6...7))
diff --git a/test/yarp/snapshots/seattlerb/parse_line_multiline_str_literal_n.txt b/test/yarp/snapshots/seattlerb/parse_line_multiline_str_literal_n.txt
index 92a7b9fed1..54e24389b9 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_multiline_str_literal_n.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_multiline_str_literal_n.txt
@@ -1,7 +1,11 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [StringNode(0...6)((0...1), (1...5), (5...6), "a\n" + "b"),
-     IntegerNode(7...8)()]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 2)
+        ├── @ StringNode (location: (0...6))
+        │   ├── opening_loc: (0...1) = "\""
+        │   ├── content_loc: (1...5) = "a\\nb"
+        │   ├── closing_loc: (5...6) = "\""
+        │   └── unescaped: "a\nb"
+        └── @ IntegerNode (location: (7...8))
diff --git a/test/yarp/snapshots/seattlerb/parse_line_newlines.txt b/test/yarp/snapshots/seattlerb/parse_line_newlines.txt
index 14b0c8cecc..48711e2d48 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_newlines.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_newlines.txt
@@ -1 +1,6 @@
-ProgramNode(0...4)([], StatementsNode(0...4)([TrueNode(0...4)()]))
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ TrueNode (location: (0...4))
diff --git a/test/yarp/snapshots/seattlerb/parse_line_op_asgn.txt b/test/yarp/snapshots/seattlerb/parse_line_op_asgn.txt
index d3aa84c986..130fe8dbce 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_op_asgn.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_op_asgn.txt
@@ -1,14 +1,32 @@
-ProgramNode(6...34)(
-  [:foo],
-  StatementsNode(6...34)(
-    [LocalVariableOperatorWriteNode(6...24)(
-       (6...9),
-       (10...12),
-       CallNode(21...24)(nil, nil, (21...24), nil, nil, nil, nil, 2, "bar"),
-       :foo,
-       :+,
-       0
-     ),
-     CallNode(31...34)(nil, nil, (31...34), nil, nil, nil, nil, 2, "baz")]
-  )
-)
+@ ProgramNode (location: (6...34))
+├── locals: [:foo]
+└── statements:
+    @ StatementsNode (location: (6...34))
+    └── body: (length: 2)
+        ├── @ LocalVariableOperatorWriteNode (location: (6...24))
+        │   ├── name_loc: (6...9) = "foo"
+        │   ├── operator_loc: (10...12) = "+="
+        │   ├── value:
+        │   │   @ CallNode (location: (21...24))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (21...24) = "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "bar"
+        │   ├── name: :foo
+        │   ├── operator: :+
+        │   └── depth: 0
+        └── @ CallNode (location: (31...34))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (31...34) = "baz"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "baz"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_postexe.txt b/test/yarp/snapshots/seattlerb/parse_line_postexe.txt
index 9e527ea587..6ece89cbfb 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_postexe.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_postexe.txt
@@ -1,13 +1,22 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [PostExecutionNode(0...11)(
-       StatementsNode(6...9)(
-         [CallNode(6...9)(nil, nil, (6...9), nil, nil, nil, nil, 2, "foo")]
-       ),
-       (0...3),
-       (4...5),
-       (10...11)
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ PostExecutionNode (location: (0...11))
+            ├── statements:
+            │   @ StatementsNode (location: (6...9))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (6...9))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (6...9) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "foo"
+            ├── keyword_loc: (0...3) = "END"
+            ├── opening_loc: (4...5) = "{"
+            └── closing_loc: (10...11) = "}"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_preexe.txt b/test/yarp/snapshots/seattlerb/parse_line_preexe.txt
index 49f485c79f..500cf46c7a 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_preexe.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_preexe.txt
@@ -1,13 +1,22 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [PreExecutionNode(0...13)(
-       StatementsNode(8...11)(
-         [CallNode(8...11)(nil, nil, (8...11), nil, nil, nil, nil, 2, "foo")]
-       ),
-       (0...5),
-       (6...7),
-       (12...13)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ PreExecutionNode (location: (0...13))
+            ├── statements:
+            │   @ StatementsNode (location: (8...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (8...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (8...11) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "foo"
+            ├── keyword_loc: (0...5) = "BEGIN"
+            ├── opening_loc: (6...7) = "{"
+            └── closing_loc: (12...13) = "}"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_rescue.txt b/test/yarp/snapshots/seattlerb/parse_line_rescue.txt
index 02704b5790..57dd72a4b6 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_rescue.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_rescue.txt
@@ -1,43 +1,62 @@
-ProgramNode(0...35)(
-  [],
-  StatementsNode(0...35)(
-    [BeginNode(0...35)(
-       (0...5),
-       StatementsNode(8...9)(
-         [CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "a")]
-       ),
-       RescueNode(10...31)(
-         (10...16),
-         [],
-         nil,
-         nil,
-         StatementsNode(19...20)(
-           [CallNode(19...20)(nil, nil, (19...20), nil, nil, nil, nil, 2, "b")]
-         ),
-         RescueNode(21...31)(
-           (21...27),
-           [],
-           nil,
-           nil,
-           StatementsNode(30...31)(
-             [CallNode(30...31)(
-                nil,
-                nil,
-                (30...31),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "c"
-              )]
-           ),
-           nil
-         )
-       ),
-       nil,
-       nil,
-       (32...35)
-     )]
-  )
-)
+@ ProgramNode (location: (0...35))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...35))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...35))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (8...9))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (8...9))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (8...9) = "a"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "a"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (10...31))
+            │   ├── keyword_loc: (10...16) = "rescue"
+            │   ├── exceptions: (length: 0)
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (19...20))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (19...20))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (19...20) = "b"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "b"
+            │   └── consequent:
+            │       @ RescueNode (location: (21...31))
+            │       ├── keyword_loc: (21...27) = "rescue"
+            │       ├── exceptions: (length: 0)
+            │       ├── operator_loc: ∅
+            │       ├── reference: ∅
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (30...31))
+            │       │   └── body: (length: 1)
+            │       │       └── @ CallNode (location: (30...31))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (30...31) = "c"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments: ∅
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: variable_call
+            │       │           └── name: "c"
+            │       └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (32...35) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_return.txt b/test/yarp/snapshots/seattlerb/parse_line_return.txt
index 8701647435..c595b18a3d 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_return.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_return.txt
@@ -1,32 +1,35 @@
-ProgramNode(6...77)(
-  [],
-  StatementsNode(6...77)(
-    [DefNode(6...77)(
-       :blah,
-       (10...14),
-       nil,
-       nil,
-       StatementsNode(23...67)(
-         [IfNode(23...67)(
-            (23...25),
-            TrueNode(26...30)(),
-            StatementsNode(46...55)(
-              [ReturnNode(46...55)(
-                 (46...52),
-                 ArgumentsNode(53...55)([IntegerNode(53...55)()])
-               )]
-            ),
-            nil,
-            (64...67)
-          )]
-       ),
-       [],
-       (6...9),
-       nil,
-       nil,
-       nil,
-       nil,
-       (74...77)
-     )]
-  )
-)
+@ ProgramNode (location: (6...77))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (6...77))
+    └── body: (length: 1)
+        └── @ DefNode (location: (6...77))
+            ├── name: :blah
+            ├── name_loc: (10...14) = "blah"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (23...67))
+            │   └── body: (length: 1)
+            │       └── @ IfNode (location: (23...67))
+            │           ├── if_keyword_loc: (23...25) = "if"
+            │           ├── predicate:
+            │           │   @ TrueNode (location: (26...30))
+            │           ├── statements:
+            │           │   @ StatementsNode (location: (46...55))
+            │           │   └── body: (length: 1)
+            │           │       └── @ ReturnNode (location: (46...55))
+            │           │           ├── keyword_loc: (46...52) = "return"
+            │           │           └── arguments:
+            │           │               @ ArgumentsNode (location: (53...55))
+            │           │               └── arguments: (length: 1)
+            │           │                   └── @ IntegerNode (location: (53...55))
+            │           ├── consequent: ∅
+            │           └── end_keyword_loc: (64...67) = "end"
+            ├── locals: []
+            ├── def_keyword_loc: (6...9) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (74...77) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_str_with_newline_escape.txt b/test/yarp/snapshots/seattlerb/parse_line_str_with_newline_escape.txt
index e75463a0e3..a5fbdd4ca5 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_str_with_newline_escape.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_str_with_newline_escape.txt
@@ -1,19 +1,23 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...12)(
-         [StringNode(2...6)((2...3), (3...5), (5...6), "\n"),
-          TrueNode(8...12)()]
-       ),
-       (12...13),
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: (1...2) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...12))
+            │   └── arguments: (length: 2)
+            │       ├── @ StringNode (location: (2...6))
+            │       │   ├── opening_loc: (2...3) = "\""
+            │       │   ├── content_loc: (3...5) = "\\n"
+            │       │   ├── closing_loc: (5...6) = "\""
+            │       │   └── unescaped: "\n"
+            │       └── @ TrueNode (location: (8...12))
+            ├── closing_loc: (12...13) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_to_ary.txt b/test/yarp/snapshots/seattlerb/parse_line_to_ary.txt
index e8736976c7..2e0b8bca97 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_to_ary.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_to_ary.txt
@@ -1,14 +1,37 @@
-ProgramNode(0...10)(
-  [:a, :b],
-  StatementsNode(0...10)(
-    [MultiWriteNode(0...8)(
-       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableTargetNode(3...4)(:b, 0)],
-       nil,
-       nil,
-       (5...6),
-       CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "c")
-     ),
-     CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "d")]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 2)
+        ├── @ MultiWriteNode (location: (0...8))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (0...1))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   └── @ LocalVariableTargetNode (location: (3...4))
+        │   │       ├── name: :b
+        │   │       └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (5...6) = "="
+        │   └── value:
+        │       @ CallNode (location: (7...8))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (7...8) = "c"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "c"
+        └── @ CallNode (location: (9...10))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (9...10) = "d"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "d"
diff --git a/test/yarp/snapshots/seattlerb/parse_line_trailing_newlines.txt b/test/yarp/snapshots/seattlerb/parse_line_trailing_newlines.txt
index 7617e15479..8754428165 100644
--- a/test/yarp/snapshots/seattlerb/parse_line_trailing_newlines.txt
+++ b/test/yarp/snapshots/seattlerb/parse_line_trailing_newlines.txt
@@ -1,7 +1,25 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-     CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b")]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...1))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "a"
+        └── @ CallNode (location: (3...4))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/parse_opt_call_args_assocs_comma.txt b/test/yarp/snapshots/seattlerb/parse_opt_call_args_assocs_comma.txt
index 9a84d358bc..24933d6b74 100644
--- a/test/yarp/snapshots/seattlerb/parse_opt_call_args_assocs_comma.txt
+++ b/test/yarp/snapshots/seattlerb/parse_opt_call_args_assocs_comma.txt
@@ -1,24 +1,26 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...8)(
-       IntegerNode(0...1)(),
-       nil,
-       (1...8),
-       (1...2),
-       ArgumentsNode(2...6)(
-         [KeywordHashNode(2...6)(
-            [AssocNode(2...6)(
-               IntegerNode(2...3)(),
-               IntegerNode(5...6)(),
-               (3...5)
-             )]
-          )]
-       ),
-       (7...8),
-       nil,
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...8))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (1...8) = "[2=>3,]"
+            ├── opening_loc: (1...2) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...6))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (2...6))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (2...6))
+            │                   ├── key:
+            │                   │   @ IntegerNode (location: (2...3))
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (5...6))
+            │                   └── operator_loc: (3...5) = "=>"
+            ├── closing_loc: (7...8) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/seattlerb/parse_opt_call_args_lit_comma.txt b/test/yarp/snapshots/seattlerb/parse_opt_call_args_lit_comma.txt
index a058d01284..d1a9ec11e5 100644
--- a/test/yarp/snapshots/seattlerb/parse_opt_call_args_lit_comma.txt
+++ b/test/yarp/snapshots/seattlerb/parse_opt_call_args_lit_comma.txt
@@ -1,16 +1,19 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       IntegerNode(0...1)(),
-       nil,
-       (1...5),
-       (1...2),
-       ArgumentsNode(2...3)([IntegerNode(2...3)()]),
-       (4...5),
-       nil,
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ IntegerNode (location: (0...1))
+            ├── call_operator_loc: ∅
+            ├── message_loc: (1...5) = "[2,]"
+            ├── opening_loc: (1...2) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...3))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (2...3))
+            ├── closing_loc: (4...5) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/seattlerb/parse_pattern_019.txt b/test/yarp/snapshots/seattlerb/parse_pattern_019.txt
index d6f5d2977a..e7359c20d9 100644
--- a/test/yarp/snapshots/seattlerb/parse_pattern_019.txt
+++ b/test/yarp/snapshots/seattlerb/parse_pattern_019.txt
@@ -1,22 +1,27 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [CaseNode(0...26)(
-       IntegerNode(5...6)(),
-       [InNode(7...22)(
-          RangeNode(10...15)(
-            IntegerNode(10...12)(),
-            IntegerNode(14...15)(),
-            (12...14),
-            0
-          ),
-          StatementsNode(18...22)([TrueNode(18...22)()]),
-          (7...9),
-          nil
-        )],
-       nil,
-       (0...4),
-       (23...26)
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...26))
+            ├── predicate:
+            │   @ IntegerNode (location: (5...6))
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (7...22))
+            │       ├── pattern:
+            │       │   @ RangeNode (location: (10...15))
+            │       │   ├── left:
+            │       │   │   @ IntegerNode (location: (10...12))
+            │       │   ├── right:
+            │       │   │   @ IntegerNode (location: (14...15))
+            │       │   ├── operator_loc: (12...14) = ".."
+            │       │   └── flags: 
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (18...22))
+            │       │   └── body: (length: 1)
+            │       │       └── @ TrueNode (location: (18...22))
+            │       ├── in_loc: (7...9) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (23...26) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_pattern_044.txt b/test/yarp/snapshots/seattlerb/parse_pattern_044.txt
index 09d0143eff..fd4157edc2 100644
--- a/test/yarp/snapshots/seattlerb/parse_pattern_044.txt
+++ b/test/yarp/snapshots/seattlerb/parse_pattern_044.txt
@@ -1,24 +1,38 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)(
-    [CaseNode(0...31)(
-       CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "obj"),
-       [InNode(9...27)(
-          ArrayPatternNode(12...20)(
-            ConstantReadNode(12...18)(:Object),
-            [],
-            nil,
-            [],
-            (18...19),
-            (19...20)
-          ),
-          StatementsNode(23...27)([TrueNode(23...27)()]),
-          (9...11),
-          nil
-        )],
-       nil,
-       (0...4),
-       (28...31)
-     )]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...31))
+            ├── predicate:
+            │   @ CallNode (location: (5...8))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (5...8) = "obj"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "obj"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (9...27))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (12...20))
+            │       │   ├── constant:
+            │       │   │   @ ConstantReadNode (location: (12...18))
+            │       │   │   └── name: :Object
+            │       │   ├── requireds: (length: 0)
+            │       │   ├── rest: ∅
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: (18...19) = "["
+            │       │   └── closing_loc: (19...20) = "]"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (23...27))
+            │       │   └── body: (length: 1)
+            │       │       └── @ TrueNode (location: (23...27))
+            │       ├── in_loc: (9...11) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (28...31) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_pattern_051.txt b/test/yarp/snapshots/seattlerb/parse_pattern_051.txt
index 7f2410212d..707ee116d0 100644
--- a/test/yarp/snapshots/seattlerb/parse_pattern_051.txt
+++ b/test/yarp/snapshots/seattlerb/parse_pattern_051.txt
@@ -1,28 +1,35 @@
-ProgramNode(0...36)(
-  [],
-  StatementsNode(0...36)(
-    [CaseNode(0...36)(
-       ArrayNode(5...14)(
-         [IntegerNode(6...7)(), IntegerNode(9...10)(), IntegerNode(12...13)()],
-         (5...6),
-         (13...14)
-       ),
-       [InNode(15...32)(
-          ArrayPatternNode(18...25)(
-            nil,
-            [IntegerNode(19...20)(), IntegerNode(22...23)()],
-            nil,
-            [],
-            (18...19),
-            (24...25)
-          ),
-          StatementsNode(28...32)([TrueNode(28...32)()]),
-          (15...17),
-          nil
-        )],
-       nil,
-       (0...4),
-       (33...36)
-     )]
-  )
-)
+@ ProgramNode (location: (0...36))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...36))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...36))
+            ├── predicate:
+            │   @ ArrayNode (location: (5...14))
+            │   ├── elements: (length: 3)
+            │   │   ├── @ IntegerNode (location: (6...7))
+            │   │   ├── @ IntegerNode (location: (9...10))
+            │   │   └── @ IntegerNode (location: (12...13))
+            │   ├── opening_loc: (5...6) = "["
+            │   └── closing_loc: (13...14) = "]"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (15...32))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (18...25))
+            │       │   ├── constant: ∅
+            │       │   ├── requireds: (length: 2)
+            │       │   │   ├── @ IntegerNode (location: (19...20))
+            │       │   │   └── @ IntegerNode (location: (22...23))
+            │       │   ├── rest: ∅
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: (18...19) = "["
+            │       │   └── closing_loc: (24...25) = "]"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (28...32))
+            │       │   └── body: (length: 1)
+            │       │       └── @ TrueNode (location: (28...32))
+            │       ├── in_loc: (15...17) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (33...36) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_pattern_058.txt b/test/yarp/snapshots/seattlerb/parse_pattern_058.txt
index d9416d4a61..42226e3435 100644
--- a/test/yarp/snapshots/seattlerb/parse_pattern_058.txt
+++ b/test/yarp/snapshots/seattlerb/parse_pattern_058.txt
@@ -1,46 +1,63 @@
-ProgramNode(0...43)(
-  [:a, :rest],
-  StatementsNode(0...43)(
-    [CaseNode(0...43)(
-       HashNode(5...11)(
-         (5...6),
-         [AssocNode(6...10)(
-            SymbolNode(6...8)(nil, (6...7), (7...8), "a"),
-            IntegerNode(9...10)(),
-            nil
-          )],
-         (10...11)
-       ),
-       [InNode(12...39)(
-          HashPatternNode(15...27)(
-            nil,
-            [AssocNode(16...18)(
-               SymbolNode(16...18)(nil, (16...17), (17...18), "a"),
-               nil,
-               nil
-             ),
-             AssocSplatNode(20...26)(
-               LocalVariableTargetNode(22...26)(:rest, 0),
-               (20...22)
-             )],
-            nil,
-            (15...16),
-            (26...27)
-          ),
-          StatementsNode(30...39)(
-            [ArrayNode(30...39)(
-               [LocalVariableReadNode(31...32)(:a, 0),
-                LocalVariableReadNode(34...38)(:rest, 0)],
-               (30...31),
-               (38...39)
-             )]
-          ),
-          (12...14),
-          nil
-        )],
-       nil,
-       (0...4),
-       (40...43)
-     )]
-  )
-)
+@ ProgramNode (location: (0...43))
+├── locals: [:a, :rest]
+└── statements:
+    @ StatementsNode (location: (0...43))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...43))
+            ├── predicate:
+            │   @ HashNode (location: (5...11))
+            │   ├── opening_loc: (5...6) = "{"
+            │   ├── elements: (length: 1)
+            │   │   └── @ AssocNode (location: (6...10))
+            │   │       ├── key:
+            │   │       │   @ SymbolNode (location: (6...8))
+            │   │       │   ├── opening_loc: ∅
+            │   │       │   ├── value_loc: (6...7) = "a"
+            │   │       │   ├── closing_loc: (7...8) = ":"
+            │   │       │   └── unescaped: "a"
+            │   │       ├── value:
+            │   │       │   @ IntegerNode (location: (9...10))
+            │   │       └── operator_loc: ∅
+            │   └── closing_loc: (10...11) = "}"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (12...39))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (15...27))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 2)
+            │       │   │   ├── @ AssocNode (location: (16...18))
+            │       │   │   │   ├── key:
+            │       │   │   │   │   @ SymbolNode (location: (16...18))
+            │       │   │   │   │   ├── opening_loc: ∅
+            │       │   │   │   │   ├── value_loc: (16...17) = "a"
+            │       │   │   │   │   ├── closing_loc: (17...18) = ":"
+            │       │   │   │   │   └── unescaped: "a"
+            │       │   │   │   ├── value: ∅
+            │       │   │   │   └── operator_loc: ∅
+            │       │   │   └── @ AssocSplatNode (location: (20...26))
+            │       │   │       ├── value:
+            │       │   │       │   @ LocalVariableTargetNode (location: (22...26))
+            │       │   │       │   ├── name: :rest
+            │       │   │       │   └── depth: 0
+            │       │   │       └── operator_loc: (20...22) = "**"
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: (15...16) = "{"
+            │       │   └── closing_loc: (26...27) = "}"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (30...39))
+            │       │   └── body: (length: 1)
+            │       │       └── @ ArrayNode (location: (30...39))
+            │       │           ├── elements: (length: 2)
+            │       │           │   ├── @ LocalVariableReadNode (location: (31...32))
+            │       │           │   │   ├── name: :a
+            │       │           │   │   └── depth: 0
+            │       │           │   └── @ LocalVariableReadNode (location: (34...38))
+            │       │           │       ├── name: :rest
+            │       │           │       └── depth: 0
+            │       │           ├── opening_loc: (30...31) = "["
+            │       │           └── closing_loc: (38...39) = "]"
+            │       ├── in_loc: (12...14) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (40...43) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_pattern_058_2.txt b/test/yarp/snapshots/seattlerb/parse_pattern_058_2.txt
index c1ba037a62..be459ce9d3 100644
--- a/test/yarp/snapshots/seattlerb/parse_pattern_058_2.txt
+++ b/test/yarp/snapshots/seattlerb/parse_pattern_058_2.txt
@@ -1,42 +1,57 @@
-ProgramNode(0...33)(
-  [:a],
-  StatementsNode(0...33)(
-    [CaseNode(0...33)(
-       HashNode(5...11)(
-         (5...6),
-         [AssocNode(6...10)(
-            SymbolNode(6...8)(nil, (6...7), (7...8), "a"),
-            IntegerNode(9...10)(),
-            nil
-          )],
-         (10...11)
-       ),
-       [InNode(12...29)(
-          HashPatternNode(15...23)(
-            nil,
-            [AssocNode(16...18)(
-               SymbolNode(16...18)(nil, (16...17), (17...18), "a"),
-               nil,
-               nil
-             ),
-             AssocSplatNode(20...22)(nil, (20...22))],
-            nil,
-            (15...16),
-            (22...23)
-          ),
-          StatementsNode(26...29)(
-            [ArrayNode(26...29)(
-               [LocalVariableReadNode(27...28)(:a, 0)],
-               (26...27),
-               (28...29)
-             )]
-          ),
-          (12...14),
-          nil
-        )],
-       nil,
-       (0...4),
-       (30...33)
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...33))
+            ├── predicate:
+            │   @ HashNode (location: (5...11))
+            │   ├── opening_loc: (5...6) = "{"
+            │   ├── elements: (length: 1)
+            │   │   └── @ AssocNode (location: (6...10))
+            │   │       ├── key:
+            │   │       │   @ SymbolNode (location: (6...8))
+            │   │       │   ├── opening_loc: ∅
+            │   │       │   ├── value_loc: (6...7) = "a"
+            │   │       │   ├── closing_loc: (7...8) = ":"
+            │   │       │   └── unescaped: "a"
+            │   │       ├── value:
+            │   │       │   @ IntegerNode (location: (9...10))
+            │   │       └── operator_loc: ∅
+            │   └── closing_loc: (10...11) = "}"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (12...29))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (15...23))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 2)
+            │       │   │   ├── @ AssocNode (location: (16...18))
+            │       │   │   │   ├── key:
+            │       │   │   │   │   @ SymbolNode (location: (16...18))
+            │       │   │   │   │   ├── opening_loc: ∅
+            │       │   │   │   │   ├── value_loc: (16...17) = "a"
+            │       │   │   │   │   ├── closing_loc: (17...18) = ":"
+            │       │   │   │   │   └── unescaped: "a"
+            │       │   │   │   ├── value: ∅
+            │       │   │   │   └── operator_loc: ∅
+            │       │   │   └── @ AssocSplatNode (location: (20...22))
+            │       │   │       ├── value: ∅
+            │       │   │       └── operator_loc: (20...22) = "**"
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: (15...16) = "{"
+            │       │   └── closing_loc: (22...23) = "}"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (26...29))
+            │       │   └── body: (length: 1)
+            │       │       └── @ ArrayNode (location: (26...29))
+            │       │           ├── elements: (length: 1)
+            │       │           │   └── @ LocalVariableReadNode (location: (27...28))
+            │       │           │       ├── name: :a
+            │       │           │       └── depth: 0
+            │       │           ├── opening_loc: (26...27) = "["
+            │       │           └── closing_loc: (28...29) = "]"
+            │       ├── in_loc: (12...14) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (30...33) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_pattern_069.txt b/test/yarp/snapshots/seattlerb/parse_pattern_069.txt
index b704851937..d02a1f17b4 100644
--- a/test/yarp/snapshots/seattlerb/parse_pattern_069.txt
+++ b/test/yarp/snapshots/seattlerb/parse_pattern_069.txt
@@ -1,27 +1,42 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)(
-    [CaseNode(0...31)(
-       SymbolNode(5...7)((5...6), (6...7), nil, "a"),
-       [InNode(8...27)(
-          HashPatternNode(11...23)(
-            ConstantReadNode(11...17)(:Object),
-            [AssocNode(18...22)(
-               SymbolNode(18...20)(nil, (18...19), (19...20), "b"),
-               IntegerNode(21...22)(),
-               nil
-             )],
-            nil,
-            (17...18),
-            (22...23)
-          ),
-          StatementsNode(26...27)([IntegerNode(26...27)()]),
-          (8...10),
-          nil
-        )],
-       nil,
-       (0...4),
-       (28...31)
-     )]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...31))
+            ├── predicate:
+            │   @ SymbolNode (location: (5...7))
+            │   ├── opening_loc: (5...6) = ":"
+            │   ├── value_loc: (6...7) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...27))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (11...23))
+            │       │   ├── constant:
+            │       │   │   @ ConstantReadNode (location: (11...17))
+            │       │   │   └── name: :Object
+            │       │   ├── assocs: (length: 1)
+            │       │   │   └── @ AssocNode (location: (18...22))
+            │       │   │       ├── key:
+            │       │   │       │   @ SymbolNode (location: (18...20))
+            │       │   │       │   ├── opening_loc: ∅
+            │       │   │       │   ├── value_loc: (18...19) = "b"
+            │       │   │       │   ├── closing_loc: (19...20) = ":"
+            │       │   │       │   └── unescaped: "b"
+            │       │   │       ├── value:
+            │       │   │       │   @ IntegerNode (location: (21...22))
+            │       │   │       └── operator_loc: ∅
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: (17...18) = "["
+            │       │   └── closing_loc: (22...23) = "]"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (26...27))
+            │       │   └── body: (length: 1)
+            │       │       └── @ IntegerNode (location: (26...27))
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (28...31) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_pattern_076.txt b/test/yarp/snapshots/seattlerb/parse_pattern_076.txt
index 493223169b..d8af0ac0a0 100644
--- a/test/yarp/snapshots/seattlerb/parse_pattern_076.txt
+++ b/test/yarp/snapshots/seattlerb/parse_pattern_076.txt
@@ -1,36 +1,52 @@
-ProgramNode(0...39)(
-  [],
-  StatementsNode(0...39)(
-    [CaseNode(0...39)(
-       HashNode(5...11)(
-         (5...6),
-         [AssocNode(6...10)(
-            SymbolNode(6...8)(nil, (6...7), (7...8), "a"),
-            IntegerNode(9...10)(),
-            nil
-          )],
-         (10...11)
-       ),
-       [InNode(12...35)(
-          HashPatternNode(15...28)(
-            nil,
-            [AssocNode(16...20)(
-               SymbolNode(16...18)(nil, (16...17), (17...18), "a"),
-               IntegerNode(19...20)(),
-               nil
-             ),
-             NoKeywordsParameterNode(22...27)((22...24), (24...27))],
-            nil,
-            (15...16),
-            (27...28)
-          ),
-          StatementsNode(31...35)([TrueNode(31...35)()]),
-          (12...14),
-          nil
-        )],
-       nil,
-       (0...4),
-       (36...39)
-     )]
-  )
-)
+@ ProgramNode (location: (0...39))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...39))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...39))
+            ├── predicate:
+            │   @ HashNode (location: (5...11))
+            │   ├── opening_loc: (5...6) = "{"
+            │   ├── elements: (length: 1)
+            │   │   └── @ AssocNode (location: (6...10))
+            │   │       ├── key:
+            │   │       │   @ SymbolNode (location: (6...8))
+            │   │       │   ├── opening_loc: ∅
+            │   │       │   ├── value_loc: (6...7) = "a"
+            │   │       │   ├── closing_loc: (7...8) = ":"
+            │   │       │   └── unescaped: "a"
+            │   │       ├── value:
+            │   │       │   @ IntegerNode (location: (9...10))
+            │   │       └── operator_loc: ∅
+            │   └── closing_loc: (10...11) = "}"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (12...35))
+            │       ├── pattern:
+            │       │   @ HashPatternNode (location: (15...28))
+            │       │   ├── constant: ∅
+            │       │   ├── assocs: (length: 2)
+            │       │   │   ├── @ AssocNode (location: (16...20))
+            │       │   │   │   ├── key:
+            │       │   │   │   │   @ SymbolNode (location: (16...18))
+            │       │   │   │   │   ├── opening_loc: ∅
+            │       │   │   │   │   ├── value_loc: (16...17) = "a"
+            │       │   │   │   │   ├── closing_loc: (17...18) = ":"
+            │       │   │   │   │   └── unescaped: "a"
+            │       │   │   │   ├── value:
+            │       │   │   │   │   @ IntegerNode (location: (19...20))
+            │       │   │   │   └── operator_loc: ∅
+            │       │   │   └── @ NoKeywordsParameterNode (location: (22...27))
+            │       │   │       ├── operator_loc: (22...24) = "**"
+            │       │   │       └── keyword_loc: (24...27) = "nil"
+            │       │   ├── kwrest: ∅
+            │       │   ├── opening_loc: (15...16) = "{"
+            │       │   └── closing_loc: (27...28) = "}"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (31...35))
+            │       │   └── body: (length: 1)
+            │       │       └── @ TrueNode (location: (31...35))
+            │       ├── in_loc: (12...14) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (36...39) = "end"
diff --git a/test/yarp/snapshots/seattlerb/parse_until_not_canonical.txt b/test/yarp/snapshots/seattlerb/parse_until_not_canonical.txt
index e84c4bf8a9..c3338a6fef 100644
--- a/test/yarp/snapshots/seattlerb/parse_until_not_canonical.txt
+++ b/test/yarp/snapshots/seattlerb/parse_until_not_canonical.txt
@@ -1,44 +1,48 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [UntilNode(0...30)(
-       (0...5),
-       (27...30),
-       CallNode(6...18)(
-         CallNode(10...18)(
-           CallNode(10...13)(
-             nil,
-             nil,
-             (10...13),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "var"
-           ),
-           (13...14),
-           (14...18),
-           nil,
-           nil,
-           nil,
-           nil,
-           0,
-           "nil?"
-         ),
-         nil,
-         (6...9),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       StatementsNode(21...26)(
-         [StringNode(21...26)((21...22), (22...25), (25...26), "foo")]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ UntilNode (location: (0...30))
+            ├── keyword_loc: (0...5) = "until"
+            ├── closing_loc: (27...30) = "end"
+            ├── predicate:
+            │   @ CallNode (location: (6...18))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (10...18))
+            │   │   ├── receiver:
+            │   │   │   @ CallNode (location: (10...13))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (10...13) = "var"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "var"
+            │   │   ├── call_operator_loc: (13...14) = "."
+            │   │   ├── message_loc: (14...18) = "nil?"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "nil?"
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (6...9) = "not"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "!"
+            ├── statements:
+            │   @ StatementsNode (location: (21...26))
+            │   └── body: (length: 1)
+            │       └── @ StringNode (location: (21...26))
+            │           ├── opening_loc: (21...22) = "'"
+            │           ├── content_loc: (22...25) = "foo"
+            │           ├── closing_loc: (25...26) = "'"
+            │           └── unescaped: "foo"
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/parse_until_not_noncanonical.txt b/test/yarp/snapshots/seattlerb/parse_until_not_noncanonical.txt
index e84c4bf8a9..c3338a6fef 100644
--- a/test/yarp/snapshots/seattlerb/parse_until_not_noncanonical.txt
+++ b/test/yarp/snapshots/seattlerb/parse_until_not_noncanonical.txt
@@ -1,44 +1,48 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [UntilNode(0...30)(
-       (0...5),
-       (27...30),
-       CallNode(6...18)(
-         CallNode(10...18)(
-           CallNode(10...13)(
-             nil,
-             nil,
-             (10...13),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "var"
-           ),
-           (13...14),
-           (14...18),
-           nil,
-           nil,
-           nil,
-           nil,
-           0,
-           "nil?"
-         ),
-         nil,
-         (6...9),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       StatementsNode(21...26)(
-         [StringNode(21...26)((21...22), (22...25), (25...26), "foo")]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ UntilNode (location: (0...30))
+            ├── keyword_loc: (0...5) = "until"
+            ├── closing_loc: (27...30) = "end"
+            ├── predicate:
+            │   @ CallNode (location: (6...18))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (10...18))
+            │   │   ├── receiver:
+            │   │   │   @ CallNode (location: (10...13))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (10...13) = "var"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "var"
+            │   │   ├── call_operator_loc: (13...14) = "."
+            │   │   ├── message_loc: (14...18) = "nil?"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "nil?"
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (6...9) = "not"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "!"
+            ├── statements:
+            │   @ StatementsNode (location: (21...26))
+            │   └── body: (length: 1)
+            │       └── @ StringNode (location: (21...26))
+            │           ├── opening_loc: (21...22) = "'"
+            │           ├── content_loc: (22...25) = "foo"
+            │           ├── closing_loc: (25...26) = "'"
+            │           └── unescaped: "foo"
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/parse_while_not_canonical.txt b/test/yarp/snapshots/seattlerb/parse_while_not_canonical.txt
index 8d152ba76e..2e893c7134 100644
--- a/test/yarp/snapshots/seattlerb/parse_while_not_canonical.txt
+++ b/test/yarp/snapshots/seattlerb/parse_while_not_canonical.txt
@@ -1,44 +1,48 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [WhileNode(0...30)(
-       (0...5),
-       (27...30),
-       CallNode(6...18)(
-         CallNode(10...18)(
-           CallNode(10...13)(
-             nil,
-             nil,
-             (10...13),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "var"
-           ),
-           (13...14),
-           (14...18),
-           nil,
-           nil,
-           nil,
-           nil,
-           0,
-           "nil?"
-         ),
-         nil,
-         (6...9),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       StatementsNode(21...26)(
-         [StringNode(21...26)((21...22), (22...25), (25...26), "foo")]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ WhileNode (location: (0...30))
+            ├── keyword_loc: (0...5) = "while"
+            ├── closing_loc: (27...30) = "end"
+            ├── predicate:
+            │   @ CallNode (location: (6...18))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (10...18))
+            │   │   ├── receiver:
+            │   │   │   @ CallNode (location: (10...13))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (10...13) = "var"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "var"
+            │   │   ├── call_operator_loc: (13...14) = "."
+            │   │   ├── message_loc: (14...18) = "nil?"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "nil?"
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (6...9) = "not"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "!"
+            ├── statements:
+            │   @ StatementsNode (location: (21...26))
+            │   └── body: (length: 1)
+            │       └── @ StringNode (location: (21...26))
+            │           ├── opening_loc: (21...22) = "'"
+            │           ├── content_loc: (22...25) = "foo"
+            │           ├── closing_loc: (25...26) = "'"
+            │           └── unescaped: "foo"
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/parse_while_not_noncanonical.txt b/test/yarp/snapshots/seattlerb/parse_while_not_noncanonical.txt
index 8d152ba76e..2e893c7134 100644
--- a/test/yarp/snapshots/seattlerb/parse_while_not_noncanonical.txt
+++ b/test/yarp/snapshots/seattlerb/parse_while_not_noncanonical.txt
@@ -1,44 +1,48 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [WhileNode(0...30)(
-       (0...5),
-       (27...30),
-       CallNode(6...18)(
-         CallNode(10...18)(
-           CallNode(10...13)(
-             nil,
-             nil,
-             (10...13),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "var"
-           ),
-           (13...14),
-           (14...18),
-           nil,
-           nil,
-           nil,
-           nil,
-           0,
-           "nil?"
-         ),
-         nil,
-         (6...9),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       StatementsNode(21...26)(
-         [StringNode(21...26)((21...22), (22...25), (25...26), "foo")]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ WhileNode (location: (0...30))
+            ├── keyword_loc: (0...5) = "while"
+            ├── closing_loc: (27...30) = "end"
+            ├── predicate:
+            │   @ CallNode (location: (6...18))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (10...18))
+            │   │   ├── receiver:
+            │   │   │   @ CallNode (location: (10...13))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (10...13) = "var"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "var"
+            │   │   ├── call_operator_loc: (13...14) = "."
+            │   │   ├── message_loc: (14...18) = "nil?"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "nil?"
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (6...9) = "not"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "!"
+            ├── statements:
+            │   @ StatementsNode (location: (21...26))
+            │   └── body: (length: 1)
+            │       └── @ StringNode (location: (21...26))
+            │           ├── opening_loc: (21...22) = "'"
+            │           ├── content_loc: (22...25) = "foo"
+            │           ├── closing_loc: (25...26) = "'"
+            │           └── unescaped: "foo"
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/pctW_lineno.txt b/test/yarp/snapshots/seattlerb/pctW_lineno.txt
index d03e41c0f2..088b02cdfd 100644
--- a/test/yarp/snapshots/seattlerb/pctW_lineno.txt
+++ b/test/yarp/snapshots/seattlerb/pctW_lineno.txt
@@ -1,16 +1,44 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [ArrayNode(0...28)(
-       [StringNode(3...7)(nil, (3...7), nil, "a\n" + "b"),
-        StringNode(8...9)(nil, (8...9), nil, "c"),
-        StringNode(10...11)(nil, (10...11), nil, "d"),
-        StringNode(12...16)(nil, (12...16), nil, "ef"),
-        StringNode(17...19)(nil, (17...19), nil, "gy"),
-        StringNode(20...23)(nil, (20...23), nil, "hy"),
-        StringNode(24...27)(nil, (24...27), nil, "iy")],
-       (0...3),
-       (27...28)
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...28))
+            ├── elements: (length: 7)
+            │   ├── @ StringNode (location: (3...7))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (3...7) = "a\\nb"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a\nb"
+            │   ├── @ StringNode (location: (8...9))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (8...9) = "c"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "c"
+            │   ├── @ StringNode (location: (10...11))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (10...11) = "d"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "d"
+            │   ├── @ StringNode (location: (12...16))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (12...16) = "e\\\nf"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "ef"
+            │   ├── @ StringNode (location: (17...19))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (17...19) = "gy"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "gy"
+            │   ├── @ StringNode (location: (20...23))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (20...23) = "h\\y"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "hy"
+            │   └── @ StringNode (location: (24...27))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (24...27) = "i\\y"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "iy"
+            ├── opening_loc: (0...3) = "%W("
+            └── closing_loc: (27...28) = ")"
diff --git a/test/yarp/snapshots/seattlerb/pct_Q_backslash_nl.txt b/test/yarp/snapshots/seattlerb/pct_Q_backslash_nl.txt
index 0725aaee49..86649d57b8 100644
--- a/test/yarp/snapshots/seattlerb/pct_Q_backslash_nl.txt
+++ b/test/yarp/snapshots/seattlerb/pct_Q_backslash_nl.txt
@@ -1,6 +1,10 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [StringNode(0...7)((0...3), (3...6), (6...7), " \\\n")]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ StringNode (location: (0...7))
+            ├── opening_loc: (0...3) = "%q{"
+            ├── content_loc: (3...6) = " \\\n"
+            ├── closing_loc: (6...7) = "}"
+            └── unescaped: " \\\n"
diff --git a/test/yarp/snapshots/seattlerb/pct_nl.txt b/test/yarp/snapshots/seattlerb/pct_nl.txt
index 4cdba9d6d6..0dee0a7c96 100644
--- a/test/yarp/snapshots/seattlerb/pct_nl.txt
+++ b/test/yarp/snapshots/seattlerb/pct_nl.txt
@@ -1,12 +1,16 @@
-ProgramNode(0...7)(
-  [:x],
-  StatementsNode(0...7)(
-    [LocalVariableWriteNode(0...7)(
-       :x,
-       0,
-       (0...1),
-       StringNode(4...7)((4...6), (6...6), (6...7), ""),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: [:x]
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...7))
+            ├── name: :x
+            ├── depth: 0
+            ├── name_loc: (0...1) = "x"
+            ├── value:
+            │   @ StringNode (location: (4...7))
+            │   ├── opening_loc: (4...6) = "%\n"
+            │   ├── content_loc: (6...6) = ""
+            │   ├── closing_loc: (6...7) = "\n"
+            │   └── unescaped: ""
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/pct_w_heredoc_interp_nested.txt b/test/yarp/snapshots/seattlerb/pct_w_heredoc_interp_nested.txt
index 8c9604e40d..0706a449f3 100644
--- a/test/yarp/snapshots/seattlerb/pct_w_heredoc_interp_nested.txt
+++ b/test/yarp/snapshots/seattlerb/pct_w_heredoc_interp_nested.txt
@@ -1,28 +1,48 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [ArrayNode(0...30)(
-       [StringNode(4...5)(nil, (4...5), nil, "1"),
-        InterpolatedStringNode(6...12)(
-          nil,
-          [EmbeddedStatementsNode(6...12)(
-             (6...8),
-             StatementsNode(8...11)(
-               [InterpolatedStringNode(8...11)(
-                  (8...11),
-                  [StringNode(15...17)(nil, (15...17), nil, "2\n")],
-                  (17...19)
-                )]
-             ),
-             (11...12)
-           )],
-          nil
-        ),
-        StringNode(13...14)(nil, (13...14), nil, "3"),
-        StringNode(25...26)(nil, (25...26), nil, "4"),
-        StringNode(27...28)(nil, (27...28), nil, "5")],
-       (0...3),
-       (29...30)
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...30))
+            ├── elements: (length: 5)
+            │   ├── @ StringNode (location: (4...5))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (4...5) = "1"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "1"
+            │   ├── @ InterpolatedStringNode (location: (6...12))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── parts: (length: 1)
+            │   │   │   └── @ EmbeddedStatementsNode (location: (6...12))
+            │   │   │       ├── opening_loc: (6...8) = "\#{"
+            │   │   │       ├── statements:
+            │   │   │       │   @ StatementsNode (location: (8...11))
+            │   │   │       │   └── body: (length: 1)
+            │   │   │       │       └── @ InterpolatedStringNode (location: (8...11))
+            │   │   │       │           ├── opening_loc: (8...11) = "<<A"
+            │   │   │       │           ├── parts: (length: 1)
+            │   │   │       │           │   └── @ StringNode (location: (15...17))
+            │   │   │       │           │       ├── opening_loc: ∅
+            │   │   │       │           │       ├── content_loc: (15...17) = "2\n"
+            │   │   │       │           │       ├── closing_loc: ∅
+            │   │   │       │           │       └── unescaped: "2\n"
+            │   │   │       │           └── closing_loc: (17...19) = "A\n"
+            │   │   │       └── closing_loc: (11...12) = "}"
+            │   │   └── closing_loc: ∅
+            │   ├── @ StringNode (location: (13...14))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (13...14) = "3"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "3"
+            │   ├── @ StringNode (location: (25...26))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (25...26) = "4"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "4"
+            │   └── @ StringNode (location: (27...28))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (27...28) = "5"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "5"
+            ├── opening_loc: (0...3) = "%W("
+            └── closing_loc: (29...30) = ")"
diff --git a/test/yarp/snapshots/seattlerb/pipe_semicolon.txt b/test/yarp/snapshots/seattlerb/pipe_semicolon.txt
index 14dc672e1c..58a6928af4 100644
--- a/test/yarp/snapshots/seattlerb/pipe_semicolon.txt
+++ b/test/yarp/snapshots/seattlerb/pipe_semicolon.txt
@@ -1,27 +1,38 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [CallNode(0...18)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...3),
-       nil,
-       nil,
-       nil,
-       BlockNode(4...18)(
-         [:c],
-         BlockParametersNode(7...14)(
-           nil,
-           [BlockLocalVariableNode(11...12)(:c)],
-           (7...8),
-           (13...14)
-         ),
-         nil,
-         (4...6),
-         (15...18)
-       ),
-       0,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...18))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...3) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (4...18))
+            │   ├── locals: [:c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (7...14))
+            │   │   ├── parameters: ∅
+            │   │   ├── locals: (length: 1)
+            │   │   │   └── @ BlockLocalVariableNode (location: (11...12))
+            │   │   │       └── name: :c
+            │   │   ├── opening_loc: (7...8) = "|"
+            │   │   └── closing_loc: (13...14) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (4...6) = "do"
+            │   └── closing_loc: (15...18) = "end"
+            ├── flags: 
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/pipe_space.txt b/test/yarp/snapshots/seattlerb/pipe_space.txt
index 8c66905d04..0bd5d833aa 100644
--- a/test/yarp/snapshots/seattlerb/pipe_space.txt
+++ b/test/yarp/snapshots/seattlerb/pipe_space.txt
@@ -1,22 +1,36 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...2),
-       (2...3),
-       nil,
-       nil,
-       nil,
-       BlockNode(4...14)(
-         [],
-         BlockParametersNode(7...10)(nil, [], (7...8), (9...10)),
-         nil,
-         (4...6),
-         (11...14)
-       ),
-       0,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...2) = "."
+            ├── message_loc: (2...3) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (4...14))
+            │   ├── locals: []
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (7...10))
+            │   │   ├── parameters: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (7...8) = "|"
+            │   │   └── closing_loc: (9...10) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (4...6) = "do"
+            │   └── closing_loc: (11...14) = "end"
+            ├── flags: 
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/qWords_space.txt b/test/yarp/snapshots/seattlerb/qWords_space.txt
index 6713c4ba71..dd74c8afc4 100644
--- a/test/yarp/snapshots/seattlerb/qWords_space.txt
+++ b/test/yarp/snapshots/seattlerb/qWords_space.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)([ArrayNode(0...5)([], (0...3), (4...5))])
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...5))
+            ├── elements: (length: 0)
+            ├── opening_loc: (0...3) = "%W("
+            └── closing_loc: (4...5) = ")"
diff --git a/test/yarp/snapshots/seattlerb/qsymbols.txt b/test/yarp/snapshots/seattlerb/qsymbols.txt
index 7cf54611c2..0b6e709d47 100644
--- a/test/yarp/snapshots/seattlerb/qsymbols.txt
+++ b/test/yarp/snapshots/seattlerb/qsymbols.txt
@@ -1,12 +1,24 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [ArrayNode(0...9)(
-       [SymbolNode(3...4)(nil, (3...4), nil, "a"),
-        SymbolNode(5...6)(nil, (5...6), nil, "b"),
-        SymbolNode(7...8)(nil, (7...8), nil, "c")],
-       (0...3),
-       (8...9)
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...9))
+            ├── elements: (length: 3)
+            │   ├── @ SymbolNode (location: (3...4))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (3...4) = "a"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a"
+            │   ├── @ SymbolNode (location: (5...6))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (5...6) = "b"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "b"
+            │   └── @ SymbolNode (location: (7...8))
+            │       ├── opening_loc: ∅
+            │       ├── value_loc: (7...8) = "c"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "c"
+            ├── opening_loc: (0...3) = "%I("
+            └── closing_loc: (8...9) = ")"
diff --git a/test/yarp/snapshots/seattlerb/qsymbols_empty.txt b/test/yarp/snapshots/seattlerb/qsymbols_empty.txt
index cad298895b..c059c8e52f 100644
--- a/test/yarp/snapshots/seattlerb/qsymbols_empty.txt
+++ b/test/yarp/snapshots/seattlerb/qsymbols_empty.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)([ArrayNode(0...4)([], (0...3), (3...4))])
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...4))
+            ├── elements: (length: 0)
+            ├── opening_loc: (0...3) = "%I("
+            └── closing_loc: (3...4) = ")"
diff --git a/test/yarp/snapshots/seattlerb/qsymbols_empty_space.txt b/test/yarp/snapshots/seattlerb/qsymbols_empty_space.txt
index 6713c4ba71..9b013ce242 100644
--- a/test/yarp/snapshots/seattlerb/qsymbols_empty_space.txt
+++ b/test/yarp/snapshots/seattlerb/qsymbols_empty_space.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)([ArrayNode(0...5)([], (0...3), (4...5))])
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...5))
+            ├── elements: (length: 0)
+            ├── opening_loc: (0...3) = "%I("
+            └── closing_loc: (4...5) = ")"
diff --git a/test/yarp/snapshots/seattlerb/qsymbols_interp.txt b/test/yarp/snapshots/seattlerb/qsymbols_interp.txt
index 2f4a44fc23..3d84785a44 100644
--- a/test/yarp/snapshots/seattlerb/qsymbols_interp.txt
+++ b/test/yarp/snapshots/seattlerb/qsymbols_interp.txt
@@ -1,33 +1,48 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [ArrayNode(0...15)(
-       [SymbolNode(3...4)(nil, (3...4), nil, "a"),
-        InterpolatedSymbolNode(5...12)(
-          nil,
-          [StringNode(5...6)(nil, (5...6), nil, "b"),
-           EmbeddedStatementsNode(6...12)(
-             (6...8),
-             StatementsNode(8...11)(
-               [CallNode(8...11)(
-                  IntegerNode(8...9)(),
-                  nil,
-                  (9...10),
-                  nil,
-                  ArgumentsNode(10...11)([IntegerNode(10...11)()]),
-                  nil,
-                  nil,
-                  0,
-                  "+"
-                )]
-             ),
-             (11...12)
-           )],
-          nil
-        ),
-        SymbolNode(13...14)(nil, (13...14), nil, "c")],
-       (0...3),
-       (14...15)
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...15))
+            ├── elements: (length: 3)
+            │   ├── @ SymbolNode (location: (3...4))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (3...4) = "a"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a"
+            │   ├── @ InterpolatedSymbolNode (location: (5...12))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── parts: (length: 2)
+            │   │   │   ├── @ StringNode (location: (5...6))
+            │   │   │   │   ├── opening_loc: ∅
+            │   │   │   │   ├── content_loc: (5...6) = "b"
+            │   │   │   │   ├── closing_loc: ∅
+            │   │   │   │   └── unescaped: "b"
+            │   │   │   └── @ EmbeddedStatementsNode (location: (6...12))
+            │   │   │       ├── opening_loc: (6...8) = "\#{"
+            │   │   │       ├── statements:
+            │   │   │       │   @ StatementsNode (location: (8...11))
+            │   │   │       │   └── body: (length: 1)
+            │   │   │       │       └── @ CallNode (location: (8...11))
+            │   │   │       │           ├── receiver:
+            │   │   │       │           │   @ IntegerNode (location: (8...9))
+            │   │   │       │           ├── call_operator_loc: ∅
+            │   │   │       │           ├── message_loc: (9...10) = "+"
+            │   │   │       │           ├── opening_loc: ∅
+            │   │   │       │           ├── arguments:
+            │   │   │       │           │   @ ArgumentsNode (location: (10...11))
+            │   │   │       │           │   └── arguments: (length: 1)
+            │   │   │       │           │       └── @ IntegerNode (location: (10...11))
+            │   │   │       │           ├── closing_loc: ∅
+            │   │   │       │           ├── block: ∅
+            │   │   │       │           ├── flags: 
+            │   │   │       │           └── name: "+"
+            │   │   │       └── closing_loc: (11...12) = "}"
+            │   │   └── closing_loc: ∅
+            │   └── @ SymbolNode (location: (13...14))
+            │       ├── opening_loc: ∅
+            │       ├── value_loc: (13...14) = "c"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "c"
+            ├── opening_loc: (0...3) = "%I("
+            └── closing_loc: (14...15) = ")"
diff --git a/test/yarp/snapshots/seattlerb/quoted_symbol_hash_arg.txt b/test/yarp/snapshots/seattlerb/quoted_symbol_hash_arg.txt
index 861fcaa6a2..13f0c81919 100644
--- a/test/yarp/snapshots/seattlerb/quoted_symbol_hash_arg.txt
+++ b/test/yarp/snapshots/seattlerb/quoted_symbol_hash_arg.txt
@@ -1,24 +1,32 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...12)(
-       nil,
-       nil,
-       (0...4),
-       nil,
-       ArgumentsNode(5...12)(
-         [KeywordHashNode(5...12)(
-            [AssocNode(5...12)(
-               SymbolNode(5...9)((5...6), (6...7), (7...9), "a"),
-               HashNode(10...12)((10...11), [], (11...12)),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "puts"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...12))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...4) = "puts"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...12))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (5...12))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (5...12))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (5...9))
+            │                   │   ├── opening_loc: (5...6) = "'"
+            │                   │   ├── value_loc: (6...7) = "a"
+            │                   │   ├── closing_loc: (7...9) = "':"
+            │                   │   └── unescaped: "a"
+            │                   ├── value:
+            │                   │   @ HashNode (location: (10...12))
+            │                   │   ├── opening_loc: (10...11) = "{"
+            │                   │   ├── elements: (length: 0)
+            │                   │   └── closing_loc: (11...12) = "}"
+            │                   └── operator_loc: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "puts"
diff --git a/test/yarp/snapshots/seattlerb/quoted_symbol_keys.txt b/test/yarp/snapshots/seattlerb/quoted_symbol_keys.txt
index 59b2b5d62d..54a8319116 100644
--- a/test/yarp/snapshots/seattlerb/quoted_symbol_keys.txt
+++ b/test/yarp/snapshots/seattlerb/quoted_symbol_keys.txt
@@ -1,14 +1,23 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [HashNode(0...11)(
-       (0...1),
-       [AssocNode(2...9)(
-          SymbolNode(2...6)((2...3), (3...4), (4...6), "a"),
-          SymbolNode(7...9)((7...8), (8...9), nil, "b"),
-          nil
-        )],
-       (10...11)
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ HashNode (location: (0...11))
+            ├── opening_loc: (0...1) = "{"
+            ├── elements: (length: 1)
+            │   └── @ AssocNode (location: (2...9))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (2...6))
+            │       │   ├── opening_loc: (2...3) = "'"
+            │       │   ├── value_loc: (3...4) = "a"
+            │       │   ├── closing_loc: (4...6) = "':"
+            │       │   └── unescaped: "a"
+            │       ├── value:
+            │       │   @ SymbolNode (location: (7...9))
+            │       │   ├── opening_loc: (7...8) = ":"
+            │       │   ├── value_loc: (8...9) = "b"
+            │       │   ├── closing_loc: ∅
+            │       │   └── unescaped: "b"
+            │       └── operator_loc: ∅
+            └── closing_loc: (10...11) = "}"
diff --git a/test/yarp/snapshots/seattlerb/qw_escape.txt b/test/yarp/snapshots/seattlerb/qw_escape.txt
index 0bf3fd8d8b..3d1ba437a3 100644
--- a/test/yarp/snapshots/seattlerb/qw_escape.txt
+++ b/test/yarp/snapshots/seattlerb/qw_escape.txt
@@ -1,6 +1,10 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [StringNode(0...7)((0...3), (3...6), (6...7), "\u0001'")]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ StringNode (location: (0...7))
+            ├── opening_loc: (0...3) = "%q("
+            ├── content_loc: (3...6) = "\u0001\\'"
+            ├── closing_loc: (6...7) = ")"
+            └── unescaped: "\u0001'"
diff --git a/test/yarp/snapshots/seattlerb/qw_escape_term.txt b/test/yarp/snapshots/seattlerb/qw_escape_term.txt
index 2c9eb48c3d..295c960e81 100644
--- a/test/yarp/snapshots/seattlerb/qw_escape_term.txt
+++ b/test/yarp/snapshots/seattlerb/qw_escape_term.txt
@@ -1,11 +1,10 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [StringNode(0...26)(
-       (0...3),
-       (3...25),
-       (25...26),
-       "blah blah \\| blah blah"
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ StringNode (location: (0...26))
+            ├── opening_loc: (0...3) = "%q|"
+            ├── content_loc: (3...25) = "blah blah \\| blah blah"
+            ├── closing_loc: (25...26) = "|"
+            └── unescaped: "blah blah \\| blah blah"
diff --git a/test/yarp/snapshots/seattlerb/qwords_empty.txt b/test/yarp/snapshots/seattlerb/qwords_empty.txt
index cad298895b..f2f70c8e51 100644
--- a/test/yarp/snapshots/seattlerb/qwords_empty.txt
+++ b/test/yarp/snapshots/seattlerb/qwords_empty.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)([ArrayNode(0...4)([], (0...3), (3...4))])
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...4))
+            ├── elements: (length: 0)
+            ├── opening_loc: (0...3) = "%w("
+            └── closing_loc: (3...4) = ")"
diff --git a/test/yarp/snapshots/seattlerb/read_escape_unicode_curlies.txt b/test/yarp/snapshots/seattlerb/read_escape_unicode_curlies.txt
index 26583c05a1..699af8c9cf 100644
--- a/test/yarp/snapshots/seattlerb/read_escape_unicode_curlies.txt
+++ b/test/yarp/snapshots/seattlerb/read_escape_unicode_curlies.txt
@@ -1,4 +1,10 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)([StringNode(0...9)((0...1), (1...9), nil, " ")])
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ StringNode (location: (0...9))
+            ├── opening_loc: (0...1) = "?"
+            ├── content_loc: (1...9) = "\\u{00a0}"
+            ├── closing_loc: ∅
+            └── unescaped: " "
diff --git a/test/yarp/snapshots/seattlerb/read_escape_unicode_h4.txt b/test/yarp/snapshots/seattlerb/read_escape_unicode_h4.txt
index b17128c620..1721429e89 100644
--- a/test/yarp/snapshots/seattlerb/read_escape_unicode_h4.txt
+++ b/test/yarp/snapshots/seattlerb/read_escape_unicode_h4.txt
@@ -1,4 +1,10 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)([StringNode(0...7)((0...1), (1...7), nil, " ")])
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ StringNode (location: (0...7))
+            ├── opening_loc: (0...1) = "?"
+            ├── content_loc: (1...7) = "\\u00a0"
+            ├── closing_loc: ∅
+            └── unescaped: " "
diff --git a/test/yarp/snapshots/seattlerb/regexp.txt b/test/yarp/snapshots/seattlerb/regexp.txt
index f642008b48..ded3b2972f 100644
--- a/test/yarp/snapshots/seattlerb/regexp.txt
+++ b/test/yarp/snapshots/seattlerb/regexp.txt
@@ -1,28 +1,35 @@
-ProgramNode(0...45)(
-  [],
-  StatementsNode(0...45)(
-    [RegularExpressionNode(0...5)((0...1), (1...4), (4...5), "wtf", 0),
-     RegularExpressionNode(7...13)((7...8), (8...11), (11...13), "wtf", 4),
-     RegularExpressionNode(15...21)(
-       (15...16),
-       (16...19),
-       (19...21),
-       "wtf",
-       16
-     ),
-     RegularExpressionNode(23...30)(
-       (23...24),
-       (24...27),
-       (27...30),
-       "wtf",
-       20
-     ),
-     RegularExpressionNode(32...45)(
-       (32...33),
-       (33...36),
-       (36...45),
-       "wtf",
-       20
-     )]
-  )
-)
+@ ProgramNode (location: (0...45))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...45))
+    └── body: (length: 5)
+        ├── @ RegularExpressionNode (location: (0...5))
+        │   ├── opening_loc: (0...1) = "/"
+        │   ├── content_loc: (1...4) = "wtf"
+        │   ├── closing_loc: (4...5) = "/"
+        │   ├── unescaped: "wtf"
+        │   └── flags: 
+        ├── @ RegularExpressionNode (location: (7...13))
+        │   ├── opening_loc: (7...8) = "/"
+        │   ├── content_loc: (8...11) = "wtf"
+        │   ├── closing_loc: (11...13) = "/m"
+        │   ├── unescaped: "wtf"
+        │   └── flags: multi_line
+        ├── @ RegularExpressionNode (location: (15...21))
+        │   ├── opening_loc: (15...16) = "/"
+        │   ├── content_loc: (16...19) = "wtf"
+        │   ├── closing_loc: (19...21) = "/n"
+        │   ├── unescaped: "wtf"
+        │   └── flags: ascii_8bit
+        ├── @ RegularExpressionNode (location: (23...30))
+        │   ├── opening_loc: (23...24) = "/"
+        │   ├── content_loc: (24...27) = "wtf"
+        │   ├── closing_loc: (27...30) = "/nm"
+        │   ├── unescaped: "wtf"
+        │   └── flags: multi_line, ascii_8bit
+        └── @ RegularExpressionNode (location: (32...45))
+            ├── opening_loc: (32...33) = "/"
+            ├── content_loc: (33...36) = "wtf"
+            ├── closing_loc: (36...45) = "/nmnmnmnm"
+            ├── unescaped: "wtf"
+            └── flags: multi_line, ascii_8bit
diff --git a/test/yarp/snapshots/seattlerb/regexp_esc_C_slash.txt b/test/yarp/snapshots/seattlerb/regexp_esc_C_slash.txt
index 2605080304..3f08f5b6dd 100644
--- a/test/yarp/snapshots/seattlerb/regexp_esc_C_slash.txt
+++ b/test/yarp/snapshots/seattlerb/regexp_esc_C_slash.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [RegularExpressionNode(0...7)((0...1), (1...6), (6...7), "\u0003d", 0)]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ RegularExpressionNode (location: (0...7))
+            ├── opening_loc: (0...1) = "/"
+            ├── content_loc: (1...6) = "\\cC\\d"
+            ├── closing_loc: (6...7) = "/"
+            ├── unescaped: "\u0003d"
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/regexp_esc_u.txt b/test/yarp/snapshots/seattlerb/regexp_esc_u.txt
index 8b13368704..39ffbe16ab 100644
--- a/test/yarp/snapshots/seattlerb/regexp_esc_u.txt
+++ b/test/yarp/snapshots/seattlerb/regexp_esc_u.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [RegularExpressionNode(0...17)((0...1), (1...16), (16...17), "[!-']", 0)]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ RegularExpressionNode (location: (0...17))
+            ├── opening_loc: (0...1) = "/"
+            ├── content_loc: (1...16) = "[\\u0021-\\u0027]"
+            ├── closing_loc: (16...17) = "/"
+            ├── unescaped: "[!-']"
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/regexp_escape_extended.txt b/test/yarp/snapshots/seattlerb/regexp_escape_extended.txt
index 699de5a196..0d320cbe10 100644
--- a/test/yarp/snapshots/seattlerb/regexp_escape_extended.txt
+++ b/test/yarp/snapshots/seattlerb/regexp_escape_extended.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [RegularExpressionNode(0...6)((0...1), (1...5), (5...6), "“", 0)]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ RegularExpressionNode (location: (0...6))
+            ├── opening_loc: (0...1) = "/"
+            ├── content_loc: (1...5) = "\\“"
+            ├── closing_loc: (5...6) = "/"
+            ├── unescaped: "“"
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/regexp_unicode_curlies.txt b/test/yarp/snapshots/seattlerb/regexp_unicode_curlies.txt
index e4502db3f7..9ed4847f7f 100644
--- a/test/yarp/snapshots/seattlerb/regexp_unicode_curlies.txt
+++ b/test/yarp/snapshots/seattlerb/regexp_unicode_curlies.txt
@@ -1,7 +1,17 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [RegularExpressionNode(0...15)((0...1), (1...14), (14...15), "샞몾", 0),
-     RegularExpressionNode(17...25)((17...18), (18...24), (24...25), "ß", 0)]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 2)
+        ├── @ RegularExpressionNode (location: (0...15))
+        │   ├── opening_loc: (0...1) = "/"
+        │   ├── content_loc: (1...14) = "\\u{c0de babe}"
+        │   ├── closing_loc: (14...15) = "/"
+        │   ├── unescaped: "샞몾"
+        │   └── flags: 
+        └── @ RegularExpressionNode (location: (17...25))
+            ├── opening_loc: (17...18) = "/"
+            ├── content_loc: (18...24) = "\\u{df}"
+            ├── closing_loc: (24...25) = "/"
+            ├── unescaped: "ß"
+            └── flags: 
diff --git a/test/yarp/snapshots/seattlerb/required_kwarg_no_value.txt b/test/yarp/snapshots/seattlerb/required_kwarg_no_value.txt
index 942400bfa1..cd7a4ac0d1 100644
--- a/test/yarp/snapshots/seattlerb/required_kwarg_no_value.txt
+++ b/test/yarp/snapshots/seattlerb/required_kwarg_no_value.txt
@@ -1,28 +1,34 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [DefNode(0...16)(
-       :x,
-       (4...5),
-       nil,
-       ParametersNode(6...12)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...8)(:a, (6...8), nil),
-          KeywordParameterNode(10...12)(:b, (10...12), nil)],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :b],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (13...16)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...16))
+            ├── name: :x
+            ├── name_loc: (4...5) = "x"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...12))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 2)
+            │   │   ├── @ KeywordParameterNode (location: (6...8))
+            │   │   │   ├── name: :a
+            │   │   │   ├── name_loc: (6...8) = "a:"
+            │   │   │   └── value: ∅
+            │   │   └── @ KeywordParameterNode (location: (10...12))
+            │   │       ├── name: :b
+            │   │       ├── name_loc: (10...12) = "b:"
+            │   │       └── value: ∅
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:a, :b]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (13...16) = "end"
diff --git a/test/yarp/snapshots/seattlerb/rescue_do_end_ensure_result.txt b/test/yarp/snapshots/seattlerb/rescue_do_end_ensure_result.txt
index 52721053a8..8632544ec7 100644
--- a/test/yarp/snapshots/seattlerb/rescue_do_end_ensure_result.txt
+++ b/test/yarp/snapshots/seattlerb/rescue_do_end_ensure_result.txt
@@ -1,47 +1,56 @@
-ProgramNode(0...42)(
-  [],
-  StatementsNode(0...42)(
-    [CallNode(0...42)(
-       CallNode(0...37)(
-         nil,
-         nil,
-         (0...4),
-         nil,
-         nil,
-         nil,
-         BlockNode(5...37)(
-           [],
-           nil,
-           BeginNode(10...37)(
-             nil,
-             StatementsNode(10...16)(
-               [SymbolNode(10...16)((10...11), (11...16), nil, "begin")]
-             ),
-             nil,
-             nil,
-             EnsureNode(17...37)(
-               (17...23),
-               StatementsNode(26...33)(
-                 [SymbolNode(26...33)((26...27), (27...33), nil, "ensure")]
-               ),
-               (34...37)
-             ),
-             (34...37)
-           ),
-           (5...7),
-           (34...37)
-         ),
-         0,
-         "proc"
-       ),
-       (37...38),
-       (38...42),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "call"
-     )]
-  )
-)
+@ ProgramNode (location: (0...42))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...42))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...42))
+            ├── receiver:
+            │   @ CallNode (location: (0...37))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...4) = "proc"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (5...37))
+            │   │   ├── locals: []
+            │   │   ├── parameters: ∅
+            │   │   ├── body:
+            │   │   │   @ BeginNode (location: (10...37))
+            │   │   │   ├── begin_keyword_loc: ∅
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (10...16))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ SymbolNode (location: (10...16))
+            │   │   │   │           ├── opening_loc: (10...11) = ":"
+            │   │   │   │           ├── value_loc: (11...16) = "begin"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "begin"
+            │   │   │   ├── rescue_clause: ∅
+            │   │   │   ├── else_clause: ∅
+            │   │   │   ├── ensure_clause:
+            │   │   │   │   @ EnsureNode (location: (17...37))
+            │   │   │   │   ├── ensure_keyword_loc: (17...23) = "ensure"
+            │   │   │   │   ├── statements:
+            │   │   │   │   │   @ StatementsNode (location: (26...33))
+            │   │   │   │   │   └── body: (length: 1)
+            │   │   │   │   │       └── @ SymbolNode (location: (26...33))
+            │   │   │   │   │           ├── opening_loc: (26...27) = ":"
+            │   │   │   │   │           ├── value_loc: (27...33) = "ensure"
+            │   │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │   │           └── unescaped: "ensure"
+            │   │   │   │   └── end_keyword_loc: (34...37) = "end"
+            │   │   │   └── end_keyword_loc: (34...37) = "end"
+            │   │   ├── opening_loc: (5...7) = "do"
+            │   │   └── closing_loc: (34...37) = "end"
+            │   ├── flags: 
+            │   └── name: "proc"
+            ├── call_operator_loc: (37...38) = "."
+            ├── message_loc: (38...42) = "call"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "call"
diff --git a/test/yarp/snapshots/seattlerb/rescue_do_end_no_raise.txt b/test/yarp/snapshots/seattlerb/rescue_do_end_no_raise.txt
index c4d46c2f7a..94a8df8a6f 100644
--- a/test/yarp/snapshots/seattlerb/rescue_do_end_no_raise.txt
+++ b/test/yarp/snapshots/seattlerb/rescue_do_end_no_raise.txt
@@ -1,52 +1,71 @@
-ProgramNode(0...66)(
-  [],
-  StatementsNode(0...66)(
-    [CallNode(0...66)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       nil,
-       nil,
-       BlockNode(4...66)(
-         [],
-         nil,
-         BeginNode(9...66)(
-           nil,
-           StatementsNode(9...15)(
-             [SymbolNode(9...15)((9...10), (10...15), nil, "begin")]
-           ),
-           RescueNode(16...32)(
-             (16...22),
-             [],
-             nil,
-             nil,
-             StatementsNode(25...32)(
-               [SymbolNode(25...32)((25...26), (26...32), nil, "rescue")]
-             ),
-             nil
-           ),
-           ElseNode(33...52)(
-             (33...37),
-             StatementsNode(40...45)(
-               [SymbolNode(40...45)((40...41), (41...45), nil, "else")]
-             ),
-             (46...52)
-           ),
-           EnsureNode(46...66)(
-             (46...52),
-             StatementsNode(55...62)(
-               [SymbolNode(55...62)((55...56), (56...62), nil, "ensure")]
-             ),
-             (63...66)
-           ),
-           (63...66)
-         ),
-         (4...6),
-         (63...66)
-       ),
-       0,
-       "tap"
-     )]
-  )
-)
+@ ProgramNode (location: (0...66))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...66))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...66))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "tap"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (4...66))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ BeginNode (location: (9...66))
+            │   │   ├── begin_keyword_loc: ∅
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (9...15))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ SymbolNode (location: (9...15))
+            │   │   │           ├── opening_loc: (9...10) = ":"
+            │   │   │           ├── value_loc: (10...15) = "begin"
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           └── unescaped: "begin"
+            │   │   ├── rescue_clause:
+            │   │   │   @ RescueNode (location: (16...32))
+            │   │   │   ├── keyword_loc: (16...22) = "rescue"
+            │   │   │   ├── exceptions: (length: 0)
+            │   │   │   ├── operator_loc: ∅
+            │   │   │   ├── reference: ∅
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (25...32))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ SymbolNode (location: (25...32))
+            │   │   │   │           ├── opening_loc: (25...26) = ":"
+            │   │   │   │           ├── value_loc: (26...32) = "rescue"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "rescue"
+            │   │   │   └── consequent: ∅
+            │   │   ├── else_clause:
+            │   │   │   @ ElseNode (location: (33...52))
+            │   │   │   ├── else_keyword_loc: (33...37) = "else"
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (40...45))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ SymbolNode (location: (40...45))
+            │   │   │   │           ├── opening_loc: (40...41) = ":"
+            │   │   │   │           ├── value_loc: (41...45) = "else"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "else"
+            │   │   │   └── end_keyword_loc: (46...52) = "ensure"
+            │   │   ├── ensure_clause:
+            │   │   │   @ EnsureNode (location: (46...66))
+            │   │   │   ├── ensure_keyword_loc: (46...52) = "ensure"
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (55...62))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ SymbolNode (location: (55...62))
+            │   │   │   │           ├── opening_loc: (55...56) = ":"
+            │   │   │   │           ├── value_loc: (56...62) = "ensure"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "ensure"
+            │   │   │   └── end_keyword_loc: (63...66) = "end"
+            │   │   └── end_keyword_loc: (63...66) = "end"
+            │   ├── opening_loc: (4...6) = "do"
+            │   └── closing_loc: (63...66) = "end"
+            ├── flags: 
+            └── name: "tap"
diff --git a/test/yarp/snapshots/seattlerb/rescue_do_end_raised.txt b/test/yarp/snapshots/seattlerb/rescue_do_end_raised.txt
index f4e4cda3ee..10188799fa 100644
--- a/test/yarp/snapshots/seattlerb/rescue_do_end_raised.txt
+++ b/test/yarp/snapshots/seattlerb/rescue_do_end_raised.txt
@@ -1,47 +1,51 @@
-ProgramNode(0...35)(
-  [],
-  StatementsNode(0...35)(
-    [CallNode(0...35)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       nil,
-       nil,
-       BlockNode(4...35)(
-         [],
-         nil,
-         BeginNode(9...35)(
-           nil,
-           StatementsNode(9...14)(
-             [CallNode(9...14)(
-                nil,
-                nil,
-                (9...14),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "raise"
-              )]
-           ),
-           nil,
-           nil,
-           EnsureNode(15...35)(
-             (15...21),
-             StatementsNode(24...31)(
-               [SymbolNode(24...31)((24...25), (25...31), nil, "ensure")]
-             ),
-             (32...35)
-           ),
-           (32...35)
-         ),
-         (4...6),
-         (32...35)
-       ),
-       0,
-       "tap"
-     )]
-  )
-)
+@ ProgramNode (location: (0...35))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...35))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...35))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "tap"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (4...35))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ BeginNode (location: (9...35))
+            │   │   ├── begin_keyword_loc: ∅
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (9...14))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (9...14))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (9...14) = "raise"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "raise"
+            │   │   ├── rescue_clause: ∅
+            │   │   ├── else_clause: ∅
+            │   │   ├── ensure_clause:
+            │   │   │   @ EnsureNode (location: (15...35))
+            │   │   │   ├── ensure_keyword_loc: (15...21) = "ensure"
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (24...31))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ SymbolNode (location: (24...31))
+            │   │   │   │           ├── opening_loc: (24...25) = ":"
+            │   │   │   │           ├── value_loc: (25...31) = "ensure"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "ensure"
+            │   │   │   └── end_keyword_loc: (32...35) = "end"
+            │   │   └── end_keyword_loc: (32...35) = "end"
+            │   ├── opening_loc: (4...6) = "do"
+            │   └── closing_loc: (32...35) = "end"
+            ├── flags: 
+            └── name: "tap"
diff --git a/test/yarp/snapshots/seattlerb/rescue_do_end_rescued.txt b/test/yarp/snapshots/seattlerb/rescue_do_end_rescued.txt
index 5376935a82..9868698cf2 100644
--- a/test/yarp/snapshots/seattlerb/rescue_do_end_rescued.txt
+++ b/test/yarp/snapshots/seattlerb/rescue_do_end_rescued.txt
@@ -1,62 +1,76 @@
-ProgramNode(0...65)(
-  [],
-  StatementsNode(0...65)(
-    [CallNode(0...65)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       nil,
-       nil,
-       BlockNode(4...65)(
-         [],
-         nil,
-         BeginNode(9...65)(
-           nil,
-           StatementsNode(9...14)(
-             [CallNode(9...14)(
-                nil,
-                nil,
-                (9...14),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "raise"
-              )]
-           ),
-           RescueNode(15...31)(
-             (15...21),
-             [],
-             nil,
-             nil,
-             StatementsNode(24...31)(
-               [SymbolNode(24...31)((24...25), (25...31), nil, "rescue")]
-             ),
-             nil
-           ),
-           ElseNode(32...51)(
-             (32...36),
-             StatementsNode(39...44)(
-               [SymbolNode(39...44)((39...40), (40...44), nil, "else")]
-             ),
-             (45...51)
-           ),
-           EnsureNode(45...65)(
-             (45...51),
-             StatementsNode(54...61)(
-               [SymbolNode(54...61)((54...55), (55...61), nil, "ensure")]
-             ),
-             (62...65)
-           ),
-           (62...65)
-         ),
-         (4...6),
-         (62...65)
-       ),
-       0,
-       "tap"
-     )]
-  )
-)
+@ ProgramNode (location: (0...65))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...65))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...65))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "tap"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (4...65))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ BeginNode (location: (9...65))
+            │   │   ├── begin_keyword_loc: ∅
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (9...14))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (9...14))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (9...14) = "raise"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "raise"
+            │   │   ├── rescue_clause:
+            │   │   │   @ RescueNode (location: (15...31))
+            │   │   │   ├── keyword_loc: (15...21) = "rescue"
+            │   │   │   ├── exceptions: (length: 0)
+            │   │   │   ├── operator_loc: ∅
+            │   │   │   ├── reference: ∅
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (24...31))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ SymbolNode (location: (24...31))
+            │   │   │   │           ├── opening_loc: (24...25) = ":"
+            │   │   │   │           ├── value_loc: (25...31) = "rescue"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "rescue"
+            │   │   │   └── consequent: ∅
+            │   │   ├── else_clause:
+            │   │   │   @ ElseNode (location: (32...51))
+            │   │   │   ├── else_keyword_loc: (32...36) = "else"
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (39...44))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ SymbolNode (location: (39...44))
+            │   │   │   │           ├── opening_loc: (39...40) = ":"
+            │   │   │   │           ├── value_loc: (40...44) = "else"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "else"
+            │   │   │   └── end_keyword_loc: (45...51) = "ensure"
+            │   │   ├── ensure_clause:
+            │   │   │   @ EnsureNode (location: (45...65))
+            │   │   │   ├── ensure_keyword_loc: (45...51) = "ensure"
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (54...61))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ SymbolNode (location: (54...61))
+            │   │   │   │           ├── opening_loc: (54...55) = ":"
+            │   │   │   │           ├── value_loc: (55...61) = "ensure"
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           └── unescaped: "ensure"
+            │   │   │   └── end_keyword_loc: (62...65) = "end"
+            │   │   └── end_keyword_loc: (62...65) = "end"
+            │   ├── opening_loc: (4...6) = "do"
+            │   └── closing_loc: (62...65) = "end"
+            ├── flags: 
+            └── name: "tap"
diff --git a/test/yarp/snapshots/seattlerb/rescue_in_block.txt b/test/yarp/snapshots/seattlerb/rescue_in_block.txt
index 2f096cdf74..58cc6cc67e 100644
--- a/test/yarp/snapshots/seattlerb/rescue_in_block.txt
+++ b/test/yarp/snapshots/seattlerb/rescue_in_block.txt
@@ -1,48 +1,47 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [CallNode(0...26)(
-       nil,
-       nil,
-       (0...4),
-       nil,
-       nil,
-       nil,
-       BlockNode(5...26)(
-         [],
-         nil,
-         BeginNode(8...26)(
-           nil,
-           nil,
-           RescueNode(8...22)(
-             (8...14),
-             [],
-             nil,
-             nil,
-             StatementsNode(17...22)(
-               [CallNode(17...22)(
-                  nil,
-                  nil,
-                  (17...22),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "stuff"
-                )]
-             ),
-             nil
-           ),
-           nil,
-           nil,
-           (23...26)
-         ),
-         (5...7),
-         (23...26)
-       ),
-       0,
-       "blah"
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...26))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...4) = "blah"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (5...26))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ BeginNode (location: (8...26))
+            │   │   ├── begin_keyword_loc: ∅
+            │   │   ├── statements: ∅
+            │   │   ├── rescue_clause:
+            │   │   │   @ RescueNode (location: (8...22))
+            │   │   │   ├── keyword_loc: (8...14) = "rescue"
+            │   │   │   ├── exceptions: (length: 0)
+            │   │   │   ├── operator_loc: ∅
+            │   │   │   ├── reference: ∅
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (17...22))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ CallNode (location: (17...22))
+            │   │   │   │           ├── receiver: ∅
+            │   │   │   │           ├── call_operator_loc: ∅
+            │   │   │   │           ├── message_loc: (17...22) = "stuff"
+            │   │   │   │           ├── opening_loc: ∅
+            │   │   │   │           ├── arguments: ∅
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           ├── block: ∅
+            │   │   │   │           ├── flags: variable_call
+            │   │   │   │           └── name: "stuff"
+            │   │   │   └── consequent: ∅
+            │   │   ├── else_clause: ∅
+            │   │   ├── ensure_clause: ∅
+            │   │   └── end_keyword_loc: (23...26) = "end"
+            │   ├── opening_loc: (5...7) = "do"
+            │   └── closing_loc: (23...26) = "end"
+            ├── flags: 
+            └── name: "blah"
diff --git a/test/yarp/snapshots/seattlerb/rescue_parens.txt b/test/yarp/snapshots/seattlerb/rescue_parens.txt
index c672e59e6f..c54d3420aa 100644
--- a/test/yarp/snapshots/seattlerb/rescue_parens.txt
+++ b/test/yarp/snapshots/seattlerb/rescue_parens.txt
@@ -1,48 +1,47 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...14)(
-         [ParenthesesNode(2...14)(
-            StatementsNode(3...13)(
-              [RescueModifierNode(3...13)(
-                 CallNode(3...4)(
-                   nil,
-                   nil,
-                   (3...4),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "b"
-                 ),
-                 (5...11),
-                 CallNode(12...13)(
-                   nil,
-                   nil,
-                   (12...13),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "c"
-                 )
-               )]
-            ),
-            (2...3),
-            (13...14)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...14))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (2...14))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (3...13))
+            │           │   └── body: (length: 1)
+            │           │       └── @ RescueModifierNode (location: (3...13))
+            │           │           ├── expression:
+            │           │           │   @ CallNode (location: (3...4))
+            │           │           │   ├── receiver: ∅
+            │           │           │   ├── call_operator_loc: ∅
+            │           │           │   ├── message_loc: (3...4) = "b"
+            │           │           │   ├── opening_loc: ∅
+            │           │           │   ├── arguments: ∅
+            │           │           │   ├── closing_loc: ∅
+            │           │           │   ├── block: ∅
+            │           │           │   ├── flags: variable_call
+            │           │           │   └── name: "b"
+            │           │           ├── keyword_loc: (5...11) = "rescue"
+            │           │           └── rescue_expression:
+            │           │               @ CallNode (location: (12...13))
+            │           │               ├── receiver: ∅
+            │           │               ├── call_operator_loc: ∅
+            │           │               ├── message_loc: (12...13) = "c"
+            │           │               ├── opening_loc: ∅
+            │           │               ├── arguments: ∅
+            │           │               ├── closing_loc: ∅
+            │           │               ├── block: ∅
+            │           │               ├── flags: variable_call
+            │           │               └── name: "c"
+            │           ├── opening_loc: (2...3) = "("
+            │           └── closing_loc: (13...14) = ")"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/seattlerb/return_call_assocs.txt b/test/yarp/snapshots/seattlerb/return_call_assocs.txt
index 9698080b5e..93ee0d351d 100644
--- a/test/yarp/snapshots/seattlerb/return_call_assocs.txt
+++ b/test/yarp/snapshots/seattlerb/return_call_assocs.txt
@@ -1,142 +1,172 @@
-ProgramNode(0...106)(
-  [],
-  StatementsNode(0...106)(
-    [ReturnNode(0...17)(
-       (0...6),
-       ArgumentsNode(7...17)(
-         [IntegerNode(7...8)(),
-          KeywordHashNode(10...17)(
-            [AssocNode(10...17)(
-               SymbolNode(10...12)((10...11), (11...12), nil, "z"),
-               IntegerNode(16...17)(),
-               (13...15)
-             )]
-          )]
-       )
-     ),
-     ReturnNode(19...45)(
-       (19...25),
-       ArgumentsNode(26...45)(
-         [IntegerNode(26...27)(),
-          KeywordHashNode(29...45)(
-            [AssocNode(29...36)(
-               SymbolNode(29...31)((29...30), (30...31), nil, "z"),
-               IntegerNode(35...36)(),
-               (32...34)
-             ),
-             AssocNode(38...45)(
-               SymbolNode(38...40)((38...39), (39...40), nil, "w"),
-               IntegerNode(44...45)(),
-               (41...43)
-             )]
-          )]
-       )
-     ),
-     ReturnNode(47...61)(
-       (47...53),
-       ArgumentsNode(54...61)(
-         [CallNode(54...61)(
-            nil,
-            nil,
-            (54...55),
-            nil,
-            ArgumentsNode(56...61)(
-              [KeywordHashNode(56...61)(
-                 [AssocNode(56...61)(
-                    SymbolNode(56...58)((56...57), (57...58), nil, "z"),
-                    IntegerNode(60...61)(),
-                    (58...60)
-                  )]
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "y"
-          )]
-       )
-     ),
-     ReturnNode(63...75)(
-       (63...69),
-       ArgumentsNode(70...75)(
-         [CallNode(70...75)(
-            nil,
-            nil,
-            (70...71),
-            nil,
-            ArgumentsNode(72...75)(
-              [KeywordHashNode(72...75)(
-                 [AssocNode(72...75)(
-                    SymbolNode(72...74)(nil, (72...73), (73...74), "z"),
-                    IntegerNode(74...75)(),
-                    nil
-                  )]
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "y"
-          )]
-       )
-     ),
-     ReturnNode(77...90)(
-       (77...83),
-       ArgumentsNode(84...90)(
-         [CallNode(84...90)(
-            nil,
-            nil,
-            (84...85),
-            (85...86),
-            ArgumentsNode(86...89)(
-              [KeywordHashNode(86...89)(
-                 [AssocNode(86...89)(
-                    SymbolNode(86...88)(nil, (86...87), (87...88), "z"),
-                    IntegerNode(88...89)(),
-                    nil
-                  )]
-               )]
-            ),
-            (89...90),
-            nil,
-            0,
-            "y"
-          )]
-       )
-     ),
-     ReturnNode(92...106)(
-       (92...98),
-       ArgumentsNode(99...106)(
-         [CallNode(99...106)(
-            nil,
-            nil,
-            (99...100),
-            (100...101),
-            ArgumentsNode(101...105)(
-              [KeywordHashNode(101...105)(
-                 [AssocNode(101...105)(
-                    CallNode(101...102)(
-                      nil,
-                      nil,
-                      (101...102),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "z"
-                    ),
-                    IntegerNode(104...105)(),
-                    (102...104)
-                  )]
-               )]
-            ),
-            (105...106),
-            nil,
-            0,
-            "y"
-          )]
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...106))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...106))
+    └── body: (length: 6)
+        ├── @ ReturnNode (location: (0...17))
+        │   ├── keyword_loc: (0...6) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (7...17))
+        │       └── arguments: (length: 2)
+        │           ├── @ IntegerNode (location: (7...8))
+        │           └── @ KeywordHashNode (location: (10...17))
+        │               └── elements: (length: 1)
+        │                   └── @ AssocNode (location: (10...17))
+        │                       ├── key:
+        │                       │   @ SymbolNode (location: (10...12))
+        │                       │   ├── opening_loc: (10...11) = ":"
+        │                       │   ├── value_loc: (11...12) = "z"
+        │                       │   ├── closing_loc: ∅
+        │                       │   └── unescaped: "z"
+        │                       ├── value:
+        │                       │   @ IntegerNode (location: (16...17))
+        │                       └── operator_loc: (13...15) = "=>"
+        ├── @ ReturnNode (location: (19...45))
+        │   ├── keyword_loc: (19...25) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (26...45))
+        │       └── arguments: (length: 2)
+        │           ├── @ IntegerNode (location: (26...27))
+        │           └── @ KeywordHashNode (location: (29...45))
+        │               └── elements: (length: 2)
+        │                   ├── @ AssocNode (location: (29...36))
+        │                   │   ├── key:
+        │                   │   │   @ SymbolNode (location: (29...31))
+        │                   │   │   ├── opening_loc: (29...30) = ":"
+        │                   │   │   ├── value_loc: (30...31) = "z"
+        │                   │   │   ├── closing_loc: ∅
+        │                   │   │   └── unescaped: "z"
+        │                   │   ├── value:
+        │                   │   │   @ IntegerNode (location: (35...36))
+        │                   │   └── operator_loc: (32...34) = "=>"
+        │                   └── @ AssocNode (location: (38...45))
+        │                       ├── key:
+        │                       │   @ SymbolNode (location: (38...40))
+        │                       │   ├── opening_loc: (38...39) = ":"
+        │                       │   ├── value_loc: (39...40) = "w"
+        │                       │   ├── closing_loc: ∅
+        │                       │   └── unescaped: "w"
+        │                       ├── value:
+        │                       │   @ IntegerNode (location: (44...45))
+        │                       └── operator_loc: (41...43) = "=>"
+        ├── @ ReturnNode (location: (47...61))
+        │   ├── keyword_loc: (47...53) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (54...61))
+        │       └── arguments: (length: 1)
+        │           └── @ CallNode (location: (54...61))
+        │               ├── receiver: ∅
+        │               ├── call_operator_loc: ∅
+        │               ├── message_loc: (54...55) = "y"
+        │               ├── opening_loc: ∅
+        │               ├── arguments:
+        │               │   @ ArgumentsNode (location: (56...61))
+        │               │   └── arguments: (length: 1)
+        │               │       └── @ KeywordHashNode (location: (56...61))
+        │               │           └── elements: (length: 1)
+        │               │               └── @ AssocNode (location: (56...61))
+        │               │                   ├── key:
+        │               │                   │   @ SymbolNode (location: (56...58))
+        │               │                   │   ├── opening_loc: (56...57) = ":"
+        │               │                   │   ├── value_loc: (57...58) = "z"
+        │               │                   │   ├── closing_loc: ∅
+        │               │                   │   └── unescaped: "z"
+        │               │                   ├── value:
+        │               │                   │   @ IntegerNode (location: (60...61))
+        │               │                   └── operator_loc: (58...60) = "=>"
+        │               ├── closing_loc: ∅
+        │               ├── block: ∅
+        │               ├── flags: 
+        │               └── name: "y"
+        ├── @ ReturnNode (location: (63...75))
+        │   ├── keyword_loc: (63...69) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (70...75))
+        │       └── arguments: (length: 1)
+        │           └── @ CallNode (location: (70...75))
+        │               ├── receiver: ∅
+        │               ├── call_operator_loc: ∅
+        │               ├── message_loc: (70...71) = "y"
+        │               ├── opening_loc: ∅
+        │               ├── arguments:
+        │               │   @ ArgumentsNode (location: (72...75))
+        │               │   └── arguments: (length: 1)
+        │               │       └── @ KeywordHashNode (location: (72...75))
+        │               │           └── elements: (length: 1)
+        │               │               └── @ AssocNode (location: (72...75))
+        │               │                   ├── key:
+        │               │                   │   @ SymbolNode (location: (72...74))
+        │               │                   │   ├── opening_loc: ∅
+        │               │                   │   ├── value_loc: (72...73) = "z"
+        │               │                   │   ├── closing_loc: (73...74) = ":"
+        │               │                   │   └── unescaped: "z"
+        │               │                   ├── value:
+        │               │                   │   @ IntegerNode (location: (74...75))
+        │               │                   └── operator_loc: ∅
+        │               ├── closing_loc: ∅
+        │               ├── block: ∅
+        │               ├── flags: 
+        │               └── name: "y"
+        ├── @ ReturnNode (location: (77...90))
+        │   ├── keyword_loc: (77...83) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (84...90))
+        │       └── arguments: (length: 1)
+        │           └── @ CallNode (location: (84...90))
+        │               ├── receiver: ∅
+        │               ├── call_operator_loc: ∅
+        │               ├── message_loc: (84...85) = "y"
+        │               ├── opening_loc: (85...86) = "("
+        │               ├── arguments:
+        │               │   @ ArgumentsNode (location: (86...89))
+        │               │   └── arguments: (length: 1)
+        │               │       └── @ KeywordHashNode (location: (86...89))
+        │               │           └── elements: (length: 1)
+        │               │               └── @ AssocNode (location: (86...89))
+        │               │                   ├── key:
+        │               │                   │   @ SymbolNode (location: (86...88))
+        │               │                   │   ├── opening_loc: ∅
+        │               │                   │   ├── value_loc: (86...87) = "z"
+        │               │                   │   ├── closing_loc: (87...88) = ":"
+        │               │                   │   └── unescaped: "z"
+        │               │                   ├── value:
+        │               │                   │   @ IntegerNode (location: (88...89))
+        │               │                   └── operator_loc: ∅
+        │               ├── closing_loc: (89...90) = ")"
+        │               ├── block: ∅
+        │               ├── flags: 
+        │               └── name: "y"
+        └── @ ReturnNode (location: (92...106))
+            ├── keyword_loc: (92...98) = "return"
+            └── arguments:
+                @ ArgumentsNode (location: (99...106))
+                └── arguments: (length: 1)
+                    └── @ CallNode (location: (99...106))
+                        ├── receiver: ∅
+                        ├── call_operator_loc: ∅
+                        ├── message_loc: (99...100) = "y"
+                        ├── opening_loc: (100...101) = "("
+                        ├── arguments:
+                        │   @ ArgumentsNode (location: (101...105))
+                        │   └── arguments: (length: 1)
+                        │       └── @ KeywordHashNode (location: (101...105))
+                        │           └── elements: (length: 1)
+                        │               └── @ AssocNode (location: (101...105))
+                        │                   ├── key:
+                        │                   │   @ CallNode (location: (101...102))
+                        │                   │   ├── receiver: ∅
+                        │                   │   ├── call_operator_loc: ∅
+                        │                   │   ├── message_loc: (101...102) = "z"
+                        │                   │   ├── opening_loc: ∅
+                        │                   │   ├── arguments: ∅
+                        │                   │   ├── closing_loc: ∅
+                        │                   │   ├── block: ∅
+                        │                   │   ├── flags: variable_call
+                        │                   │   └── name: "z"
+                        │                   ├── value:
+                        │                   │   @ IntegerNode (location: (104...105))
+                        │                   └── operator_loc: (102...104) = "=>"
+                        ├── closing_loc: (105...106) = ")"
+                        ├── block: ∅
+                        ├── flags: 
+                        └── name: "y"
diff --git a/test/yarp/snapshots/seattlerb/rhs_asgn.txt b/test/yarp/snapshots/seattlerb/rhs_asgn.txt
index 604a14667b..4f40b07ec1 100644
--- a/test/yarp/snapshots/seattlerb/rhs_asgn.txt
+++ b/test/yarp/snapshots/seattlerb/rhs_asgn.txt
@@ -1,10 +1,13 @@
-ProgramNode(0...7)(
-  [:n],
-  StatementsNode(0...7)(
-    [MatchRequiredNode(0...7)(
-       IntegerNode(0...2)(),
-       LocalVariableTargetNode(6...7)(:n, 0),
-       (3...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: [:n]
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ MatchRequiredNode (location: (0...7))
+            ├── value:
+            │   @ IntegerNode (location: (0...2))
+            ├── pattern:
+            │   @ LocalVariableTargetNode (location: (6...7))
+            │   ├── name: :n
+            │   └── depth: 0
+            └── operator_loc: (3...5) = "=>"
diff --git a/test/yarp/snapshots/seattlerb/ruby21_numbers.txt b/test/yarp/snapshots/seattlerb/ruby21_numbers.txt
index f250397d15..2b70316da4 100644
--- a/test/yarp/snapshots/seattlerb/ruby21_numbers.txt
+++ b/test/yarp/snapshots/seattlerb/ruby21_numbers.txt
@@ -1,12 +1,20 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [ArrayNode(0...13)(
-       [ImaginaryNode(1...3)(IntegerNode(1...2)()),
-        RationalNode(5...7)(IntegerNode(5...6)()),
-        ImaginaryNode(9...12)(RationalNode(9...11)(IntegerNode(9...10)()))],
-       (0...1),
-       (12...13)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...13))
+            ├── elements: (length: 3)
+            │   ├── @ ImaginaryNode (location: (1...3))
+            │   │   └── numeric:
+            │   │       @ IntegerNode (location: (1...2))
+            │   ├── @ RationalNode (location: (5...7))
+            │   │   └── numeric:
+            │   │       @ IntegerNode (location: (5...6))
+            │   └── @ ImaginaryNode (location: (9...12))
+            │       └── numeric:
+            │           @ RationalNode (location: (9...11))
+            │           └── numeric:
+            │               @ IntegerNode (location: (9...10))
+            ├── opening_loc: (0...1) = "["
+            └── closing_loc: (12...13) = "]"
diff --git a/test/yarp/snapshots/seattlerb/safe_attrasgn.txt b/test/yarp/snapshots/seattlerb/safe_attrasgn.txt
index a48f189f41..d6dc44e783 100644
--- a/test/yarp/snapshots/seattlerb/safe_attrasgn.txt
+++ b/test/yarp/snapshots/seattlerb/safe_attrasgn.txt
@@ -1,16 +1,28 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...8)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       ArgumentsNode(7...8)([IntegerNode(7...8)()]),
-       nil,
-       nil,
-       1,
-       "b="
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...8))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (7...8))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (7...8))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "b="
diff --git a/test/yarp/snapshots/seattlerb/safe_attrasgn_constant.txt b/test/yarp/snapshots/seattlerb/safe_attrasgn_constant.txt
index 8f51d30863..cd9163caab 100644
--- a/test/yarp/snapshots/seattlerb/safe_attrasgn_constant.txt
+++ b/test/yarp/snapshots/seattlerb/safe_attrasgn_constant.txt
@@ -1,16 +1,28 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...8)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       ArgumentsNode(7...8)([IntegerNode(7...8)()]),
-       nil,
-       nil,
-       1,
-       "B="
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...8))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = "B"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (7...8))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (7...8))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "B="
diff --git a/test/yarp/snapshots/seattlerb/safe_call.txt b/test/yarp/snapshots/seattlerb/safe_call.txt
index d170db0f55..281a3e3df6 100644
--- a/test/yarp/snapshots/seattlerb/safe_call.txt
+++ b/test/yarp/snapshots/seattlerb/safe_call.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [CallNode(0...4)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...4))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/safe_call_after_newline.txt b/test/yarp/snapshots/seattlerb/safe_call_after_newline.txt
index 0f48cd9867..530d8c3da9 100644
--- a/test/yarp/snapshots/seattlerb/safe_call_after_newline.txt
+++ b/test/yarp/snapshots/seattlerb/safe_call_after_newline.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (2...4),
-       (4...5),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (2...4) = "&."
+            ├── message_loc: (4...5) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/safe_call_dot_parens.txt b/test/yarp/snapshots/seattlerb/safe_call_dot_parens.txt
index 5800090fbb..be8bd5cc0e 100644
--- a/test/yarp/snapshots/seattlerb/safe_call_dot_parens.txt
+++ b/test/yarp/snapshots/seattlerb/safe_call_dot_parens.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [CallNode(0...5)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       nil,
-       (3...4),
-       nil,
-       (4...5),
-       nil,
-       1,
-       "call"
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...5))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: ∅
+            ├── opening_loc: (3...4) = "("
+            ├── arguments: ∅
+            ├── closing_loc: (4...5) = ")"
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "call"
diff --git a/test/yarp/snapshots/seattlerb/safe_call_newline.txt b/test/yarp/snapshots/seattlerb/safe_call_newline.txt
index d170db0f55..281a3e3df6 100644
--- a/test/yarp/snapshots/seattlerb/safe_call_newline.txt
+++ b/test/yarp/snapshots/seattlerb/safe_call_newline.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [CallNode(0...4)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...4))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/safe_call_operator.txt b/test/yarp/snapshots/seattlerb/safe_call_operator.txt
index 58df15db4a..ec378a7641 100644
--- a/test/yarp/snapshots/seattlerb/safe_call_operator.txt
+++ b/test/yarp/snapshots/seattlerb/safe_call_operator.txt
@@ -1,16 +1,28 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       ArgumentsNode(5...6)([IntegerNode(5...6)()]),
-       nil,
-       nil,
-       1,
-       ">"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = ">"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...6))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (5...6))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: ">"
diff --git a/test/yarp/snapshots/seattlerb/safe_call_rhs_newline.txt b/test/yarp/snapshots/seattlerb/safe_call_rhs_newline.txt
index 7785c7921e..a8580d80fd 100644
--- a/test/yarp/snapshots/seattlerb/safe_call_rhs_newline.txt
+++ b/test/yarp/snapshots/seattlerb/safe_call_rhs_newline.txt
@@ -1,22 +1,31 @@
-ProgramNode(0...8)(
-  [:c],
-  StatementsNode(0...8)(
-    [LocalVariableWriteNode(0...8)(
-       :c,
-       0,
-       (0...1),
-       CallNode(4...8)(
-         CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "a"),
-         (5...7),
-         (7...8),
-         nil,
-         nil,
-         nil,
-         nil,
-         1,
-         "b"
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: [:c]
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...8))
+            ├── name: :c
+            ├── depth: 0
+            ├── name_loc: (0...1) = "c"
+            ├── value:
+            │   @ CallNode (location: (4...8))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (4...5))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (4...5) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (5...7) = "&."
+            │   ├── message_loc: (7...8) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: safe_navigation
+            │   └── name: "b"
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/seattlerb/safe_calls.txt b/test/yarp/snapshots/seattlerb/safe_calls.txt
index 400667a354..200e53f644 100644
--- a/test/yarp/snapshots/seattlerb/safe_calls.txt
+++ b/test/yarp/snapshots/seattlerb/safe_calls.txt
@@ -1,26 +1,38 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [CallNode(0...10)(
-       CallNode(0...4)(
-         CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-         (1...3),
-         (3...4),
-         nil,
-         nil,
-         nil,
-         nil,
-         1,
-         "b"
-       ),
-       (4...6),
-       (6...7),
-       (7...8),
-       ArgumentsNode(8...9)([IntegerNode(8...9)()]),
-       (9...10),
-       nil,
-       1,
-       "c"
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...10))
+            ├── receiver:
+            │   @ CallNode (location: (0...4))
+            │   ├── receiver:
+            │   │   @ CallNode (location: (0...1))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (0...1) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "a"
+            │   ├── call_operator_loc: (1...3) = "&."
+            │   ├── message_loc: (3...4) = "b"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: safe_navigation
+            │   └── name: "b"
+            ├── call_operator_loc: (4...6) = "&."
+            ├── message_loc: (6...7) = "c"
+            ├── opening_loc: (7...8) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (8...9))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (8...9))
+            ├── closing_loc: (9...10) = ")"
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "c"
diff --git a/test/yarp/snapshots/seattlerb/safe_op_asgn.txt b/test/yarp/snapshots/seattlerb/safe_op_asgn.txt
index e5bc617610..d959a8789a 100644
--- a/test/yarp/snapshots/seattlerb/safe_op_asgn.txt
+++ b/test/yarp/snapshots/seattlerb/safe_op_asgn.txt
@@ -1,29 +1,41 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallOperatorWriteNode(0...11)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       1,
-       "b",
-       "b=",
-       :+,
-       (5...7),
-       CallNode(8...11)(
-         nil,
-         nil,
-         (8...9),
-         nil,
-         ArgumentsNode(10...11)([IntegerNode(10...11)()]),
-         nil,
-         nil,
-         0,
-         "x"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallOperatorWriteNode (location: (0...11))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: safe_navigation
+            ├── read_name: "b"
+            ├── write_name: "b="
+            ├── operator: :+
+            ├── operator_loc: (5...7) = "+="
+            └── value:
+                @ CallNode (location: (8...11))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (8...9) = "x"
+                ├── opening_loc: ∅
+                ├── arguments:
+                │   @ ArgumentsNode (location: (10...11))
+                │   └── arguments: (length: 1)
+                │       └── @ IntegerNode (location: (10...11))
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/safe_op_asgn2.txt b/test/yarp/snapshots/seattlerb/safe_op_asgn2.txt
index c1175989ae..3b6433287c 100644
--- a/test/yarp/snapshots/seattlerb/safe_op_asgn2.txt
+++ b/test/yarp/snapshots/seattlerb/safe_op_asgn2.txt
@@ -1,18 +1,37 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [CallOrWriteNode(0...10)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       1,
-       "b",
-       "b=",
-       (5...8),
-       CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "x")
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ CallOrWriteNode (location: (0...10))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: safe_navigation
+            ├── read_name: "b"
+            ├── write_name: "b="
+            ├── operator_loc: (5...8) = "||="
+            └── value:
+                @ CallNode (location: (9...10))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (9...10) = "x"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/slashy_newlines_within_string.txt b/test/yarp/snapshots/seattlerb/slashy_newlines_within_string.txt
index 1ef9123f4c..a158c983b9 100644
--- a/test/yarp/snapshots/seattlerb/slashy_newlines_within_string.txt
+++ b/test/yarp/snapshots/seattlerb/slashy_newlines_within_string.txt
@@ -1,36 +1,54 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [CallNode(0...33)(
-       nil,
-       nil,
-       (0...4),
-       nil,
-       ArgumentsNode(5...33)(
-         [StringNode(5...33)(
-            (5...6),
-            (6...32),
-            (32...33),
-            "hello my dear friend"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "puts"
-     ),
-     CallNode(35...40)(
-       CallNode(35...36)(nil, nil, (35...36), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (37...38),
-       nil,
-       ArgumentsNode(39...40)(
-         [CallNode(39...40)(nil, nil, (39...40), nil, nil, nil, nil, 2, "b")]
-       ),
-       nil,
-       nil,
-       0,
-       "+"
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...33))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...4) = "puts"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (5...33))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (5...33))
+        │   │           ├── opening_loc: (5...6) = "\""
+        │   │           ├── content_loc: (6...32) = "hello\\\n my\\\n dear\\\n friend"
+        │   │           ├── closing_loc: (32...33) = "\""
+        │   │           └── unescaped: "hello my dear friend"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "puts"
+        └── @ CallNode (location: (35...40))
+            ├── receiver:
+            │   @ CallNode (location: (35...36))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (35...36) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (37...38) = "+"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (39...40))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (39...40))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (39...40) = "b"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "b"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "+"
diff --git a/test/yarp/snapshots/seattlerb/stabby_arg_no_paren.txt b/test/yarp/snapshots/seattlerb/stabby_arg_no_paren.txt
index d999e4ea47..51bc081644 100644
--- a/test/yarp/snapshots/seattlerb/stabby_arg_no_paren.txt
+++ b/test/yarp/snapshots/seattlerb/stabby_arg_no_paren.txt
@@ -1,26 +1,27 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [LambdaNode(0...5)(
-       [:a],
-       (0...2),
-       (3...4),
-       (4...5),
-       BlockParametersNode(2...3)(
-         ParametersNode(2...3)(
-           [RequiredParameterNode(2...3)(:a)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         nil,
-         nil
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...5))
+            ├── locals: [:a]
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (3...4) = "{"
+            ├── closing_loc: (4...5) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (2...3))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (2...3))
+            │   │   ├── requireds: (length: 1)
+            │   │   │   └── @ RequiredParameterNode (location: (2...3))
+            │   │   │       └── name: :a
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 0)
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: ∅
+            │   └── closing_loc: ∅
+            └── body: ∅
diff --git a/test/yarp/snapshots/seattlerb/stabby_arg_opt_splat_arg_block_omfg.txt b/test/yarp/snapshots/seattlerb/stabby_arg_opt_splat_arg_block_omfg.txt
index fa7b9fe5a4..3faa5c69f0 100644
--- a/test/yarp/snapshots/seattlerb/stabby_arg_opt_splat_arg_block_omfg.txt
+++ b/test/yarp/snapshots/seattlerb/stabby_arg_opt_splat_arg_block_omfg.txt
@@ -1,31 +1,43 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [LambdaNode(0...23)(
-       [:b, :c, :d, :e, :f],
-       (0...2),
-       (21...22),
-       (22...23),
-       BlockParametersNode(2...21)(
-         ParametersNode(3...20)(
-           [RequiredParameterNode(3...4)(:b)],
-           [OptionalParameterNode(6...9)(
-              :c,
-              (6...7),
-              (7...8),
-              IntegerNode(8...9)()
-            )],
-           [RequiredParameterNode(15...16)(:e)],
-           RestParameterNode(11...13)(:d, (12...13), (11...12)),
-           [],
-           nil,
-           BlockParameterNode(18...20)(:f, (19...20), (18...19))
-         ),
-         [],
-         (2...3),
-         (20...21)
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...23))
+            ├── locals: [:b, :c, :d, :e, :f]
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (21...22) = "{"
+            ├── closing_loc: (22...23) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (2...21))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (3...20))
+            │   │   ├── requireds: (length: 1)
+            │   │   │   └── @ RequiredParameterNode (location: (3...4))
+            │   │   │       └── name: :b
+            │   │   ├── optionals: (length: 1)
+            │   │   │   └── @ OptionalParameterNode (location: (6...9))
+            │   │   │       ├── name: :c
+            │   │   │       ├── name_loc: (6...7) = "c"
+            │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │       └── value:
+            │   │   │           @ IntegerNode (location: (8...9))
+            │   │   ├── posts: (length: 1)
+            │   │   │   └── @ RequiredParameterNode (location: (15...16))
+            │   │   │       └── name: :e
+            │   │   ├── rest:
+            │   │   │   @ RestParameterNode (location: (11...13))
+            │   │   │   ├── name: :d
+            │   │   │   ├── name_loc: (12...13) = "d"
+            │   │   │   └── operator_loc: (11...12) = "*"
+            │   │   ├── keywords: (length: 0)
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block:
+            │   │       @ BlockParameterNode (location: (18...20))
+            │   │       ├── name: :f
+            │   │       ├── name_loc: (19...20) = "f"
+            │   │       └── operator_loc: (18...19) = "&"
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: (2...3) = "("
+            │   └── closing_loc: (20...21) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/seattlerb/stabby_block_iter_call.txt b/test/yarp/snapshots/seattlerb/stabby_block_iter_call.txt
index 719c895b99..a9ac1f2778 100644
--- a/test/yarp/snapshots/seattlerb/stabby_block_iter_call.txt
+++ b/test/yarp/snapshots/seattlerb/stabby_block_iter_call.txt
@@ -1,47 +1,57 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [CallNode(0...25)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...25)(
-         [LambdaNode(2...25)(
-            [],
-            (2...4),
-            (8...10),
-            (22...25),
-            BlockParametersNode(5...7)(nil, [], (5...6), (6...7)),
-            StatementsNode(11...21)(
-              [CallNode(11...21)(
-                 CallNode(11...12)(
-                   nil,
-                   nil,
-                   (11...12),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "a"
-                 ),
-                 (12...13),
-                 (13...14),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(15...21)([], nil, nil, (15...17), (18...21)),
-                 0,
-                 "b"
-               )]
-            )
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "x"
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...25))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "x"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...25))
+            │   └── arguments: (length: 1)
+            │       └── @ LambdaNode (location: (2...25))
+            │           ├── locals: []
+            │           ├── operator_loc: (2...4) = "->"
+            │           ├── opening_loc: (8...10) = "do"
+            │           ├── closing_loc: (22...25) = "end"
+            │           ├── parameters:
+            │           │   @ BlockParametersNode (location: (5...7))
+            │           │   ├── parameters: ∅
+            │           │   ├── locals: (length: 0)
+            │           │   ├── opening_loc: (5...6) = "("
+            │           │   └── closing_loc: (6...7) = ")"
+            │           └── body:
+            │               @ StatementsNode (location: (11...21))
+            │               └── body: (length: 1)
+            │                   └── @ CallNode (location: (11...21))
+            │                       ├── receiver:
+            │                       │   @ CallNode (location: (11...12))
+            │                       │   ├── receiver: ∅
+            │                       │   ├── call_operator_loc: ∅
+            │                       │   ├── message_loc: (11...12) = "a"
+            │                       │   ├── opening_loc: ∅
+            │                       │   ├── arguments: ∅
+            │                       │   ├── closing_loc: ∅
+            │                       │   ├── block: ∅
+            │                       │   ├── flags: variable_call
+            │                       │   └── name: "a"
+            │                       ├── call_operator_loc: (12...13) = "."
+            │                       ├── message_loc: (13...14) = "b"
+            │                       ├── opening_loc: ∅
+            │                       ├── arguments: ∅
+            │                       ├── closing_loc: ∅
+            │                       ├── block:
+            │                       │   @ BlockNode (location: (15...21))
+            │                       │   ├── locals: []
+            │                       │   ├── parameters: ∅
+            │                       │   ├── body: ∅
+            │                       │   ├── opening_loc: (15...17) = "do"
+            │                       │   └── closing_loc: (18...21) = "end"
+            │                       ├── flags: 
+            │                       └── name: "b"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/stabby_block_iter_call_no_target_with_arg.txt b/test/yarp/snapshots/seattlerb/stabby_block_iter_call_no_target_with_arg.txt
index 14b7a3eb98..d9ad0ec960 100644
--- a/test/yarp/snapshots/seattlerb/stabby_block_iter_call_no_target_with_arg.txt
+++ b/test/yarp/snapshots/seattlerb/stabby_block_iter_call_no_target_with_arg.txt
@@ -1,37 +1,50 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [CallNode(0...26)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...26)(
-         [LambdaNode(2...26)(
-            [],
-            (2...4),
-            (8...10),
-            (23...26),
-            BlockParametersNode(5...7)(nil, [], (5...6), (6...7)),
-            StatementsNode(11...22)(
-              [CallNode(11...22)(
-                 nil,
-                 nil,
-                 (11...12),
-                 (12...13),
-                 ArgumentsNode(13...14)([IntegerNode(13...14)()]),
-                 (14...15),
-                 BlockNode(16...22)([], nil, nil, (16...18), (19...22)),
-                 0,
-                 "a"
-               )]
-            )
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "x"
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...26))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "x"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...26))
+            │   └── arguments: (length: 1)
+            │       └── @ LambdaNode (location: (2...26))
+            │           ├── locals: []
+            │           ├── operator_loc: (2...4) = "->"
+            │           ├── opening_loc: (8...10) = "do"
+            │           ├── closing_loc: (23...26) = "end"
+            │           ├── parameters:
+            │           │   @ BlockParametersNode (location: (5...7))
+            │           │   ├── parameters: ∅
+            │           │   ├── locals: (length: 0)
+            │           │   ├── opening_loc: (5...6) = "("
+            │           │   └── closing_loc: (6...7) = ")"
+            │           └── body:
+            │               @ StatementsNode (location: (11...22))
+            │               └── body: (length: 1)
+            │                   └── @ CallNode (location: (11...22))
+            │                       ├── receiver: ∅
+            │                       ├── call_operator_loc: ∅
+            │                       ├── message_loc: (11...12) = "a"
+            │                       ├── opening_loc: (12...13) = "("
+            │                       ├── arguments:
+            │                       │   @ ArgumentsNode (location: (13...14))
+            │                       │   └── arguments: (length: 1)
+            │                       │       └── @ IntegerNode (location: (13...14))
+            │                       ├── closing_loc: (14...15) = ")"
+            │                       ├── block:
+            │                       │   @ BlockNode (location: (16...22))
+            │                       │   ├── locals: []
+            │                       │   ├── parameters: ∅
+            │                       │   ├── body: ∅
+            │                       │   ├── opening_loc: (16...18) = "do"
+            │                       │   └── closing_loc: (19...22) = "end"
+            │                       ├── flags: 
+            │                       └── name: "a"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/stabby_block_kw.txt b/test/yarp/snapshots/seattlerb/stabby_block_kw.txt
index ffb2033386..2b27573266 100644
--- a/test/yarp/snapshots/seattlerb/stabby_block_kw.txt
+++ b/test/yarp/snapshots/seattlerb/stabby_block_kw.txt
@@ -1,26 +1,30 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [LambdaNode(0...13)(
-       [:k],
-       (0...2),
-       (10...11),
-       (12...13),
-       BlockParametersNode(3...9)(
-         ParametersNode(4...8)(
-           [],
-           [],
-           [],
-           nil,
-           [KeywordParameterNode(4...8)(:k, (4...6), IntegerNode(6...8)())],
-           nil,
-           nil
-         ),
-         [],
-         (3...4),
-         (8...9)
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...13))
+            ├── locals: [:k]
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (10...11) = "{"
+            ├── closing_loc: (12...13) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (3...9))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (4...8))
+            │   │   ├── requireds: (length: 0)
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 1)
+            │   │   │   └── @ KeywordParameterNode (location: (4...8))
+            │   │   │       ├── name: :k
+            │   │   │       ├── name_loc: (4...6) = "k:"
+            │   │   │       └── value:
+            │   │   │           @ IntegerNode (location: (6...8))
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: (3...4) = "("
+            │   └── closing_loc: (8...9) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/seattlerb/stabby_block_kw__required.txt b/test/yarp/snapshots/seattlerb/stabby_block_kw__required.txt
index 3b1ba23e9d..5cd0f0f9da 100644
--- a/test/yarp/snapshots/seattlerb/stabby_block_kw__required.txt
+++ b/test/yarp/snapshots/seattlerb/stabby_block_kw__required.txt
@@ -1,26 +1,29 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [LambdaNode(0...11)(
-       [:k],
-       (0...2),
-       (8...9),
-       (10...11),
-       BlockParametersNode(3...7)(
-         ParametersNode(4...6)(
-           [],
-           [],
-           [],
-           nil,
-           [KeywordParameterNode(4...6)(:k, (4...6), nil)],
-           nil,
-           nil
-         ),
-         [],
-         (3...4),
-         (6...7)
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...11))
+            ├── locals: [:k]
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (8...9) = "{"
+            ├── closing_loc: (10...11) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (3...7))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (4...6))
+            │   │   ├── requireds: (length: 0)
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 1)
+            │   │   │   └── @ KeywordParameterNode (location: (4...6))
+            │   │   │       ├── name: :k
+            │   │   │       ├── name_loc: (4...6) = "k:"
+            │   │   │       └── value: ∅
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: (3...4) = "("
+            │   └── closing_loc: (6...7) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/seattlerb/stabby_proc_scope.txt b/test/yarp/snapshots/seattlerb/stabby_proc_scope.txt
index d8e06afa0f..bc4092827f 100644
--- a/test/yarp/snapshots/seattlerb/stabby_proc_scope.txt
+++ b/test/yarp/snapshots/seattlerb/stabby_proc_scope.txt
@@ -1,26 +1,29 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [LambdaNode(0...11)(
-       [:a, :b],
-       (0...2),
-       (9...10),
-       (10...11),
-       BlockParametersNode(2...8)(
-         ParametersNode(3...4)(
-           [RequiredParameterNode(3...4)(:a)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [BlockLocalVariableNode(6...7)(:b)],
-         (2...3),
-         (7...8)
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...11))
+            ├── locals: [:a, :b]
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (9...10) = "{"
+            ├── closing_loc: (10...11) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (2...8))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (3...4))
+            │   │   ├── requireds: (length: 1)
+            │   │   │   └── @ RequiredParameterNode (location: (3...4))
+            │   │   │       └── name: :a
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 0)
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 1)
+            │   │   └── @ BlockLocalVariableNode (location: (6...7))
+            │   │       └── name: :b
+            │   ├── opening_loc: (2...3) = "("
+            │   └── closing_loc: (7...8) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/seattlerb/str_backslashes.txt b/test/yarp/snapshots/seattlerb/str_backslashes.txt
index 8ad6906611..e394f85bca 100644
--- a/test/yarp/snapshots/seattlerb/str_backslashes.txt
+++ b/test/yarp/snapshots/seattlerb/str_backslashes.txt
@@ -1,23 +1,22 @@
-ProgramNode(0...204)(
-  [],
-  StatementsNode(0...204)(
-    [CallNode(0...204)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...204)(
-         [StringNode(2...204)(
-            (2...3),
-            (3...203),
-            (203...204),
-            "\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "x"
-     )]
-  )
-)
+@ ProgramNode (location: (0...204))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...204))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...204))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "x"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...204))
+            │   └── arguments: (length: 1)
+            │       └── @ StringNode (location: (2...204))
+            │           ├── opening_loc: (2...3) = "'"
+            │           ├── content_loc: (3...203) = "\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n"
+            │           ├── closing_loc: (203...204) = "'"
+            │           └── unescaped: "\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "x"
diff --git a/test/yarp/snapshots/seattlerb/str_double_double_escaped_newline.txt b/test/yarp/snapshots/seattlerb/str_double_double_escaped_newline.txt
index 2be5ea34e9..3692663d4b 100644
--- a/test/yarp/snapshots/seattlerb/str_double_double_escaped_newline.txt
+++ b/test/yarp/snapshots/seattlerb/str_double_double_escaped_newline.txt
@@ -1,19 +1,32 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...7)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...7)(
-         [StringNode(2...7)((2...3), (3...6), (6...7), "\\n")]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "b")]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...7))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...7))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (2...7))
+        │   │           ├── opening_loc: (2...3) = "\""
+        │   │           ├── content_loc: (3...6) = "\\\\n"
+        │   │           ├── closing_loc: (6...7) = "\""
+        │   │           └── unescaped: "\\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (8...9))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (8...9) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/str_double_escaped_newline.txt b/test/yarp/snapshots/seattlerb/str_double_escaped_newline.txt
index 7b724c6b80..12ae475914 100644
--- a/test/yarp/snapshots/seattlerb/str_double_escaped_newline.txt
+++ b/test/yarp/snapshots/seattlerb/str_double_escaped_newline.txt
@@ -1,19 +1,32 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...6)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...6)(
-         [StringNode(2...6)((2...3), (3...5), (5...6), "\n")]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "b")]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...6))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...6))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (2...6))
+        │   │           ├── opening_loc: (2...3) = "\""
+        │   │           ├── content_loc: (3...5) = "\\n"
+        │   │           ├── closing_loc: (5...6) = "\""
+        │   │           └── unescaped: "\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (7...8))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (7...8) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/str_double_newline.txt b/test/yarp/snapshots/seattlerb/str_double_newline.txt
index 6b7a3afb32..3f33e719f2 100644
--- a/test/yarp/snapshots/seattlerb/str_double_newline.txt
+++ b/test/yarp/snapshots/seattlerb/str_double_newline.txt
@@ -1,19 +1,32 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...5)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...5)(
-         [StringNode(2...5)((2...3), (3...4), (4...5), "\n")]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b")]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...5))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...5))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (2...5))
+        │   │           ├── opening_loc: (2...3) = "\""
+        │   │           ├── content_loc: (3...4) = "\n"
+        │   │           ├── closing_loc: (4...5) = "\""
+        │   │           └── unescaped: "\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (6...7))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (6...7) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/str_evstr.txt b/test/yarp/snapshots/seattlerb/str_evstr.txt
index 18d41a9b6a..f1ace3d195 100644
--- a/test/yarp/snapshots/seattlerb/str_evstr.txt
+++ b/test/yarp/snapshots/seattlerb/str_evstr.txt
@@ -1,17 +1,30 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [InterpolatedStringNode(0...8)(
-       (0...1),
-       [StringNode(1...3)(nil, (1...3), nil, "a "),
-        EmbeddedStatementsNode(3...7)(
-          (3...5),
-          StatementsNode(5...6)(
-            [CallNode(5...6)(nil, nil, (5...6), nil, nil, nil, nil, 2, "b")]
-          ),
-          (6...7)
-        )],
-       (7...8)
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...8))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 2)
+            │   ├── @ StringNode (location: (1...3))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (1...3) = "a "
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a "
+            │   └── @ EmbeddedStatementsNode (location: (3...7))
+            │       ├── opening_loc: (3...5) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (5...6))
+            │       │   └── body: (length: 1)
+            │       │       └── @ CallNode (location: (5...6))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (5...6) = "b"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments: ∅
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: variable_call
+            │       │           └── name: "b"
+            │       └── closing_loc: (6...7) = "}"
+            └── closing_loc: (7...8) = "\""
diff --git a/test/yarp/snapshots/seattlerb/str_evstr_escape.txt b/test/yarp/snapshots/seattlerb/str_evstr_escape.txt
index e95335e227..b100aff40e 100644
--- a/test/yarp/snapshots/seattlerb/str_evstr_escape.txt
+++ b/test/yarp/snapshots/seattlerb/str_evstr_escape.txt
@@ -1,18 +1,35 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [InterpolatedStringNode(0...16)(
-       (0...1),
-       [StringNode(1...3)(nil, (1...3), nil, "a "),
-        EmbeddedStatementsNode(3...7)(
-          (3...5),
-          StatementsNode(5...6)(
-            [CallNode(5...6)(nil, nil, (5...6), nil, nil, nil, nil, 2, "b")]
-          ),
-          (6...7)
-        ),
-        StringNode(7...15)(nil, (7...15), nil, "½")],
-       (15...16)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...16))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (1...3))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (1...3) = "a "
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a "
+            │   ├── @ EmbeddedStatementsNode (location: (3...7))
+            │   │   ├── opening_loc: (3...5) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (5...6))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (5...6))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (5...6) = "b"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "b"
+            │   │   └── closing_loc: (6...7) = "}"
+            │   └── @ StringNode (location: (7...15))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (7...15) = "\\302\\275"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "½"
+            └── closing_loc: (15...16) = "\""
diff --git a/test/yarp/snapshots/seattlerb/str_heredoc_interp.txt b/test/yarp/snapshots/seattlerb/str_heredoc_interp.txt
index 22f5a96755..f475cf505f 100644
--- a/test/yarp/snapshots/seattlerb/str_heredoc_interp.txt
+++ b/test/yarp/snapshots/seattlerb/str_heredoc_interp.txt
@@ -1,17 +1,30 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [InterpolatedStringNode(0...4)(
-       (0...4),
-       [EmbeddedStatementsNode(5...9)(
-          (5...7),
-          StatementsNode(7...8)(
-            [CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "x")]
-          ),
-          (8...9)
-        ),
-        StringNode(9...16)(nil, (9...16), nil, "\n" + "blah2\n")],
-       (16...17)
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...4))
+            ├── opening_loc: (0...4) = "<<\"\""
+            ├── parts: (length: 2)
+            │   ├── @ EmbeddedStatementsNode (location: (5...9))
+            │   │   ├── opening_loc: (5...7) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (7...8))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (7...8))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (7...8) = "x"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "x"
+            │   │   └── closing_loc: (8...9) = "}"
+            │   └── @ StringNode (location: (9...16))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (9...16) = "\nblah2\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\nblah2\n"
+            └── closing_loc: (16...17) = "\n"
diff --git a/test/yarp/snapshots/seattlerb/str_interp_ternary_or_label.txt b/test/yarp/snapshots/seattlerb/str_interp_ternary_or_label.txt
index d2ec64657f..997996ccc0 100644
--- a/test/yarp/snapshots/seattlerb/str_interp_ternary_or_label.txt
+++ b/test/yarp/snapshots/seattlerb/str_interp_ternary_or_label.txt
@@ -1,89 +1,98 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [InterpolatedStringNode(0...23)(
-       (0...1),
-       [EmbeddedStatementsNode(1...22)(
-          (1...3),
-          StatementsNode(3...21)(
-            [IfNode(3...21)(
-               nil,
-               CallNode(3...7)(
-                 CallNode(3...4)(
-                   nil,
-                   nil,
-                   (3...4),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "a"
-                 ),
-                 (4...5),
-                 (5...7),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 0,
-                 "b?"
-               ),
-               StatementsNode(10...17)(
-                 [CallNode(10...17)(
-                    CallNode(10...14)(
-                      StringNode(10...12)((10...11), (11...11), (11...12), ""),
-                      nil,
-                      (12...13),
-                      nil,
-                      ArgumentsNode(13...14)(
-                        [CallNode(13...14)(
-                           nil,
-                           nil,
-                           (13...14),
-                           nil,
-                           nil,
-                           nil,
-                           nil,
-                           2,
-                           "a"
-                         )]
-                      ),
-                      nil,
-                      nil,
-                      0,
-                      "+"
-                    ),
-                    nil,
-                    (14...15),
-                    nil,
-                    ArgumentsNode(15...17)(
-                      [StringNode(15...17)(
-                         (15...16),
-                         (16...16),
-                         (16...17),
-                         ""
-                       )]
-                    ),
-                    nil,
-                    nil,
-                    0,
-                    "+"
-                  )]
-               ),
-               ElseNode(17...21)(
-                 (17...18),
-                 StatementsNode(19...21)(
-                   [StringNode(19...21)((19...20), (20...20), (20...21), "")]
-                 ),
-                 nil
-               ),
-               nil
-             )]
-          ),
-          (21...22)
-        )],
-       (22...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...23))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 1)
+            │   └── @ EmbeddedStatementsNode (location: (1...22))
+            │       ├── opening_loc: (1...3) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (3...21))
+            │       │   └── body: (length: 1)
+            │       │       └── @ IfNode (location: (3...21))
+            │       │           ├── if_keyword_loc: ∅
+            │       │           ├── predicate:
+            │       │           │   @ CallNode (location: (3...7))
+            │       │           │   ├── receiver:
+            │       │           │   │   @ CallNode (location: (3...4))
+            │       │           │   │   ├── receiver: ∅
+            │       │           │   │   ├── call_operator_loc: ∅
+            │       │           │   │   ├── message_loc: (3...4) = "a"
+            │       │           │   │   ├── opening_loc: ∅
+            │       │           │   │   ├── arguments: ∅
+            │       │           │   │   ├── closing_loc: ∅
+            │       │           │   │   ├── block: ∅
+            │       │           │   │   ├── flags: variable_call
+            │       │           │   │   └── name: "a"
+            │       │           │   ├── call_operator_loc: (4...5) = "."
+            │       │           │   ├── message_loc: (5...7) = "b?"
+            │       │           │   ├── opening_loc: ∅
+            │       │           │   ├── arguments: ∅
+            │       │           │   ├── closing_loc: ∅
+            │       │           │   ├── block: ∅
+            │       │           │   ├── flags: 
+            │       │           │   └── name: "b?"
+            │       │           ├── statements:
+            │       │           │   @ StatementsNode (location: (10...17))
+            │       │           │   └── body: (length: 1)
+            │       │           │       └── @ CallNode (location: (10...17))
+            │       │           │           ├── receiver:
+            │       │           │           │   @ CallNode (location: (10...14))
+            │       │           │           │   ├── receiver:
+            │       │           │           │   │   @ StringNode (location: (10...12))
+            │       │           │           │   │   ├── opening_loc: (10...11) = "\""
+            │       │           │           │   │   ├── content_loc: (11...11) = ""
+            │       │           │           │   │   ├── closing_loc: (11...12) = "\""
+            │       │           │           │   │   └── unescaped: ""
+            │       │           │           │   ├── call_operator_loc: ∅
+            │       │           │           │   ├── message_loc: (12...13) = "+"
+            │       │           │           │   ├── opening_loc: ∅
+            │       │           │           │   ├── arguments:
+            │       │           │           │   │   @ ArgumentsNode (location: (13...14))
+            │       │           │           │   │   └── arguments: (length: 1)
+            │       │           │           │   │       └── @ CallNode (location: (13...14))
+            │       │           │           │   │           ├── receiver: ∅
+            │       │           │           │   │           ├── call_operator_loc: ∅
+            │       │           │           │   │           ├── message_loc: (13...14) = "a"
+            │       │           │           │   │           ├── opening_loc: ∅
+            │       │           │           │   │           ├── arguments: ∅
+            │       │           │           │   │           ├── closing_loc: ∅
+            │       │           │           │   │           ├── block: ∅
+            │       │           │           │   │           ├── flags: variable_call
+            │       │           │           │   │           └── name: "a"
+            │       │           │           │   ├── closing_loc: ∅
+            │       │           │           │   ├── block: ∅
+            │       │           │           │   ├── flags: 
+            │       │           │           │   └── name: "+"
+            │       │           │           ├── call_operator_loc: ∅
+            │       │           │           ├── message_loc: (14...15) = "+"
+            │       │           │           ├── opening_loc: ∅
+            │       │           │           ├── arguments:
+            │       │           │           │   @ ArgumentsNode (location: (15...17))
+            │       │           │           │   └── arguments: (length: 1)
+            │       │           │           │       └── @ StringNode (location: (15...17))
+            │       │           │           │           ├── opening_loc: (15...16) = "\""
+            │       │           │           │           ├── content_loc: (16...16) = ""
+            │       │           │           │           ├── closing_loc: (16...17) = "\""
+            │       │           │           │           └── unescaped: ""
+            │       │           │           ├── closing_loc: ∅
+            │       │           │           ├── block: ∅
+            │       │           │           ├── flags: 
+            │       │           │           └── name: "+"
+            │       │           ├── consequent:
+            │       │           │   @ ElseNode (location: (17...21))
+            │       │           │   ├── else_keyword_loc: (17...18) = ":"
+            │       │           │   ├── statements:
+            │       │           │   │   @ StatementsNode (location: (19...21))
+            │       │           │   │   └── body: (length: 1)
+            │       │           │   │       └── @ StringNode (location: (19...21))
+            │       │           │   │           ├── opening_loc: (19...20) = "\""
+            │       │           │   │           ├── content_loc: (20...20) = ""
+            │       │           │   │           ├── closing_loc: (20...21) = "\""
+            │       │           │   │           └── unescaped: ""
+            │       │           │   └── end_keyword_loc: ∅
+            │       │           └── end_keyword_loc: ∅
+            │       └── closing_loc: (21...22) = "}"
+            └── closing_loc: (22...23) = "\""
diff --git a/test/yarp/snapshots/seattlerb/str_lit_concat_bad_encodings.txt b/test/yarp/snapshots/seattlerb/str_lit_concat_bad_encodings.txt
index 350cc6b6b9..f40a3e6e88 100644
--- a/test/yarp/snapshots/seattlerb/str_lit_concat_bad_encodings.txt
+++ b/test/yarp/snapshots/seattlerb/str_lit_concat_bad_encodings.txt
@@ -1,19 +1,18 @@
-ProgramNode(0...131)(
-  [],
-  StatementsNode(0...131)(
-    [StringConcatNode(0...131)(
-       StringNode(0...62)(
-         (0...1),
-         (1...61),
-         (61...62),
-         "\xE3Ӌー\x83\xE3\x83コ\xA3\x82\x99"
-       ),
-       StringNode(73...131)(
-         (73...74),
-         (74...130),
-         (130...131),
-         "ンパý;foo@bar.com"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...131))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...131))
+    └── body: (length: 1)
+        └── @ StringConcatNode (location: (0...131))
+            ├── left:
+            │   @ StringNode (location: (0...62))
+            │   ├── opening_loc: (0...1) = "\""
+            │   ├── content_loc: (1...61) = "\\xE3\\xD3\\x8B\\xE3\\x83\\xBC\\x83\\xE3\\x83\\xE3\\x82\\xB3\\xA3\\x82\\x99"
+            │   ├── closing_loc: (61...62) = "\""
+            │   └── unescaped: "\xE3Ӌー\x83\xE3\x83コ\xA3\x82\x99"
+            └── right:
+                @ StringNode (location: (73...131))
+                ├── opening_loc: (73...74) = "\""
+                ├── content_loc: (74...130) = "\\xE3\\x83\\xB3\\xE3\\x83\\x8F\\xE3\\x82\\x9A\\xC3\\xBD;foo@bar.com"
+                ├── closing_loc: (130...131) = "\""
+                └── unescaped: "ンパý;foo@bar.com"
diff --git a/test/yarp/snapshots/seattlerb/str_newline_hash_line_number.txt b/test/yarp/snapshots/seattlerb/str_newline_hash_line_number.txt
index e56d74eed7..866fcf3b6a 100644
--- a/test/yarp/snapshots/seattlerb/str_newline_hash_line_number.txt
+++ b/test/yarp/snapshots/seattlerb/str_newline_hash_line_number.txt
@@ -1,12 +1,11 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [StringNode(0...11)(
-       (0...1),
-       (1...10),
-       (10...11),
-       "\n" + "\n" + "\n" + "\n" + "#"
-     ),
-     IntegerNode(12...13)()]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 2)
+        ├── @ StringNode (location: (0...11))
+        │   ├── opening_loc: (0...1) = "\""
+        │   ├── content_loc: (1...10) = "\\n\\n\\n\\n#"
+        │   ├── closing_loc: (10...11) = "\""
+        │   └── unescaped: "\n\n\n\n#"
+        └── @ IntegerNode (location: (12...13))
diff --git a/test/yarp/snapshots/seattlerb/str_pct_Q_nested.txt b/test/yarp/snapshots/seattlerb/str_pct_Q_nested.txt
index 613e85a088..a3e778ad19 100644
--- a/test/yarp/snapshots/seattlerb/str_pct_Q_nested.txt
+++ b/test/yarp/snapshots/seattlerb/str_pct_Q_nested.txt
@@ -1,28 +1,35 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [InterpolatedStringNode(0...26)(
-       (0...3),
-       [StringNode(3...11)(nil, (3...11), nil, "before ["),
-        EmbeddedStatementsNode(11...18)(
-          (11...13),
-          StatementsNode(13...17)(
-            [CallNode(13...17)(
-               nil,
-               nil,
-               (13...17),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "nest"
-             )]
-          ),
-          (17...18)
-        ),
-        StringNode(18...25)(nil, (18...25), nil, "] after")],
-       (25...26)
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...26))
+            ├── opening_loc: (0...3) = "%Q["
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (3...11))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (3...11) = "before ["
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "before ["
+            │   ├── @ EmbeddedStatementsNode (location: (11...18))
+            │   │   ├── opening_loc: (11...13) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (13...17))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (13...17))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (13...17) = "nest"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "nest"
+            │   │   └── closing_loc: (17...18) = "}"
+            │   └── @ StringNode (location: (18...25))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (18...25) = "] after"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "] after"
+            └── closing_loc: (25...26) = "]"
diff --git a/test/yarp/snapshots/seattlerb/str_pct_nested_nested.txt b/test/yarp/snapshots/seattlerb/str_pct_nested_nested.txt
index b615b691cc..017c71f38e 100644
--- a/test/yarp/snapshots/seattlerb/str_pct_nested_nested.txt
+++ b/test/yarp/snapshots/seattlerb/str_pct_nested_nested.txt
@@ -1,26 +1,36 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [InterpolatedStringNode(0...20)(
-       (0...2),
-       [StringNode(2...5)(nil, (2...5), nil, " { "),
-        EmbeddedStatementsNode(5...16)(
-          (5...7),
-          StatementsNode(8...14)(
-            [InterpolatedStringNode(8...14)(
-               (8...9),
-               [EmbeddedStatementsNode(9...13)(
-                  (9...11),
-                  StatementsNode(11...12)([IntegerNode(11...12)()]),
-                  (12...13)
-                )],
-               (13...14)
-             )]
-          ),
-          (15...16)
-        ),
-        StringNode(16...19)(nil, (16...19), nil, " } ")],
-       (19...20)
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...20))
+            ├── opening_loc: (0...2) = "%{"
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (2...5))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (2...5) = " { "
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: " { "
+            │   ├── @ EmbeddedStatementsNode (location: (5...16))
+            │   │   ├── opening_loc: (5...7) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (8...14))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ InterpolatedStringNode (location: (8...14))
+            │   │   │           ├── opening_loc: (8...9) = "\""
+            │   │   │           ├── parts: (length: 1)
+            │   │   │           │   └── @ EmbeddedStatementsNode (location: (9...13))
+            │   │   │           │       ├── opening_loc: (9...11) = "\#{"
+            │   │   │           │       ├── statements:
+            │   │   │           │       │   @ StatementsNode (location: (11...12))
+            │   │   │           │       │   └── body: (length: 1)
+            │   │   │           │       │       └── @ IntegerNode (location: (11...12))
+            │   │   │           │       └── closing_loc: (12...13) = "}"
+            │   │   │           └── closing_loc: (13...14) = "\""
+            │   │   └── closing_loc: (15...16) = "}"
+            │   └── @ StringNode (location: (16...19))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (16...19) = " } "
+            │       ├── closing_loc: ∅
+            │       └── unescaped: " } "
+            └── closing_loc: (19...20) = "}"
diff --git a/test/yarp/snapshots/seattlerb/str_pct_q.txt b/test/yarp/snapshots/seattlerb/str_pct_q.txt
index be3f92365c..cd31f859fe 100644
--- a/test/yarp/snapshots/seattlerb/str_pct_q.txt
+++ b/test/yarp/snapshots/seattlerb/str_pct_q.txt
@@ -1,6 +1,10 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [StringNode(0...9)((0...3), (3...8), (8...9), "a b c")]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ StringNode (location: (0...9))
+            ├── opening_loc: (0...3) = "%q{"
+            ├── content_loc: (3...8) = "a b c"
+            ├── closing_loc: (8...9) = "}"
+            └── unescaped: "a b c"
diff --git a/test/yarp/snapshots/seattlerb/str_single_double_escaped_newline.txt b/test/yarp/snapshots/seattlerb/str_single_double_escaped_newline.txt
index 2be5ea34e9..3a899e072a 100644
--- a/test/yarp/snapshots/seattlerb/str_single_double_escaped_newline.txt
+++ b/test/yarp/snapshots/seattlerb/str_single_double_escaped_newline.txt
@@ -1,19 +1,32 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...7)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...7)(
-         [StringNode(2...7)((2...3), (3...6), (6...7), "\\n")]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "b")]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...7))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...7))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (2...7))
+        │   │           ├── opening_loc: (2...3) = "'"
+        │   │           ├── content_loc: (3...6) = "\\\\n"
+        │   │           ├── closing_loc: (6...7) = "'"
+        │   │           └── unescaped: "\\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (8...9))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (8...9) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/str_single_escaped_newline.txt b/test/yarp/snapshots/seattlerb/str_single_escaped_newline.txt
index d97f1ce016..49b8315856 100644
--- a/test/yarp/snapshots/seattlerb/str_single_escaped_newline.txt
+++ b/test/yarp/snapshots/seattlerb/str_single_escaped_newline.txt
@@ -1,19 +1,32 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...6)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...6)(
-         [StringNode(2...6)((2...3), (3...5), (5...6), "\\n")]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "b")]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...6))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...6))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (2...6))
+        │   │           ├── opening_loc: (2...3) = "'"
+        │   │           ├── content_loc: (3...5) = "\\n"
+        │   │           ├── closing_loc: (5...6) = "'"
+        │   │           └── unescaped: "\\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (7...8))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (7...8) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/str_single_newline.txt b/test/yarp/snapshots/seattlerb/str_single_newline.txt
index 6b7a3afb32..a8db423693 100644
--- a/test/yarp/snapshots/seattlerb/str_single_newline.txt
+++ b/test/yarp/snapshots/seattlerb/str_single_newline.txt
@@ -1,19 +1,32 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...5)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...5)(
-         [StringNode(2...5)((2...3), (3...4), (4...5), "\n")]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b")]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...5))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...5))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (2...5))
+        │   │           ├── opening_loc: (2...3) = "'"
+        │   │           ├── content_loc: (3...4) = "\n"
+        │   │           ├── closing_loc: (4...5) = "'"
+        │   │           └── unescaped: "\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (6...7))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (6...7) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "b"
diff --git a/test/yarp/snapshots/seattlerb/str_str.txt b/test/yarp/snapshots/seattlerb/str_str.txt
index 964ac52f5f..284e99cbdb 100644
--- a/test/yarp/snapshots/seattlerb/str_str.txt
+++ b/test/yarp/snapshots/seattlerb/str_str.txt
@@ -1,17 +1,25 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [InterpolatedStringNode(0...10)(
-       (0...1),
-       [StringNode(1...3)(nil, (1...3), nil, "a "),
-        EmbeddedStatementsNode(3...9)(
-          (3...5),
-          StatementsNode(5...8)(
-            [StringNode(5...8)((5...6), (6...7), (7...8), "b")]
-          ),
-          (8...9)
-        )],
-       (9...10)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...10))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 2)
+            │   ├── @ StringNode (location: (1...3))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (1...3) = "a "
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a "
+            │   └── @ EmbeddedStatementsNode (location: (3...9))
+            │       ├── opening_loc: (3...5) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (5...8))
+            │       │   └── body: (length: 1)
+            │       │       └── @ StringNode (location: (5...8))
+            │       │           ├── opening_loc: (5...6) = "'"
+            │       │           ├── content_loc: (6...7) = "b"
+            │       │           ├── closing_loc: (7...8) = "'"
+            │       │           └── unescaped: "b"
+            │       └── closing_loc: (8...9) = "}"
+            └── closing_loc: (9...10) = "\""
diff --git a/test/yarp/snapshots/seattlerb/str_str_str.txt b/test/yarp/snapshots/seattlerb/str_str_str.txt
index f7ca61b950..a4b624a4b2 100644
--- a/test/yarp/snapshots/seattlerb/str_str_str.txt
+++ b/test/yarp/snapshots/seattlerb/str_str_str.txt
@@ -1,18 +1,30 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [InterpolatedStringNode(0...12)(
-       (0...1),
-       [StringNode(1...3)(nil, (1...3), nil, "a "),
-        EmbeddedStatementsNode(3...9)(
-          (3...5),
-          StatementsNode(5...8)(
-            [StringNode(5...8)((5...6), (6...7), (7...8), "b")]
-          ),
-          (8...9)
-        ),
-        StringNode(9...11)(nil, (9...11), nil, " c")],
-       (11...12)
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...12))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (1...3))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (1...3) = "a "
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a "
+            │   ├── @ EmbeddedStatementsNode (location: (3...9))
+            │   │   ├── opening_loc: (3...5) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (5...8))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ StringNode (location: (5...8))
+            │   │   │           ├── opening_loc: (5...6) = "'"
+            │   │   │           ├── content_loc: (6...7) = "b"
+            │   │   │           ├── closing_loc: (7...8) = "'"
+            │   │   │           └── unescaped: "b"
+            │   │   └── closing_loc: (8...9) = "}"
+            │   └── @ StringNode (location: (9...11))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (9...11) = " c"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: " c"
+            └── closing_loc: (11...12) = "\""
diff --git a/test/yarp/snapshots/seattlerb/super_arg.txt b/test/yarp/snapshots/seattlerb/super_arg.txt
index 3885dbac14..df6a2b23f6 100644
--- a/test/yarp/snapshots/seattlerb/super_arg.txt
+++ b/test/yarp/snapshots/seattlerb/super_arg.txt
@@ -1,12 +1,14 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [SuperNode(0...8)(
-       (0...5),
-       nil,
-       ArgumentsNode(6...8)([IntegerNode(6...8)()]),
-       nil,
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ SuperNode (location: (0...8))
+            ├── keyword_loc: (0...5) = "super"
+            ├── lparen_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (6...8))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (6...8))
+            ├── rparen_loc: ∅
+            └── block: ∅
diff --git a/test/yarp/snapshots/seattlerb/symbol_empty.txt b/test/yarp/snapshots/seattlerb/symbol_empty.txt
index f299d17642..aef1e821a2 100644
--- a/test/yarp/snapshots/seattlerb/symbol_empty.txt
+++ b/test/yarp/snapshots/seattlerb/symbol_empty.txt
@@ -1,4 +1,10 @@
-ProgramNode(0...3)(
-  [],
-  StatementsNode(0...3)([SymbolNode(0...3)((0...2), (2...2), (2...3), "")])
-)
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ SymbolNode (location: (0...3))
+            ├── opening_loc: (0...2) = ":'"
+            ├── value_loc: (2...2) = ""
+            ├── closing_loc: (2...3) = "'"
+            └── unescaped: ""
diff --git a/test/yarp/snapshots/seattlerb/symbol_list.txt b/test/yarp/snapshots/seattlerb/symbol_list.txt
index 386ac609df..06739f6f9e 100644
--- a/test/yarp/snapshots/seattlerb/symbol_list.txt
+++ b/test/yarp/snapshots/seattlerb/symbol_list.txt
@@ -1,41 +1,49 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [ArrayNode(0...13)(
-       [InterpolatedSymbolNode(3...7)(
-          nil,
-          [EmbeddedStatementsNode(3...7)(
-             (3...5),
-             StatementsNode(5...6)(
-               [CallNode(5...6)(nil, nil, (5...6), nil, nil, nil, nil, 2, "a")]
-             ),
-             (6...7)
-           )],
-          nil
-        ),
-        InterpolatedSymbolNode(8...12)(
-          nil,
-          [EmbeddedStatementsNode(8...12)(
-             (8...10),
-             StatementsNode(10...11)(
-               [CallNode(10...11)(
-                  nil,
-                  nil,
-                  (10...11),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "b"
-                )]
-             ),
-             (11...12)
-           )],
-          nil
-        )],
-       (0...3),
-       (12...13)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...13))
+            ├── elements: (length: 2)
+            │   ├── @ InterpolatedSymbolNode (location: (3...7))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── parts: (length: 1)
+            │   │   │   └── @ EmbeddedStatementsNode (location: (3...7))
+            │   │   │       ├── opening_loc: (3...5) = "\#{"
+            │   │   │       ├── statements:
+            │   │   │       │   @ StatementsNode (location: (5...6))
+            │   │   │       │   └── body: (length: 1)
+            │   │   │       │       └── @ CallNode (location: (5...6))
+            │   │   │       │           ├── receiver: ∅
+            │   │   │       │           ├── call_operator_loc: ∅
+            │   │   │       │           ├── message_loc: (5...6) = "a"
+            │   │   │       │           ├── opening_loc: ∅
+            │   │   │       │           ├── arguments: ∅
+            │   │   │       │           ├── closing_loc: ∅
+            │   │   │       │           ├── block: ∅
+            │   │   │       │           ├── flags: variable_call
+            │   │   │       │           └── name: "a"
+            │   │   │       └── closing_loc: (6...7) = "}"
+            │   │   └── closing_loc: ∅
+            │   └── @ InterpolatedSymbolNode (location: (8...12))
+            │       ├── opening_loc: ∅
+            │       ├── parts: (length: 1)
+            │       │   └── @ EmbeddedStatementsNode (location: (8...12))
+            │       │       ├── opening_loc: (8...10) = "\#{"
+            │       │       ├── statements:
+            │       │       │   @ StatementsNode (location: (10...11))
+            │       │       │   └── body: (length: 1)
+            │       │       │       └── @ CallNode (location: (10...11))
+            │       │       │           ├── receiver: ∅
+            │       │       │           ├── call_operator_loc: ∅
+            │       │       │           ├── message_loc: (10...11) = "b"
+            │       │       │           ├── opening_loc: ∅
+            │       │       │           ├── arguments: ∅
+            │       │       │           ├── closing_loc: ∅
+            │       │       │           ├── block: ∅
+            │       │       │           ├── flags: variable_call
+            │       │       │           └── name: "b"
+            │       │       └── closing_loc: (11...12) = "}"
+            │       └── closing_loc: ∅
+            ├── opening_loc: (0...3) = "%I["
+            └── closing_loc: (12...13) = "]"
diff --git a/test/yarp/snapshots/seattlerb/symbols.txt b/test/yarp/snapshots/seattlerb/symbols.txt
index 7cf54611c2..9a246f0f89 100644
--- a/test/yarp/snapshots/seattlerb/symbols.txt
+++ b/test/yarp/snapshots/seattlerb/symbols.txt
@@ -1,12 +1,24 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [ArrayNode(0...9)(
-       [SymbolNode(3...4)(nil, (3...4), nil, "a"),
-        SymbolNode(5...6)(nil, (5...6), nil, "b"),
-        SymbolNode(7...8)(nil, (7...8), nil, "c")],
-       (0...3),
-       (8...9)
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...9))
+            ├── elements: (length: 3)
+            │   ├── @ SymbolNode (location: (3...4))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (3...4) = "a"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a"
+            │   ├── @ SymbolNode (location: (5...6))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (5...6) = "b"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "b"
+            │   └── @ SymbolNode (location: (7...8))
+            │       ├── opening_loc: ∅
+            │       ├── value_loc: (7...8) = "c"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "c"
+            ├── opening_loc: (0...3) = "%i("
+            └── closing_loc: (8...9) = ")"
diff --git a/test/yarp/snapshots/seattlerb/symbols_empty.txt b/test/yarp/snapshots/seattlerb/symbols_empty.txt
index cad298895b..c6a1b95da1 100644
--- a/test/yarp/snapshots/seattlerb/symbols_empty.txt
+++ b/test/yarp/snapshots/seattlerb/symbols_empty.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)([ArrayNode(0...4)([], (0...3), (3...4))])
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...4))
+            ├── elements: (length: 0)
+            ├── opening_loc: (0...3) = "%i("
+            └── closing_loc: (3...4) = ")"
diff --git a/test/yarp/snapshots/seattlerb/symbols_empty_space.txt b/test/yarp/snapshots/seattlerb/symbols_empty_space.txt
index 6713c4ba71..70b316e03c 100644
--- a/test/yarp/snapshots/seattlerb/symbols_empty_space.txt
+++ b/test/yarp/snapshots/seattlerb/symbols_empty_space.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)([ArrayNode(0...5)([], (0...3), (4...5))])
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...5))
+            ├── elements: (length: 0)
+            ├── opening_loc: (0...3) = "%i("
+            └── closing_loc: (4...5) = ")"
diff --git a/test/yarp/snapshots/seattlerb/symbols_interp.txt b/test/yarp/snapshots/seattlerb/symbols_interp.txt
index 2aa2914312..424f4d2693 100644
--- a/test/yarp/snapshots/seattlerb/symbols_interp.txt
+++ b/test/yarp/snapshots/seattlerb/symbols_interp.txt
@@ -1,12 +1,24 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [ArrayNode(0...15)(
-       [SymbolNode(3...4)(nil, (3...4), nil, "a"),
-        SymbolNode(5...12)(nil, (5...12), nil, "b\#{1+1}"),
-        SymbolNode(13...14)(nil, (13...14), nil, "c")],
-       (0...3),
-       (14...15)
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...15))
+            ├── elements: (length: 3)
+            │   ├── @ SymbolNode (location: (3...4))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (3...4) = "a"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "a"
+            │   ├── @ SymbolNode (location: (5...12))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (5...12) = "b\#{1+1}"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "b\#{1+1}"
+            │   └── @ SymbolNode (location: (13...14))
+            │       ├── opening_loc: ∅
+            │       ├── value_loc: (13...14) = "c"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "c"
+            ├── opening_loc: (0...3) = "%i("
+            └── closing_loc: (14...15) = ")"
diff --git a/test/yarp/snapshots/seattlerb/thingy.txt b/test/yarp/snapshots/seattlerb/thingy.txt
index 929dd9fd96..8ca331af09 100644
--- a/test/yarp/snapshots/seattlerb/thingy.txt
+++ b/test/yarp/snapshots/seattlerb/thingy.txt
@@ -1,27 +1,51 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...6)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "f"),
-       (1...2),
-       nil,
-       (2...3),
-       ArgumentsNode(3...5)([IntegerNode(3...5)()]),
-       (5...6),
-       nil,
-       0,
-       "call"
-     ),
-     CallNode(8...15)(
-       CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "f"),
-       (9...11),
-       nil,
-       (11...12),
-       ArgumentsNode(12...14)([IntegerNode(12...14)()]),
-       (14...15),
-       nil,
-       0,
-       "call"
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...6))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...1))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...1) = "f"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "f"
+        │   ├── call_operator_loc: (1...2) = "."
+        │   ├── message_loc: ∅
+        │   ├── opening_loc: (2...3) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (3...5))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (3...5))
+        │   ├── closing_loc: (5...6) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "call"
+        └── @ CallNode (location: (8...15))
+            ├── receiver:
+            │   @ CallNode (location: (8...9))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (8...9) = "f"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "f"
+            ├── call_operator_loc: (9...11) = "::"
+            ├── message_loc: ∅
+            ├── opening_loc: (11...12) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (12...14))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (12...14))
+            ├── closing_loc: (14...15) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "call"
diff --git a/test/yarp/snapshots/seattlerb/uminus_float.txt b/test/yarp/snapshots/seattlerb/uminus_float.txt
index fe6bbc4150..0c02dd89b2 100644
--- a/test/yarp/snapshots/seattlerb/uminus_float.txt
+++ b/test/yarp/snapshots/seattlerb/uminus_float.txt
@@ -1 +1,6 @@
-ProgramNode(0...4)([], StatementsNode(0...4)([FloatNode(0...4)()]))
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ FloatNode (location: (0...4))
diff --git a/test/yarp/snapshots/seattlerb/unary_minus.txt b/test/yarp/snapshots/seattlerb/unary_minus.txt
index 8f5ed5003c..1be09f754e 100644
--- a/test/yarp/snapshots/seattlerb/unary_minus.txt
+++ b/test/yarp/snapshots/seattlerb/unary_minus.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...2)(
-  [],
-  StatementsNode(0...2)(
-    [CallNode(0...2)(
-       CallNode(1...2)(nil, nil, (1...2), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "-@"
-     )]
-  )
-)
+@ ProgramNode (location: (0...2))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...2))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...2))
+            ├── receiver:
+            │   @ CallNode (location: (1...2))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (1...2) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "-"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "-@"
diff --git a/test/yarp/snapshots/seattlerb/unary_plus.txt b/test/yarp/snapshots/seattlerb/unary_plus.txt
index 6d74a2b362..7452abcb4f 100644
--- a/test/yarp/snapshots/seattlerb/unary_plus.txt
+++ b/test/yarp/snapshots/seattlerb/unary_plus.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...2)(
-  [],
-  StatementsNode(0...2)(
-    [CallNode(0...2)(
-       CallNode(1...2)(nil, nil, (1...2), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "+@"
-     )]
-  )
-)
+@ ProgramNode (location: (0...2))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...2))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...2))
+            ├── receiver:
+            │   @ CallNode (location: (1...2))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (1...2) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "+"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "+@"
diff --git a/test/yarp/snapshots/seattlerb/unary_plus_on_literal.txt b/test/yarp/snapshots/seattlerb/unary_plus_on_literal.txt
index 08370e47e9..e467fcded7 100644
--- a/test/yarp/snapshots/seattlerb/unary_plus_on_literal.txt
+++ b/test/yarp/snapshots/seattlerb/unary_plus_on_literal.txt
@@ -1,16 +1,20 @@
-ProgramNode(0...3)(
-  [],
-  StatementsNode(0...3)(
-    [CallNode(0...3)(
-       SymbolNode(1...3)((1...2), (2...3), nil, "a"),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "+@"
-     )]
-  )
-)
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...3))
+            ├── receiver:
+            │   @ SymbolNode (location: (1...3))
+            │   ├── opening_loc: (1...2) = ":"
+            │   ├── value_loc: (2...3) = "a"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "+"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "+@"
diff --git a/test/yarp/snapshots/seattlerb/unary_tilde.txt b/test/yarp/snapshots/seattlerb/unary_tilde.txt
index 8ec6e9145f..4cbe0ba9d3 100644
--- a/test/yarp/snapshots/seattlerb/unary_tilde.txt
+++ b/test/yarp/snapshots/seattlerb/unary_tilde.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...2)(
-  [],
-  StatementsNode(0...2)(
-    [CallNode(0...2)(
-       CallNode(1...2)(nil, nil, (1...2), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "~"
-     )]
-  )
-)
+@ ProgramNode (location: (0...2))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...2))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...2))
+            ├── receiver:
+            │   @ CallNode (location: (1...2))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (1...2) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "~"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "~"
diff --git a/test/yarp/snapshots/seattlerb/utf8_bom.txt b/test/yarp/snapshots/seattlerb/utf8_bom.txt
index 81f1227688..073913e179 100644
--- a/test/yarp/snapshots/seattlerb/utf8_bom.txt
+++ b/test/yarp/snapshots/seattlerb/utf8_bom.txt
@@ -1,16 +1,18 @@
-ProgramNode(26...29)(
-  [],
-  StatementsNode(26...29)(
-    [CallNode(26...29)(
-       nil,
-       nil,
-       (26...27),
-       nil,
-       ArgumentsNode(28...29)([IntegerNode(28...29)()]),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (26...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (26...29))
+    └── body: (length: 1)
+        └── @ CallNode (location: (26...29))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (26...27) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (28...29))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (28...29))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/seattlerb/when_splat.txt b/test/yarp/snapshots/seattlerb/when_splat.txt
index 75e44cd75d..330f3aa83d 100644
--- a/test/yarp/snapshots/seattlerb/when_splat.txt
+++ b/test/yarp/snapshots/seattlerb/when_splat.txt
@@ -1,19 +1,38 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [CaseNode(0...25)(
-       CallNode(5...6)(nil, nil, (5...6), nil, nil, nil, nil, 2, "a"),
-       [WhenNode(8...15)(
-          (8...12),
-          [SplatNode(13...15)(
-             (13...14),
-             CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "b")
-           )],
-          nil
-        )],
-       nil,
-       (0...4),
-       (22...25)
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...25))
+            ├── predicate:
+            │   @ CallNode (location: (5...6))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (5...6) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (8...15))
+            │       ├── keyword_loc: (8...12) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ SplatNode (location: (13...15))
+            │       │       ├── operator_loc: (13...14) = "*"
+            │       │       └── expression:
+            │       │           @ CallNode (location: (14...15))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (14...15) = "b"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments: ∅
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: variable_call
+            │       │           └── name: "b"
+            │       └── statements: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (22...25) = "end"
diff --git a/test/yarp/snapshots/seattlerb/words_interp.txt b/test/yarp/snapshots/seattlerb/words_interp.txt
index 982de5f806..4113afea82 100644
--- a/test/yarp/snapshots/seattlerb/words_interp.txt
+++ b/test/yarp/snapshots/seattlerb/words_interp.txt
@@ -1,19 +1,25 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [ArrayNode(0...9)(
-       [InterpolatedStringNode(3...8)(
-          nil,
-          [EmbeddedStatementsNode(3...7)(
-             (3...5),
-             StatementsNode(5...6)([IntegerNode(5...6)()]),
-             (6...7)
-           ),
-           StringNode(7...8)(nil, (7...8), nil, "b")],
-          nil
-        )],
-       (0...3),
-       (8...9)
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...9))
+            ├── elements: (length: 1)
+            │   └── @ InterpolatedStringNode (location: (3...8))
+            │       ├── opening_loc: ∅
+            │       ├── parts: (length: 2)
+            │       │   ├── @ EmbeddedStatementsNode (location: (3...7))
+            │       │   │   ├── opening_loc: (3...5) = "\#{"
+            │       │   │   ├── statements:
+            │       │   │   │   @ StatementsNode (location: (5...6))
+            │       │   │   │   └── body: (length: 1)
+            │       │   │   │       └── @ IntegerNode (location: (5...6))
+            │       │   │   └── closing_loc: (6...7) = "}"
+            │       │   └── @ StringNode (location: (7...8))
+            │       │       ├── opening_loc: ∅
+            │       │       ├── content_loc: (7...8) = "b"
+            │       │       ├── closing_loc: ∅
+            │       │       └── unescaped: "b"
+            │       └── closing_loc: ∅
+            ├── opening_loc: (0...3) = "%W("
+            └── closing_loc: (8...9) = ")"
diff --git a/test/yarp/snapshots/seattlerb/yield_arg.txt b/test/yarp/snapshots/seattlerb/yield_arg.txt
index 8fa3535617..f9cd7e6929 100644
--- a/test/yarp/snapshots/seattlerb/yield_arg.txt
+++ b/test/yarp/snapshots/seattlerb/yield_arg.txt
@@ -1,11 +1,13 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [YieldNode(0...8)(
-       (0...5),
-       nil,
-       ArgumentsNode(6...8)([IntegerNode(6...8)()]),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ YieldNode (location: (0...8))
+            ├── keyword_loc: (0...5) = "yield"
+            ├── lparen_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (6...8))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (6...8))
+            └── rparen_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/yield_call_assocs.txt b/test/yarp/snapshots/seattlerb/yield_call_assocs.txt
index 820afa6c08..67148ed6fa 100644
--- a/test/yarp/snapshots/seattlerb/yield_call_assocs.txt
+++ b/test/yarp/snapshots/seattlerb/yield_call_assocs.txt
@@ -1,154 +1,184 @@
-ProgramNode(0...100)(
-  [],
-  StatementsNode(0...100)(
-    [YieldNode(0...16)(
-       (0...5),
-       nil,
-       ArgumentsNode(6...16)(
-         [IntegerNode(6...7)(),
-          KeywordHashNode(9...16)(
-            [AssocNode(9...16)(
-               SymbolNode(9...11)((9...10), (10...11), nil, "z"),
-               IntegerNode(15...16)(),
-               (12...14)
-             )]
-          )]
-       ),
-       nil
-     ),
-     YieldNode(18...43)(
-       (18...23),
-       nil,
-       ArgumentsNode(24...43)(
-         [IntegerNode(24...25)(),
-          KeywordHashNode(27...43)(
-            [AssocNode(27...34)(
-               SymbolNode(27...29)((27...28), (28...29), nil, "z"),
-               IntegerNode(33...34)(),
-               (30...32)
-             ),
-             AssocNode(36...43)(
-               SymbolNode(36...38)((36...37), (37...38), nil, "w"),
-               IntegerNode(42...43)(),
-               (39...41)
-             )]
-          )]
-       ),
-       nil
-     ),
-     YieldNode(45...58)(
-       (45...50),
-       nil,
-       ArgumentsNode(51...58)(
-         [CallNode(51...58)(
-            nil,
-            nil,
-            (51...52),
-            nil,
-            ArgumentsNode(53...58)(
-              [KeywordHashNode(53...58)(
-                 [AssocNode(53...58)(
-                    SymbolNode(53...55)((53...54), (54...55), nil, "z"),
-                    IntegerNode(57...58)(),
-                    (55...57)
-                  )]
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "y"
-          )]
-       ),
-       nil
-     ),
-     YieldNode(60...71)(
-       (60...65),
-       nil,
-       ArgumentsNode(66...71)(
-         [CallNode(66...71)(
-            nil,
-            nil,
-            (66...67),
-            nil,
-            ArgumentsNode(68...71)(
-              [KeywordHashNode(68...71)(
-                 [AssocNode(68...71)(
-                    SymbolNode(68...70)(nil, (68...69), (69...70), "z"),
-                    IntegerNode(70...71)(),
-                    nil
-                  )]
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "y"
-          )]
-       ),
-       nil
-     ),
-     YieldNode(73...85)(
-       (73...78),
-       nil,
-       ArgumentsNode(79...85)(
-         [CallNode(79...85)(
-            nil,
-            nil,
-            (79...80),
-            (80...81),
-            ArgumentsNode(81...84)(
-              [KeywordHashNode(81...84)(
-                 [AssocNode(81...84)(
-                    SymbolNode(81...83)(nil, (81...82), (82...83), "z"),
-                    IntegerNode(83...84)(),
-                    nil
-                  )]
-               )]
-            ),
-            (84...85),
-            nil,
-            0,
-            "y"
-          )]
-       ),
-       nil
-     ),
-     YieldNode(87...100)(
-       (87...92),
-       nil,
-       ArgumentsNode(93...100)(
-         [CallNode(93...100)(
-            nil,
-            nil,
-            (93...94),
-            (94...95),
-            ArgumentsNode(95...99)(
-              [KeywordHashNode(95...99)(
-                 [AssocNode(95...99)(
-                    CallNode(95...96)(
-                      nil,
-                      nil,
-                      (95...96),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "z"
-                    ),
-                    IntegerNode(98...99)(),
-                    (96...98)
-                  )]
-               )]
-            ),
-            (99...100),
-            nil,
-            0,
-            "y"
-          )]
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...100))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...100))
+    └── body: (length: 6)
+        ├── @ YieldNode (location: (0...16))
+        │   ├── keyword_loc: (0...5) = "yield"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (6...16))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ IntegerNode (location: (6...7))
+        │   │       └── @ KeywordHashNode (location: (9...16))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (9...16))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (9...11))
+        │   │                   │   ├── opening_loc: (9...10) = ":"
+        │   │                   │   ├── value_loc: (10...11) = "z"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "z"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (15...16))
+        │   │                   └── operator_loc: (12...14) = "=>"
+        │   └── rparen_loc: ∅
+        ├── @ YieldNode (location: (18...43))
+        │   ├── keyword_loc: (18...23) = "yield"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (24...43))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ IntegerNode (location: (24...25))
+        │   │       └── @ KeywordHashNode (location: (27...43))
+        │   │           └── elements: (length: 2)
+        │   │               ├── @ AssocNode (location: (27...34))
+        │   │               │   ├── key:
+        │   │               │   │   @ SymbolNode (location: (27...29))
+        │   │               │   │   ├── opening_loc: (27...28) = ":"
+        │   │               │   │   ├── value_loc: (28...29) = "z"
+        │   │               │   │   ├── closing_loc: ∅
+        │   │               │   │   └── unescaped: "z"
+        │   │               │   ├── value:
+        │   │               │   │   @ IntegerNode (location: (33...34))
+        │   │               │   └── operator_loc: (30...32) = "=>"
+        │   │               └── @ AssocNode (location: (36...43))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (36...38))
+        │   │                   │   ├── opening_loc: (36...37) = ":"
+        │   │                   │   ├── value_loc: (37...38) = "w"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "w"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (42...43))
+        │   │                   └── operator_loc: (39...41) = "=>"
+        │   └── rparen_loc: ∅
+        ├── @ YieldNode (location: (45...58))
+        │   ├── keyword_loc: (45...50) = "yield"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (51...58))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (51...58))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (51...52) = "y"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (53...58))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ KeywordHashNode (location: (53...58))
+        │   │           │           └── elements: (length: 1)
+        │   │           │               └── @ AssocNode (location: (53...58))
+        │   │           │                   ├── key:
+        │   │           │                   │   @ SymbolNode (location: (53...55))
+        │   │           │                   │   ├── opening_loc: (53...54) = ":"
+        │   │           │                   │   ├── value_loc: (54...55) = "z"
+        │   │           │                   │   ├── closing_loc: ∅
+        │   │           │                   │   └── unescaped: "z"
+        │   │           │                   ├── value:
+        │   │           │                   │   @ IntegerNode (location: (57...58))
+        │   │           │                   └── operator_loc: (55...57) = "=>"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "y"
+        │   └── rparen_loc: ∅
+        ├── @ YieldNode (location: (60...71))
+        │   ├── keyword_loc: (60...65) = "yield"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (66...71))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (66...71))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (66...67) = "y"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (68...71))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ KeywordHashNode (location: (68...71))
+        │   │           │           └── elements: (length: 1)
+        │   │           │               └── @ AssocNode (location: (68...71))
+        │   │           │                   ├── key:
+        │   │           │                   │   @ SymbolNode (location: (68...70))
+        │   │           │                   │   ├── opening_loc: ∅
+        │   │           │                   │   ├── value_loc: (68...69) = "z"
+        │   │           │                   │   ├── closing_loc: (69...70) = ":"
+        │   │           │                   │   └── unescaped: "z"
+        │   │           │                   ├── value:
+        │   │           │                   │   @ IntegerNode (location: (70...71))
+        │   │           │                   └── operator_loc: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "y"
+        │   └── rparen_loc: ∅
+        ├── @ YieldNode (location: (73...85))
+        │   ├── keyword_loc: (73...78) = "yield"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (79...85))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (79...85))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (79...80) = "y"
+        │   │           ├── opening_loc: (80...81) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (81...84))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ KeywordHashNode (location: (81...84))
+        │   │           │           └── elements: (length: 1)
+        │   │           │               └── @ AssocNode (location: (81...84))
+        │   │           │                   ├── key:
+        │   │           │                   │   @ SymbolNode (location: (81...83))
+        │   │           │                   │   ├── opening_loc: ∅
+        │   │           │                   │   ├── value_loc: (81...82) = "z"
+        │   │           │                   │   ├── closing_loc: (82...83) = ":"
+        │   │           │                   │   └── unescaped: "z"
+        │   │           │                   ├── value:
+        │   │           │                   │   @ IntegerNode (location: (83...84))
+        │   │           │                   └── operator_loc: ∅
+        │   │           ├── closing_loc: (84...85) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "y"
+        │   └── rparen_loc: ∅
+        └── @ YieldNode (location: (87...100))
+            ├── keyword_loc: (87...92) = "yield"
+            ├── lparen_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (93...100))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (93...100))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (93...94) = "y"
+            │           ├── opening_loc: (94...95) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (95...99))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ KeywordHashNode (location: (95...99))
+            │           │           └── elements: (length: 1)
+            │           │               └── @ AssocNode (location: (95...99))
+            │           │                   ├── key:
+            │           │                   │   @ CallNode (location: (95...96))
+            │           │                   │   ├── receiver: ∅
+            │           │                   │   ├── call_operator_loc: ∅
+            │           │                   │   ├── message_loc: (95...96) = "z"
+            │           │                   │   ├── opening_loc: ∅
+            │           │                   │   ├── arguments: ∅
+            │           │                   │   ├── closing_loc: ∅
+            │           │                   │   ├── block: ∅
+            │           │                   │   ├── flags: variable_call
+            │           │                   │   └── name: "z"
+            │           │                   ├── value:
+            │           │                   │   @ IntegerNode (location: (98...99))
+            │           │                   └── operator_loc: (96...98) = "=>"
+            │           ├── closing_loc: (99...100) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "y"
+            └── rparen_loc: ∅
diff --git a/test/yarp/snapshots/seattlerb/yield_empty_parens.txt b/test/yarp/snapshots/seattlerb/yield_empty_parens.txt
index 14871f50e7..94c15c2ffc 100644
--- a/test/yarp/snapshots/seattlerb/yield_empty_parens.txt
+++ b/test/yarp/snapshots/seattlerb/yield_empty_parens.txt
@@ -1,4 +1,10 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)([YieldNode(0...7)((0...5), (5...6), nil, (6...7))])
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ YieldNode (location: (0...7))
+            ├── keyword_loc: (0...5) = "yield"
+            ├── lparen_loc: (5...6) = "("
+            ├── arguments: ∅
+            └── rparen_loc: (6...7) = ")"
diff --git a/test/yarp/snapshots/single_quote_heredocs.txt b/test/yarp/snapshots/single_quote_heredocs.txt
index 13e0f12fac..c69bdf39fc 100644
--- a/test/yarp/snapshots/single_quote_heredocs.txt
+++ b/test/yarp/snapshots/single_quote_heredocs.txt
@@ -1,15 +1,14 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [InterpolatedStringNode(0...8)(
-       (0...8),
-       [StringNode(9...44)(
-          nil,
-          (9...44),
-          nil,
-          "    cd L:\\Work\\MG3710IQPro\\Develop\n"
-        )],
-       (44...48)
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...8))
+            ├── opening_loc: (0...8) = "<<-'EOS'"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (9...44))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (9...44) = "    cd L:\\Work\\MG3710IQPro\\Develop\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "    cd L:\\Work\\MG3710IQPro\\Develop\n"
+            └── closing_loc: (44...48) = "EOS\n"
diff --git a/test/yarp/snapshots/spanning_heredoc.txt b/test/yarp/snapshots/spanning_heredoc.txt
index 301c70adf2..9d35b06eac 100644
--- a/test/yarp/snapshots/spanning_heredoc.txt
+++ b/test/yarp/snapshots/spanning_heredoc.txt
@@ -1,215 +1,311 @@
-ProgramNode(164...964)(
-  [],
-  StatementsNode(164...964)(
-    [CallNode(164...192)(
-       nil,
-       nil,
-       (164...166),
-       nil,
-       ArgumentsNode(167...192)(
-         [CallNode(167...192)(
-            InterpolatedStringNode(167...171)(
-              (167...171),
-              [StringNode(181...183)(nil, (181...183), nil, "a\n")],
-              (183...185)
-            ),
-            (171...172),
-            (172...176),
-            (176...177),
-            ArgumentsNode(177...191)(
-              [InterpolatedRegularExpressionNode(177...187)(
-                 (177...178),
-                 [StringNode(178...181)(nil, (178...181), nil, "b"),
-                  StringNode(185...186)(nil, (185...186), nil, "b")],
-                 (186...187),
-                 0
-               ),
-               StringNode(189...191)(
-                 (189...190),
-                 (190...190),
-                 (190...191),
-                 ""
-               )]
-            ),
-            (191...192),
-            nil,
-            0,
-            "gsub"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "pp"
-     ),
-     CallNode(276...295)(
-       nil,
-       nil,
-       (276...278),
-       nil,
-       ArgumentsNode(279...295)(
-         [InterpolatedStringNode(279...283)(
-            (279...283),
-            [StringNode(289...291)(nil, (289...291), nil, "c\n")],
-            (291...293)
-          ),
-          InterpolatedStringNode(285...295)(
-            (285...286),
-            [StringNode(286...289)(nil, (286...289), nil, "d"),
-             StringNode(293...294)(nil, (293...294), nil, "d")],
-            (294...295)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "pp"
-     ),
-     CallNode(322...343)(
-       nil,
-       nil,
-       (322...324),
-       nil,
-       ArgumentsNode(325...343)(
-         [InterpolatedStringNode(325...329)(
-            (325...329),
-            [StringNode(337...339)(nil, (337...339), nil, "e\n")],
-            (339...341)
-          ),
-          InterpolatedStringNode(331...343)(
-            (331...334),
-            [StringNode(334...337)(nil, (334...337), nil, "f\\\n"),
-             StringNode(341...342)(nil, (341...342), nil, "f")],
-            (342...343)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "pp"
-     ),
-     CallNode(427...448)(
-       nil,
-       nil,
-       (427...429),
-       nil,
-       ArgumentsNode(430...448)(
-         [InterpolatedStringNode(430...434)(
-            (430...434),
-            [StringNode(442...444)(nil, (442...444), nil, "g\n")],
-            (444...446)
-          ),
-          InterpolatedStringNode(436...448)(
-            (436...439),
-            [StringNode(439...442)(nil, (439...442), nil, "h"),
-             StringNode(446...447)(nil, (446...447), nil, "h")],
-            (447...448)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "pp"
-     ),
-     CallNode(520...541)(
-       nil,
-       nil,
-       (520...522),
-       nil,
-       ArgumentsNode(523...541)(
-         [InterpolatedStringNode(523...527)(
-            (523...527),
-            [StringNode(535...537)(nil, (535...537), nil, "i\n")],
-            (537...539)
-          ),
-          ArrayNode(529...541)(
-            [StringNode(532...535)(nil, (532...535), nil, "j\\\n"),
-             StringNode(539...540)(nil, (539...540), nil, "j")],
-            (529...532),
-            (540...541)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "pp"
-     ),
-     CallNode(688...709)(
-       nil,
-       nil,
-       (688...690),
-       nil,
-       ArgumentsNode(691...709)(
-         [InterpolatedStringNode(691...695)(
-            (691...695),
-            [StringNode(703...705)(nil, (703...705), nil, "k\n")],
-            (705...707)
-          ),
-          ArrayNode(697...709)(
-            [InterpolatedStringNode(700...708)(
-               nil,
-               [StringNode(700...703)(nil, (700...703), nil, "l"),
-                StringNode(707...708)(nil, (707...708), nil, "l")],
-               nil
-             )],
-            (697...700),
-            (708...709)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "pp"
-     ),
-     CallNode(781...802)(
-       nil,
-       nil,
-       (781...783),
-       nil,
-       ArgumentsNode(784...802)(
-         [InterpolatedStringNode(784...788)(
-            (784...788),
-            [StringNode(796...798)(nil, (796...798), nil, "m\n")],
-            (798...800)
-          ),
-          ArrayNode(790...802)(
-            [SymbolNode(793...796)(nil, (793...796), nil, "n\\\n"),
-             SymbolNode(800...801)(nil, (800...801), nil, "n")],
-            (790...793),
-            (801...802)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "pp"
-     ),
-     CallNode(943...964)(
-       nil,
-       nil,
-       (943...945),
-       nil,
-       ArgumentsNode(946...964)(
-         [InterpolatedStringNode(946...950)(
-            (946...950),
-            [StringNode(958...960)(nil, (958...960), nil, "o\n")],
-            (960...962)
-          ),
-          ArrayNode(952...964)(
-            [InterpolatedSymbolNode(955...963)(
-               nil,
-               [SymbolNode(955...958)(nil, (955...958), nil, "p"),
-                StringNode(962...963)(nil, (962...963), nil, "p")],
-               nil
-             )],
-            (952...955),
-            (963...964)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "pp"
-     )]
-  )
-)
+@ ProgramNode (location: (164...964))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (164...964))
+    └── body: (length: 8)
+        ├── @ CallNode (location: (164...192))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (164...166) = "pp"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (167...192))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (167...192))
+        │   │           ├── receiver:
+        │   │           │   @ InterpolatedStringNode (location: (167...171))
+        │   │           │   ├── opening_loc: (167...171) = "<<-A"
+        │   │           │   ├── parts: (length: 1)
+        │   │           │   │   └── @ StringNode (location: (181...183))
+        │   │           │   │       ├── opening_loc: ∅
+        │   │           │   │       ├── content_loc: (181...183) = "a\n"
+        │   │           │   │       ├── closing_loc: ∅
+        │   │           │   │       └── unescaped: "a\n"
+        │   │           │   └── closing_loc: (183...185) = "A\n"
+        │   │           ├── call_operator_loc: (171...172) = "."
+        │   │           ├── message_loc: (172...176) = "gsub"
+        │   │           ├── opening_loc: (176...177) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (177...191))
+        │   │           │   └── arguments: (length: 2)
+        │   │           │       ├── @ InterpolatedRegularExpressionNode (location: (177...187))
+        │   │           │       │   ├── opening_loc: (177...178) = "/"
+        │   │           │       │   ├── parts: (length: 2)
+        │   │           │       │   │   ├── @ StringNode (location: (178...181))
+        │   │           │       │   │   │   ├── opening_loc: ∅
+        │   │           │       │   │   │   ├── content_loc: (178...181) = "b\\\n"
+        │   │           │       │   │   │   ├── closing_loc: ∅
+        │   │           │       │   │   │   └── unescaped: "b"
+        │   │           │       │   │   └── @ StringNode (location: (185...186))
+        │   │           │       │   │       ├── opening_loc: ∅
+        │   │           │       │   │       ├── content_loc: (185...186) = "b"
+        │   │           │       │   │       ├── closing_loc: ∅
+        │   │           │       │   │       └── unescaped: "b"
+        │   │           │       │   ├── closing_loc: (186...187) = "/"
+        │   │           │       │   └── flags: 
+        │   │           │       └── @ StringNode (location: (189...191))
+        │   │           │           ├── opening_loc: (189...190) = "\""
+        │   │           │           ├── content_loc: (190...190) = ""
+        │   │           │           ├── closing_loc: (190...191) = "\""
+        │   │           │           └── unescaped: ""
+        │   │           ├── closing_loc: (191...192) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "gsub"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "pp"
+        ├── @ CallNode (location: (276...295))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (276...278) = "pp"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (279...295))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ InterpolatedStringNode (location: (279...283))
+        │   │       │   ├── opening_loc: (279...283) = "<<-A"
+        │   │       │   ├── parts: (length: 1)
+        │   │       │   │   └── @ StringNode (location: (289...291))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (289...291) = "c\n"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "c\n"
+        │   │       │   └── closing_loc: (291...293) = "A\n"
+        │   │       └── @ InterpolatedStringNode (location: (285...295))
+        │   │           ├── opening_loc: (285...286) = "\""
+        │   │           ├── parts: (length: 2)
+        │   │           │   ├── @ StringNode (location: (286...289))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (286...289) = "d\\\n"
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "d"
+        │   │           │   └── @ StringNode (location: (293...294))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (293...294) = "d"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "d"
+        │   │           └── closing_loc: (294...295) = "\""
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "pp"
+        ├── @ CallNode (location: (322...343))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (322...324) = "pp"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (325...343))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ InterpolatedStringNode (location: (325...329))
+        │   │       │   ├── opening_loc: (325...329) = "<<-A"
+        │   │       │   ├── parts: (length: 1)
+        │   │       │   │   └── @ StringNode (location: (337...339))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (337...339) = "e\n"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "e\n"
+        │   │       │   └── closing_loc: (339...341) = "A\n"
+        │   │       └── @ InterpolatedStringNode (location: (331...343))
+        │   │           ├── opening_loc: (331...334) = "%q["
+        │   │           ├── parts: (length: 2)
+        │   │           │   ├── @ StringNode (location: (334...337))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (334...337) = "f\\\n"
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "f\\\n"
+        │   │           │   └── @ StringNode (location: (341...342))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (341...342) = "f"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "f"
+        │   │           └── closing_loc: (342...343) = "]"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "pp"
+        ├── @ CallNode (location: (427...448))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (427...429) = "pp"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (430...448))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ InterpolatedStringNode (location: (430...434))
+        │   │       │   ├── opening_loc: (430...434) = "<<-A"
+        │   │       │   ├── parts: (length: 1)
+        │   │       │   │   └── @ StringNode (location: (442...444))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (442...444) = "g\n"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "g\n"
+        │   │       │   └── closing_loc: (444...446) = "A\n"
+        │   │       └── @ InterpolatedStringNode (location: (436...448))
+        │   │           ├── opening_loc: (436...439) = "%Q["
+        │   │           ├── parts: (length: 2)
+        │   │           │   ├── @ StringNode (location: (439...442))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (439...442) = "h\\\n"
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "h"
+        │   │           │   └── @ StringNode (location: (446...447))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (446...447) = "h"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "h"
+        │   │           └── closing_loc: (447...448) = "]"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "pp"
+        ├── @ CallNode (location: (520...541))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (520...522) = "pp"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (523...541))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ InterpolatedStringNode (location: (523...527))
+        │   │       │   ├── opening_loc: (523...527) = "<<-A"
+        │   │       │   ├── parts: (length: 1)
+        │   │       │   │   └── @ StringNode (location: (535...537))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (535...537) = "i\n"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "i\n"
+        │   │       │   └── closing_loc: (537...539) = "A\n"
+        │   │       └── @ ArrayNode (location: (529...541))
+        │   │           ├── elements: (length: 2)
+        │   │           │   ├── @ StringNode (location: (532...535))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (532...535) = "j\\\n"
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "j\\\n"
+        │   │           │   └── @ StringNode (location: (539...540))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (539...540) = "j"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "j"
+        │   │           ├── opening_loc: (529...532) = "%w["
+        │   │           └── closing_loc: (540...541) = "]"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "pp"
+        ├── @ CallNode (location: (688...709))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (688...690) = "pp"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (691...709))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ InterpolatedStringNode (location: (691...695))
+        │   │       │   ├── opening_loc: (691...695) = "<<-A"
+        │   │       │   ├── parts: (length: 1)
+        │   │       │   │   └── @ StringNode (location: (703...705))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (703...705) = "k\n"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "k\n"
+        │   │       │   └── closing_loc: (705...707) = "A\n"
+        │   │       └── @ ArrayNode (location: (697...709))
+        │   │           ├── elements: (length: 1)
+        │   │           │   └── @ InterpolatedStringNode (location: (700...708))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── parts: (length: 2)
+        │   │           │       │   ├── @ StringNode (location: (700...703))
+        │   │           │       │   │   ├── opening_loc: ∅
+        │   │           │       │   │   ├── content_loc: (700...703) = "l\\\n"
+        │   │           │       │   │   ├── closing_loc: ∅
+        │   │           │       │   │   └── unescaped: "l"
+        │   │           │       │   └── @ StringNode (location: (707...708))
+        │   │           │       │       ├── opening_loc: ∅
+        │   │           │       │       ├── content_loc: (707...708) = "l"
+        │   │           │       │       ├── closing_loc: ∅
+        │   │           │       │       └── unescaped: "l"
+        │   │           │       └── closing_loc: ∅
+        │   │           ├── opening_loc: (697...700) = "%W["
+        │   │           └── closing_loc: (708...709) = "]"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "pp"
+        ├── @ CallNode (location: (781...802))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (781...783) = "pp"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (784...802))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ InterpolatedStringNode (location: (784...788))
+        │   │       │   ├── opening_loc: (784...788) = "<<-A"
+        │   │       │   ├── parts: (length: 1)
+        │   │       │   │   └── @ StringNode (location: (796...798))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (796...798) = "m\n"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "m\n"
+        │   │       │   └── closing_loc: (798...800) = "A\n"
+        │   │       └── @ ArrayNode (location: (790...802))
+        │   │           ├── elements: (length: 2)
+        │   │           │   ├── @ SymbolNode (location: (793...796))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── value_loc: (793...796) = "n\\\n"
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "n\\\n"
+        │   │           │   └── @ SymbolNode (location: (800...801))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── value_loc: (800...801) = "n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "n"
+        │   │           ├── opening_loc: (790...793) = "%i["
+        │   │           └── closing_loc: (801...802) = "]"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "pp"
+        └── @ CallNode (location: (943...964))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (943...945) = "pp"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (946...964))
+            │   └── arguments: (length: 2)
+            │       ├── @ InterpolatedStringNode (location: (946...950))
+            │       │   ├── opening_loc: (946...950) = "<<-A"
+            │       │   ├── parts: (length: 1)
+            │       │   │   └── @ StringNode (location: (958...960))
+            │       │   │       ├── opening_loc: ∅
+            │       │   │       ├── content_loc: (958...960) = "o\n"
+            │       │   │       ├── closing_loc: ∅
+            │       │   │       └── unescaped: "o\n"
+            │       │   └── closing_loc: (960...962) = "A\n"
+            │       └── @ ArrayNode (location: (952...964))
+            │           ├── elements: (length: 1)
+            │           │   └── @ InterpolatedSymbolNode (location: (955...963))
+            │           │       ├── opening_loc: ∅
+            │           │       ├── parts: (length: 2)
+            │           │       │   ├── @ SymbolNode (location: (955...958))
+            │           │       │   │   ├── opening_loc: ∅
+            │           │       │   │   ├── value_loc: (955...958) = "p\\\n"
+            │           │       │   │   ├── closing_loc: ∅
+            │           │       │   │   └── unescaped: "p"
+            │           │       │   └── @ StringNode (location: (962...963))
+            │           │       │       ├── opening_loc: ∅
+            │           │       │       ├── content_loc: (962...963) = "p"
+            │           │       │       ├── closing_loc: ∅
+            │           │       │       └── unescaped: "p"
+            │           │       └── closing_loc: ∅
+            │           ├── opening_loc: (952...955) = "%I["
+            │           └── closing_loc: (963...964) = "]"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "pp"
diff --git a/test/yarp/snapshots/strings.txt b/test/yarp/snapshots/strings.txt
index ca98151c14..25825b6715 100644
--- a/test/yarp/snapshots/strings.txt
+++ b/test/yarp/snapshots/strings.txt
@@ -1,201 +1,431 @@
-ProgramNode(0...498)(
-  [],
-  StatementsNode(0...498)(
-    [StringNode(0...6)((0...2), (2...5), (5...6), "abc"),
-     StringNode(8...14)((8...10), (10...13), (13...14), "abc"),
-     StringNode(16...22)((16...18), (18...21), (21...22), "abc"),
-     StringNode(24...30)((24...26), (26...29), (29...30), "abc"),
-     StringNode(32...38)((32...34), (34...37), (37...38), "abc"),
-     StringNode(40...46)((40...42), (42...45), (45...46), "abc"),
-     StringNode(48...54)((48...50), (50...53), (53...54), "abc"),
-     StringNode(56...62)((56...58), (58...61), (61...62), "abc"),
-     StringNode(64...70)((64...66), (66...69), (69...70), "abc"),
-     StringNode(72...78)((72...74), (74...77), (77...78), "abc"),
-     StringNode(80...86)((80...82), (82...85), (85...86), "abc"),
-     StringNode(88...94)((88...90), (90...93), (93...94), "abc"),
-     ArrayNode(96...104)([], (96...99), (103...104)),
-     StringNode(106...112)((106...108), (108...111), (111...112), "abc"),
-     StringNode(114...120)((114...116), (116...119), (119...120), "abc"),
-     InterpolatedStringNode(122...130)(
-       (122...123),
-       [EmbeddedVariableNode(123...129)(
-          (123...124),
-          ClassVariableReadNode(124...129)(:@@foo)
-        )],
-       (129...130)
-     ),
-     StringNode(132...138)((132...134), (134...137), (137...138), "abc"),
-     InterpolatedStringNode(140...157)(
-       (140...142),
-       [StringNode(142...146)(nil, (142...146), nil, "aaa "),
-        EmbeddedStatementsNode(146...152)(
-          (146...148),
-          StatementsNode(148...151)(
-            [CallNode(148...151)(
-               nil,
-               nil,
-               (148...151),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bbb"
-             )]
-          ),
-          (151...152)
-        ),
-        StringNode(152...156)(nil, (152...156), nil, " ccc")],
-       (156...157)
-     ),
-     StringNode(159...167)((159...161), (161...166), (166...167), "foo[]"),
-     CallNode(169...184)(
-       StringNode(169...174)((169...170), (170...173), (173...174), "foo"),
-       nil,
-       (175...176),
-       nil,
-       ArgumentsNode(179...184)(
-         [StringNode(179...184)((179...180), (180...183), (183...184), "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     StringNode(186...193)((186...189), (189...192), (192...193), "abc"),
-     SymbolNode(195...202)((195...198), (198...201), (201...202), "abc"),
-     StringNode(204...210)((204...206), (206...209), (209...210), "abc"),
-     StringNode(212...214)((212...213), (213...213), (213...214), ""),
-     StringNode(216...221)((216...217), (217...220), (220...221), "abc"),
-     StringNode(223...230)((223...224), (224...229), (229...230), "\#@---"),
-     InterpolatedStringNode(232...248)(
-       (232...233),
-       [StringNode(233...237)(nil, (233...237), nil, "aaa "),
-        EmbeddedStatementsNode(237...243)(
-          (237...239),
-          StatementsNode(239...242)(
-            [CallNode(239...242)(
-               nil,
-               nil,
-               (239...242),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bbb"
-             )]
-          ),
-          (242...243)
-        ),
-        StringNode(243...247)(nil, (243...247), nil, " ccc")],
-       (247...248)
-     ),
-     StringNode(250...255)((250...251), (251...254), (254...255), "abc"),
-     ArrayNode(257...266)(
-       [StringNode(260...261)(nil, (260...261), nil, "a"),
-        StringNode(262...263)(nil, (262...263), nil, "b"),
-        StringNode(264...265)(nil, (264...265), nil, "c")],
-       (257...260),
-       (265...266)
-     ),
-     ArrayNode(268...285)(
-       [StringNode(271...274)(nil, (271...274), nil, "a[]"),
-        StringNode(275...280)(nil, (275...280), nil, "b[[]]"),
-        StringNode(281...284)(nil, (281...284), nil, "c[]")],
-       (268...271),
-       (284...285)
-     ),
-     ArrayNode(287...305)(
-       [StringNode(290...298)(nil, (290...298), nil, "foo\\ bar"),
-        StringNode(299...304)(nil, (299...304), nil, "\\\#{1}")],
-       (287...290),
-       (304...305)
-     ),
-     ArrayNode(307...323)(
-       [StringNode(310...318)(nil, (310...318), nil, "foo\\ bar"),
-        StringNode(319...322)(nil, (319...322), nil, "baz")],
-       (307...310),
-       (322...323)
-     ),
-     ArrayNode(325...339)(
-       [StringNode(328...329)(nil, (328...329), nil, "a"),
-        InterpolatedStringNode(330...336)(
-          nil,
-          [StringNode(330...331)(nil, (330...331), nil, "b"),
-           EmbeddedStatementsNode(331...335)(
-             (331...333),
-             StatementsNode(333...334)(
-               [CallNode(333...334)(
-                  nil,
-                  nil,
-                  (333...334),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "c"
-                )]
-             ),
-             (334...335)
-           ),
-           StringNode(335...336)(nil, (335...336), nil, "d")],
-          nil
-        ),
-        StringNode(337...338)(nil, (337...338), nil, "e")],
-       (325...328),
-       (338...339)
-     ),
-     ArrayNode(341...350)(
-       [StringNode(344...345)(nil, (344...345), nil, "a"),
-        StringNode(346...347)(nil, (346...347), nil, "b"),
-        StringNode(348...349)(nil, (348...349), nil, "c")],
-       (341...344),
-       (349...350)
-     ),
-     ArrayNode(352...369)(
-       [StringNode(358...359)(nil, (358...359), nil, "a"),
-        StringNode(362...363)(nil, (362...363), nil, "b"),
-        StringNode(366...367)(nil, (366...367), nil, "c")],
-       (352...355),
-       (368...369)
-     ),
-     StringNode(371...386)(
-       (371...372),
-       (372...385),
-       (385...386),
-       "' foo ' bar"
-     ),
-     StringNode(388...403)(
-       (388...389),
-       (389...402),
-       (402...403),
-       "\\ foo \\ bar"
-     ),
-     InterpolatedStringNode(405...412)(
-       (405...406),
-       [EmbeddedVariableNode(406...411)(
-          (406...407),
-          GlobalVariableReadNode(407...411)(:$foo)
-        )],
-       (411...412)
-     ),
-     InterpolatedStringNode(414...421)(
-       (414...415),
-       [EmbeddedVariableNode(415...420)(
-          (415...416),
-          InstanceVariableReadNode(416...420)(:@foo)
-        )],
-       (420...421)
-     ),
-     StringNode(423...438)((423...424), (424...437), (437...438), "\a # a"),
-     StringNode(440...453)((440...441), (441...452), (452...453), "\a # a"),
-     StringNode(455...461)((455...457), (457...460), (460...461), "abc"),
-     StringNode(463...469)((463...465), (465...468), (468...469), "abc"),
-     StringNode(471...477)((471...473), (473...476), (476...477), "abc"),
-     StringNode(479...485)((479...481), (481...484), (484...485), "abc"),
-     StringNode(487...489)((487...488), (488...489), nil, "a"),
-     StringNode(491...498)((491...494), (494...497), (497...498), "abc")]
-  )
-)
+@ ProgramNode (location: (0...498))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...498))
+    └── body: (length: 47)
+        ├── @ StringNode (location: (0...6))
+        │   ├── opening_loc: (0...2) = "%%"
+        │   ├── content_loc: (2...5) = "abc"
+        │   ├── closing_loc: (5...6) = "%"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (8...14))
+        │   ├── opening_loc: (8...10) = "%^"
+        │   ├── content_loc: (10...13) = "abc"
+        │   ├── closing_loc: (13...14) = "^"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (16...22))
+        │   ├── opening_loc: (16...18) = "%&"
+        │   ├── content_loc: (18...21) = "abc"
+        │   ├── closing_loc: (21...22) = "&"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (24...30))
+        │   ├── opening_loc: (24...26) = "%*"
+        │   ├── content_loc: (26...29) = "abc"
+        │   ├── closing_loc: (29...30) = "*"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (32...38))
+        │   ├── opening_loc: (32...34) = "%_"
+        │   ├── content_loc: (34...37) = "abc"
+        │   ├── closing_loc: (37...38) = "_"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (40...46))
+        │   ├── opening_loc: (40...42) = "%+"
+        │   ├── content_loc: (42...45) = "abc"
+        │   ├── closing_loc: (45...46) = "+"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (48...54))
+        │   ├── opening_loc: (48...50) = "%-"
+        │   ├── content_loc: (50...53) = "abc"
+        │   ├── closing_loc: (53...54) = "-"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (56...62))
+        │   ├── opening_loc: (56...58) = "%:"
+        │   ├── content_loc: (58...61) = "abc"
+        │   ├── closing_loc: (61...62) = ":"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (64...70))
+        │   ├── opening_loc: (64...66) = "%;"
+        │   ├── content_loc: (66...69) = "abc"
+        │   ├── closing_loc: (69...70) = ";"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (72...78))
+        │   ├── opening_loc: (72...74) = "%'"
+        │   ├── content_loc: (74...77) = "abc"
+        │   ├── closing_loc: (77...78) = "'"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (80...86))
+        │   ├── opening_loc: (80...82) = "%~"
+        │   ├── content_loc: (82...85) = "abc"
+        │   ├── closing_loc: (85...86) = "~"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (88...94))
+        │   ├── opening_loc: (88...90) = "%?"
+        │   ├── content_loc: (90...93) = "abc"
+        │   ├── closing_loc: (93...94) = "?"
+        │   └── unescaped: "abc"
+        ├── @ ArrayNode (location: (96...104))
+        │   ├── elements: (length: 0)
+        │   ├── opening_loc: (96...99) = "%w{"
+        │   └── closing_loc: (103...104) = "}"
+        ├── @ StringNode (location: (106...112))
+        │   ├── opening_loc: (106...108) = "%/"
+        │   ├── content_loc: (108...111) = "abc"
+        │   ├── closing_loc: (111...112) = "/"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (114...120))
+        │   ├── opening_loc: (114...116) = "%`"
+        │   ├── content_loc: (116...119) = "abc"
+        │   ├── closing_loc: (119...120) = "`"
+        │   └── unescaped: "abc"
+        ├── @ InterpolatedStringNode (location: (122...130))
+        │   ├── opening_loc: (122...123) = "\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedVariableNode (location: (123...129))
+        │   │       ├── operator_loc: (123...124) = "#"
+        │   │       └── variable:
+        │   │           @ ClassVariableReadNode (location: (124...129))
+        │   │           └── name: :@@foo
+        │   └── closing_loc: (129...130) = "\""
+        ├── @ StringNode (location: (132...138))
+        │   ├── opening_loc: (132...134) = "%\\"
+        │   ├── content_loc: (134...137) = "abc"
+        │   ├── closing_loc: (137...138) = "\\"
+        │   └── unescaped: "abc"
+        ├── @ InterpolatedStringNode (location: (140...157))
+        │   ├── opening_loc: (140...142) = "%{"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (142...146))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (142...146) = "aaa "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "aaa "
+        │   │   ├── @ EmbeddedStatementsNode (location: (146...152))
+        │   │   │   ├── opening_loc: (146...148) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (148...151))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (148...151))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (148...151) = "bbb"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bbb"
+        │   │   │   └── closing_loc: (151...152) = "}"
+        │   │   └── @ StringNode (location: (152...156))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (152...156) = " ccc"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: " ccc"
+        │   └── closing_loc: (156...157) = "}"
+        ├── @ StringNode (location: (159...167))
+        │   ├── opening_loc: (159...161) = "%["
+        │   ├── content_loc: (161...166) = "foo[]"
+        │   ├── closing_loc: (166...167) = "]"
+        │   └── unescaped: "foo[]"
+        ├── @ CallNode (location: (169...184))
+        │   ├── receiver:
+        │   │   @ StringNode (location: (169...174))
+        │   │   ├── opening_loc: (169...170) = "\""
+        │   │   ├── content_loc: (170...173) = "foo"
+        │   │   ├── closing_loc: (173...174) = "\""
+        │   │   └── unescaped: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (175...176) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (179...184))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (179...184))
+        │   │           ├── opening_loc: (179...180) = "\""
+        │   │           ├── content_loc: (180...183) = "bar"
+        │   │           ├── closing_loc: (183...184) = "\""
+        │   │           └── unescaped: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        ├── @ StringNode (location: (186...193))
+        │   ├── opening_loc: (186...189) = "%q{"
+        │   ├── content_loc: (189...192) = "abc"
+        │   ├── closing_loc: (192...193) = "}"
+        │   └── unescaped: "abc"
+        ├── @ SymbolNode (location: (195...202))
+        │   ├── opening_loc: (195...198) = "%s["
+        │   ├── value_loc: (198...201) = "abc"
+        │   ├── closing_loc: (201...202) = "]"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (204...210))
+        │   ├── opening_loc: (204...206) = "%{"
+        │   ├── content_loc: (206...209) = "abc"
+        │   ├── closing_loc: (209...210) = "}"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (212...214))
+        │   ├── opening_loc: (212...213) = "'"
+        │   ├── content_loc: (213...213) = ""
+        │   ├── closing_loc: (213...214) = "'"
+        │   └── unescaped: ""
+        ├── @ StringNode (location: (216...221))
+        │   ├── opening_loc: (216...217) = "\""
+        │   ├── content_loc: (217...220) = "abc"
+        │   ├── closing_loc: (220...221) = "\""
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (223...230))
+        │   ├── opening_loc: (223...224) = "\""
+        │   ├── content_loc: (224...229) = "\#@---"
+        │   ├── closing_loc: (229...230) = "\""
+        │   └── unescaped: "\#@---"
+        ├── @ InterpolatedStringNode (location: (232...248))
+        │   ├── opening_loc: (232...233) = "\""
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (233...237))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (233...237) = "aaa "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "aaa "
+        │   │   ├── @ EmbeddedStatementsNode (location: (237...243))
+        │   │   │   ├── opening_loc: (237...239) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (239...242))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (239...242))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (239...242) = "bbb"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bbb"
+        │   │   │   └── closing_loc: (242...243) = "}"
+        │   │   └── @ StringNode (location: (243...247))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (243...247) = " ccc"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: " ccc"
+        │   └── closing_loc: (247...248) = "\""
+        ├── @ StringNode (location: (250...255))
+        │   ├── opening_loc: (250...251) = "'"
+        │   ├── content_loc: (251...254) = "abc"
+        │   ├── closing_loc: (254...255) = "'"
+        │   └── unescaped: "abc"
+        ├── @ ArrayNode (location: (257...266))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ StringNode (location: (260...261))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (260...261) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ StringNode (location: (262...263))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (262...263) = "b"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "b"
+        │   │   └── @ StringNode (location: (264...265))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (264...265) = "c"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "c"
+        │   ├── opening_loc: (257...260) = "%w["
+        │   └── closing_loc: (265...266) = "]"
+        ├── @ ArrayNode (location: (268...285))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ StringNode (location: (271...274))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (271...274) = "a[]"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a[]"
+        │   │   ├── @ StringNode (location: (275...280))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (275...280) = "b[[]]"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "b[[]]"
+        │   │   └── @ StringNode (location: (281...284))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (281...284) = "c[]"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "c[]"
+        │   ├── opening_loc: (268...271) = "%w["
+        │   └── closing_loc: (284...285) = "]"
+        ├── @ ArrayNode (location: (287...305))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ StringNode (location: (290...298))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (290...298) = "foo\\ bar"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo\\ bar"
+        │   │   └── @ StringNode (location: (299...304))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (299...304) = "\\\#{1}"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\\\#{1}"
+        │   ├── opening_loc: (287...290) = "%w["
+        │   └── closing_loc: (304...305) = "]"
+        ├── @ ArrayNode (location: (307...323))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ StringNode (location: (310...318))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (310...318) = "foo\\ bar"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo\\ bar"
+        │   │   └── @ StringNode (location: (319...322))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (319...322) = "baz"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "baz"
+        │   ├── opening_loc: (307...310) = "%w["
+        │   └── closing_loc: (322...323) = "]"
+        ├── @ ArrayNode (location: (325...339))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ StringNode (location: (328...329))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (328...329) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ InterpolatedStringNode (location: (330...336))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── parts: (length: 3)
+        │   │   │   │   ├── @ StringNode (location: (330...331))
+        │   │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   │   ├── content_loc: (330...331) = "b"
+        │   │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   │   └── unescaped: "b"
+        │   │   │   │   ├── @ EmbeddedStatementsNode (location: (331...335))
+        │   │   │   │   │   ├── opening_loc: (331...333) = "\#{"
+        │   │   │   │   │   ├── statements:
+        │   │   │   │   │   │   @ StatementsNode (location: (333...334))
+        │   │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │   │       └── @ CallNode (location: (333...334))
+        │   │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │   │           ├── message_loc: (333...334) = "c"
+        │   │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │   │           └── name: "c"
+        │   │   │   │   │   └── closing_loc: (334...335) = "}"
+        │   │   │   │   └── @ StringNode (location: (335...336))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── content_loc: (335...336) = "d"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "d"
+        │   │   │   └── closing_loc: ∅
+        │   │   └── @ StringNode (location: (337...338))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (337...338) = "e"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "e"
+        │   ├── opening_loc: (325...328) = "%W["
+        │   └── closing_loc: (338...339) = "]"
+        ├── @ ArrayNode (location: (341...350))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ StringNode (location: (344...345))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (344...345) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ StringNode (location: (346...347))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (346...347) = "b"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "b"
+        │   │   └── @ StringNode (location: (348...349))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (348...349) = "c"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "c"
+        │   ├── opening_loc: (341...344) = "%W["
+        │   └── closing_loc: (349...350) = "]"
+        ├── @ ArrayNode (location: (352...369))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ StringNode (location: (358...359))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (358...359) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ StringNode (location: (362...363))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (362...363) = "b"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "b"
+        │   │   └── @ StringNode (location: (366...367))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (366...367) = "c"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "c"
+        │   ├── opening_loc: (352...355) = "%w["
+        │   └── closing_loc: (368...369) = "]"
+        ├── @ StringNode (location: (371...386))
+        │   ├── opening_loc: (371...372) = "'"
+        │   ├── content_loc: (372...385) = "\\' foo \\' bar"
+        │   ├── closing_loc: (385...386) = "'"
+        │   └── unescaped: "' foo ' bar"
+        ├── @ StringNode (location: (388...403))
+        │   ├── opening_loc: (388...389) = "'"
+        │   ├── content_loc: (389...402) = "\\\\ foo \\\\ bar"
+        │   ├── closing_loc: (402...403) = "'"
+        │   └── unescaped: "\\ foo \\ bar"
+        ├── @ InterpolatedStringNode (location: (405...412))
+        │   ├── opening_loc: (405...406) = "\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedVariableNode (location: (406...411))
+        │   │       ├── operator_loc: (406...407) = "#"
+        │   │       └── variable:
+        │   │           @ GlobalVariableReadNode (location: (407...411))
+        │   │           └── name: :$foo
+        │   └── closing_loc: (411...412) = "\""
+        ├── @ InterpolatedStringNode (location: (414...421))
+        │   ├── opening_loc: (414...415) = "\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedVariableNode (location: (415...420))
+        │   │       ├── operator_loc: (415...416) = "#"
+        │   │       └── variable:
+        │   │           @ InstanceVariableReadNode (location: (416...420))
+        │   │           └── name: :@foo
+        │   └── closing_loc: (420...421) = "\""
+        ├── @ StringNode (location: (423...438))
+        │   ├── opening_loc: (423...424) = "\""
+        │   ├── content_loc: (424...437) = "\\x7 \\x23 \\x61"
+        │   ├── closing_loc: (437...438) = "\""
+        │   └── unescaped: "\a # a"
+        ├── @ StringNode (location: (440...453))
+        │   ├── opening_loc: (440...441) = "\""
+        │   ├── content_loc: (441...452) = "\\7 \\43 \\141"
+        │   ├── closing_loc: (452...453) = "\""
+        │   └── unescaped: "\a # a"
+        ├── @ StringNode (location: (455...461))
+        │   ├── opening_loc: (455...457) = "%["
+        │   ├── content_loc: (457...460) = "abc"
+        │   ├── closing_loc: (460...461) = "]"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (463...469))
+        │   ├── opening_loc: (463...465) = "%("
+        │   ├── content_loc: (465...468) = "abc"
+        │   ├── closing_loc: (468...469) = ")"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (471...477))
+        │   ├── opening_loc: (471...473) = "%@"
+        │   ├── content_loc: (473...476) = "abc"
+        │   ├── closing_loc: (476...477) = "@"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (479...485))
+        │   ├── opening_loc: (479...481) = "%$"
+        │   ├── content_loc: (481...484) = "abc"
+        │   ├── closing_loc: (484...485) = "$"
+        │   └── unescaped: "abc"
+        ├── @ StringNode (location: (487...489))
+        │   ├── opening_loc: (487...488) = "?"
+        │   ├── content_loc: (488...489) = "a"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "a"
+        └── @ StringNode (location: (491...498))
+            ├── opening_loc: (491...494) = "%Q{"
+            ├── content_loc: (494...497) = "abc"
+            ├── closing_loc: (497...498) = "}"
+            └── unescaped: "abc"
diff --git a/test/yarp/snapshots/super.txt b/test/yarp/snapshots/super.txt
index e9d32d14bd..499c62fbc7 100644
--- a/test/yarp/snapshots/super.txt
+++ b/test/yarp/snapshots/super.txt
@@ -1,25 +1,33 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [ForwardingSuperNode(0...5)(nil),
-     SuperNode(7...14)((7...12), (12...13), nil, (13...14), nil),
-     SuperNode(16...24)(
-       (16...21),
-       (21...22),
-       ArgumentsNode(22...23)([IntegerNode(22...23)()]),
-       (23...24),
-       nil
-     ),
-     SuperNode(26...40)(
-       (26...31),
-       (31...32),
-       ArgumentsNode(32...39)(
-         [IntegerNode(32...33)(),
-          IntegerNode(35...36)(),
-          IntegerNode(38...39)()]
-       ),
-       (39...40),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 4)
+        ├── @ ForwardingSuperNode (location: (0...5))
+        │   └── block: ∅
+        ├── @ SuperNode (location: (7...14))
+        │   ├── keyword_loc: (7...12) = "super"
+        │   ├── lparen_loc: (12...13) = "("
+        │   ├── arguments: ∅
+        │   ├── rparen_loc: (13...14) = ")"
+        │   └── block: ∅
+        ├── @ SuperNode (location: (16...24))
+        │   ├── keyword_loc: (16...21) = "super"
+        │   ├── lparen_loc: (21...22) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (22...23))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (22...23))
+        │   ├── rparen_loc: (23...24) = ")"
+        │   └── block: ∅
+        └── @ SuperNode (location: (26...40))
+            ├── keyword_loc: (26...31) = "super"
+            ├── lparen_loc: (31...32) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (32...39))
+            │   └── arguments: (length: 3)
+            │       ├── @ IntegerNode (location: (32...33))
+            │       ├── @ IntegerNode (location: (35...36))
+            │       └── @ IntegerNode (location: (38...39))
+            ├── rparen_loc: (39...40) = ")"
+            └── block: ∅
diff --git a/test/yarp/snapshots/symbols.txt b/test/yarp/snapshots/symbols.txt
index f53a208bce..e17f5a318a 100644
--- a/test/yarp/snapshots/symbols.txt
+++ b/test/yarp/snapshots/symbols.txt
@@ -1,147 +1,386 @@
-ProgramNode(0...345)(
-  [],
-  StatementsNode(0...345)(
-    [SymbolNode(0...6)((0...2), (2...5), (5...6), "abc"),
-     InterpolatedSymbolNode(8...17)(
-       (8...10),
-       [EmbeddedStatementsNode(10...16)(
-          (10...12),
-          StatementsNode(12...15)(
-            [CallNode(12...15)(
-               nil,
-               nil,
-               (12...15),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "var"
-             )]
-          ),
-          (15...16)
-        )],
-       (16...17)
-     ),
-     InterpolatedSymbolNode(19...29)(
-       (19...21),
-       [StringNode(21...24)(nil, (21...24), nil, "abc"),
-        EmbeddedStatementsNode(24...28)(
-          (24...26),
-          StatementsNode(26...27)([IntegerNode(26...27)()]),
-          (27...28)
-        )],
-       (28...29)
-     ),
-     ArrayNode(31...51)(
-       [SymbolNode(32...35)((32...33), (33...35), nil, "Υ"),
-        SymbolNode(37...40)((37...38), (38...40), nil, "ά"),
-        SymbolNode(42...45)((42...43), (43...45), nil, "ŗ"),
-        SymbolNode(47...50)((47...48), (48...50), nil, "ρ")],
-       (31...32),
-       (50...51)
-     ),
-     SymbolNode(53...56)((53...54), (54...56), nil, "-@"),
-     SymbolNode(58...60)((58...59), (59...60), nil, "-"),
-     SymbolNode(62...64)((62...63), (63...64), nil, "%"),
-     SymbolNode(66...68)((66...67), (67...68), nil, "|"),
-     SymbolNode(70...73)((70...71), (71...73), nil, "+@"),
-     SymbolNode(75...77)((75...76), (76...77), nil, "+"),
-     SymbolNode(79...81)((79...80), (80...81), nil, "/"),
-     SymbolNode(83...86)((83...84), (84...86), nil, "**"),
-     SymbolNode(88...90)((88...89), (89...90), nil, "*"),
-     SymbolNode(92...95)((92...93), (93...95), nil, "~@"),
-     ArrayNode(97...113)(
-       [IntegerNode(98...99)(),
-        FloatNode(101...104)(),
-        RationalNode(106...108)(IntegerNode(106...107)()),
-        ImaginaryNode(110...112)(IntegerNode(110...111)())],
-       (97...98),
-       (112...113)
-     ),
-     SymbolNode(115...117)((115...116), (116...117), nil, "~"),
-     SymbolNode(119...121)((119...120), (120...121), nil, "a"),
-     ArrayNode(123...132)(
-       [SymbolNode(126...127)(nil, (126...127), nil, "a"),
-        SymbolNode(128...129)(nil, (128...129), nil, "b"),
-        SymbolNode(130...131)(nil, (130...131), nil, "c")],
-       (123...126),
-       (131...132)
-     ),
-     ArrayNode(134...158)(
-       [SymbolNode(137...138)(nil, (137...138), nil, "a"),
-        SymbolNode(139...144)(nil, (139...144), nil, "b\#{1}"),
-        SymbolNode(145...150)(nil, (145...150), nil, "\#{2}c"),
-        SymbolNode(151...157)(nil, (151...157), nil, "d\#{3}f")],
-       (134...137),
-       (157...158)
-     ),
-     ArrayNode(160...184)(
-       [SymbolNode(163...164)(nil, (163...164), nil, "a"),
-        InterpolatedSymbolNode(165...170)(
-          nil,
-          [StringNode(165...166)(nil, (165...166), nil, "b"),
-           EmbeddedStatementsNode(166...170)(
-             (166...168),
-             StatementsNode(168...169)([IntegerNode(168...169)()]),
-             (169...170)
-           )],
-          nil
-        ),
-        InterpolatedSymbolNode(171...176)(
-          nil,
-          [EmbeddedStatementsNode(171...175)(
-             (171...173),
-             StatementsNode(173...174)([IntegerNode(173...174)()]),
-             (174...175)
-           ),
-           StringNode(175...176)(nil, (175...176), nil, "c")],
-          nil
-        ),
-        InterpolatedSymbolNode(177...183)(
-          nil,
-          [StringNode(177...178)(nil, (177...178), nil, "d"),
-           EmbeddedStatementsNode(178...182)(
-             (178...180),
-             StatementsNode(180...181)([IntegerNode(180...181)()]),
-             (181...182)
-           ),
-           StringNode(182...183)(nil, (182...183), nil, "f")],
-          nil
-        )],
-       (160...163),
-       (183...184)
-     ),
-     SymbolNode(186...190)((186...187), (187...190), nil, "@@a"),
-     SymbolNode(192...197)((192...193), (193...197), nil, "👍"),
-     ArrayNode(199...206)(
-       [SymbolNode(202...205)(nil, (202...205), nil, "a\\b")],
-       (199...202),
-       (205...206)
-     ),
-     SymbolNode(208...211)((208...209), (209...211), nil, "$a"),
-     SymbolNode(213...216)((213...214), (214...216), nil, "@a"),
-     SymbolNode(218...221)((218...219), (219...221), nil, "do"),
-     SymbolNode(223...225)((223...224), (224...225), nil, "&"),
-     SymbolNode(227...229)((227...228), (228...229), nil, "`"),
-     SymbolNode(231...234)((231...232), (232...234), nil, "!@"),
-     SymbolNode(236...239)((236...237), (237...239), nil, "!~"),
-     SymbolNode(241...243)((241...242), (242...243), nil, "!"),
-     SymbolNode(245...248)((245...246), (246...248), nil, "[]"),
-     SymbolNode(250...254)((250...251), (251...254), nil, "[]="),
-     SymbolNode(256...258)((256...257), (257...258), nil, "^"),
-     SymbolNode(260...263)((260...261), (261...263), nil, "=="),
-     SymbolNode(265...269)((265...266), (266...269), nil, "==="),
-     SymbolNode(271...274)((271...272), (272...274), nil, "=~"),
-     SymbolNode(276...279)((276...277), (277...279), nil, ">="),
-     SymbolNode(281...284)((281...282), (282...284), nil, ">>"),
-     SymbolNode(286...288)((286...287), (287...288), nil, ">"),
-     SymbolNode(290...294)((290...291), (291...294), nil, "<=>"),
-     SymbolNode(296...299)((296...297), (297...299), nil, "<="),
-     SymbolNode(301...304)((301...302), (302...304), nil, "<<"),
-     SymbolNode(306...308)((306...307), (307...308), nil, "<"),
-     SymbolNode(310...319)((310...311), (311...319), nil, "__LINE__"),
-     SymbolNode(321...330)((321...322), (322...330), nil, "__FILE__"),
-     SymbolNode(332...345)((332...333), (333...345), nil, "__ENCODING__")]
-  )
-)
+@ ProgramNode (location: (0...345))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...345))
+    └── body: (length: 47)
+        ├── @ SymbolNode (location: (0...6))
+        │   ├── opening_loc: (0...2) = ":'"
+        │   ├── value_loc: (2...5) = "abc"
+        │   ├── closing_loc: (5...6) = "'"
+        │   └── unescaped: "abc"
+        ├── @ InterpolatedSymbolNode (location: (8...17))
+        │   ├── opening_loc: (8...10) = ":\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedStatementsNode (location: (10...16))
+        │   │       ├── opening_loc: (10...12) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (12...15))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ CallNode (location: (12...15))
+        │   │       │           ├── receiver: ∅
+        │   │       │           ├── call_operator_loc: ∅
+        │   │       │           ├── message_loc: (12...15) = "var"
+        │   │       │           ├── opening_loc: ∅
+        │   │       │           ├── arguments: ∅
+        │   │       │           ├── closing_loc: ∅
+        │   │       │           ├── block: ∅
+        │   │       │           ├── flags: variable_call
+        │   │       │           └── name: "var"
+        │   │       └── closing_loc: (15...16) = "}"
+        │   └── closing_loc: (16...17) = "\""
+        ├── @ InterpolatedSymbolNode (location: (19...29))
+        │   ├── opening_loc: (19...21) = ":\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (21...24))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (21...24) = "abc"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "abc"
+        │   │   └── @ EmbeddedStatementsNode (location: (24...28))
+        │   │       ├── opening_loc: (24...26) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (26...27))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ IntegerNode (location: (26...27))
+        │   │       └── closing_loc: (27...28) = "}"
+        │   └── closing_loc: (28...29) = "\""
+        ├── @ ArrayNode (location: (31...51))
+        │   ├── elements: (length: 4)
+        │   │   ├── @ SymbolNode (location: (32...35))
+        │   │   │   ├── opening_loc: (32...33) = ":"
+        │   │   │   ├── value_loc: (33...35) = "Υ"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "Υ"
+        │   │   ├── @ SymbolNode (location: (37...40))
+        │   │   │   ├── opening_loc: (37...38) = ":"
+        │   │   │   ├── value_loc: (38...40) = "ά"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "ά"
+        │   │   ├── @ SymbolNode (location: (42...45))
+        │   │   │   ├── opening_loc: (42...43) = ":"
+        │   │   │   ├── value_loc: (43...45) = "ŗ"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "ŗ"
+        │   │   └── @ SymbolNode (location: (47...50))
+        │   │       ├── opening_loc: (47...48) = ":"
+        │   │       ├── value_loc: (48...50) = "ρ"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "ρ"
+        │   ├── opening_loc: (31...32) = "["
+        │   └── closing_loc: (50...51) = "]"
+        ├── @ SymbolNode (location: (53...56))
+        │   ├── opening_loc: (53...54) = ":"
+        │   ├── value_loc: (54...56) = "-@"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "-@"
+        ├── @ SymbolNode (location: (58...60))
+        │   ├── opening_loc: (58...59) = ":"
+        │   ├── value_loc: (59...60) = "-"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "-"
+        ├── @ SymbolNode (location: (62...64))
+        │   ├── opening_loc: (62...63) = ":"
+        │   ├── value_loc: (63...64) = "%"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "%"
+        ├── @ SymbolNode (location: (66...68))
+        │   ├── opening_loc: (66...67) = ":"
+        │   ├── value_loc: (67...68) = "|"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "|"
+        ├── @ SymbolNode (location: (70...73))
+        │   ├── opening_loc: (70...71) = ":"
+        │   ├── value_loc: (71...73) = "+@"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "+@"
+        ├── @ SymbolNode (location: (75...77))
+        │   ├── opening_loc: (75...76) = ":"
+        │   ├── value_loc: (76...77) = "+"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "+"
+        ├── @ SymbolNode (location: (79...81))
+        │   ├── opening_loc: (79...80) = ":"
+        │   ├── value_loc: (80...81) = "/"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "/"
+        ├── @ SymbolNode (location: (83...86))
+        │   ├── opening_loc: (83...84) = ":"
+        │   ├── value_loc: (84...86) = "**"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "**"
+        ├── @ SymbolNode (location: (88...90))
+        │   ├── opening_loc: (88...89) = ":"
+        │   ├── value_loc: (89...90) = "*"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "*"
+        ├── @ SymbolNode (location: (92...95))
+        │   ├── opening_loc: (92...93) = ":"
+        │   ├── value_loc: (93...95) = "~@"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "~@"
+        ├── @ ArrayNode (location: (97...113))
+        │   ├── elements: (length: 4)
+        │   │   ├── @ IntegerNode (location: (98...99))
+        │   │   ├── @ FloatNode (location: (101...104))
+        │   │   ├── @ RationalNode (location: (106...108))
+        │   │   │   └── numeric:
+        │   │   │       @ IntegerNode (location: (106...107))
+        │   │   └── @ ImaginaryNode (location: (110...112))
+        │   │       └── numeric:
+        │   │           @ IntegerNode (location: (110...111))
+        │   ├── opening_loc: (97...98) = "["
+        │   └── closing_loc: (112...113) = "]"
+        ├── @ SymbolNode (location: (115...117))
+        │   ├── opening_loc: (115...116) = ":"
+        │   ├── value_loc: (116...117) = "~"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "~"
+        ├── @ SymbolNode (location: (119...121))
+        │   ├── opening_loc: (119...120) = ":"
+        │   ├── value_loc: (120...121) = "a"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "a"
+        ├── @ ArrayNode (location: (123...132))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ SymbolNode (location: (126...127))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (126...127) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ SymbolNode (location: (128...129))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (128...129) = "b"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "b"
+        │   │   └── @ SymbolNode (location: (130...131))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (130...131) = "c"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "c"
+        │   ├── opening_loc: (123...126) = "%i["
+        │   └── closing_loc: (131...132) = "]"
+        ├── @ ArrayNode (location: (134...158))
+        │   ├── elements: (length: 4)
+        │   │   ├── @ SymbolNode (location: (137...138))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (137...138) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ SymbolNode (location: (139...144))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (139...144) = "b\#{1}"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "b\#{1}"
+        │   │   ├── @ SymbolNode (location: (145...150))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (145...150) = "\#{2}c"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "\#{2}c"
+        │   │   └── @ SymbolNode (location: (151...157))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (151...157) = "d\#{3}f"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "d\#{3}f"
+        │   ├── opening_loc: (134...137) = "%i["
+        │   └── closing_loc: (157...158) = "]"
+        ├── @ ArrayNode (location: (160...184))
+        │   ├── elements: (length: 4)
+        │   │   ├── @ SymbolNode (location: (163...164))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (163...164) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ InterpolatedSymbolNode (location: (165...170))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── parts: (length: 2)
+        │   │   │   │   ├── @ StringNode (location: (165...166))
+        │   │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   │   ├── content_loc: (165...166) = "b"
+        │   │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   │   └── unescaped: "b"
+        │   │   │   │   └── @ EmbeddedStatementsNode (location: (166...170))
+        │   │   │   │       ├── opening_loc: (166...168) = "\#{"
+        │   │   │   │       ├── statements:
+        │   │   │   │       │   @ StatementsNode (location: (168...169))
+        │   │   │   │       │   └── body: (length: 1)
+        │   │   │   │       │       └── @ IntegerNode (location: (168...169))
+        │   │   │   │       └── closing_loc: (169...170) = "}"
+        │   │   │   └── closing_loc: ∅
+        │   │   ├── @ InterpolatedSymbolNode (location: (171...176))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── parts: (length: 2)
+        │   │   │   │   ├── @ EmbeddedStatementsNode (location: (171...175))
+        │   │   │   │   │   ├── opening_loc: (171...173) = "\#{"
+        │   │   │   │   │   ├── statements:
+        │   │   │   │   │   │   @ StatementsNode (location: (173...174))
+        │   │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │   │       └── @ IntegerNode (location: (173...174))
+        │   │   │   │   │   └── closing_loc: (174...175) = "}"
+        │   │   │   │   └── @ StringNode (location: (175...176))
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── content_loc: (175...176) = "c"
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       └── unescaped: "c"
+        │   │   │   └── closing_loc: ∅
+        │   │   └── @ InterpolatedSymbolNode (location: (177...183))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── parts: (length: 3)
+        │   │       │   ├── @ StringNode (location: (177...178))
+        │   │       │   │   ├── opening_loc: ∅
+        │   │       │   │   ├── content_loc: (177...178) = "d"
+        │   │       │   │   ├── closing_loc: ∅
+        │   │       │   │   └── unescaped: "d"
+        │   │       │   ├── @ EmbeddedStatementsNode (location: (178...182))
+        │   │       │   │   ├── opening_loc: (178...180) = "\#{"
+        │   │       │   │   ├── statements:
+        │   │       │   │   │   @ StatementsNode (location: (180...181))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ IntegerNode (location: (180...181))
+        │   │       │   │   └── closing_loc: (181...182) = "}"
+        │   │       │   └── @ StringNode (location: (182...183))
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── content_loc: (182...183) = "f"
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       └── unescaped: "f"
+        │   │       └── closing_loc: ∅
+        │   ├── opening_loc: (160...163) = "%I["
+        │   └── closing_loc: (183...184) = "]"
+        ├── @ SymbolNode (location: (186...190))
+        │   ├── opening_loc: (186...187) = ":"
+        │   ├── value_loc: (187...190) = "@@a"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "@@a"
+        ├── @ SymbolNode (location: (192...197))
+        │   ├── opening_loc: (192...193) = ":"
+        │   ├── value_loc: (193...197) = "👍"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "👍"
+        ├── @ ArrayNode (location: (199...206))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SymbolNode (location: (202...205))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (202...205) = "a\\b"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\\b"
+        │   ├── opening_loc: (199...202) = "%i["
+        │   └── closing_loc: (205...206) = "]"
+        ├── @ SymbolNode (location: (208...211))
+        │   ├── opening_loc: (208...209) = ":"
+        │   ├── value_loc: (209...211) = "$a"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "$a"
+        ├── @ SymbolNode (location: (213...216))
+        │   ├── opening_loc: (213...214) = ":"
+        │   ├── value_loc: (214...216) = "@a"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "@a"
+        ├── @ SymbolNode (location: (218...221))
+        │   ├── opening_loc: (218...219) = ":"
+        │   ├── value_loc: (219...221) = "do"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "do"
+        ├── @ SymbolNode (location: (223...225))
+        │   ├── opening_loc: (223...224) = ":"
+        │   ├── value_loc: (224...225) = "&"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "&"
+        ├── @ SymbolNode (location: (227...229))
+        │   ├── opening_loc: (227...228) = ":"
+        │   ├── value_loc: (228...229) = "`"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "`"
+        ├── @ SymbolNode (location: (231...234))
+        │   ├── opening_loc: (231...232) = ":"
+        │   ├── value_loc: (232...234) = "!@"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "!@"
+        ├── @ SymbolNode (location: (236...239))
+        │   ├── opening_loc: (236...237) = ":"
+        │   ├── value_loc: (237...239) = "!~"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "!~"
+        ├── @ SymbolNode (location: (241...243))
+        │   ├── opening_loc: (241...242) = ":"
+        │   ├── value_loc: (242...243) = "!"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "!"
+        ├── @ SymbolNode (location: (245...248))
+        │   ├── opening_loc: (245...246) = ":"
+        │   ├── value_loc: (246...248) = "[]"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "[]"
+        ├── @ SymbolNode (location: (250...254))
+        │   ├── opening_loc: (250...251) = ":"
+        │   ├── value_loc: (251...254) = "[]="
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "[]="
+        ├── @ SymbolNode (location: (256...258))
+        │   ├── opening_loc: (256...257) = ":"
+        │   ├── value_loc: (257...258) = "^"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "^"
+        ├── @ SymbolNode (location: (260...263))
+        │   ├── opening_loc: (260...261) = ":"
+        │   ├── value_loc: (261...263) = "=="
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "=="
+        ├── @ SymbolNode (location: (265...269))
+        │   ├── opening_loc: (265...266) = ":"
+        │   ├── value_loc: (266...269) = "==="
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "==="
+        ├── @ SymbolNode (location: (271...274))
+        │   ├── opening_loc: (271...272) = ":"
+        │   ├── value_loc: (272...274) = "=~"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "=~"
+        ├── @ SymbolNode (location: (276...279))
+        │   ├── opening_loc: (276...277) = ":"
+        │   ├── value_loc: (277...279) = ">="
+        │   ├── closing_loc: ∅
+        │   └── unescaped: ">="
+        ├── @ SymbolNode (location: (281...284))
+        │   ├── opening_loc: (281...282) = ":"
+        │   ├── value_loc: (282...284) = ">>"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: ">>"
+        ├── @ SymbolNode (location: (286...288))
+        │   ├── opening_loc: (286...287) = ":"
+        │   ├── value_loc: (287...288) = ">"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: ">"
+        ├── @ SymbolNode (location: (290...294))
+        │   ├── opening_loc: (290...291) = ":"
+        │   ├── value_loc: (291...294) = "<=>"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "<=>"
+        ├── @ SymbolNode (location: (296...299))
+        │   ├── opening_loc: (296...297) = ":"
+        │   ├── value_loc: (297...299) = "<="
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "<="
+        ├── @ SymbolNode (location: (301...304))
+        │   ├── opening_loc: (301...302) = ":"
+        │   ├── value_loc: (302...304) = "<<"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "<<"
+        ├── @ SymbolNode (location: (306...308))
+        │   ├── opening_loc: (306...307) = ":"
+        │   ├── value_loc: (307...308) = "<"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "<"
+        ├── @ SymbolNode (location: (310...319))
+        │   ├── opening_loc: (310...311) = ":"
+        │   ├── value_loc: (311...319) = "__LINE__"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "__LINE__"
+        ├── @ SymbolNode (location: (321...330))
+        │   ├── opening_loc: (321...322) = ":"
+        │   ├── value_loc: (322...330) = "__FILE__"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "__FILE__"
+        └── @ SymbolNode (location: (332...345))
+            ├── opening_loc: (332...333) = ":"
+            ├── value_loc: (333...345) = "__ENCODING__"
+            ├── closing_loc: ∅
+            └── unescaped: "__ENCODING__"
diff --git a/test/yarp/snapshots/ternary_operator.txt b/test/yarp/snapshots/ternary_operator.txt
index 9751d53a31..4afcedf271 100644
--- a/test/yarp/snapshots/ternary_operator.txt
+++ b/test/yarp/snapshots/ternary_operator.txt
@@ -1,163 +1,283 @@
-ProgramNode(0...131)(
-  [:_a],
-  StatementsNode(0...131)(
-    [IfNode(0...9)(
-       nil,
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       StatementsNode(4...5)(
-         [CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "b")]
-       ),
-       ElseNode(6...9)(
-         (6...7),
-         StatementsNode(8...9)(
-           [CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "c")]
-         ),
-         nil
-       ),
-       nil
-     ),
-     IfNode(11...38)(
-       nil,
-       CallNode(11...12)(nil, nil, (11...12), nil, nil, nil, nil, 2, "a"),
-       StatementsNode(15...25)(
-         [DefinedNode(15...25)(
-            nil,
-            CallNode(24...25)(nil, nil, (24...25), nil, nil, nil, nil, 2, "b"),
-            nil,
-            (15...23)
-          )]
-       ),
-       ElseNode(26...38)(
-         (26...27),
-         StatementsNode(28...38)(
-           [DefinedNode(28...38)(
-              nil,
-              CallNode(37...38)(
-                nil,
-                nil,
-                (37...38),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "c"
-              ),
-              nil,
-              (28...36)
-            )]
-         ),
-         nil
-       ),
-       nil
-     ),
-     IfNode(40...55)(
-       nil,
-       CallNode(40...46)(nil, nil, (40...46), nil, nil, nil, nil, 0, "empty?"),
-       StatementsNode(47...51)([TrueNode(47...51)()]),
-       ElseNode(51...55)(
-         (51...52),
-         StatementsNode(52...55)([NilNode(52...55)()]),
-         nil
-       ),
-       nil
-     ),
-     IfNode(57...73)(
-       nil,
-       CallNode(57...63)(nil, nil, (57...63), nil, nil, nil, nil, 0, "empty?"),
-       StatementsNode(64...69)([FalseNode(64...69)()]),
-       ElseNode(69...73)(
-         (69...70),
-         StatementsNode(70...73)([NilNode(70...73)()]),
-         nil
-       ),
-       nil
-     ),
-     IfNode(75...89)(
-       nil,
-       CallNode(75...81)(nil, nil, (75...81), nil, nil, nil, nil, 0, "empty?"),
-       StatementsNode(82...85)([NilNode(82...85)()]),
-       ElseNode(85...89)(
-         (85...86),
-         StatementsNode(86...89)([NilNode(86...89)()]),
-         nil
-       ),
-       nil
-     ),
-     IfNode(91...101)(
-       nil,
-       CallNode(91...93)(nil, nil, (91...93), nil, nil, nil, nil, 0, "a?"),
-       StatementsNode(94...97)([NilNode(94...97)()]),
-       ElseNode(97...101)(
-         (97...98),
-         StatementsNode(98...101)([NilNode(98...101)()]),
-         nil
-       ),
-       nil
-     ),
-     IfNode(103...117)(
-       nil,
-       CallNode(103...104)(nil, nil, (103...104), nil, nil, nil, nil, 2, "a"),
-       StatementsNode(106...110)(
-         [CallNode(106...110)(
-            nil,
-            nil,
-            (106...110),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "var1"
-          )]
-       ),
-       ElseNode(111...117)(
-         (111...112),
-         StatementsNode(113...117)(
-           [CallNode(113...117)(
-              nil,
-              nil,
-              (113...117),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "var2"
-            )]
-         ),
-         nil
-       ),
-       nil
-     ),
-     IfNode(119...131)(
-       nil,
-       CallNode(119...123)(
-         nil,
-         nil,
-         (119...123),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "nil?"
-       ),
-       StatementsNode(124...129)(
-         [LocalVariableWriteNode(124...129)(
-            :_a,
-            0,
-            (124...126),
-            IntegerNode(128...129)(),
-            (127...128)
-          )]
-       ),
-       ElseNode(129...131)(
-         (129...130),
-         StatementsNode(130...131)([IntegerNode(130...131)()]),
-         nil
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...131))
+├── locals: [:_a]
+└── statements:
+    @ StatementsNode (location: (0...131))
+    └── body: (length: 8)
+        ├── @ IfNode (location: (0...9))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (0...1))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...1) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (4...5))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (4...5))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (4...5) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (6...9))
+        │   │   ├── else_keyword_loc: (6...7) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (8...9))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (8...9))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (8...9) = "c"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "c"
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (11...38))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (11...12))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (11...12) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (15...25))
+        │   │   └── body: (length: 1)
+        │   │       └── @ DefinedNode (location: (15...25))
+        │   │           ├── lparen_loc: ∅
+        │   │           ├── value:
+        │   │           │   @ CallNode (location: (24...25))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (24...25) = "b"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "b"
+        │   │           ├── rparen_loc: ∅
+        │   │           └── keyword_loc: (15...23) = "defined?"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (26...38))
+        │   │   ├── else_keyword_loc: (26...27) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (28...38))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ DefinedNode (location: (28...38))
+        │   │   │           ├── lparen_loc: ∅
+        │   │   │           ├── value:
+        │   │   │           │   @ CallNode (location: (37...38))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (37...38) = "c"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "c"
+        │   │   │           ├── rparen_loc: ∅
+        │   │   │           └── keyword_loc: (28...36) = "defined?"
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (40...55))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (40...46))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (40...46) = "empty?"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "empty?"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (47...51))
+        │   │   └── body: (length: 1)
+        │   │       └── @ TrueNode (location: (47...51))
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (51...55))
+        │   │   ├── else_keyword_loc: (51...52) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (52...55))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ NilNode (location: (52...55))
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (57...73))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (57...63))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (57...63) = "empty?"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "empty?"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (64...69))
+        │   │   └── body: (length: 1)
+        │   │       └── @ FalseNode (location: (64...69))
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (69...73))
+        │   │   ├── else_keyword_loc: (69...70) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (70...73))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ NilNode (location: (70...73))
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (75...89))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (75...81))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (75...81) = "empty?"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "empty?"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (82...85))
+        │   │   └── body: (length: 1)
+        │   │       └── @ NilNode (location: (82...85))
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (85...89))
+        │   │   ├── else_keyword_loc: (85...86) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (86...89))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ NilNode (location: (86...89))
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (91...101))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (91...93))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (91...93) = "a?"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "a?"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (94...97))
+        │   │   └── body: (length: 1)
+        │   │       └── @ NilNode (location: (94...97))
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (97...101))
+        │   │   ├── else_keyword_loc: (97...98) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (98...101))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ NilNode (location: (98...101))
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (103...117))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (103...104))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (103...104) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (106...110))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (106...110))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (106...110) = "var1"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "var1"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (111...117))
+        │   │   ├── else_keyword_loc: (111...112) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (113...117))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (113...117))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (113...117) = "var2"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "var2"
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        └── @ IfNode (location: (119...131))
+            ├── if_keyword_loc: ∅
+            ├── predicate:
+            │   @ CallNode (location: (119...123))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (119...123) = "nil?"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "nil?"
+            ├── statements:
+            │   @ StatementsNode (location: (124...129))
+            │   └── body: (length: 1)
+            │       └── @ LocalVariableWriteNode (location: (124...129))
+            │           ├── name: :_a
+            │           ├── depth: 0
+            │           ├── name_loc: (124...126) = "_a"
+            │           ├── value:
+            │           │   @ IntegerNode (location: (128...129))
+            │           └── operator_loc: (127...128) = "="
+            ├── consequent:
+            │   @ ElseNode (location: (129...131))
+            │   ├── else_keyword_loc: (129...130) = ":"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (130...131))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (130...131))
+            │   └── end_keyword_loc: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/tilde_heredocs.txt b/test/yarp/snapshots/tilde_heredocs.txt
index 864ea645b3..fb814f3019 100644
--- a/test/yarp/snapshots/tilde_heredocs.txt
+++ b/test/yarp/snapshots/tilde_heredocs.txt
@@ -1,134 +1,229 @@
-ProgramNode(0...372)(
-  [],
-  StatementsNode(0...372)(
-    [InterpolatedStringNode(0...6)(
-       (0...6),
-       [StringNode(7...11)(nil, (7...11), nil, "a\n")],
-       (11...15)
-     ),
-     InterpolatedStringNode(16...22)(
-       (16...22),
-       [StringNode(23...34)(nil, (23...34), nil, "\ta\n" + "b\n" + "\t\tc\n")],
-       (34...38)
-     ),
-     InterpolatedStringNode(39...45)(
-       (39...45),
-       [EmbeddedStatementsNode(48...52)(
-          (48...50),
-          StatementsNode(50...51)([IntegerNode(50...51)()]),
-          (51...52)
-        ),
-        StringNode(52...55)(nil, (52...55), nil, " a\n")],
-       (55...59)
-     ),
-     InterpolatedStringNode(60...66)(
-       (60...66),
-       [StringNode(67...71)(nil, (67...71), nil, "a "),
-        EmbeddedStatementsNode(71...75)(
-          (71...73),
-          StatementsNode(73...74)([IntegerNode(73...74)()]),
-          (74...75)
-        ),
-        StringNode(75...76)(nil, (75...76), nil, "\n")],
-       (76...80)
-     ),
-     InterpolatedStringNode(81...87)(
-       (81...87),
-       [StringNode(88...93)(nil, (88...93), nil, " a\n"),
-        EmbeddedStatementsNode(93...97)(
-          (93...95),
-          StatementsNode(95...96)([IntegerNode(95...96)()]),
-          (96...97)
-        ),
-        StringNode(97...98)(nil, (97...98), nil, "\n")],
-       (98...102)
-     ),
-     InterpolatedStringNode(103...109)(
-       (103...109),
-       [StringNode(110...116)(nil, (110...116), nil, "a\n"),
-        EmbeddedStatementsNode(116...120)(
-          (116...118),
-          StatementsNode(118...119)([IntegerNode(118...119)()]),
-          (119...120)
-        ),
-        StringNode(120...121)(nil, (120...121), nil, "\n")],
-       (121...125)
-     ),
-     InterpolatedStringNode(126...132)(
-       (126...132),
-       [StringNode(133...141)(nil, (133...141), nil, "a\n" + "b\n")],
-       (141...145)
-     ),
-     InterpolatedStringNode(146...152)(
-       (146...152),
-       [StringNode(153...162)(nil, (153...162), nil, "a\n" + " b\n")],
-       (162...166)
-     ),
-     InterpolatedStringNode(167...173)(
-       (167...173),
-       [StringNode(174...183)(nil, (174...183), nil, "\ta\n" + "b\n")],
-       (183...187)
-     ),
-     InterpolatedStringNode(188...196)(
-       (188...196),
-       [StringNode(197...206)(nil, (197...206), nil, "a \#{1}\n")],
-       (206...210)
-     ),
-     InterpolatedStringNode(211...217)(
-       (211...217),
-       [StringNode(218...225)(nil, (218...225), nil, "a\n" + " b\n")],
-       (225...229)
-     ),
-     InterpolatedStringNode(230...236)(
-       (230...236),
-       [StringNode(237...244)(nil, (237...244), nil, " a\n" + "b\n")],
-       (244...248)
-     ),
-     InterpolatedStringNode(249...255)(
-       (249...255),
-       [StringNode(256...271)(nil, (256...271), nil, "a\n" + "b\n")],
-       (271...275)
-     ),
-     InterpolatedStringNode(276...282)(
-       (276...282),
-       [StringNode(283...292)(nil, (283...292), nil, "a\n" + "\n" + "b\n")],
-       (292...296)
-     ),
-     InterpolatedStringNode(297...303)(
-       (297...303),
-       [StringNode(304...313)(nil, (304...313), nil, "a\n" + "\n" + "b\n")],
-       (313...317)
-     ),
-     InterpolatedStringNode(318...324)(
-       (318...324),
-       [StringNode(325...336)(
-          nil,
-          (325...336),
-          nil,
-          "a\n" + "\n" + "\n" + "\n" + "b\n"
-        )],
-       (336...340)
-     ),
-     InterpolatedStringNode(341...347)(
-       (341...347),
-       [StringNode(348...351)(nil, (348...351), nil, "\n"),
-        EmbeddedStatementsNode(351...355)(
-          (351...353),
-          StatementsNode(353...354)([IntegerNode(353...354)()]),
-          (354...355)
-        ),
-        StringNode(355...357)(nil, (355...357), nil, "a\n")],
-       (357...365)
-     ),
-     InterpolatedStringNode(366...372)(
-       (366...372),
-       [EmbeddedStatementsNode(375...379)(
-          (375...377),
-          StatementsNode(377...378)([IntegerNode(377...378)()]),
-          (378...379)
-        ),
-        StringNode(379...383)(nil, (379...383), nil, "\n" + "\tb\n")],
-       (383...387)
-     )]
-  )
-)
+@ ProgramNode (location: (0...372))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...372))
+    └── body: (length: 18)
+        ├── @ InterpolatedStringNode (location: (0...6))
+        │   ├── opening_loc: (0...6) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (7...11))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (7...11) = "  a\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n"
+        │   └── closing_loc: (11...15) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (16...22))
+        │   ├── opening_loc: (16...22) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (23...34))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (23...34) = "\ta\n  b\n\t\tc\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\ta\nb\n\t\tc\n"
+        │   └── closing_loc: (34...38) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (39...45))
+        │   ├── opening_loc: (39...45) = "<<~EOF"
+        │   ├── parts: (length: 2)
+        │   │   ├── @ EmbeddedStatementsNode (location: (48...52))
+        │   │   │   ├── opening_loc: (48...50) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (50...51))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ IntegerNode (location: (50...51))
+        │   │   │   └── closing_loc: (51...52) = "}"
+        │   │   └── @ StringNode (location: (52...55))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (52...55) = " a\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: " a\n"
+        │   └── closing_loc: (55...59) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (60...66))
+        │   ├── opening_loc: (60...66) = "<<~EOF"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (67...71))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (67...71) = "  a "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a "
+        │   │   ├── @ EmbeddedStatementsNode (location: (71...75))
+        │   │   │   ├── opening_loc: (71...73) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (73...74))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ IntegerNode (location: (73...74))
+        │   │   │   └── closing_loc: (74...75) = "}"
+        │   │   └── @ StringNode (location: (75...76))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (75...76) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (76...80) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (81...87))
+        │   ├── opening_loc: (81...87) = "<<~EOF"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (88...93))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (88...93) = "  a\n "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: " a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (93...97))
+        │   │   │   ├── opening_loc: (93...95) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (95...96))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ IntegerNode (location: (95...96))
+        │   │   │   └── closing_loc: (96...97) = "}"
+        │   │   └── @ StringNode (location: (97...98))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (97...98) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (98...102) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (103...109))
+        │   ├── opening_loc: (103...109) = "<<~EOF"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (110...116))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (110...116) = "  a\n  "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (116...120))
+        │   │   │   ├── opening_loc: (116...118) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (118...119))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ IntegerNode (location: (118...119))
+        │   │   │   └── closing_loc: (119...120) = "}"
+        │   │   └── @ StringNode (location: (120...121))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (120...121) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (121...125) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (126...132))
+        │   ├── opening_loc: (126...132) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (133...141))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (133...141) = "  a\n  b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\nb\n"
+        │   └── closing_loc: (141...145) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (146...152))
+        │   ├── opening_loc: (146...152) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (153...162))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (153...162) = "  a\n   b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n b\n"
+        │   └── closing_loc: (162...166) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (167...173))
+        │   ├── opening_loc: (167...173) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (174...183))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (174...183) = "\t\t\ta\n\t\tb\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\ta\nb\n"
+        │   └── closing_loc: (183...187) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (188...196))
+        │   ├── opening_loc: (188...196) = "<<~'EOF'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (197...206))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (197...206) = "  a \#{1}\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a \#{1}\n"
+        │   └── closing_loc: (206...210) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (211...217))
+        │   ├── opening_loc: (211...217) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (218...225))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (218...225) = "\ta\n\t b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n b\n"
+        │   └── closing_loc: (225...229) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (230...236))
+        │   ├── opening_loc: (230...236) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (237...244))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (237...244) = "\t a\n\tb\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: " a\nb\n"
+        │   └── closing_loc: (244...248) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (249...255))
+        │   ├── opening_loc: (249...255) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (256...271))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (256...271) = "  \ta\n        b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\nb\n"
+        │   └── closing_loc: (271...275) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (276...282))
+        │   ├── opening_loc: (276...282) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (283...292))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (283...292) = "  a\n\n  b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n\nb\n"
+        │   └── closing_loc: (292...296) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (297...303))
+        │   ├── opening_loc: (297...303) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (304...313))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (304...313) = "  a\n\n  b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n\nb\n"
+        │   └── closing_loc: (313...317) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (318...324))
+        │   ├── opening_loc: (318...324) = "<<~EOF"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (325...336))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (325...336) = "  a\n\n\n\n  b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n\n\n\nb\n"
+        │   └── closing_loc: (336...340) = "EOF\n"
+        ├── @ InterpolatedStringNode (location: (341...347))
+        │   ├── opening_loc: (341...347) = "<<~EOF"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (348...351))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (348...351) = "\n  "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (351...355))
+        │   │   │   ├── opening_loc: (351...353) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (353...354))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ IntegerNode (location: (353...354))
+        │   │   │   └── closing_loc: (354...355) = "}"
+        │   │   └── @ StringNode (location: (355...357))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (355...357) = "a\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n"
+        │   └── closing_loc: (357...365) = "    EOF\n"
+        └── @ InterpolatedStringNode (location: (366...372))
+            ├── opening_loc: (366...372) = "<<~EOT"
+            ├── parts: (length: 2)
+            │   ├── @ EmbeddedStatementsNode (location: (375...379))
+            │   │   ├── opening_loc: (375...377) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (377...378))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ IntegerNode (location: (377...378))
+            │   │   └── closing_loc: (378...379) = "}"
+            │   └── @ StringNode (location: (379...383))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (379...383) = "\n\tb\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\n\tb\n"
+            └── closing_loc: (383...387) = "EOT\n"
diff --git a/test/yarp/snapshots/undef.txt b/test/yarp/snapshots/undef.txt
index d3173a3f1c..4ebc7b5383 100644
--- a/test/yarp/snapshots/undef.txt
+++ b/test/yarp/snapshots/undef.txt
@@ -1,50 +1,103 @@
-ProgramNode(0...116)(
-  [],
-  StatementsNode(0...116)(
-    [UndefNode(0...7)([SymbolNode(6...7)(nil, (6...7), nil, "a")], (0...5)),
-     UndefNode(9...19)(
-       [SymbolNode(15...16)(nil, (15...16), nil, "a"),
-        SymbolNode(18...19)(nil, (18...19), nil, "b")],
-       (9...14)
-     ),
-     UndefNode(21...29)(
-       [SymbolNode(27...29)(nil, (27...29), nil, "if")],
-       (21...26)
-     ),
-     UndefNode(31...40)(
-       [SymbolNode(37...40)(nil, (37...40), nil, "<=>")],
-       (31...36)
-     ),
-     UndefNode(42...50)(
-       [SymbolNode(48...50)((48...49), (49...50), nil, "a")],
-       (42...47)
-     ),
-     UndefNode(52...68)(
-       [SymbolNode(58...60)((58...59), (59...60), nil, "a"),
-        SymbolNode(62...64)((62...63), (63...64), nil, "b"),
-        SymbolNode(66...68)((66...67), (67...68), nil, "c")],
-       (52...57)
-     ),
-     UndefNode(70...82)(
-       [SymbolNode(76...82)((76...78), (78...81), (81...82), "abc")],
-       (70...75)
-     ),
-     UndefNode(84...100)(
-       [InterpolatedSymbolNode(90...100)(
-          (90...92),
-          [StringNode(92...95)(nil, (92...95), nil, "abc"),
-           EmbeddedStatementsNode(95...99)(
-             (95...97),
-             StatementsNode(97...98)([IntegerNode(97...98)()]),
-             (98...99)
-           )],
-          (99...100)
-        )],
-       (84...89)
-     ),
-     UndefNode(102...116)(
-       [SymbolNode(108...116)(nil, (108...116), nil, "Constant")],
-       (102...107)
-     )]
-  )
-)
+@ ProgramNode (location: (0...116))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...116))
+    └── body: (length: 9)
+        ├── @ UndefNode (location: (0...7))
+        │   ├── names: (length: 1)
+        │   │   └── @ SymbolNode (location: (6...7))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (6...7) = "a"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a"
+        │   └── keyword_loc: (0...5) = "undef"
+        ├── @ UndefNode (location: (9...19))
+        │   ├── names: (length: 2)
+        │   │   ├── @ SymbolNode (location: (15...16))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (15...16) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ SymbolNode (location: (18...19))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (18...19) = "b"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "b"
+        │   └── keyword_loc: (9...14) = "undef"
+        ├── @ UndefNode (location: (21...29))
+        │   ├── names: (length: 1)
+        │   │   └── @ SymbolNode (location: (27...29))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (27...29) = "if"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "if"
+        │   └── keyword_loc: (21...26) = "undef"
+        ├── @ UndefNode (location: (31...40))
+        │   ├── names: (length: 1)
+        │   │   └── @ SymbolNode (location: (37...40))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (37...40) = "<=>"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "<=>"
+        │   └── keyword_loc: (31...36) = "undef"
+        ├── @ UndefNode (location: (42...50))
+        │   ├── names: (length: 1)
+        │   │   └── @ SymbolNode (location: (48...50))
+        │   │       ├── opening_loc: (48...49) = ":"
+        │   │       ├── value_loc: (49...50) = "a"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a"
+        │   └── keyword_loc: (42...47) = "undef"
+        ├── @ UndefNode (location: (52...68))
+        │   ├── names: (length: 3)
+        │   │   ├── @ SymbolNode (location: (58...60))
+        │   │   │   ├── opening_loc: (58...59) = ":"
+        │   │   │   ├── value_loc: (59...60) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   ├── @ SymbolNode (location: (62...64))
+        │   │   │   ├── opening_loc: (62...63) = ":"
+        │   │   │   ├── value_loc: (63...64) = "b"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "b"
+        │   │   └── @ SymbolNode (location: (66...68))
+        │   │       ├── opening_loc: (66...67) = ":"
+        │   │       ├── value_loc: (67...68) = "c"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "c"
+        │   └── keyword_loc: (52...57) = "undef"
+        ├── @ UndefNode (location: (70...82))
+        │   ├── names: (length: 1)
+        │   │   └── @ SymbolNode (location: (76...82))
+        │   │       ├── opening_loc: (76...78) = ":'"
+        │   │       ├── value_loc: (78...81) = "abc"
+        │   │       ├── closing_loc: (81...82) = "'"
+        │   │       └── unescaped: "abc"
+        │   └── keyword_loc: (70...75) = "undef"
+        ├── @ UndefNode (location: (84...100))
+        │   ├── names: (length: 1)
+        │   │   └── @ InterpolatedSymbolNode (location: (90...100))
+        │   │       ├── opening_loc: (90...92) = ":\""
+        │   │       ├── parts: (length: 2)
+        │   │       │   ├── @ StringNode (location: (92...95))
+        │   │       │   │   ├── opening_loc: ∅
+        │   │       │   │   ├── content_loc: (92...95) = "abc"
+        │   │       │   │   ├── closing_loc: ∅
+        │   │       │   │   └── unescaped: "abc"
+        │   │       │   └── @ EmbeddedStatementsNode (location: (95...99))
+        │   │       │       ├── opening_loc: (95...97) = "\#{"
+        │   │       │       ├── statements:
+        │   │       │       │   @ StatementsNode (location: (97...98))
+        │   │       │       │   └── body: (length: 1)
+        │   │       │       │       └── @ IntegerNode (location: (97...98))
+        │   │       │       └── closing_loc: (98...99) = "}"
+        │   │       └── closing_loc: (99...100) = "\""
+        │   └── keyword_loc: (84...89) = "undef"
+        └── @ UndefNode (location: (102...116))
+            ├── names: (length: 1)
+            │   └── @ SymbolNode (location: (108...116))
+            │       ├── opening_loc: ∅
+            │       ├── value_loc: (108...116) = "Constant"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "Constant"
+            └── keyword_loc: (102...107) = "undef"
diff --git a/test/yarp/snapshots/unescaping.txt b/test/yarp/snapshots/unescaping.txt
index 17387dbc6c..d0208ca2a5 100644
--- a/test/yarp/snapshots/unescaping.txt
+++ b/test/yarp/snapshots/unescaping.txt
@@ -1,23 +1,34 @@
-ProgramNode(0...39)(
-  [],
-  StatementsNode(0...39)(
-    [ArrayNode(0...10)(
-       [StringNode(1...9)((1...2), (2...8), (8...9), "\u0003{1}")],
-       (0...1),
-       (9...10)
-     ),
-     RegularExpressionNode(12...20)(
-       (12...13),
-       (13...19),
-       (19...20),
-       "\u0003{1}",
-       0
-     ),
-     StringNode(22...30)((22...23), (23...29), (29...30), "\u0003{1}"),
-     InterpolatedStringNode(32...39)(
-       (32...39),
-       [StringNode(40...50)(nil, (40...50), nil, "\u0003{1}\n")],
-       (50...55)
-     )]
-  )
-)
+@ ProgramNode (location: (0...39))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...39))
+    └── body: (length: 4)
+        ├── @ ArrayNode (location: (0...10))
+        │   ├── elements: (length: 1)
+        │   │   └── @ StringNode (location: (1...9))
+        │   │       ├── opening_loc: (1...2) = "\""
+        │   │       ├── content_loc: (2...8) = "\\c\#{1}"
+        │   │       ├── closing_loc: (8...9) = "\""
+        │   │       └── unescaped: "\u0003{1}"
+        │   ├── opening_loc: (0...1) = "["
+        │   └── closing_loc: (9...10) = "]"
+        ├── @ RegularExpressionNode (location: (12...20))
+        │   ├── opening_loc: (12...13) = "/"
+        │   ├── content_loc: (13...19) = "\\c\#{1}"
+        │   ├── closing_loc: (19...20) = "/"
+        │   ├── unescaped: "\u0003{1}"
+        │   └── flags: 
+        ├── @ StringNode (location: (22...30))
+        │   ├── opening_loc: (22...23) = "\""
+        │   ├── content_loc: (23...29) = "\\c\#{1}"
+        │   ├── closing_loc: (29...30) = "\""
+        │   └── unescaped: "\u0003{1}"
+        └── @ InterpolatedStringNode (location: (32...39))
+            ├── opening_loc: (32...39) = "<<~HERE"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (40...50))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (40...50) = "   \\c\#{1}\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\u0003{1}\n"
+            └── closing_loc: (50...55) = "HERE\n"
diff --git a/test/yarp/snapshots/unless.txt b/test/yarp/snapshots/unless.txt
index 66d61a7307..badf1fe82e 100644
--- a/test/yarp/snapshots/unless.txt
+++ b/test/yarp/snapshots/unless.txt
@@ -1,83 +1,118 @@
-ProgramNode(0...141)(
-  [],
-  StatementsNode(0...141)(
-    [UnlessNode(0...19)(
-       (0...6),
-       TrueNode(7...11)(),
-       StatementsNode(13...14)([IntegerNode(13...14)()]),
-       nil,
-       (16...19)
-     ),
-     UnlessNode(21...45)(
-       (21...27),
-       TrueNode(28...32)(),
-       StatementsNode(33...34)([IntegerNode(33...34)()]),
-       ElseNode(35...45)(
-         (35...39),
-         StatementsNode(40...41)([IntegerNode(40...41)()]),
-         (42...45)
-       ),
-       (42...45)
-     ),
-     UnlessNode(47...60)(
-       (49...55),
-       TrueNode(56...60)(),
-       StatementsNode(47...48)([IntegerNode(47...48)()]),
-       nil,
-       nil
-     ),
-     UnlessNode(62...79)(
-       (68...74),
-       TrueNode(75...79)(),
-       StatementsNode(62...67)([BreakNode(62...67)(nil, (62...67))]),
-       nil,
-       nil
-     ),
-     UnlessNode(81...97)(
-       (86...92),
-       TrueNode(93...97)(),
-       StatementsNode(81...85)([NextNode(81...85)(nil, (81...85))]),
-       nil,
-       nil
-     ),
-     UnlessNode(99...117)(
-       (106...112),
-       TrueNode(113...117)(),
-       StatementsNode(99...105)([ReturnNode(99...105)((99...105), nil)]),
-       nil,
-       nil
-     ),
-     UnlessNode(119...141)(
-       (130...136),
-       CallNode(137...141)(
-         nil,
-         nil,
-         (137...141),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "bar?"
-       ),
-       StatementsNode(119...129)(
-         [CallNode(119...129)(
-            nil,
-            nil,
-            (119...122),
-            nil,
-            ArgumentsNode(123...129)(
-              [SymbolNode(123...125)((123...124), (124...125), nil, "a"),
-               SymbolNode(127...129)((127...128), (128...129), nil, "b")]
-            ),
-            nil,
-            nil,
-            0,
-            "foo"
-          )]
-       ),
-       nil,
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...141))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...141))
+    └── body: (length: 7)
+        ├── @ UnlessNode (location: (0...19))
+        │   ├── keyword_loc: (0...6) = "unless"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (7...11))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (13...14))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (13...14))
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (16...19) = "end"
+        ├── @ UnlessNode (location: (21...45))
+        │   ├── keyword_loc: (21...27) = "unless"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (28...32))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (33...34))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (33...34))
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (35...45))
+        │   │   ├── else_keyword_loc: (35...39) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (40...41))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (40...41))
+        │   │   └── end_keyword_loc: (42...45) = "end"
+        │   └── end_keyword_loc: (42...45) = "end"
+        ├── @ UnlessNode (location: (47...60))
+        │   ├── keyword_loc: (49...55) = "unless"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (56...60))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (47...48))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (47...48))
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ UnlessNode (location: (62...79))
+        │   ├── keyword_loc: (68...74) = "unless"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (75...79))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (62...67))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (62...67))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (62...67) = "break"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ UnlessNode (location: (81...97))
+        │   ├── keyword_loc: (86...92) = "unless"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (93...97))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (81...85))
+        │   │   └── body: (length: 1)
+        │   │       └── @ NextNode (location: (81...85))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (81...85) = "next"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ UnlessNode (location: (99...117))
+        │   ├── keyword_loc: (106...112) = "unless"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (113...117))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (99...105))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ReturnNode (location: (99...105))
+        │   │           ├── keyword_loc: (99...105) = "return"
+        │   │           └── arguments: ∅
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: ∅
+        └── @ UnlessNode (location: (119...141))
+            ├── keyword_loc: (130...136) = "unless"
+            ├── predicate:
+            │   @ CallNode (location: (137...141))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (137...141) = "bar?"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "bar?"
+            ├── statements:
+            │   @ StatementsNode (location: (119...129))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (119...129))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (119...122) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (123...129))
+            │           │   └── arguments: (length: 2)
+            │           │       ├── @ SymbolNode (location: (123...125))
+            │           │       │   ├── opening_loc: (123...124) = ":"
+            │           │       │   ├── value_loc: (124...125) = "a"
+            │           │       │   ├── closing_loc: ∅
+            │           │       │   └── unescaped: "a"
+            │           │       └── @ SymbolNode (location: (127...129))
+            │           │           ├── opening_loc: (127...128) = ":"
+            │           │           ├── value_loc: (128...129) = "b"
+            │           │           ├── closing_loc: ∅
+            │           │           └── unescaped: "b"
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "foo"
+            ├── consequent: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/unparser/corpus/literal/alias.txt b/test/yarp/snapshots/unparser/corpus/literal/alias.txt
index 18e16e1dd9..96a4e6f636 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/alias.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/alias.txt
@@ -1,15 +1,27 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)(
-    [AliasNode(0...15)(
-       GlobalVariableReadNode(6...10)(:$foo),
-       GlobalVariableReadNode(11...15)(:$bar),
-       (0...5)
-     ),
-     AliasNode(16...31)(
-       SymbolNode(22...26)((22...23), (23...26), nil, "foo"),
-       SymbolNode(27...31)((27...28), (28...31), nil, "bar"),
-       (16...21)
-     )]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 2)
+        ├── @ AliasNode (location: (0...15))
+        │   ├── new_name:
+        │   │   @ GlobalVariableReadNode (location: (6...10))
+        │   │   └── name: :$foo
+        │   ├── old_name:
+        │   │   @ GlobalVariableReadNode (location: (11...15))
+        │   │   └── name: :$bar
+        │   └── keyword_loc: (0...5) = "alias"
+        └── @ AliasNode (location: (16...31))
+            ├── new_name:
+            │   @ SymbolNode (location: (22...26))
+            │   ├── opening_loc: (22...23) = ":"
+            │   ├── value_loc: (23...26) = "foo"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "foo"
+            ├── old_name:
+            │   @ SymbolNode (location: (27...31))
+            │   ├── opening_loc: (27...28) = ":"
+            │   ├── value_loc: (28...31) = "bar"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "bar"
+            └── keyword_loc: (16...21) = "alias"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/assignment.txt b/test/yarp/snapshots/unparser/corpus/literal/assignment.txt
index 3f82c3a8e4..bd1a2a8256 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/assignment.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/assignment.txt
@@ -1,690 +1,944 @@
-ProgramNode(0...704)(
-  [:a, :b, :foo, :c, :x],
-  StatementsNode(0...704)(
-    [GlobalVariableWriteNode(0...6)(
-       :$a,
-       (0...2),
-       IntegerNode(5...6)(),
-       (3...4)
-     ),
-     MultiWriteNode(7...24)(
-       [GlobalVariableTargetNode(8...10)(:$a),
-        GlobalVariableTargetNode(12...14)(:$b)],
-       (7...8),
-       (14...15),
-       (16...17),
-       ArrayNode(18...24)(
-         [IntegerNode(19...20)(), IntegerNode(22...23)()],
-         (18...19),
-         (23...24)
-       )
-     ),
-     MultiWriteNode(25...38)(
-       [MultiTargetNode(26...30)(
-          [LocalVariableTargetNode(27...28)(:a, 0),
-           SplatNode(28...29)((28...29), nil)],
-          (26...27),
-          (29...30)
-        ),
-        LocalVariableTargetNode(32...33)(:b, 0)],
-       (25...26),
-       (33...34),
-       (35...36),
-       IntegerNode(37...38)()
-     ),
-     MultiWriteNode(39...48)(
-       [SplatNode(40...42)(
-          (40...41),
-          LocalVariableTargetNode(41...42)(:a, 0)
-        )],
-       (39...40),
-       (42...43),
-       (44...45),
-       ArrayNode(46...48)([], (46...47), (47...48))
-     ),
-     MultiWriteNode(49...64)(
-       [SplatNode(50...54)(
-          (50...51),
-          LocalVariableTargetNode(51...54)(:foo, 0)
-        )],
-       (49...50),
-       (54...55),
-       (56...57),
-       ArrayNode(58...64)(
-         [IntegerNode(59...60)(), IntegerNode(62...63)()],
-         (58...59),
-         (63...64)
-       )
-     ),
-     MultiWriteNode(65...84)(
-       [ClassVariableTargetNode(66...69)(:@@a),
-        ClassVariableTargetNode(71...74)(:@@b)],
-       (65...66),
-       (74...75),
-       (76...77),
-       ArrayNode(78...84)(
-         [IntegerNode(79...80)(), IntegerNode(82...83)()],
-         (78...79),
-         (83...84)
-       )
-     ),
-     MultiWriteNode(85...102)(
-       [InstanceVariableTargetNode(86...88)(:@a),
-        InstanceVariableTargetNode(90...92)(:@b)],
-       (85...86),
-       (92...93),
-       (94...95),
-       ArrayNode(96...102)(
-         [IntegerNode(97...98)(), IntegerNode(100...101)()],
-         (96...97),
-         (101...102)
-       )
-     ),
-     MultiWriteNode(103...128)(
-       [LocalVariableTargetNode(104...105)(:a, 0),
-        MultiTargetNode(107...113)(
-          [LocalVariableTargetNode(108...109)(:b, 0),
-           LocalVariableTargetNode(111...112)(:c, 0)],
-          (107...108),
-          (112...113)
-        )],
-       (103...104),
-       (113...114),
-       (115...116),
-       ArrayNode(117...128)(
-         [IntegerNode(118...119)(),
-          ArrayNode(121...127)(
-            [IntegerNode(122...123)(), IntegerNode(125...126)()],
-            (121...122),
-            (126...127)
-          )],
-         (117...118),
-         (127...128)
-       )
-     ),
-     MultiWriteNode(129...144)(
-       [LocalVariableTargetNode(130...131)(:a, 0),
-        SplatNode(133...134)((133...134), nil)],
-       (129...130),
-       (134...135),
-       (136...137),
-       ArrayNode(138...144)(
-         [IntegerNode(139...140)(), IntegerNode(142...143)()],
-         (138...139),
-         (143...144)
-       )
-     ),
-     MultiWriteNode(145...163)(
-       [LocalVariableTargetNode(146...147)(:a, 0),
-        SplatNode(149...153)(
-          (149...150),
-          LocalVariableTargetNode(150...153)(:foo, 0)
-        )],
-       (145...146),
-       (153...154),
-       (155...156),
-       ArrayNode(157...163)(
-         [IntegerNode(158...159)(), IntegerNode(161...162)()],
-         (157...158),
-         (162...163)
-       )
-     ),
-     MultiWriteNode(164...179)(
-       [LocalVariableTargetNode(165...166)(:a, 0),
-        LocalVariableTargetNode(168...169)(:b, 0)],
-       (164...165),
-       (169...170),
-       (171...172),
-       ArrayNode(173...179)(
-         [IntegerNode(174...175)(), IntegerNode(177...178)()],
-         (173...174),
-         (178...179)
-       )
-     ),
-     MultiWriteNode(180...192)(
-       [LocalVariableTargetNode(181...182)(:a, 0),
-        LocalVariableTargetNode(184...185)(:b, 0)],
-       (180...181),
-       (185...186),
-       (187...188),
-       LocalVariableReadNode(189...192)(:foo, 0)
-     ),
-     MultiWriteNode(193...203)(
-       [LocalVariableTargetNode(194...195)(:a, 0),
-        SplatNode(195...196)((195...196), nil)],
-       (193...194),
-       (196...197),
-       (198...199),
-       LocalVariableReadNode(200...203)(:foo, 0)
-     ),
-     MultiWriteNode(204...227)(
-       [CallNode(205...210)(
-          LocalVariableReadNode(205...206)(:a, 0),
-          (206...207),
-          (207...210),
-          nil,
-          nil,
-          nil,
-          nil,
-          0,
-          "foo="
-        ),
-        CallNode(212...217)(
-          LocalVariableReadNode(212...213)(:a, 0),
-          (213...214),
-          (214...217),
-          nil,
-          nil,
-          nil,
-          nil,
-          0,
-          "bar="
-        )],
-       (204...205),
-       (217...218),
-       (219...220),
-       ArrayNode(221...227)(
-         [IntegerNode(222...223)(), IntegerNode(225...226)()],
-         (221...222),
-         (226...227)
-       )
-     ),
-     MultiWriteNode(228...252)(
-       [CallNode(229...236)(
-          LocalVariableReadNode(229...230)(:a, 0),
-          nil,
-          (230...236),
-          (230...231),
-          ArgumentsNode(231...235)(
-            [SplatNode(231...235)(
-               (231...232),
-               LocalVariableReadNode(232...235)(:foo, 0)
-             )]
-          ),
-          (235...236),
-          nil,
-          0,
-          "[]="
-        ),
-        CallNode(238...242)(
-          LocalVariableReadNode(238...239)(:a, 0),
-          nil,
-          (239...242),
-          (239...240),
-          ArgumentsNode(240...241)([IntegerNode(240...241)()]),
-          (241...242),
-          nil,
-          0,
-          "[]="
-        )],
-       (228...229),
-       (242...243),
-       (244...245),
-       ArrayNode(246...252)(
-         [IntegerNode(247...248)(), IntegerNode(250...251)()],
-         (246...247),
-         (251...252)
-       )
-     ),
-     MultiWriteNode(253...274)(
-       [CallNode(254...258)(
-          LocalVariableReadNode(254...255)(:a, 0),
-          nil,
-          (255...258),
-          (255...256),
-          ArgumentsNode(256...257)([IntegerNode(256...257)()]),
-          (257...258),
-          nil,
-          0,
-          "[]="
-        ),
-        CallNode(260...264)(
-          LocalVariableReadNode(260...261)(:a, 0),
-          nil,
-          (261...264),
-          (261...262),
-          ArgumentsNode(262...263)([IntegerNode(262...263)()]),
-          (263...264),
-          nil,
-          0,
-          "[]="
-        )],
-       (253...254),
-       (264...265),
-       (266...267),
-       ArrayNode(268...274)(
-         [IntegerNode(269...270)(), IntegerNode(272...273)()],
-         (268...269),
-         (273...274)
-       )
-     ),
-     MultiWriteNode(275...287)(
-       [SplatNode(276...282)(
-          (276...277),
-          CallNode(277...282)(
-            LocalVariableReadNode(277...278)(:c, 0),
-            (278...279),
-            (279...282),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "foo="
-          )
-        )],
-       (275...276),
-       (282...283),
-       (284...285),
-       IntegerNode(286...287)()
-     ),
-     ConstantPathWriteNode(288...301)(
-       ConstantPathNode(288...293)(
-         nil,
-         ConstantReadNode(290...293)(:Foo),
-         (288...290)
-       ),
-       (294...295),
-       ConstantPathNode(296...301)(
-         nil,
-         ConstantReadNode(298...301)(:Bar),
-         (296...298)
-       )
-     ),
-     ClassVariableWriteNode(302...309)(
-       :@@a,
-       (302...305),
-       IntegerNode(308...309)(),
-       (306...307)
-     ),
-     InstanceVariableWriteNode(310...316)(
-       :@a,
-       (310...312),
-       IntegerNode(315...316)(),
-       (313...314)
-     ),
-     ConstantWriteNode(317...326)(
-       :CONST,
-       (317...322),
-       IntegerNode(325...326)(),
-       (323...324)
-     ),
-     ConstantPathWriteNode(327...350)(
-       ConstantPathNode(327...346)(
-         ConstantPathNode(327...339)(
-           ConstantReadNode(327...331)(:Name),
-           ConstantReadNode(333...339)(:Spaced),
-           (331...333)
-         ),
-         ConstantReadNode(341...346)(:CONST),
-         (339...341)
-       ),
-       (347...348),
-       IntegerNode(349...350)()
-     ),
-     LocalVariableWriteNode(351...367)(
-       :a,
-       0,
-       (351...352),
-       ParenthesesNode(355...367)(
-         StatementsNode(356...366)(
-           [MultiWriteNode(356...366)(
-              [LocalVariableTargetNode(357...358)(:b, 0),
-               LocalVariableTargetNode(360...361)(:c, 0)],
-              (356...357),
-              (361...362),
-              (363...364),
-              IntegerNode(365...366)()
-            )]
-         ),
-         (355...356),
-         (366...367)
-       ),
-       (353...354)
-     ),
-     LocalVariableWriteNode(368...373)(
-       :a,
-       0,
-       (368...369),
-       IntegerNode(372...373)(),
-       (370...371)
-     ),
-     LocalVariableWriteNode(374...385)(
-       :foo,
-       0,
-       (374...377),
-       CallNode(380...385)(
-         nil,
-         nil,
-         (380...383),
-         (383...384),
-         nil,
-         (384...385),
-         nil,
-         0,
-         "foo"
-       ),
-       (378...379)
-     ),
-     CallNode(386...395)(
-       LocalVariableReadNode(386...389)(:foo, 0),
-       (389...390),
-       (390...393),
-       (393...394),
-       nil,
-       (394...395),
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(396...409)(
-       LocalVariableReadNode(396...399)(:foo, 0),
-       (399...400),
-       (400...403),
-       (403...404),
-       ArgumentsNode(404...408)(
-         [IntegerNode(404...405)(), IntegerNode(407...408)()]
-       ),
-       (408...409),
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(410...421)(
-       LocalVariableReadNode(410...413)(:foo, 0),
-       (413...414),
-       (414...417),
-       nil,
-       ArgumentsNode(417...421)([TrueNode(417...421)()]),
-       nil,
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(422...441)(
-       LocalVariableReadNode(422...425)(:foo, 0),
-       nil,
-       (425...433),
-       (425...426),
-       ArgumentsNode(426...441)(
-         [SplatNode(426...432)(
-            (426...427),
-            CallNode(427...432)(
-              nil,
-              nil,
-              (427...432),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "index"
-            )
-          ),
-          CallNode(436...441)(
-            nil,
-            nil,
-            (436...441),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "value"
-          )]
-       ),
-       (432...433),
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(442...459)(
-       LocalVariableReadNode(442...445)(:foo, 0),
-       nil,
-       (445...451),
-       (445...446),
-       ArgumentsNode(446...459)(
-         [RangeNode(446...450)(
-            IntegerNode(446...447)(),
-            IntegerNode(449...450)(),
-            (447...449),
-            0
-          ),
-          CallNode(454...459)(
-            nil,
-            nil,
-            (454...459),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "value"
-          )]
-       ),
-       (450...451),
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(460...469)(
-       LocalVariableReadNode(460...463)(:foo, 0),
-       nil,
-       (463...465),
-       (463...464),
-       ArgumentsNode(468...469)([IntegerNode(468...469)()]),
-       (464...465),
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(470...487)(
-       LocalVariableReadNode(470...473)(:foo, 0),
-       nil,
-       (473...479),
-       (473...474),
-       ArgumentsNode(474...487)(
-         [LocalVariableReadNode(474...475)(:a, 0),
-          LocalVariableReadNode(477...478)(:b, 0),
-          CallNode(482...487)(
-            nil,
-            nil,
-            (482...487),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "value"
-          )]
-       ),
-       (478...479),
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(488...506)(
-       LocalVariableReadNode(488...491)(:foo, 0),
-       nil,
-       (491...498),
-       (491...492),
-       ArgumentsNode(492...506)(
-         [CallNode(492...497)(
-            nil,
-            nil,
-            (492...497),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "index"
-          ),
-          CallNode(501...506)(
-            nil,
-            nil,
-            (501...506),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "value"
-          )]
-       ),
-       (497...498),
-       nil,
-       0,
-       "[]="
-     ),
-     LocalVariableWriteNode(507...514)(
-       :x,
-       0,
-       (507...508),
-       StringNode(511...514)((511...513), (513...513), (513...514), ""),
-       (509...510)
-     ),
-     CallNode(515...522)(
-       LocalVariableReadNode(515...516)(:x, 0),
-       (516...517),
-       (517...518),
-       nil,
-       ArgumentsNode(519...522)(
-         [StringNode(519...522)((519...521), (521...521), (521...522), "")]
-       ),
-       nil,
-       nil,
-       0,
-       "x="
-     ),
-     CallNode(523...535)(
-       LocalVariableReadNode(523...524)(:x, 0),
-       nil,
-       (524...529),
-       (524...525),
-       ArgumentsNode(525...535)(
-         [StringNode(525...528)((525...527), (527...527), (527...528), ""),
-          CallNode(532...535)(
-            nil,
-            nil,
-            (532...535),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       (528...529),
-       nil,
-       0,
-       "[]="
-     ),
-     CallOrWriteNode(536...550)(
-       LocalVariableReadNode(536...537)(:a, 0),
-       nil,
-       (537...542),
-       (537...538),
-       ArgumentsNode(538...541)(
-         [StringNode(538...541)((538...540), (540...540), (540...541), "")]
-       ),
-       (541...542),
-       0,
-       "[]",
-       "[]=",
-       (543...546),
-       CallNode(547...550)(nil, nil, (547...550), nil, nil, nil, nil, 2, "bar")
-     ),
-     InstanceVariableOrWriteNode(551...561)(
-       :@a,
-       (551...553),
-       (554...557),
-       StringNode(558...561)((558...560), (560...560), (560...561), "")
-     ),
-     LocalVariableWriteNode(562...576)(
-       :x,
-       0,
-       (562...563),
-       InterpolatedStringNode(566...576)(
-         (566...576),
-         [StringNode(577...579)(nil, (577...579), nil, "  "),
-          EmbeddedStatementsNode(579...582)((579...581), nil, (581...582)),
-          StringNode(582...583)(nil, (582...583), nil, "\n")],
-         (583...591)
-       ),
-       (564...565)
-     ),
-     CallNode(591...605)(
-       LocalVariableReadNode(591...592)(:x, 0),
-       (592...593),
-       (593...594),
-       nil,
-       ArgumentsNode(595...605)(
-         [InterpolatedStringNode(595...605)(
-            (595...605),
-            [StringNode(606...608)(nil, (606...608), nil, "  "),
-             EmbeddedStatementsNode(608...611)((608...610), nil, (610...611)),
-             StringNode(611...612)(nil, (611...612), nil, "\n")],
-            (612...620)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "x="
-     ),
-     CallNode(620...636)(
-       LocalVariableReadNode(620...621)(:x, 0),
-       nil,
-       (621...623),
-       (621...622),
-       ArgumentsNode(626...636)(
-         [InterpolatedStringNode(626...636)(
-            (626...636),
-            [StringNode(637...639)(nil, (637...639), nil, "  "),
-             EmbeddedStatementsNode(639...642)((639...641), nil, (641...642)),
-             StringNode(642...643)(nil, (642...643), nil, "\n")],
-            (643...651)
-          )]
-       ),
-       (622...623),
-       nil,
-       0,
-       "[]="
-     ),
-     CallOrWriteNode(651...672)(
-       LocalVariableReadNode(651...652)(:a, 0),
-       nil,
-       (652...664),
-       (652...653),
-       ArgumentsNode(653...663)(
-         [InterpolatedStringNode(653...663)(
-            (653...663),
-            [StringNode(673...675)(nil, (673...675), nil, "  "),
-             EmbeddedStatementsNode(675...678)((675...677), nil, (677...678)),
-             StringNode(678...679)(nil, (678...679), nil, "\n")],
-            (679...687)
-          )]
-       ),
-       (663...664),
-       0,
-       "[]",
-       "[]=",
-       (665...668),
-       CallNode(669...672)(nil, nil, (669...672), nil, nil, nil, nil, 2, "bar")
-     ),
-     InstanceVariableOrWriteNode(687...704)(
-       :@a,
-       (687...689),
-       (690...693),
-       InterpolatedStringNode(694...704)(
-         (694...704),
-         [StringNode(705...707)(nil, (705...707), nil, "  "),
-          EmbeddedStatementsNode(707...710)((707...709), nil, (709...710)),
-          StringNode(710...711)(nil, (710...711), nil, "\n")],
-         (711...719)
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...704))
+├── locals: [:a, :b, :foo, :c, :x]
+└── statements:
+    @ StatementsNode (location: (0...704))
+    └── body: (length: 43)
+        ├── @ GlobalVariableWriteNode (location: (0...6))
+        │   ├── name: :$a
+        │   ├── name_loc: (0...2) = "$a"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (5...6))
+        │   └── operator_loc: (3...4) = "="
+        ├── @ MultiWriteNode (location: (7...24))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ GlobalVariableTargetNode (location: (8...10))
+        │   │   │   └── name: :$a
+        │   │   └── @ GlobalVariableTargetNode (location: (12...14))
+        │   │       └── name: :$b
+        │   ├── lparen_loc: (7...8) = "("
+        │   ├── rparen_loc: (14...15) = ")"
+        │   ├── operator_loc: (16...17) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (18...24))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (19...20))
+        │       │   └── @ IntegerNode (location: (22...23))
+        │       ├── opening_loc: (18...19) = "["
+        │       └── closing_loc: (23...24) = "]"
+        ├── @ MultiWriteNode (location: (25...38))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ MultiTargetNode (location: (26...30))
+        │   │   │   ├── targets: (length: 2)
+        │   │   │   │   ├── @ LocalVariableTargetNode (location: (27...28))
+        │   │   │   │   │   ├── name: :a
+        │   │   │   │   │   └── depth: 0
+        │   │   │   │   └── @ SplatNode (location: (28...29))
+        │   │   │   │       ├── operator_loc: (28...29) = ","
+        │   │   │   │       └── expression: ∅
+        │   │   │   ├── lparen_loc: (26...27) = "("
+        │   │   │   └── rparen_loc: (29...30) = ")"
+        │   │   └── @ LocalVariableTargetNode (location: (32...33))
+        │   │       ├── name: :b
+        │   │       └── depth: 0
+        │   ├── lparen_loc: (25...26) = "("
+        │   ├── rparen_loc: (33...34) = ")"
+        │   ├── operator_loc: (35...36) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (37...38))
+        ├── @ MultiWriteNode (location: (39...48))
+        │   ├── targets: (length: 1)
+        │   │   └── @ SplatNode (location: (40...42))
+        │   │       ├── operator_loc: (40...41) = "*"
+        │   │       └── expression:
+        │   │           @ LocalVariableTargetNode (location: (41...42))
+        │   │           ├── name: :a
+        │   │           └── depth: 0
+        │   ├── lparen_loc: (39...40) = "("
+        │   ├── rparen_loc: (42...43) = ")"
+        │   ├── operator_loc: (44...45) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (46...48))
+        │       ├── elements: (length: 0)
+        │       ├── opening_loc: (46...47) = "["
+        │       └── closing_loc: (47...48) = "]"
+        ├── @ MultiWriteNode (location: (49...64))
+        │   ├── targets: (length: 1)
+        │   │   └── @ SplatNode (location: (50...54))
+        │   │       ├── operator_loc: (50...51) = "*"
+        │   │       └── expression:
+        │   │           @ LocalVariableTargetNode (location: (51...54))
+        │   │           ├── name: :foo
+        │   │           └── depth: 0
+        │   ├── lparen_loc: (49...50) = "("
+        │   ├── rparen_loc: (54...55) = ")"
+        │   ├── operator_loc: (56...57) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (58...64))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (59...60))
+        │       │   └── @ IntegerNode (location: (62...63))
+        │       ├── opening_loc: (58...59) = "["
+        │       └── closing_loc: (63...64) = "]"
+        ├── @ MultiWriteNode (location: (65...84))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ ClassVariableTargetNode (location: (66...69))
+        │   │   │   └── name: :@@a
+        │   │   └── @ ClassVariableTargetNode (location: (71...74))
+        │   │       └── name: :@@b
+        │   ├── lparen_loc: (65...66) = "("
+        │   ├── rparen_loc: (74...75) = ")"
+        │   ├── operator_loc: (76...77) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (78...84))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (79...80))
+        │       │   └── @ IntegerNode (location: (82...83))
+        │       ├── opening_loc: (78...79) = "["
+        │       └── closing_loc: (83...84) = "]"
+        ├── @ MultiWriteNode (location: (85...102))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ InstanceVariableTargetNode (location: (86...88))
+        │   │   │   └── name: :@a
+        │   │   └── @ InstanceVariableTargetNode (location: (90...92))
+        │   │       └── name: :@b
+        │   ├── lparen_loc: (85...86) = "("
+        │   ├── rparen_loc: (92...93) = ")"
+        │   ├── operator_loc: (94...95) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (96...102))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (97...98))
+        │       │   └── @ IntegerNode (location: (100...101))
+        │       ├── opening_loc: (96...97) = "["
+        │       └── closing_loc: (101...102) = "]"
+        ├── @ MultiWriteNode (location: (103...128))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (104...105))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   └── @ MultiTargetNode (location: (107...113))
+        │   │       ├── targets: (length: 2)
+        │   │       │   ├── @ LocalVariableTargetNode (location: (108...109))
+        │   │       │   │   ├── name: :b
+        │   │       │   │   └── depth: 0
+        │   │       │   └── @ LocalVariableTargetNode (location: (111...112))
+        │   │       │       ├── name: :c
+        │   │       │       └── depth: 0
+        │   │       ├── lparen_loc: (107...108) = "("
+        │   │       └── rparen_loc: (112...113) = ")"
+        │   ├── lparen_loc: (103...104) = "("
+        │   ├── rparen_loc: (113...114) = ")"
+        │   ├── operator_loc: (115...116) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (117...128))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (118...119))
+        │       │   └── @ ArrayNode (location: (121...127))
+        │       │       ├── elements: (length: 2)
+        │       │       │   ├── @ IntegerNode (location: (122...123))
+        │       │       │   └── @ IntegerNode (location: (125...126))
+        │       │       ├── opening_loc: (121...122) = "["
+        │       │       └── closing_loc: (126...127) = "]"
+        │       ├── opening_loc: (117...118) = "["
+        │       └── closing_loc: (127...128) = "]"
+        ├── @ MultiWriteNode (location: (129...144))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (130...131))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   └── @ SplatNode (location: (133...134))
+        │   │       ├── operator_loc: (133...134) = "*"
+        │   │       └── expression: ∅
+        │   ├── lparen_loc: (129...130) = "("
+        │   ├── rparen_loc: (134...135) = ")"
+        │   ├── operator_loc: (136...137) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (138...144))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (139...140))
+        │       │   └── @ IntegerNode (location: (142...143))
+        │       ├── opening_loc: (138...139) = "["
+        │       └── closing_loc: (143...144) = "]"
+        ├── @ MultiWriteNode (location: (145...163))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (146...147))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   └── @ SplatNode (location: (149...153))
+        │   │       ├── operator_loc: (149...150) = "*"
+        │   │       └── expression:
+        │   │           @ LocalVariableTargetNode (location: (150...153))
+        │   │           ├── name: :foo
+        │   │           └── depth: 0
+        │   ├── lparen_loc: (145...146) = "("
+        │   ├── rparen_loc: (153...154) = ")"
+        │   ├── operator_loc: (155...156) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (157...163))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (158...159))
+        │       │   └── @ IntegerNode (location: (161...162))
+        │       ├── opening_loc: (157...158) = "["
+        │       └── closing_loc: (162...163) = "]"
+        ├── @ MultiWriteNode (location: (164...179))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (165...166))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   └── @ LocalVariableTargetNode (location: (168...169))
+        │   │       ├── name: :b
+        │   │       └── depth: 0
+        │   ├── lparen_loc: (164...165) = "("
+        │   ├── rparen_loc: (169...170) = ")"
+        │   ├── operator_loc: (171...172) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (173...179))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (174...175))
+        │       │   └── @ IntegerNode (location: (177...178))
+        │       ├── opening_loc: (173...174) = "["
+        │       └── closing_loc: (178...179) = "]"
+        ├── @ MultiWriteNode (location: (180...192))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (181...182))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   └── @ LocalVariableTargetNode (location: (184...185))
+        │   │       ├── name: :b
+        │   │       └── depth: 0
+        │   ├── lparen_loc: (180...181) = "("
+        │   ├── rparen_loc: (185...186) = ")"
+        │   ├── operator_loc: (187...188) = "="
+        │   └── value:
+        │       @ LocalVariableReadNode (location: (189...192))
+        │       ├── name: :foo
+        │       └── depth: 0
+        ├── @ MultiWriteNode (location: (193...203))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (194...195))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   └── @ SplatNode (location: (195...196))
+        │   │       ├── operator_loc: (195...196) = ","
+        │   │       └── expression: ∅
+        │   ├── lparen_loc: (193...194) = "("
+        │   ├── rparen_loc: (196...197) = ")"
+        │   ├── operator_loc: (198...199) = "="
+        │   └── value:
+        │       @ LocalVariableReadNode (location: (200...203))
+        │       ├── name: :foo
+        │       └── depth: 0
+        ├── @ MultiWriteNode (location: (204...227))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ CallNode (location: (205...210))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ LocalVariableReadNode (location: (205...206))
+        │   │   │   │   ├── name: :a
+        │   │   │   │   └── depth: 0
+        │   │   │   ├── call_operator_loc: (206...207) = "."
+        │   │   │   ├── message_loc: (207...210) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "foo="
+        │   │   └── @ CallNode (location: (212...217))
+        │   │       ├── receiver:
+        │   │       │   @ LocalVariableReadNode (location: (212...213))
+        │   │       │   ├── name: :a
+        │   │       │   └── depth: 0
+        │   │       ├── call_operator_loc: (213...214) = "."
+        │   │       ├── message_loc: (214...217) = "bar"
+        │   │       ├── opening_loc: ∅
+        │   │       ├── arguments: ∅
+        │   │       ├── closing_loc: ∅
+        │   │       ├── block: ∅
+        │   │       ├── flags: 
+        │   │       └── name: "bar="
+        │   ├── lparen_loc: (204...205) = "("
+        │   ├── rparen_loc: (217...218) = ")"
+        │   ├── operator_loc: (219...220) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (221...227))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (222...223))
+        │       │   └── @ IntegerNode (location: (225...226))
+        │       ├── opening_loc: (221...222) = "["
+        │       └── closing_loc: (226...227) = "]"
+        ├── @ MultiWriteNode (location: (228...252))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ CallNode (location: (229...236))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ LocalVariableReadNode (location: (229...230))
+        │   │   │   │   ├── name: :a
+        │   │   │   │   └── depth: 0
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (230...236) = "[*foo]"
+        │   │   │   ├── opening_loc: (230...231) = "["
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (231...235))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ SplatNode (location: (231...235))
+        │   │   │   │           ├── operator_loc: (231...232) = "*"
+        │   │   │   │           └── expression:
+        │   │   │   │               @ LocalVariableReadNode (location: (232...235))
+        │   │   │   │               ├── name: :foo
+        │   │   │   │               └── depth: 0
+        │   │   │   ├── closing_loc: (235...236) = "]"
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "[]="
+        │   │   └── @ CallNode (location: (238...242))
+        │   │       ├── receiver:
+        │   │       │   @ LocalVariableReadNode (location: (238...239))
+        │   │       │   ├── name: :a
+        │   │       │   └── depth: 0
+        │   │       ├── call_operator_loc: ∅
+        │   │       ├── message_loc: (239...242) = "[1]"
+        │   │       ├── opening_loc: (239...240) = "["
+        │   │       ├── arguments:
+        │   │       │   @ ArgumentsNode (location: (240...241))
+        │   │       │   └── arguments: (length: 1)
+        │   │       │       └── @ IntegerNode (location: (240...241))
+        │   │       ├── closing_loc: (241...242) = "]"
+        │   │       ├── block: ∅
+        │   │       ├── flags: 
+        │   │       └── name: "[]="
+        │   ├── lparen_loc: (228...229) = "("
+        │   ├── rparen_loc: (242...243) = ")"
+        │   ├── operator_loc: (244...245) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (246...252))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (247...248))
+        │       │   └── @ IntegerNode (location: (250...251))
+        │       ├── opening_loc: (246...247) = "["
+        │       └── closing_loc: (251...252) = "]"
+        ├── @ MultiWriteNode (location: (253...274))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ CallNode (location: (254...258))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ LocalVariableReadNode (location: (254...255))
+        │   │   │   │   ├── name: :a
+        │   │   │   │   └── depth: 0
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (255...258) = "[0]"
+        │   │   │   ├── opening_loc: (255...256) = "["
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (256...257))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ IntegerNode (location: (256...257))
+        │   │   │   ├── closing_loc: (257...258) = "]"
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "[]="
+        │   │   └── @ CallNode (location: (260...264))
+        │   │       ├── receiver:
+        │   │       │   @ LocalVariableReadNode (location: (260...261))
+        │   │       │   ├── name: :a
+        │   │       │   └── depth: 0
+        │   │       ├── call_operator_loc: ∅
+        │   │       ├── message_loc: (261...264) = "[1]"
+        │   │       ├── opening_loc: (261...262) = "["
+        │   │       ├── arguments:
+        │   │       │   @ ArgumentsNode (location: (262...263))
+        │   │       │   └── arguments: (length: 1)
+        │   │       │       └── @ IntegerNode (location: (262...263))
+        │   │       ├── closing_loc: (263...264) = "]"
+        │   │       ├── block: ∅
+        │   │       ├── flags: 
+        │   │       └── name: "[]="
+        │   ├── lparen_loc: (253...254) = "("
+        │   ├── rparen_loc: (264...265) = ")"
+        │   ├── operator_loc: (266...267) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (268...274))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (269...270))
+        │       │   └── @ IntegerNode (location: (272...273))
+        │       ├── opening_loc: (268...269) = "["
+        │       └── closing_loc: (273...274) = "]"
+        ├── @ MultiWriteNode (location: (275...287))
+        │   ├── targets: (length: 1)
+        │   │   └── @ SplatNode (location: (276...282))
+        │   │       ├── operator_loc: (276...277) = "*"
+        │   │       └── expression:
+        │   │           @ CallNode (location: (277...282))
+        │   │           ├── receiver:
+        │   │           │   @ LocalVariableReadNode (location: (277...278))
+        │   │           │   ├── name: :c
+        │   │           │   └── depth: 0
+        │   │           ├── call_operator_loc: (278...279) = "."
+        │   │           ├── message_loc: (279...282) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "foo="
+        │   ├── lparen_loc: (275...276) = "("
+        │   ├── rparen_loc: (282...283) = ")"
+        │   ├── operator_loc: (284...285) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (286...287))
+        ├── @ ConstantPathWriteNode (location: (288...301))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (288...293))
+        │   │   ├── parent: ∅
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (290...293))
+        │   │   │   └── name: :Foo
+        │   │   └── delimiter_loc: (288...290) = "::"
+        │   ├── operator_loc: (294...295) = "="
+        │   └── value:
+        │       @ ConstantPathNode (location: (296...301))
+        │       ├── parent: ∅
+        │       ├── child:
+        │       │   @ ConstantReadNode (location: (298...301))
+        │       │   └── name: :Bar
+        │       └── delimiter_loc: (296...298) = "::"
+        ├── @ ClassVariableWriteNode (location: (302...309))
+        │   ├── name: :@@a
+        │   ├── name_loc: (302...305) = "@@a"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (308...309))
+        │   └── operator_loc: (306...307) = "="
+        ├── @ InstanceVariableWriteNode (location: (310...316))
+        │   ├── name: :@a
+        │   ├── name_loc: (310...312) = "@a"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (315...316))
+        │   └── operator_loc: (313...314) = "="
+        ├── @ ConstantWriteNode (location: (317...326))
+        │   ├── name: :CONST
+        │   ├── name_loc: (317...322) = "CONST"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (325...326))
+        │   └── operator_loc: (323...324) = "="
+        ├── @ ConstantPathWriteNode (location: (327...350))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (327...346))
+        │   │   ├── parent:
+        │   │   │   @ ConstantPathNode (location: (327...339))
+        │   │   │   ├── parent:
+        │   │   │   │   @ ConstantReadNode (location: (327...331))
+        │   │   │   │   └── name: :Name
+        │   │   │   ├── child:
+        │   │   │   │   @ ConstantReadNode (location: (333...339))
+        │   │   │   │   └── name: :Spaced
+        │   │   │   └── delimiter_loc: (331...333) = "::"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (341...346))
+        │   │   │   └── name: :CONST
+        │   │   └── delimiter_loc: (339...341) = "::"
+        │   ├── operator_loc: (347...348) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (349...350))
+        ├── @ LocalVariableWriteNode (location: (351...367))
+        │   ├── name: :a
+        │   ├── depth: 0
+        │   ├── name_loc: (351...352) = "a"
+        │   ├── value:
+        │   │   @ ParenthesesNode (location: (355...367))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (356...366))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ MultiWriteNode (location: (356...366))
+        │   │   │           ├── targets: (length: 2)
+        │   │   │           │   ├── @ LocalVariableTargetNode (location: (357...358))
+        │   │   │           │   │   ├── name: :b
+        │   │   │           │   │   └── depth: 0
+        │   │   │           │   └── @ LocalVariableTargetNode (location: (360...361))
+        │   │   │           │       ├── name: :c
+        │   │   │           │       └── depth: 0
+        │   │   │           ├── lparen_loc: (356...357) = "("
+        │   │   │           ├── rparen_loc: (361...362) = ")"
+        │   │   │           ├── operator_loc: (363...364) = "="
+        │   │   │           └── value:
+        │   │   │               @ IntegerNode (location: (365...366))
+        │   │   ├── opening_loc: (355...356) = "("
+        │   │   └── closing_loc: (366...367) = ")"
+        │   └── operator_loc: (353...354) = "="
+        ├── @ LocalVariableWriteNode (location: (368...373))
+        │   ├── name: :a
+        │   ├── depth: 0
+        │   ├── name_loc: (368...369) = "a"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (372...373))
+        │   └── operator_loc: (370...371) = "="
+        ├── @ LocalVariableWriteNode (location: (374...385))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (374...377) = "foo"
+        │   ├── value:
+        │   │   @ CallNode (location: (380...385))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (380...383) = "foo"
+        │   │   ├── opening_loc: (383...384) = "("
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: (384...385) = ")"
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "foo"
+        │   └── operator_loc: (378...379) = "="
+        ├── @ CallNode (location: (386...395))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (386...389))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (389...390) = "."
+        │   ├── message_loc: (390...393) = "[]="
+        │   ├── opening_loc: (393...394) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (394...395) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (396...409))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (396...399))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (399...400) = "."
+        │   ├── message_loc: (400...403) = "[]="
+        │   ├── opening_loc: (403...404) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (404...408))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ IntegerNode (location: (404...405))
+        │   │       └── @ IntegerNode (location: (407...408))
+        │   ├── closing_loc: (408...409) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (410...421))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (410...413))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (413...414) = "."
+        │   ├── message_loc: (414...417) = "[]="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (417...421))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ TrueNode (location: (417...421))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (422...441))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (422...425))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (425...433) = "[*index]"
+        │   ├── opening_loc: (425...426) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (426...441))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SplatNode (location: (426...432))
+        │   │       │   ├── operator_loc: (426...427) = "*"
+        │   │       │   └── expression:
+        │   │       │       @ CallNode (location: (427...432))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (427...432) = "index"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "index"
+        │   │       └── @ CallNode (location: (436...441))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (436...441) = "value"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "value"
+        │   ├── closing_loc: (432...433) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (442...459))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (442...445))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (445...451) = "[1..2]"
+        │   ├── opening_loc: (445...446) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (446...459))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ RangeNode (location: (446...450))
+        │   │       │   ├── left:
+        │   │       │   │   @ IntegerNode (location: (446...447))
+        │   │       │   ├── right:
+        │   │       │   │   @ IntegerNode (location: (449...450))
+        │   │       │   ├── operator_loc: (447...449) = ".."
+        │   │       │   └── flags: 
+        │   │       └── @ CallNode (location: (454...459))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (454...459) = "value"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "value"
+        │   ├── closing_loc: (450...451) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (460...469))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (460...463))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (463...465) = "[]"
+        │   ├── opening_loc: (463...464) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (468...469))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (468...469))
+        │   ├── closing_loc: (464...465) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (470...487))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (470...473))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (473...479) = "[a, b]"
+        │   ├── opening_loc: (473...474) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (474...487))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ LocalVariableReadNode (location: (474...475))
+        │   │       │   ├── name: :a
+        │   │       │   └── depth: 0
+        │   │       ├── @ LocalVariableReadNode (location: (477...478))
+        │   │       │   ├── name: :b
+        │   │       │   └── depth: 0
+        │   │       └── @ CallNode (location: (482...487))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (482...487) = "value"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "value"
+        │   ├── closing_loc: (478...479) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (488...506))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (488...491))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (491...498) = "[index]"
+        │   ├── opening_loc: (491...492) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (492...506))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (492...497))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (492...497) = "index"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "index"
+        │   │       └── @ CallNode (location: (501...506))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (501...506) = "value"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "value"
+        │   ├── closing_loc: (497...498) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ LocalVariableWriteNode (location: (507...514))
+        │   ├── name: :x
+        │   ├── depth: 0
+        │   ├── name_loc: (507...508) = "x"
+        │   ├── value:
+        │   │   @ StringNode (location: (511...514))
+        │   │   ├── opening_loc: (511...513) = "%("
+        │   │   ├── content_loc: (513...513) = ""
+        │   │   ├── closing_loc: (513...514) = ")"
+        │   │   └── unescaped: ""
+        │   └── operator_loc: (509...510) = "="
+        ├── @ CallNode (location: (515...522))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (515...516))
+        │   │   ├── name: :x
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (516...517) = "."
+        │   ├── message_loc: (517...518) = "x"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (519...522))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (519...522))
+        │   │           ├── opening_loc: (519...521) = "%("
+        │   │           ├── content_loc: (521...521) = ""
+        │   │           ├── closing_loc: (521...522) = ")"
+        │   │           └── unescaped: ""
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "x="
+        ├── @ CallNode (location: (523...535))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (523...524))
+        │   │   ├── name: :x
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (524...529) = "[%()]"
+        │   ├── opening_loc: (524...525) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (525...535))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ StringNode (location: (525...528))
+        │   │       │   ├── opening_loc: (525...527) = "%("
+        │   │       │   ├── content_loc: (527...527) = ""
+        │   │       │   ├── closing_loc: (527...528) = ")"
+        │   │       │   └── unescaped: ""
+        │   │       └── @ CallNode (location: (532...535))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (532...535) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: (528...529) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallOrWriteNode (location: (536...550))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (536...537))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (537...542) = "[%()]"
+        │   ├── opening_loc: (537...538) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (538...541))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (538...541))
+        │   │           ├── opening_loc: (538...540) = "%("
+        │   │           ├── content_loc: (540...540) = ""
+        │   │           ├── closing_loc: (540...541) = ")"
+        │   │           └── unescaped: ""
+        │   ├── closing_loc: (541...542) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator_loc: (543...546) = "||="
+        │   └── value:
+        │       @ CallNode (location: (547...550))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (547...550) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        ├── @ InstanceVariableOrWriteNode (location: (551...561))
+        │   ├── name: :@a
+        │   ├── name_loc: (551...553) = "@a"
+        │   ├── operator_loc: (554...557) = "||="
+        │   └── value:
+        │       @ StringNode (location: (558...561))
+        │       ├── opening_loc: (558...560) = "%("
+        │       ├── content_loc: (560...560) = ""
+        │       ├── closing_loc: (560...561) = ")"
+        │       └── unescaped: ""
+        ├── @ LocalVariableWriteNode (location: (562...576))
+        │   ├── name: :x
+        │   ├── depth: 0
+        │   ├── name_loc: (562...563) = "x"
+        │   ├── value:
+        │   │   @ InterpolatedStringNode (location: (566...576))
+        │   │   ├── opening_loc: (566...576) = "<<-HEREDOC"
+        │   │   ├── parts: (length: 3)
+        │   │   │   ├── @ StringNode (location: (577...579))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── content_loc: (577...579) = "  "
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   └── unescaped: "  "
+        │   │   │   ├── @ EmbeddedStatementsNode (location: (579...582))
+        │   │   │   │   ├── opening_loc: (579...581) = "\#{"
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── closing_loc: (581...582) = "}"
+        │   │   │   └── @ StringNode (location: (582...583))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (582...583) = "\n"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "\n"
+        │   │   └── closing_loc: (583...591) = "HEREDOC\n"
+        │   └── operator_loc: (564...565) = "="
+        ├── @ CallNode (location: (591...605))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (591...592))
+        │   │   ├── name: :x
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (592...593) = "."
+        │   ├── message_loc: (593...594) = "x"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (595...605))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (595...605))
+        │   │           ├── opening_loc: (595...605) = "<<-HEREDOC"
+        │   │           ├── parts: (length: 3)
+        │   │           │   ├── @ StringNode (location: (606...608))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (606...608) = "  "
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "  "
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (608...611))
+        │   │           │   │   ├── opening_loc: (608...610) = "\#{"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── closing_loc: (610...611) = "}"
+        │   │           │   └── @ StringNode (location: (611...612))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (611...612) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (612...620) = "HEREDOC\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "x="
+        ├── @ CallNode (location: (620...636))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (620...621))
+        │   │   ├── name: :x
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (621...623) = "[]"
+        │   ├── opening_loc: (621...622) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (626...636))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (626...636))
+        │   │           ├── opening_loc: (626...636) = "<<-HEREDOC"
+        │   │           ├── parts: (length: 3)
+        │   │           │   ├── @ StringNode (location: (637...639))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (637...639) = "  "
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "  "
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (639...642))
+        │   │           │   │   ├── opening_loc: (639...641) = "\#{"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── closing_loc: (641...642) = "}"
+        │   │           │   └── @ StringNode (location: (642...643))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (642...643) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (643...651) = "HEREDOC\n"
+        │   ├── closing_loc: (622...623) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallOrWriteNode (location: (651...672))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (651...652))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (652...664) = "[<<-HEREDOC]"
+        │   ├── opening_loc: (652...653) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (653...663))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (653...663))
+        │   │           ├── opening_loc: (653...663) = "<<-HEREDOC"
+        │   │           ├── parts: (length: 3)
+        │   │           │   ├── @ StringNode (location: (673...675))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (673...675) = "  "
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "  "
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (675...678))
+        │   │           │   │   ├── opening_loc: (675...677) = "\#{"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── closing_loc: (677...678) = "}"
+        │   │           │   └── @ StringNode (location: (678...679))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (678...679) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (679...687) = "HEREDOC\n"
+        │   ├── closing_loc: (663...664) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator_loc: (665...668) = "||="
+        │   └── value:
+        │       @ CallNode (location: (669...672))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (669...672) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        └── @ InstanceVariableOrWriteNode (location: (687...704))
+            ├── name: :@a
+            ├── name_loc: (687...689) = "@a"
+            ├── operator_loc: (690...693) = "||="
+            └── value:
+                @ InterpolatedStringNode (location: (694...704))
+                ├── opening_loc: (694...704) = "<<-HEREDOC"
+                ├── parts: (length: 3)
+                │   ├── @ StringNode (location: (705...707))
+                │   │   ├── opening_loc: ∅
+                │   │   ├── content_loc: (705...707) = "  "
+                │   │   ├── closing_loc: ∅
+                │   │   └── unescaped: "  "
+                │   ├── @ EmbeddedStatementsNode (location: (707...710))
+                │   │   ├── opening_loc: (707...709) = "\#{"
+                │   │   ├── statements: ∅
+                │   │   └── closing_loc: (709...710) = "}"
+                │   └── @ StringNode (location: (710...711))
+                │       ├── opening_loc: ∅
+                │       ├── content_loc: (710...711) = "\n"
+                │       ├── closing_loc: ∅
+                │       └── unescaped: "\n"
+                └── closing_loc: (711...719) = "HEREDOC\n"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/block.txt b/test/yarp/snapshots/unparser/corpus/literal/block.txt
index 43a1ead2e8..0cf0db68b9 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/block.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/block.txt
@@ -1,1275 +1,1379 @@
-ProgramNode(0...737)(
-  [],
-  StatementsNode(0...737)(
-    [CallNode(0...7)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       nil,
-       nil,
-       BlockNode(4...7)([], nil, nil, (4...5), (6...7)),
-       0,
-       "foo"
-     ),
-     CallNode(8...19)(
-       nil,
-       nil,
-       (8...11),
-       nil,
-       nil,
-       nil,
-       BlockNode(12...19)(
-         [:a],
-         BlockParametersNode(14...17)(
-           ParametersNode(15...16)(
-             [RequiredParameterNode(15...16)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (14...15),
-           (16...17)
-         ),
-         nil,
-         (12...13),
-         (18...19)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(20...32)(
-       nil,
-       nil,
-       (20...23),
-       nil,
-       nil,
-       nil,
-       BlockNode(24...32)(
-         [:a],
-         BlockParametersNode(26...30)(
-           ParametersNode(27...29)(
-             [RequiredParameterNode(27...28)(:a)],
-             [],
-             [],
-             RestParameterNode(28...29)(nil, nil, (28...29)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (26...27),
-           (29...30)
-         ),
-         nil,
-         (24...25),
-         (31...32)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(33...48)(
-       nil,
-       nil,
-       (33...36),
-       nil,
-       nil,
-       nil,
-       BlockNode(37...48)(
-         [:a, :x],
-         BlockParametersNode(39...46)(
-           ParametersNode(40...42)(
-             [RequiredParameterNode(40...41)(:a)],
-             [],
-             [],
-             RestParameterNode(41...42)(nil, nil, (41...42)),
-             [],
-             nil,
-             nil
-           ),
-           [BlockLocalVariableNode(44...45)(:x)],
-           (39...40),
-           (45...46)
-         ),
-         nil,
-         (37...38),
-         (47...48)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(49...63)(
-       nil,
-       nil,
-       (49...52),
-       nil,
-       nil,
-       nil,
-       BlockNode(53...63)(
-         [:a, :b],
-         BlockParametersNode(55...61)(
-           ParametersNode(56...60)(
-             [RequiredParameterNode(56...57)(:a),
-              RequiredParameterNode(59...60)(:b)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (55...56),
-           (60...61)
-         ),
-         nil,
-         (53...54),
-         (62...63)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(64...80)(
-       nil,
-       nil,
-       (64...67),
-       (67...68),
-       ArgumentsNode(68...69)([IntegerNode(68...69)()]),
-       (69...70),
-       BlockNode(71...80)(
-         [],
-         nil,
-         StatementsNode(75...78)([NilNode(75...78)()]),
-         (71...72),
-         (79...80)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(81...102)(
-       nil,
-       nil,
-       (81...84),
-       nil,
-       nil,
-       nil,
-       BlockNode(85...102)(
-         [:a, :b],
-         BlockParametersNode(87...94)(
-           ParametersNode(88...93)(
-             [RequiredParameterNode(88...89)(:a)],
-             [],
-             [],
-             RestParameterNode(91...93)(:b, (92...93), (91...92)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (87...88),
-           (93...94)
-         ),
-         StatementsNode(97...100)([NilNode(97...100)()]),
-         (85...86),
-         (101...102)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(103...123)(
-       nil,
-       nil,
-       (103...106),
-       nil,
-       nil,
-       nil,
-       BlockNode(107...123)(
-         [:a, :*],
-         BlockParametersNode(109...115)(
-           ParametersNode(110...114)(
-             [RequiredParameterNode(110...111)(:a)],
-             [],
-             [],
-             RestParameterNode(113...114)(nil, nil, (113...114)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (109...110),
-           (114...115)
-         ),
-         StatementsNode(118...121)([NilNode(118...121)()]),
-         (107...108),
-         (122...123)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(124...137)(
-       nil,
-       nil,
-       (124...127),
-       nil,
-       nil,
-       nil,
-       BlockNode(128...137)(
-         [],
-         nil,
-         StatementsNode(132...135)(
-           [CallNode(132...135)(
-              nil,
-              nil,
-              (132...135),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         (128...129),
-         (136...137)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(138...165)(
-       CallNode(138...141)(
-         nil,
-         nil,
-         (138...141),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (141...142),
-       (142...145),
-       nil,
-       nil,
-       nil,
-       BlockNode(146...165)(
-         [:a, :b, :c],
-         BlockParametersNode(148...159)(
-           ParametersNode(149...158)(
-             [RequiredDestructuredParameterNode(149...155)(
-                [RequiredParameterNode(150...151)(:a),
-                 RequiredParameterNode(153...154)(:b)],
-                (149...150),
-                (154...155)
-              ),
-              RequiredParameterNode(157...158)(:c)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (148...149),
-           (158...159)
-         ),
-         StatementsNode(162...163)(
-           [CallNode(162...163)(
-              nil,
-              nil,
-              (162...163),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "d"
-            )]
-         ),
-         (146...147),
-         (164...165)
-       ),
-       0,
-       "bar"
-     ),
-     CallNode(166...185)(
-       CallNode(166...169)(
-         nil,
-         nil,
-         (166...169),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (169...170),
-       (170...173),
-       nil,
-       nil,
-       nil,
-       BlockNode(174...185)(
-         [:a, :b],
-         BlockParametersNode(176...183)(
-           ParametersNode(177...179)(
-             [],
-             [],
-             [],
-             RestParameterNode(177...179)(:a, (178...179), (177...178)),
-             [],
-             nil,
-             nil
-           ),
-           [BlockLocalVariableNode(181...182)(:b)],
-           (176...177),
-           (182...183)
-         ),
-         nil,
-         (174...175),
-         (184...185)
-       ),
-       0,
-       "bar"
-     ),
-     CallNode(186...204)(
-       CallNode(186...189)(
-         nil,
-         nil,
-         (186...189),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (189...190),
-       (190...193),
-       nil,
-       nil,
-       nil,
-       BlockNode(194...204)(
-         [:a, :b],
-         BlockParametersNode(196...202)(
-           ParametersNode(197...198)(
-             [RequiredParameterNode(197...198)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [BlockLocalVariableNode(200...201)(:b)],
-           (196...197),
-           (201...202)
-         ),
-         nil,
-         (194...195),
-         (203...204)
-       ),
-       0,
-       "bar"
-     ),
-     CallNode(205...225)(
-       CallNode(205...208)(
-         nil,
-         nil,
-         (205...208),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (208...209),
-       (209...212),
-       nil,
-       nil,
-       nil,
-       BlockNode(213...225)(
-         [:a, :b],
-         BlockParametersNode(215...223)(
-           nil,
-           [BlockLocalVariableNode(218...219)(:a),
-            BlockLocalVariableNode(221...222)(:b)],
-           (215...216),
-           (222...223)
-         ),
-         nil,
-         (213...214),
-         (224...225)
-       ),
-       0,
-       "bar"
-     ),
-     CallNode(226...245)(
-       CallNode(226...229)(
-         nil,
-         nil,
-         (226...229),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (229...230),
-       (230...233),
-       nil,
-       nil,
-       nil,
-       BlockNode(234...245)(
-         [:*],
-         BlockParametersNode(236...239)(
-           ParametersNode(237...238)(
-             [],
-             [],
-             [],
-             RestParameterNode(237...238)(nil, nil, (237...238)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (236...237),
-           (238...239)
-         ),
-         StatementsNode(242...243)(
-           [CallNode(242...243)(
-              nil,
-              nil,
-              (242...243),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "d"
-            )]
-         ),
-         (234...235),
-         (244...245)
-       ),
-       0,
-       "bar"
-     ),
-     CallNode(246...267)(
-       CallNode(246...249)(
-         nil,
-         nil,
-         (246...249),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (249...250),
-       (250...253),
-       nil,
-       nil,
-       nil,
-       BlockNode(254...267)(
-         [],
-         BlockParametersNode(256...261)(
-           ParametersNode(257...260)(
-             [RequiredDestructuredParameterNode(257...260)(
-                [SplatNode(258...259)((258...259), nil)],
-                (257...258),
-                (259...260)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (256...257),
-           (260...261)
-         ),
-         StatementsNode(264...265)(
-           [CallNode(264...265)(
-              nil,
-              nil,
-              (264...265),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "d"
-            )]
-         ),
-         (254...255),
-         (266...267)
-       ),
-       0,
-       "bar"
-     ),
-     CallNode(268...291)(
-       CallNode(268...271)(
-         nil,
-         nil,
-         (268...271),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (271...272),
-       (272...275),
-       nil,
-       nil,
-       nil,
-       BlockNode(276...291)(
-         [],
-         BlockParametersNode(278...285)(
-           ParametersNode(279...284)(
-             [RequiredDestructuredParameterNode(279...284)(
-                [RequiredDestructuredParameterNode(280...283)(
-                   [SplatNode(281...282)((281...282), nil)],
-                   (280...281),
-                   (282...283)
-                 )],
-                (279...280),
-                (283...284)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (278...279),
-           (284...285)
-         ),
-         StatementsNode(288...289)(
-           [CallNode(288...289)(
-              nil,
-              nil,
-              (288...289),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "d"
-            )]
-         ),
-         (276...277),
-         (290...291)
-       ),
-       0,
-       "bar"
-     ),
-     CallNode(292...318)(
-       CallNode(292...295)(
-         nil,
-         nil,
-         (292...295),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (295...296),
-       (296...299),
-       nil,
-       nil,
-       nil,
-       BlockNode(300...318)(
-         [:a],
-         BlockParametersNode(302...312)(
-           ParametersNode(303...311)(
-             [RequiredDestructuredParameterNode(303...311)(
-                [RequiredParameterNode(304...305)(:a),
-                 RequiredDestructuredParameterNode(307...310)(
-                   [SplatNode(308...309)((308...309), nil)],
-                   (307...308),
-                   (309...310)
-                 )],
-                (303...304),
-                (310...311)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (302...303),
-           (311...312)
-         ),
-         StatementsNode(315...316)(
-           [CallNode(315...316)(
-              nil,
-              nil,
-              (315...316),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "d"
-            )]
-         ),
-         (300...301),
-         (317...318)
-       ),
-       0,
-       "bar"
-     ),
-     CallNode(319...343)(
-       CallNode(319...322)(
-         nil,
-         nil,
-         (319...322),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (322...323),
-       (323...326),
-       nil,
-       nil,
-       nil,
-       BlockNode(327...343)(
-         [:a, :b],
-         BlockParametersNode(329...337)(
-           ParametersNode(330...336)(
-             [RequiredDestructuredParameterNode(330...336)(
-                [RequiredParameterNode(331...332)(:a),
-                 RequiredParameterNode(334...335)(:b)],
-                (330...331),
-                (335...336)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (329...330),
-           (336...337)
-         ),
-         StatementsNode(340...341)(
-           [CallNode(340...341)(
-              nil,
-              nil,
-              (340...341),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "d"
-            )]
-         ),
-         (327...328),
-         (342...343)
-       ),
-       0,
-       "bar"
-     ),
-     CallNode(344...359)(
-       CallNode(344...355)(
-         CallNode(344...347)(
-           nil,
-           nil,
-           (344...347),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         (347...348),
-         (348...351),
-         nil,
-         nil,
-         nil,
-         BlockNode(352...355)([], nil, nil, (352...353), (354...355)),
-         0,
-         "bar"
-       ),
-       (355...356),
-       (356...359),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "baz"
-     ),
-     CallNode(360...390)(
-       nil,
-       nil,
-       (360...361),
-       nil,
-       nil,
-       nil,
-       BlockNode(362...390)(
-         [:e],
-         nil,
-         BeginNode(365...390)(
-           nil,
-           nil,
-           RescueNode(365...386)(
-             (365...371),
-             [ConstantReadNode(372...381)(:Exception)],
-             (382...384),
-             LocalVariableTargetNode(385...386)(:e, 0),
-             nil,
-             nil
-           ),
-           nil,
-           nil,
-           (387...390)
-         ),
-         (362...364),
-         (387...390)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(391...435)(
-       nil,
-       nil,
-       (391...392),
-       nil,
-       nil,
-       nil,
-       BlockNode(393...435)(
-         [:bar],
-         nil,
-         BeginNode(398...435)(
-           nil,
-           StatementsNode(398...401)(
-             [CallNode(398...401)(
-                nil,
-                nil,
-                (398...401),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "foo"
-              )]
-           ),
-           RescueNode(402...431)(
-             (402...408),
-             [ConstantReadNode(409...418)(:Exception)],
-             (419...421),
-             LocalVariableTargetNode(422...425)(:bar, 0),
-             StatementsNode(428...431)(
-               [LocalVariableReadNode(428...431)(:bar, 0)]
-             ),
-             nil
-           ),
-           nil,
-           nil,
-           (432...435)
-         ),
-         (393...395),
-         (432...435)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(436...479)(
-       nil,
-       nil,
-       (436...437),
-       nil,
-       nil,
-       nil,
-       BlockNode(438...479)(
-         [],
-         nil,
-         BeginNode(443...479)(
-           nil,
-           StatementsNode(443...446)(
-             [CallNode(443...446)(
-                nil,
-                nil,
-                (443...446),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           RescueNode(447...475)(
-             (447...453),
-             [ConstantReadNode(454...463)(:SomeError),
-              SplatNode(465...469)(
-                (465...466),
-                CallNode(466...469)(
-                  nil,
-                  nil,
-                  (466...469),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )
-              )],
-             nil,
-             nil,
-             StatementsNode(472...475)(
-               [CallNode(472...475)(
-                  nil,
-                  nil,
-                  (472...475),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "baz"
-                )]
-             ),
-             nil
-           ),
-           nil,
-           nil,
-           (476...479)
-         ),
-         (438...440),
-         (476...479)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(480...536)(
-       nil,
-       nil,
-       (480...481),
-       nil,
-       nil,
-       nil,
-       BlockNode(482...536)(
-         [:exception],
-         nil,
-         BeginNode(487...536)(
-           nil,
-           StatementsNode(487...490)(
-             [CallNode(487...490)(
-                nil,
-                nil,
-                (487...490),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           RescueNode(491...532)(
-             (491...497),
-             [ConstantReadNode(498...507)(:SomeError),
-              SplatNode(509...513)(
-                (509...510),
-                CallNode(510...513)(
-                  nil,
-                  nil,
-                  (510...513),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )
-              )],
-             (514...516),
-             LocalVariableTargetNode(517...526)(:exception, 0),
-             StatementsNode(529...532)(
-               [CallNode(529...532)(
-                  nil,
-                  nil,
-                  (529...532),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "baz"
-                )]
-             ),
-             nil
-           ),
-           nil,
-           nil,
-           (533...536)
-         ),
-         (482...484),
-         (533...536)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(537...569)(
-       nil,
-       nil,
-       (537...538),
-       nil,
-       nil,
-       nil,
-       BlockNode(539...569)(
-         [],
-         nil,
-         BeginNode(544...569)(
-           nil,
-           StatementsNode(544...547)(
-             [CallNode(544...547)(
-                nil,
-                nil,
-                (544...547),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           RescueNode(548...565)(
-             (548...554),
-             [SplatNode(555...559)(
-                (555...556),
-                CallNode(556...559)(
-                  nil,
-                  nil,
-                  (556...559),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )
-              )],
-             nil,
-             nil,
-             StatementsNode(562...565)(
-               [CallNode(562...565)(
-                  nil,
-                  nil,
-                  (562...565),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "baz"
-                )]
-             ),
-             nil
-           ),
-           nil,
-           nil,
-           (566...569)
-         ),
-         (539...541),
-         (566...569)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(570...601)(
-       nil,
-       nil,
-       (570...571),
-       nil,
-       nil,
-       nil,
-       BlockNode(572...601)(
-         [],
-         nil,
-         BeginNode(577...601)(
-           nil,
-           StatementsNode(577...580)(
-             [CallNode(577...580)(
-                nil,
-                nil,
-                (577...580),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           RescueNode(581...597)(
-             (581...587),
-             [ConstantReadNode(588...597)(:LoadError)],
-             nil,
-             nil,
-             nil,
-             nil
-           ),
-           nil,
-           nil,
-           (598...601)
-         ),
-         (572...574),
-         (598...601)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(602...634)(
-       nil,
-       nil,
-       (602...603),
-       nil,
-       nil,
-       nil,
-       BlockNode(604...634)(
-         [],
-         nil,
-         BeginNode(609...634)(
-           nil,
-           StatementsNode(609...612)(
-             [CallNode(609...612)(
-                nil,
-                nil,
-                (609...612),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           RescueNode(613...619)((613...619), [], nil, nil, nil, nil),
-           ElseNode(620...634)(
-             (620...624),
-             StatementsNode(627...630)(
-               [CallNode(627...630)(
-                  nil,
-                  nil,
-                  (627...630),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "baz"
-                )]
-             ),
-             (631...634)
-           ),
-           nil,
-           (631...634)
-         ),
-         (604...606),
-         (631...634)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(635...680)(
-       nil,
-       nil,
-       (635...636),
-       nil,
-       nil,
-       nil,
-       BlockNode(637...680)(
-         [:exception],
-         nil,
-         BeginNode(642...680)(
-           nil,
-           StatementsNode(642...645)(
-             [CallNode(642...645)(
-                nil,
-                nil,
-                (642...645),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           RescueNode(646...676)(
-             (646...652),
-             [SplatNode(653...657)(
-                (653...654),
-                CallNode(654...657)(
-                  nil,
-                  nil,
-                  (654...657),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )
-              )],
-             (658...660),
-             LocalVariableTargetNode(661...670)(:exception, 0),
-             StatementsNode(673...676)(
-               [CallNode(673...676)(
-                  nil,
-                  nil,
-                  (673...676),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "baz"
-                )]
-             ),
-             nil
-           ),
-           nil,
-           nil,
-           (677...680)
-         ),
-         (637...639),
-         (677...680)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(681...696)(
-       nil,
-       nil,
-       (681...682),
-       nil,
-       nil,
-       nil,
-       BlockNode(683...696)(
-         [],
-         nil,
-         BeginNode(686...696)(
-           nil,
-           nil,
-           nil,
-           nil,
-           EnsureNode(686...696)((686...692), nil, (693...696)),
-           (693...696)
-         ),
-         (683...685),
-         (693...696)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(697...719)(
-       nil,
-       nil,
-       (697...698),
-       nil,
-       nil,
-       nil,
-       BlockNode(699...719)(
-         [],
-         nil,
-         BeginNode(702...719)(
-           nil,
-           nil,
-           RescueNode(702...708)((702...708), [], nil, nil, nil, nil),
-           nil,
-           EnsureNode(709...719)((709...715), nil, (716...719)),
-           (716...719)
-         ),
-         (699...701),
-         (716...719)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(720...737)(
-       nil,
-       nil,
-       (720...723),
-       nil,
-       nil,
-       nil,
-       BlockNode(724...737)(
-         [],
-         nil,
-         StatementsNode(728...735)(
-           [CallNode(728...735)(
-              CallNode(728...730)(
-                nil,
-                nil,
-                (728...730),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "_1"
-              ),
-              nil,
-              (731...732),
-              nil,
-              ArgumentsNode(733...735)(
-                [CallNode(733...735)(
-                   nil,
-                   nil,
-                   (733...735),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "_2"
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "+"
-            )]
-         ),
-         (724...725),
-         (736...737)
-       ),
-       0,
-       "bar"
-     )]
-  )
-)
+@ ProgramNode (location: (0...737))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...737))
+    └── body: (length: 30)
+        ├── @ CallNode (location: (0...7))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (4...7))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (4...5) = "{"
+        │   │   └── closing_loc: (6...7) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (8...19))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (8...11) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (12...19))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (14...17))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (15...16))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (15...16))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (14...15) = "|"
+        │   │   │   └── closing_loc: (16...17) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (12...13) = "{"
+        │   │   └── closing_loc: (18...19) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (20...32))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (20...23) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (24...32))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (26...30))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (27...29))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (27...28))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (28...29))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (28...29) = ","
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (26...27) = "|"
+        │   │   │   └── closing_loc: (29...30) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (24...25) = "{"
+        │   │   └── closing_loc: (31...32) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (33...48))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (33...36) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (37...48))
+        │   │   ├── locals: [:a, :x]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (39...46))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (40...42))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (40...41))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (41...42))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (41...42) = ","
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 1)
+        │   │   │   │   └── @ BlockLocalVariableNode (location: (44...45))
+        │   │   │   │       └── name: :x
+        │   │   │   ├── opening_loc: (39...40) = "|"
+        │   │   │   └── closing_loc: (45...46) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (37...38) = "{"
+        │   │   └── closing_loc: (47...48) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (49...63))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (49...52) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (53...63))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (55...61))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (56...60))
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ RequiredParameterNode (location: (56...57))
+        │   │   │   │   │   │   └── name: :a
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (59...60))
+        │   │   │   │   │       └── name: :b
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (55...56) = "|"
+        │   │   │   └── closing_loc: (60...61) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (53...54) = "{"
+        │   │   └── closing_loc: (62...63) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (64...80))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (64...67) = "foo"
+        │   ├── opening_loc: (67...68) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (68...69))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (68...69))
+        │   ├── closing_loc: (69...70) = ")"
+        │   ├── block:
+        │   │   @ BlockNode (location: (71...80))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (75...78))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ NilNode (location: (75...78))
+        │   │   ├── opening_loc: (71...72) = "{"
+        │   │   └── closing_loc: (79...80) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (81...102))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (81...84) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (85...102))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (87...94))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (88...93))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (88...89))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (91...93))
+        │   │   │   │   │   ├── name: :b
+        │   │   │   │   │   ├── name_loc: (92...93) = "b"
+        │   │   │   │   │   └── operator_loc: (91...92) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (87...88) = "|"
+        │   │   │   └── closing_loc: (93...94) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (97...100))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ NilNode (location: (97...100))
+        │   │   ├── opening_loc: (85...86) = "{"
+        │   │   └── closing_loc: (101...102) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (103...123))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (103...106) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (107...123))
+        │   │   ├── locals: [:a, :*]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (109...115))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (110...114))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (110...111))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (113...114))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (113...114) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (109...110) = "|"
+        │   │   │   └── closing_loc: (114...115) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (118...121))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ NilNode (location: (118...121))
+        │   │   ├── opening_loc: (107...108) = "{"
+        │   │   └── closing_loc: (122...123) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (124...137))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (124...127) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (128...137))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (132...135))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (132...135))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (132...135) = "bar"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "bar"
+        │   │   ├── opening_loc: (128...129) = "{"
+        │   │   └── closing_loc: (136...137) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (138...165))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (138...141))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (138...141) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (141...142) = "."
+        │   ├── message_loc: (142...145) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (146...165))
+        │   │   ├── locals: [:a, :b, :c]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (148...159))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (149...158))
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ RequiredDestructuredParameterNode (location: (149...155))
+        │   │   │   │   │   │   ├── parameters: (length: 2)
+        │   │   │   │   │   │   │   ├── @ RequiredParameterNode (location: (150...151))
+        │   │   │   │   │   │   │   │   └── name: :a
+        │   │   │   │   │   │   │   └── @ RequiredParameterNode (location: (153...154))
+        │   │   │   │   │   │   │       └── name: :b
+        │   │   │   │   │   │   ├── opening_loc: (149...150) = "("
+        │   │   │   │   │   │   └── closing_loc: (154...155) = ")"
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (157...158))
+        │   │   │   │   │       └── name: :c
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (148...149) = "|"
+        │   │   │   └── closing_loc: (158...159) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (162...163))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (162...163))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (162...163) = "d"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "d"
+        │   │   ├── opening_loc: (146...147) = "{"
+        │   │   └── closing_loc: (164...165) = "}"
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (166...185))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (166...169))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (166...169) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (169...170) = "."
+        │   ├── message_loc: (170...173) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (174...185))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (176...183))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (177...179))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (177...179))
+        │   │   │   │   │   ├── name: :a
+        │   │   │   │   │   ├── name_loc: (178...179) = "a"
+        │   │   │   │   │   └── operator_loc: (177...178) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 1)
+        │   │   │   │   └── @ BlockLocalVariableNode (location: (181...182))
+        │   │   │   │       └── name: :b
+        │   │   │   ├── opening_loc: (176...177) = "|"
+        │   │   │   └── closing_loc: (182...183) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (174...175) = "{"
+        │   │   └── closing_loc: (184...185) = "}"
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (186...204))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (186...189))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (186...189) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (189...190) = "."
+        │   ├── message_loc: (190...193) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (194...204))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (196...202))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (197...198))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (197...198))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 1)
+        │   │   │   │   └── @ BlockLocalVariableNode (location: (200...201))
+        │   │   │   │       └── name: :b
+        │   │   │   ├── opening_loc: (196...197) = "|"
+        │   │   │   └── closing_loc: (201...202) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (194...195) = "{"
+        │   │   └── closing_loc: (203...204) = "}"
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (205...225))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (205...208))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (205...208) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (208...209) = "."
+        │   ├── message_loc: (209...212) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (213...225))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (215...223))
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── locals: (length: 2)
+        │   │   │   │   ├── @ BlockLocalVariableNode (location: (218...219))
+        │   │   │   │   │   └── name: :a
+        │   │   │   │   └── @ BlockLocalVariableNode (location: (221...222))
+        │   │   │   │       └── name: :b
+        │   │   │   ├── opening_loc: (215...216) = "|"
+        │   │   │   └── closing_loc: (222...223) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (213...214) = "{"
+        │   │   └── closing_loc: (224...225) = "}"
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (226...245))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (226...229))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (226...229) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (229...230) = "."
+        │   ├── message_loc: (230...233) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (234...245))
+        │   │   ├── locals: [:*]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (236...239))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (237...238))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (237...238))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (237...238) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (236...237) = "|"
+        │   │   │   └── closing_loc: (238...239) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (242...243))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (242...243))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (242...243) = "d"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "d"
+        │   │   ├── opening_loc: (234...235) = "{"
+        │   │   └── closing_loc: (244...245) = "}"
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (246...267))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (246...249))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (246...249) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (249...250) = "."
+        │   ├── message_loc: (250...253) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (254...267))
+        │   │   ├── locals: []
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (256...261))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (257...260))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (257...260))
+        │   │   │   │   │       ├── parameters: (length: 1)
+        │   │   │   │   │       │   └── @ SplatNode (location: (258...259))
+        │   │   │   │   │       │       ├── operator_loc: (258...259) = "*"
+        │   │   │   │   │       │       └── expression: ∅
+        │   │   │   │   │       ├── opening_loc: (257...258) = "("
+        │   │   │   │   │       └── closing_loc: (259...260) = ")"
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (256...257) = "|"
+        │   │   │   └── closing_loc: (260...261) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (264...265))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (264...265))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (264...265) = "d"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "d"
+        │   │   ├── opening_loc: (254...255) = "{"
+        │   │   └── closing_loc: (266...267) = "}"
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (268...291))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (268...271))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (268...271) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (271...272) = "."
+        │   ├── message_loc: (272...275) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (276...291))
+        │   │   ├── locals: []
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (278...285))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (279...284))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (279...284))
+        │   │   │   │   │       ├── parameters: (length: 1)
+        │   │   │   │   │       │   └── @ RequiredDestructuredParameterNode (location: (280...283))
+        │   │   │   │   │       │       ├── parameters: (length: 1)
+        │   │   │   │   │       │       │   └── @ SplatNode (location: (281...282))
+        │   │   │   │   │       │       │       ├── operator_loc: (281...282) = "*"
+        │   │   │   │   │       │       │       └── expression: ∅
+        │   │   │   │   │       │       ├── opening_loc: (280...281) = "("
+        │   │   │   │   │       │       └── closing_loc: (282...283) = ")"
+        │   │   │   │   │       ├── opening_loc: (279...280) = "("
+        │   │   │   │   │       └── closing_loc: (283...284) = ")"
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (278...279) = "|"
+        │   │   │   └── closing_loc: (284...285) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (288...289))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (288...289))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (288...289) = "d"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "d"
+        │   │   ├── opening_loc: (276...277) = "{"
+        │   │   └── closing_loc: (290...291) = "}"
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (292...318))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (292...295))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (292...295) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (295...296) = "."
+        │   ├── message_loc: (296...299) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (300...318))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (302...312))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (303...311))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (303...311))
+        │   │   │   │   │       ├── parameters: (length: 2)
+        │   │   │   │   │       │   ├── @ RequiredParameterNode (location: (304...305))
+        │   │   │   │   │       │   │   └── name: :a
+        │   │   │   │   │       │   └── @ RequiredDestructuredParameterNode (location: (307...310))
+        │   │   │   │   │       │       ├── parameters: (length: 1)
+        │   │   │   │   │       │       │   └── @ SplatNode (location: (308...309))
+        │   │   │   │   │       │       │       ├── operator_loc: (308...309) = "*"
+        │   │   │   │   │       │       │       └── expression: ∅
+        │   │   │   │   │       │       ├── opening_loc: (307...308) = "("
+        │   │   │   │   │       │       └── closing_loc: (309...310) = ")"
+        │   │   │   │   │       ├── opening_loc: (303...304) = "("
+        │   │   │   │   │       └── closing_loc: (310...311) = ")"
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (302...303) = "|"
+        │   │   │   └── closing_loc: (311...312) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (315...316))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (315...316))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (315...316) = "d"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "d"
+        │   │   ├── opening_loc: (300...301) = "{"
+        │   │   └── closing_loc: (317...318) = "}"
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (319...343))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (319...322))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (319...322) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (322...323) = "."
+        │   ├── message_loc: (323...326) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (327...343))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (329...337))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (330...336))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (330...336))
+        │   │   │   │   │       ├── parameters: (length: 2)
+        │   │   │   │   │       │   ├── @ RequiredParameterNode (location: (331...332))
+        │   │   │   │   │       │   │   └── name: :a
+        │   │   │   │   │       │   └── @ RequiredParameterNode (location: (334...335))
+        │   │   │   │   │       │       └── name: :b
+        │   │   │   │   │       ├── opening_loc: (330...331) = "("
+        │   │   │   │   │       └── closing_loc: (335...336) = ")"
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (329...330) = "|"
+        │   │   │   └── closing_loc: (336...337) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (340...341))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (340...341))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (340...341) = "d"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "d"
+        │   │   ├── opening_loc: (327...328) = "{"
+        │   │   └── closing_loc: (342...343) = "}"
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (344...359))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (344...355))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (344...347))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (344...347) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── call_operator_loc: (347...348) = "."
+        │   │   ├── message_loc: (348...351) = "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (352...355))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (352...353) = "{"
+        │   │   │   └── closing_loc: (354...355) = "}"
+        │   │   ├── flags: 
+        │   │   └── name: "bar"
+        │   ├── call_operator_loc: (355...356) = "."
+        │   ├── message_loc: (356...359) = "baz"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "baz"
+        ├── @ CallNode (location: (360...390))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (360...361) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (362...390))
+        │   │   ├── locals: [:e]
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (365...390))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements: ∅
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (365...386))
+        │   │   │   │   ├── keyword_loc: (365...371) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 1)
+        │   │   │   │   │   └── @ ConstantReadNode (location: (372...381))
+        │   │   │   │   │       └── name: :Exception
+        │   │   │   │   ├── operator_loc: (382...384) = "=>"
+        │   │   │   │   ├── reference:
+        │   │   │   │   │   @ LocalVariableTargetNode (location: (385...386))
+        │   │   │   │   │   ├── name: :e
+        │   │   │   │   │   └── depth: 0
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (387...390) = "end"
+        │   │   ├── opening_loc: (362...364) = "do"
+        │   │   └── closing_loc: (387...390) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        ├── @ CallNode (location: (391...435))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (391...392) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (393...435))
+        │   │   ├── locals: [:bar]
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (398...435))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (398...401))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (398...401))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (398...401) = "foo"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "foo"
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (402...431))
+        │   │   │   │   ├── keyword_loc: (402...408) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 1)
+        │   │   │   │   │   └── @ ConstantReadNode (location: (409...418))
+        │   │   │   │   │       └── name: :Exception
+        │   │   │   │   ├── operator_loc: (419...421) = "=>"
+        │   │   │   │   ├── reference:
+        │   │   │   │   │   @ LocalVariableTargetNode (location: (422...425))
+        │   │   │   │   │   ├── name: :bar
+        │   │   │   │   │   └── depth: 0
+        │   │   │   │   ├── statements:
+        │   │   │   │   │   @ StatementsNode (location: (428...431))
+        │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │       └── @ LocalVariableReadNode (location: (428...431))
+        │   │   │   │   │           ├── name: :bar
+        │   │   │   │   │           └── depth: 0
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (432...435) = "end"
+        │   │   ├── opening_loc: (393...395) = "do"
+        │   │   └── closing_loc: (432...435) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        ├── @ CallNode (location: (436...479))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (436...437) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (438...479))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (443...479))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (443...446))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (443...446))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (443...446) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (447...475))
+        │   │   │   │   ├── keyword_loc: (447...453) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 2)
+        │   │   │   │   │   ├── @ ConstantReadNode (location: (454...463))
+        │   │   │   │   │   │   └── name: :SomeError
+        │   │   │   │   │   └── @ SplatNode (location: (465...469))
+        │   │   │   │   │       ├── operator_loc: (465...466) = "*"
+        │   │   │   │   │       └── expression:
+        │   │   │   │   │           @ CallNode (location: (466...469))
+        │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (466...469) = "bar"
+        │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │           └── name: "bar"
+        │   │   │   │   ├── operator_loc: ∅
+        │   │   │   │   ├── reference: ∅
+        │   │   │   │   ├── statements:
+        │   │   │   │   │   @ StatementsNode (location: (472...475))
+        │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │       └── @ CallNode (location: (472...475))
+        │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (472...475) = "baz"
+        │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │           └── name: "baz"
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (476...479) = "end"
+        │   │   ├── opening_loc: (438...440) = "do"
+        │   │   └── closing_loc: (476...479) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        ├── @ CallNode (location: (480...536))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (480...481) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (482...536))
+        │   │   ├── locals: [:exception]
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (487...536))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (487...490))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (487...490))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (487...490) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (491...532))
+        │   │   │   │   ├── keyword_loc: (491...497) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 2)
+        │   │   │   │   │   ├── @ ConstantReadNode (location: (498...507))
+        │   │   │   │   │   │   └── name: :SomeError
+        │   │   │   │   │   └── @ SplatNode (location: (509...513))
+        │   │   │   │   │       ├── operator_loc: (509...510) = "*"
+        │   │   │   │   │       └── expression:
+        │   │   │   │   │           @ CallNode (location: (510...513))
+        │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (510...513) = "bar"
+        │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │           └── name: "bar"
+        │   │   │   │   ├── operator_loc: (514...516) = "=>"
+        │   │   │   │   ├── reference:
+        │   │   │   │   │   @ LocalVariableTargetNode (location: (517...526))
+        │   │   │   │   │   ├── name: :exception
+        │   │   │   │   │   └── depth: 0
+        │   │   │   │   ├── statements:
+        │   │   │   │   │   @ StatementsNode (location: (529...532))
+        │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │       └── @ CallNode (location: (529...532))
+        │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (529...532) = "baz"
+        │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │           └── name: "baz"
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (533...536) = "end"
+        │   │   ├── opening_loc: (482...484) = "do"
+        │   │   └── closing_loc: (533...536) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        ├── @ CallNode (location: (537...569))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (537...538) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (539...569))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (544...569))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (544...547))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (544...547))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (544...547) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (548...565))
+        │   │   │   │   ├── keyword_loc: (548...554) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 1)
+        │   │   │   │   │   └── @ SplatNode (location: (555...559))
+        │   │   │   │   │       ├── operator_loc: (555...556) = "*"
+        │   │   │   │   │       └── expression:
+        │   │   │   │   │           @ CallNode (location: (556...559))
+        │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (556...559) = "bar"
+        │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │           └── name: "bar"
+        │   │   │   │   ├── operator_loc: ∅
+        │   │   │   │   ├── reference: ∅
+        │   │   │   │   ├── statements:
+        │   │   │   │   │   @ StatementsNode (location: (562...565))
+        │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │       └── @ CallNode (location: (562...565))
+        │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (562...565) = "baz"
+        │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │           └── name: "baz"
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (566...569) = "end"
+        │   │   ├── opening_loc: (539...541) = "do"
+        │   │   └── closing_loc: (566...569) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        ├── @ CallNode (location: (570...601))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (570...571) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (572...601))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (577...601))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (577...580))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (577...580))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (577...580) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (581...597))
+        │   │   │   │   ├── keyword_loc: (581...587) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 1)
+        │   │   │   │   │   └── @ ConstantReadNode (location: (588...597))
+        │   │   │   │   │       └── name: :LoadError
+        │   │   │   │   ├── operator_loc: ∅
+        │   │   │   │   ├── reference: ∅
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (598...601) = "end"
+        │   │   ├── opening_loc: (572...574) = "do"
+        │   │   └── closing_loc: (598...601) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        ├── @ CallNode (location: (602...634))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (602...603) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (604...634))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (609...634))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (609...612))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (609...612))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (609...612) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (613...619))
+        │   │   │   │   ├── keyword_loc: (613...619) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 0)
+        │   │   │   │   ├── operator_loc: ∅
+        │   │   │   │   ├── reference: ∅
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause:
+        │   │   │   │   @ ElseNode (location: (620...634))
+        │   │   │   │   ├── else_keyword_loc: (620...624) = "else"
+        │   │   │   │   ├── statements:
+        │   │   │   │   │   @ StatementsNode (location: (627...630))
+        │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │       └── @ CallNode (location: (627...630))
+        │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (627...630) = "baz"
+        │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │           └── name: "baz"
+        │   │   │   │   └── end_keyword_loc: (631...634) = "end"
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (631...634) = "end"
+        │   │   ├── opening_loc: (604...606) = "do"
+        │   │   └── closing_loc: (631...634) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        ├── @ CallNode (location: (635...680))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (635...636) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (637...680))
+        │   │   ├── locals: [:exception]
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (642...680))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (642...645))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (642...645))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (642...645) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (646...676))
+        │   │   │   │   ├── keyword_loc: (646...652) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 1)
+        │   │   │   │   │   └── @ SplatNode (location: (653...657))
+        │   │   │   │   │       ├── operator_loc: (653...654) = "*"
+        │   │   │   │   │       └── expression:
+        │   │   │   │   │           @ CallNode (location: (654...657))
+        │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (654...657) = "bar"
+        │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │           └── name: "bar"
+        │   │   │   │   ├── operator_loc: (658...660) = "=>"
+        │   │   │   │   ├── reference:
+        │   │   │   │   │   @ LocalVariableTargetNode (location: (661...670))
+        │   │   │   │   │   ├── name: :exception
+        │   │   │   │   │   └── depth: 0
+        │   │   │   │   ├── statements:
+        │   │   │   │   │   @ StatementsNode (location: (673...676))
+        │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │       └── @ CallNode (location: (673...676))
+        │   │   │   │   │           ├── receiver: ∅
+        │   │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │   │           ├── message_loc: (673...676) = "baz"
+        │   │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │   │           ├── arguments: ∅
+        │   │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │   │           ├── block: ∅
+        │   │   │   │   │           ├── flags: variable_call
+        │   │   │   │   │           └── name: "baz"
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (677...680) = "end"
+        │   │   ├── opening_loc: (637...639) = "do"
+        │   │   └── closing_loc: (677...680) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        ├── @ CallNode (location: (681...696))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (681...682) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (683...696))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (686...696))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements: ∅
+        │   │   │   ├── rescue_clause: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause:
+        │   │   │   │   @ EnsureNode (location: (686...696))
+        │   │   │   │   ├── ensure_keyword_loc: (686...692) = "ensure"
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── end_keyword_loc: (693...696) = "end"
+        │   │   │   └── end_keyword_loc: (693...696) = "end"
+        │   │   ├── opening_loc: (683...685) = "do"
+        │   │   └── closing_loc: (693...696) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        ├── @ CallNode (location: (697...719))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (697...698) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (699...719))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (702...719))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements: ∅
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (702...708))
+        │   │   │   │   ├── keyword_loc: (702...708) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 0)
+        │   │   │   │   ├── operator_loc: ∅
+        │   │   │   │   ├── reference: ∅
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause:
+        │   │   │   │   @ EnsureNode (location: (709...719))
+        │   │   │   │   ├── ensure_keyword_loc: (709...715) = "ensure"
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── end_keyword_loc: (716...719) = "end"
+        │   │   │   └── end_keyword_loc: (716...719) = "end"
+        │   │   ├── opening_loc: (699...701) = "do"
+        │   │   └── closing_loc: (716...719) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        └── @ CallNode (location: (720...737))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (720...723) = "bar"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (724...737))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (728...735))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (728...735))
+            │   │           ├── receiver:
+            │   │           │   @ CallNode (location: (728...730))
+            │   │           │   ├── receiver: ∅
+            │   │           │   ├── call_operator_loc: ∅
+            │   │           │   ├── message_loc: (728...730) = "_1"
+            │   │           │   ├── opening_loc: ∅
+            │   │           │   ├── arguments: ∅
+            │   │           │   ├── closing_loc: ∅
+            │   │           │   ├── block: ∅
+            │   │           │   ├── flags: variable_call
+            │   │           │   └── name: "_1"
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (731...732) = "+"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments:
+            │   │           │   @ ArgumentsNode (location: (733...735))
+            │   │           │   └── arguments: (length: 1)
+            │   │           │       └── @ CallNode (location: (733...735))
+            │   │           │           ├── receiver: ∅
+            │   │           │           ├── call_operator_loc: ∅
+            │   │           │           ├── message_loc: (733...735) = "_2"
+            │   │           │           ├── opening_loc: ∅
+            │   │           │           ├── arguments: ∅
+            │   │           │           ├── closing_loc: ∅
+            │   │           │           ├── block: ∅
+            │   │           │           ├── flags: variable_call
+            │   │           │           └── name: "_2"
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "+"
+            │   ├── opening_loc: (724...725) = "{"
+            │   └── closing_loc: (736...737) = "}"
+            ├── flags: 
+            └── name: "bar"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/case.txt b/test/yarp/snapshots/unparser/corpus/literal/case.txt
index 8470bd39aa..c3ea29cc8b 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/case.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/case.txt
@@ -1,402 +1,428 @@
-ProgramNode(0...284)(
-  [],
-  StatementsNode(0...284)(
-    [CaseNode(0...38)(
-       nil,
-       [WhenNode(5...19)(
-          (5...9),
-          [CallNode(10...13)(
-             nil,
-             nil,
-             (10...13),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "bar"
-           )],
-          StatementsNode(16...19)(
-            [CallNode(16...19)(
-               nil,
-               nil,
-               (16...19),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "baz"
-             )]
-          )
-        ),
-        WhenNode(20...34)(
-          (20...24),
-          [CallNode(25...28)(
-             nil,
-             nil,
-             (25...28),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "baz"
-           )],
-          StatementsNode(31...34)(
-            [CallNode(31...34)(
-               nil,
-               nil,
-               (31...34),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          )
-        )],
-       nil,
-       (0...4),
-       (35...38)
-     ),
-     CaseNode(39...75)(
-       CallNode(44...47)(nil, nil, (44...47), nil, nil, nil, nil, 2, "foo"),
-       [WhenNode(48...56)(
-          (48...52),
-          [CallNode(53...56)(
-             nil,
-             nil,
-             (53...56),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "bar"
-           )],
-          nil
-        ),
-        WhenNode(57...71)(
-          (57...61),
-          [CallNode(62...65)(
-             nil,
-             nil,
-             (62...65),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "baz"
-           )],
-          StatementsNode(68...71)(
-            [CallNode(68...71)(
-               nil,
-               nil,
-               (68...71),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          )
-        )],
-       nil,
-       (39...43),
-       (72...75)
-     ),
-     CaseNode(76...118)(
-       CallNode(81...84)(nil, nil, (81...84), nil, nil, nil, nil, 2, "foo"),
-       [WhenNode(85...99)(
-          (85...89),
-          [CallNode(90...93)(
-             nil,
-             nil,
-             (90...93),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "bar"
-           )],
-          StatementsNode(96...99)(
-            [CallNode(96...99)(
-               nil,
-               nil,
-               (96...99),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "baz"
-             )]
-          )
-        ),
-        WhenNode(100...114)(
-          (100...104),
-          [CallNode(105...108)(
-             nil,
-             nil,
-             (105...108),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "baz"
-           )],
-          StatementsNode(111...114)(
-            [CallNode(111...114)(
-               nil,
-               nil,
-               (111...114),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          )
-        )],
-       nil,
-       (76...80),
-       (115...118)
-     ),
-     CaseNode(119...154)(
-       CallNode(124...127)(
-         nil,
-         nil,
-         (124...127),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [WhenNode(128...150)(
-          (128...132),
-          [CallNode(133...136)(
-             nil,
-             nil,
-             (133...136),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "bar"
-           ),
-           CallNode(138...141)(
-             nil,
-             nil,
-             (138...141),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "baz"
-           )],
-          StatementsNode(144...150)(
-            [SymbolNode(144...150)((144...145), (145...150), nil, "other")]
-          )
-        )],
-       nil,
-       (119...123),
-       (151...154)
-     ),
-     CaseNode(155...186)(
-       CallNode(160...163)(
-         nil,
-         nil,
-         (160...163),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [WhenNode(164...182)(
-          (164...168),
-          [SplatNode(169...173)(
-             (169...170),
-             CallNode(170...173)(
-               nil,
-               nil,
-               (170...173),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )
-           )],
-          StatementsNode(176...182)(
-            [SymbolNode(176...182)((176...177), (177...182), nil, "value")]
-          )
-        )],
-       nil,
-       (155...159),
-       (183...186)
-     ),
-     CaseNode(187...226)(
-       CallNode(192...195)(
-         nil,
-         nil,
-         (192...195),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [WhenNode(196...210)(
-          (196...200),
-          [CallNode(201...204)(
-             nil,
-             nil,
-             (201...204),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "bar"
-           )],
-          StatementsNode(207...210)(
-            [CallNode(207...210)(
-               nil,
-               nil,
-               (207...210),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "baz"
-             )]
-          )
-        )],
-       ElseNode(211...226)(
-         (211...215),
-         StatementsNode(218...222)(
-           [SymbolNode(218...222)((218...219), (219...222), nil, "foo")]
-         ),
-         (223...226)
-       ),
-       (187...191),
-       (223...226)
-     ),
-     CaseNode(227...255)(
-       CallNode(232...235)(
-         nil,
-         nil,
-         (232...235),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [WhenNode(236...251)(
-          (236...240),
-          [SplatNode(241...251)(
-             (241...242),
-             CallNode(242...251)(
-               CallNode(242...245)(
-                 nil,
-                 nil,
-                 (242...245),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "bar"
-               ),
-               nil,
-               (246...247),
-               nil,
-               ArgumentsNode(248...251)(
-                 [CallNode(248...251)(
-                    nil,
-                    nil,
-                    (248...251),
-                    nil,
-                    nil,
-                    nil,
-                    nil,
-                    2,
-                    "baz"
-                  )]
-               ),
-               nil,
-               nil,
-               0,
-               "|"
-             )
-           )],
-          nil
-        )],
-       nil,
-       (227...231),
-       (252...255)
-     ),
-     CaseNode(256...284)(
-       CallNode(261...264)(
-         nil,
-         nil,
-         (261...264),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [WhenNode(265...280)(
-          (265...269),
-          [SplatNode(270...280)(
-             (270...271),
-             CallNode(271...280)(
-               CallNode(271...274)(
-                 nil,
-                 nil,
-                 (271...274),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "bar"
-               ),
-               (274...275),
-               (275...278),
-               nil,
-               ArgumentsNode(279...280)([IntegerNode(279...280)()]),
-               nil,
-               nil,
-               0,
-               "baz="
-             )
-           )],
-          nil
-        )],
-       nil,
-       (256...260),
-       (281...284)
-     )]
-  )
-)
+@ ProgramNode (location: (0...284))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...284))
+    └── body: (length: 8)
+        ├── @ CaseNode (location: (0...38))
+        │   ├── predicate: ∅
+        │   ├── conditions: (length: 2)
+        │   │   ├── @ WhenNode (location: (5...19))
+        │   │   │   ├── keyword_loc: (5...9) = "when"
+        │   │   │   ├── conditions: (length: 1)
+        │   │   │   │   └── @ CallNode (location: (10...13))
+        │   │   │   │       ├── receiver: ∅
+        │   │   │   │       ├── call_operator_loc: ∅
+        │   │   │   │       ├── message_loc: (10...13) = "bar"
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── arguments: ∅
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       ├── block: ∅
+        │   │   │   │       ├── flags: variable_call
+        │   │   │   │       └── name: "bar"
+        │   │   │   └── statements:
+        │   │   │       @ StatementsNode (location: (16...19))
+        │   │   │       └── body: (length: 1)
+        │   │   │           └── @ CallNode (location: (16...19))
+        │   │   │               ├── receiver: ∅
+        │   │   │               ├── call_operator_loc: ∅
+        │   │   │               ├── message_loc: (16...19) = "baz"
+        │   │   │               ├── opening_loc: ∅
+        │   │   │               ├── arguments: ∅
+        │   │   │               ├── closing_loc: ∅
+        │   │   │               ├── block: ∅
+        │   │   │               ├── flags: variable_call
+        │   │   │               └── name: "baz"
+        │   │   └── @ WhenNode (location: (20...34))
+        │   │       ├── keyword_loc: (20...24) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ CallNode (location: (25...28))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (25...28) = "baz"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "baz"
+        │   │       └── statements:
+        │   │           @ StatementsNode (location: (31...34))
+        │   │           └── body: (length: 1)
+        │   │               └── @ CallNode (location: (31...34))
+        │   │                   ├── receiver: ∅
+        │   │                   ├── call_operator_loc: ∅
+        │   │                   ├── message_loc: (31...34) = "bar"
+        │   │                   ├── opening_loc: ∅
+        │   │                   ├── arguments: ∅
+        │   │                   ├── closing_loc: ∅
+        │   │                   ├── block: ∅
+        │   │                   ├── flags: variable_call
+        │   │                   └── name: "bar"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (0...4) = "case"
+        │   └── end_keyword_loc: (35...38) = "end"
+        ├── @ CaseNode (location: (39...75))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (44...47))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (44...47) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 2)
+        │   │   ├── @ WhenNode (location: (48...56))
+        │   │   │   ├── keyword_loc: (48...52) = "when"
+        │   │   │   ├── conditions: (length: 1)
+        │   │   │   │   └── @ CallNode (location: (53...56))
+        │   │   │   │       ├── receiver: ∅
+        │   │   │   │       ├── call_operator_loc: ∅
+        │   │   │   │       ├── message_loc: (53...56) = "bar"
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── arguments: ∅
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       ├── block: ∅
+        │   │   │   │       ├── flags: variable_call
+        │   │   │   │       └── name: "bar"
+        │   │   │   └── statements: ∅
+        │   │   └── @ WhenNode (location: (57...71))
+        │   │       ├── keyword_loc: (57...61) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ CallNode (location: (62...65))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (62...65) = "baz"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "baz"
+        │   │       └── statements:
+        │   │           @ StatementsNode (location: (68...71))
+        │   │           └── body: (length: 1)
+        │   │               └── @ CallNode (location: (68...71))
+        │   │                   ├── receiver: ∅
+        │   │                   ├── call_operator_loc: ∅
+        │   │                   ├── message_loc: (68...71) = "bar"
+        │   │                   ├── opening_loc: ∅
+        │   │                   ├── arguments: ∅
+        │   │                   ├── closing_loc: ∅
+        │   │                   ├── block: ∅
+        │   │                   ├── flags: variable_call
+        │   │                   └── name: "bar"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (39...43) = "case"
+        │   └── end_keyword_loc: (72...75) = "end"
+        ├── @ CaseNode (location: (76...118))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (81...84))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (81...84) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 2)
+        │   │   ├── @ WhenNode (location: (85...99))
+        │   │   │   ├── keyword_loc: (85...89) = "when"
+        │   │   │   ├── conditions: (length: 1)
+        │   │   │   │   └── @ CallNode (location: (90...93))
+        │   │   │   │       ├── receiver: ∅
+        │   │   │   │       ├── call_operator_loc: ∅
+        │   │   │   │       ├── message_loc: (90...93) = "bar"
+        │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │       ├── arguments: ∅
+        │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │       ├── block: ∅
+        │   │   │   │       ├── flags: variable_call
+        │   │   │   │       └── name: "bar"
+        │   │   │   └── statements:
+        │   │   │       @ StatementsNode (location: (96...99))
+        │   │   │       └── body: (length: 1)
+        │   │   │           └── @ CallNode (location: (96...99))
+        │   │   │               ├── receiver: ∅
+        │   │   │               ├── call_operator_loc: ∅
+        │   │   │               ├── message_loc: (96...99) = "baz"
+        │   │   │               ├── opening_loc: ∅
+        │   │   │               ├── arguments: ∅
+        │   │   │               ├── closing_loc: ∅
+        │   │   │               ├── block: ∅
+        │   │   │               ├── flags: variable_call
+        │   │   │               └── name: "baz"
+        │   │   └── @ WhenNode (location: (100...114))
+        │   │       ├── keyword_loc: (100...104) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ CallNode (location: (105...108))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (105...108) = "baz"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "baz"
+        │   │       └── statements:
+        │   │           @ StatementsNode (location: (111...114))
+        │   │           └── body: (length: 1)
+        │   │               └── @ CallNode (location: (111...114))
+        │   │                   ├── receiver: ∅
+        │   │                   ├── call_operator_loc: ∅
+        │   │                   ├── message_loc: (111...114) = "bar"
+        │   │                   ├── opening_loc: ∅
+        │   │                   ├── arguments: ∅
+        │   │                   ├── closing_loc: ∅
+        │   │                   ├── block: ∅
+        │   │                   ├── flags: variable_call
+        │   │                   └── name: "bar"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (76...80) = "case"
+        │   └── end_keyword_loc: (115...118) = "end"
+        ├── @ CaseNode (location: (119...154))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (124...127))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (124...127) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (128...150))
+        │   │       ├── keyword_loc: (128...132) = "when"
+        │   │       ├── conditions: (length: 2)
+        │   │       │   ├── @ CallNode (location: (133...136))
+        │   │       │   │   ├── receiver: ∅
+        │   │       │   │   ├── call_operator_loc: ∅
+        │   │       │   │   ├── message_loc: (133...136) = "bar"
+        │   │       │   │   ├── opening_loc: ∅
+        │   │       │   │   ├── arguments: ∅
+        │   │       │   │   ├── closing_loc: ∅
+        │   │       │   │   ├── block: ∅
+        │   │       │   │   ├── flags: variable_call
+        │   │       │   │   └── name: "bar"
+        │   │       │   └── @ CallNode (location: (138...141))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (138...141) = "baz"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "baz"
+        │   │       └── statements:
+        │   │           @ StatementsNode (location: (144...150))
+        │   │           └── body: (length: 1)
+        │   │               └── @ SymbolNode (location: (144...150))
+        │   │                   ├── opening_loc: (144...145) = ":"
+        │   │                   ├── value_loc: (145...150) = "other"
+        │   │                   ├── closing_loc: ∅
+        │   │                   └── unescaped: "other"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (119...123) = "case"
+        │   └── end_keyword_loc: (151...154) = "end"
+        ├── @ CaseNode (location: (155...186))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (160...163))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (160...163) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (164...182))
+        │   │       ├── keyword_loc: (164...168) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ SplatNode (location: (169...173))
+        │   │       │       ├── operator_loc: (169...170) = "*"
+        │   │       │       └── expression:
+        │   │       │           @ CallNode (location: (170...173))
+        │   │       │           ├── receiver: ∅
+        │   │       │           ├── call_operator_loc: ∅
+        │   │       │           ├── message_loc: (170...173) = "bar"
+        │   │       │           ├── opening_loc: ∅
+        │   │       │           ├── arguments: ∅
+        │   │       │           ├── closing_loc: ∅
+        │   │       │           ├── block: ∅
+        │   │       │           ├── flags: variable_call
+        │   │       │           └── name: "bar"
+        │   │       └── statements:
+        │   │           @ StatementsNode (location: (176...182))
+        │   │           └── body: (length: 1)
+        │   │               └── @ SymbolNode (location: (176...182))
+        │   │                   ├── opening_loc: (176...177) = ":"
+        │   │                   ├── value_loc: (177...182) = "value"
+        │   │                   ├── closing_loc: ∅
+        │   │                   └── unescaped: "value"
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (155...159) = "case"
+        │   └── end_keyword_loc: (183...186) = "end"
+        ├── @ CaseNode (location: (187...226))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (192...195))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (192...195) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (196...210))
+        │   │       ├── keyword_loc: (196...200) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ CallNode (location: (201...204))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (201...204) = "bar"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "bar"
+        │   │       └── statements:
+        │   │           @ StatementsNode (location: (207...210))
+        │   │           └── body: (length: 1)
+        │   │               └── @ CallNode (location: (207...210))
+        │   │                   ├── receiver: ∅
+        │   │                   ├── call_operator_loc: ∅
+        │   │                   ├── message_loc: (207...210) = "baz"
+        │   │                   ├── opening_loc: ∅
+        │   │                   ├── arguments: ∅
+        │   │                   ├── closing_loc: ∅
+        │   │                   ├── block: ∅
+        │   │                   ├── flags: variable_call
+        │   │                   └── name: "baz"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (211...226))
+        │   │   ├── else_keyword_loc: (211...215) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (218...222))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ SymbolNode (location: (218...222))
+        │   │   │           ├── opening_loc: (218...219) = ":"
+        │   │   │           ├── value_loc: (219...222) = "foo"
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           └── unescaped: "foo"
+        │   │   └── end_keyword_loc: (223...226) = "end"
+        │   ├── case_keyword_loc: (187...191) = "case"
+        │   └── end_keyword_loc: (223...226) = "end"
+        ├── @ CaseNode (location: (227...255))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (232...235))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (232...235) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ WhenNode (location: (236...251))
+        │   │       ├── keyword_loc: (236...240) = "when"
+        │   │       ├── conditions: (length: 1)
+        │   │       │   └── @ SplatNode (location: (241...251))
+        │   │       │       ├── operator_loc: (241...242) = "*"
+        │   │       │       └── expression:
+        │   │       │           @ CallNode (location: (242...251))
+        │   │       │           ├── receiver:
+        │   │       │           │   @ CallNode (location: (242...245))
+        │   │       │           │   ├── receiver: ∅
+        │   │       │           │   ├── call_operator_loc: ∅
+        │   │       │           │   ├── message_loc: (242...245) = "bar"
+        │   │       │           │   ├── opening_loc: ∅
+        │   │       │           │   ├── arguments: ∅
+        │   │       │           │   ├── closing_loc: ∅
+        │   │       │           │   ├── block: ∅
+        │   │       │           │   ├── flags: variable_call
+        │   │       │           │   └── name: "bar"
+        │   │       │           ├── call_operator_loc: ∅
+        │   │       │           ├── message_loc: (246...247) = "|"
+        │   │       │           ├── opening_loc: ∅
+        │   │       │           ├── arguments:
+        │   │       │           │   @ ArgumentsNode (location: (248...251))
+        │   │       │           │   └── arguments: (length: 1)
+        │   │       │           │       └── @ CallNode (location: (248...251))
+        │   │       │           │           ├── receiver: ∅
+        │   │       │           │           ├── call_operator_loc: ∅
+        │   │       │           │           ├── message_loc: (248...251) = "baz"
+        │   │       │           │           ├── opening_loc: ∅
+        │   │       │           │           ├── arguments: ∅
+        │   │       │           │           ├── closing_loc: ∅
+        │   │       │           │           ├── block: ∅
+        │   │       │           │           ├── flags: variable_call
+        │   │       │           │           └── name: "baz"
+        │   │       │           ├── closing_loc: ∅
+        │   │       │           ├── block: ∅
+        │   │       │           ├── flags: 
+        │   │       │           └── name: "|"
+        │   │       └── statements: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (227...231) = "case"
+        │   └── end_keyword_loc: (252...255) = "end"
+        └── @ CaseNode (location: (256...284))
+            ├── predicate:
+            │   @ CallNode (location: (261...264))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (261...264) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (265...280))
+            │       ├── keyword_loc: (265...269) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ SplatNode (location: (270...280))
+            │       │       ├── operator_loc: (270...271) = "*"
+            │       │       └── expression:
+            │       │           @ CallNode (location: (271...280))
+            │       │           ├── receiver:
+            │       │           │   @ CallNode (location: (271...274))
+            │       │           │   ├── receiver: ∅
+            │       │           │   ├── call_operator_loc: ∅
+            │       │           │   ├── message_loc: (271...274) = "bar"
+            │       │           │   ├── opening_loc: ∅
+            │       │           │   ├── arguments: ∅
+            │       │           │   ├── closing_loc: ∅
+            │       │           │   ├── block: ∅
+            │       │           │   ├── flags: variable_call
+            │       │           │   └── name: "bar"
+            │       │           ├── call_operator_loc: (274...275) = "."
+            │       │           ├── message_loc: (275...278) = "baz"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments:
+            │       │           │   @ ArgumentsNode (location: (279...280))
+            │       │           │   └── arguments: (length: 1)
+            │       │           │       └── @ IntegerNode (location: (279...280))
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: 
+            │       │           └── name: "baz="
+            │       └── statements: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (256...260) = "case"
+            └── end_keyword_loc: (281...284) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/class.txt b/test/yarp/snapshots/unparser/corpus/literal/class.txt
index 5d0ca9da7b..a963e0054f 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/class.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/class.txt
@@ -1,171 +1,231 @@
-ProgramNode(0...213)(
-  [],
-  StatementsNode(0...213)(
-    [ClassNode(0...11)(
-       [],
-       (0...5),
-       ConstantReadNode(6...7)(:A),
-       nil,
-       nil,
-       nil,
-       (8...11),
-       :A
-     ),
-     SingletonClassNode(13...27)(
-       [],
-       (13...18),
-       (19...21),
-       CallNode(22...23)(nil, nil, (22...23), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (24...27)
-     ),
-     SingletonClassNode(29...47)(
-       [],
-       (29...34),
-       (35...37),
-       CallNode(38...39)(nil, nil, (38...39), nil, nil, nil, nil, 2, "a"),
-       StatementsNode(42...43)(
-         [CallNode(42...43)(nil, nil, (42...43), nil, nil, nil, nil, 2, "b")]
-       ),
-       (44...47)
-     ),
-     ClassNode(49...63)(
-       [],
-       (49...54),
-       ConstantPathNode(55...59)(
-         ConstantReadNode(55...56)(:A),
-         ConstantReadNode(58...59)(:B),
-         (56...58)
-       ),
-       nil,
-       nil,
-       nil,
-       (60...63),
-       :B
-     ),
-     ClassNode(65...82)(
-       [],
-       (65...70),
-       ConstantPathNode(71...78)(
-         ConstantPathNode(71...75)(
-           ConstantReadNode(71...72)(:A),
-           ConstantReadNode(74...75)(:B),
-           (72...74)
-         ),
-         ConstantReadNode(77...78)(:C),
-         (75...77)
-       ),
-       nil,
-       nil,
-       nil,
-       (79...82),
-       :C
-     ),
-     ClassNode(84...99)(
-       [],
-       (84...89),
-       ConstantReadNode(90...91)(:A),
-       (92...93),
-       ConstantReadNode(94...95)(:B),
-       nil,
-       (96...99),
-       :A
-     ),
-     ClassNode(101...119)(
-       [],
-       (101...106),
-       ConstantReadNode(107...108)(:A),
-       (109...110),
-       ConstantPathNode(111...115)(
-         ConstantReadNode(111...112)(:B),
-         ConstantReadNode(114...115)(:C),
-         (112...114)
-       ),
-       nil,
-       (116...119),
-       :A
-     ),
-     ClassNode(121...142)(
-       [],
-       (121...126),
-       ConstantPathNode(127...131)(
-         ConstantReadNode(127...128)(:A),
-         ConstantReadNode(130...131)(:B),
-         (128...130)
-       ),
-       (132...133),
-       ConstantPathNode(134...138)(
-         ConstantReadNode(134...135)(:C),
-         ConstantReadNode(137...138)(:D),
-         (135...137)
-       ),
-       nil,
-       (139...142),
-       :B
-     ),
-     ClassNode(144...198)(
-       [],
-       (144...149),
-       ConstantReadNode(150...151)(:A),
-       nil,
-       nil,
-       StatementsNode(154...194)(
-         [CallNode(154...168)(
-            nil,
-            nil,
-            (154...161),
-            (161...162),
-            ArgumentsNode(162...167)(
-              [CallNode(162...167)(
-                 ConstantReadNode(162...163)(:B),
-                 (163...164),
-                 (164...167),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 0,
-                 "new"
-               )]
-            ),
-            (167...168),
-            nil,
-            0,
-            "include"
-          ),
-          DefNode(172...194)(
-            :foo,
-            (176...179),
-            nil,
-            nil,
-            StatementsNode(184...188)(
-              [SymbolNode(184...188)((184...185), (185...188), nil, "bar")]
-            ),
-            [],
-            (172...175),
-            nil,
-            nil,
-            nil,
-            nil,
-            (191...194)
-          )]
-       ),
-       (195...198),
-       :A
-     ),
-     ClassNode(200...213)(
-       [],
-       (200...205),
-       ConstantPathNode(206...209)(
-         nil,
-         ConstantReadNode(208...209)(:A),
-         (206...208)
-       ),
-       nil,
-       nil,
-       nil,
-       (210...213),
-       :A
-     )]
-  )
-)
+@ ProgramNode (location: (0...213))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...213))
+    └── body: (length: 10)
+        ├── @ ClassNode (location: (0...11))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (0...5) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (6...7))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (8...11) = "end"
+        │   └── name: :A
+        ├── @ SingletonClassNode (location: (13...27))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (13...18) = "class"
+        │   ├── operator_loc: (19...21) = "<<"
+        │   ├── expression:
+        │   │   @ CallNode (location: (22...23))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (22...23) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── body: ∅
+        │   └── end_keyword_loc: (24...27) = "end"
+        ├── @ SingletonClassNode (location: (29...47))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (29...34) = "class"
+        │   ├── operator_loc: (35...37) = "<<"
+        │   ├── expression:
+        │   │   @ CallNode (location: (38...39))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (38...39) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── body:
+        │   │   @ StatementsNode (location: (42...43))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (42...43))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (42...43) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   └── end_keyword_loc: (44...47) = "end"
+        ├── @ ClassNode (location: (49...63))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (49...54) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (55...59))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (55...56))
+        │   │   │   └── name: :A
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (58...59))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (56...58) = "::"
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (60...63) = "end"
+        │   └── name: :B
+        ├── @ ClassNode (location: (65...82))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (65...70) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (71...78))
+        │   │   ├── parent:
+        │   │   │   @ ConstantPathNode (location: (71...75))
+        │   │   │   ├── parent:
+        │   │   │   │   @ ConstantReadNode (location: (71...72))
+        │   │   │   │   └── name: :A
+        │   │   │   ├── child:
+        │   │   │   │   @ ConstantReadNode (location: (74...75))
+        │   │   │   │   └── name: :B
+        │   │   │   └── delimiter_loc: (72...74) = "::"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (77...78))
+        │   │   │   └── name: :C
+        │   │   └── delimiter_loc: (75...77) = "::"
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (79...82) = "end"
+        │   └── name: :C
+        ├── @ ClassNode (location: (84...99))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (84...89) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (90...91))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: (92...93) = "<"
+        │   ├── superclass:
+        │   │   @ ConstantReadNode (location: (94...95))
+        │   │   └── name: :B
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (96...99) = "end"
+        │   └── name: :A
+        ├── @ ClassNode (location: (101...119))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (101...106) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (107...108))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: (109...110) = "<"
+        │   ├── superclass:
+        │   │   @ ConstantPathNode (location: (111...115))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (111...112))
+        │   │   │   └── name: :B
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (114...115))
+        │   │   │   └── name: :C
+        │   │   └── delimiter_loc: (112...114) = "::"
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (116...119) = "end"
+        │   └── name: :A
+        ├── @ ClassNode (location: (121...142))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (121...126) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (127...131))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (127...128))
+        │   │   │   └── name: :A
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (130...131))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (128...130) = "::"
+        │   ├── inheritance_operator_loc: (132...133) = "<"
+        │   ├── superclass:
+        │   │   @ ConstantPathNode (location: (134...138))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (134...135))
+        │   │   │   └── name: :C
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (137...138))
+        │   │   │   └── name: :D
+        │   │   └── delimiter_loc: (135...137) = "::"
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (139...142) = "end"
+        │   └── name: :B
+        ├── @ ClassNode (location: (144...198))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (144...149) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (150...151))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (154...194))
+        │   │   └── body: (length: 2)
+        │   │       ├── @ CallNode (location: (154...168))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (154...161) = "include"
+        │   │       │   ├── opening_loc: (161...162) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (162...167))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (162...167))
+        │   │       │   │           ├── receiver:
+        │   │       │   │           │   @ ConstantReadNode (location: (162...163))
+        │   │       │   │           │   └── name: :B
+        │   │       │   │           ├── call_operator_loc: (163...164) = "."
+        │   │       │   │           ├── message_loc: (164...167) = "new"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments: ∅
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "new"
+        │   │       │   ├── closing_loc: (167...168) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "include"
+        │   │       └── @ DefNode (location: (172...194))
+        │   │           ├── name: :foo
+        │   │           ├── name_loc: (176...179) = "foo"
+        │   │           ├── receiver: ∅
+        │   │           ├── parameters: ∅
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (184...188))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ SymbolNode (location: (184...188))
+        │   │           │           ├── opening_loc: (184...185) = ":"
+        │   │           │           ├── value_loc: (185...188) = "bar"
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           └── unescaped: "bar"
+        │   │           ├── locals: []
+        │   │           ├── def_keyword_loc: (172...175) = "def"
+        │   │           ├── operator_loc: ∅
+        │   │           ├── lparen_loc: ∅
+        │   │           ├── rparen_loc: ∅
+        │   │           ├── equal_loc: ∅
+        │   │           └── end_keyword_loc: (191...194) = "end"
+        │   ├── end_keyword_loc: (195...198) = "end"
+        │   └── name: :A
+        └── @ ClassNode (location: (200...213))
+            ├── locals: []
+            ├── class_keyword_loc: (200...205) = "class"
+            ├── constant_path:
+            │   @ ConstantPathNode (location: (206...209))
+            │   ├── parent: ∅
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (208...209))
+            │   │   └── name: :A
+            │   └── delimiter_loc: (206...208) = "::"
+            ├── inheritance_operator_loc: ∅
+            ├── superclass: ∅
+            ├── body: ∅
+            ├── end_keyword_loc: (210...213) = "end"
+            └── name: :A
diff --git a/test/yarp/snapshots/unparser/corpus/literal/control.txt b/test/yarp/snapshots/unparser/corpus/literal/control.txt
index 182bddab60..90907ee44e 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/control.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/control.txt
@@ -1,83 +1,118 @@
-ProgramNode(0...144)(
-  [],
-  StatementsNode(0...144)(
-    [NextNode(0...4)(nil, (0...4)),
-     ReturnNode(5...11)((5...11), nil),
-     BreakNode(12...17)(nil, (12...17)),
-     RetryNode(18...23)(),
-     RedoNode(24...28)(),
-     ReturnNode(29...37)(
-       (29...35),
-       ArgumentsNode(36...37)([IntegerNode(36...37)()])
-     ),
-     ReturnNode(38...49)(
-       (38...44),
-       ArgumentsNode(45...49)([IntegerNode(45...46)(), IntegerNode(48...49)()])
-     ),
-     ReturnNode(50...69)(
-       (50...56),
-       ArgumentsNode(57...69)(
-         [IfNode(57...69)(
-            nil,
-            TrueNode(57...61)(),
-            StatementsNode(64...65)([IntegerNode(64...65)()]),
-            ElseNode(66...69)(
-              (66...67),
-              StatementsNode(68...69)([IntegerNode(68...69)()]),
-              nil
-            ),
-            nil
-          )]
-       )
-     ),
-     BreakNode(70...88)(
-       ArgumentsNode(76...88)(
-         [IfNode(76...88)(
-            nil,
-            TrueNode(76...80)(),
-            StatementsNode(83...84)([IntegerNode(83...84)()]),
-            ElseNode(85...88)(
-              (85...86),
-              StatementsNode(87...88)([IntegerNode(87...88)()]),
-              nil
-            ),
-            nil
-          )]
-       ),
-       (70...75)
-     ),
-     NextNode(89...106)(
-       ArgumentsNode(94...106)(
-         [IfNode(94...106)(
-            nil,
-            TrueNode(94...98)(),
-            StatementsNode(101...102)([IntegerNode(101...102)()]),
-            ElseNode(103...106)(
-              (103...104),
-              StatementsNode(105...106)([IntegerNode(105...106)()]),
-              nil
-            ),
-            nil
-          )]
-       ),
-       (89...93)
-     ),
-     ReturnNode(107...144)(
-       (107...113),
-       ArgumentsNode(114...144)(
-         [TrueNode(114...118)(),
-          IfNode(120...144)(
-            (120...122),
-            TrueNode(123...127)(),
-            StatementsNode(130...131)([IntegerNode(130...131)()]),
-            ElseNode(132...144)(
-              (132...136),
-              StatementsNode(139...140)([IntegerNode(139...140)()]),
-              (141...144)
-            ),
-            (141...144)
-          )]
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...144))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...144))
+    └── body: (length: 11)
+        ├── @ NextNode (location: (0...4))
+        │   ├── arguments: ∅
+        │   └── keyword_loc: (0...4) = "next"
+        ├── @ ReturnNode (location: (5...11))
+        │   ├── keyword_loc: (5...11) = "return"
+        │   └── arguments: ∅
+        ├── @ BreakNode (location: (12...17))
+        │   ├── arguments: ∅
+        │   └── keyword_loc: (12...17) = "break"
+        ├── @ RetryNode (location: (18...23))
+        ├── @ RedoNode (location: (24...28))
+        ├── @ ReturnNode (location: (29...37))
+        │   ├── keyword_loc: (29...35) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (36...37))
+        │       └── arguments: (length: 1)
+        │           └── @ IntegerNode (location: (36...37))
+        ├── @ ReturnNode (location: (38...49))
+        │   ├── keyword_loc: (38...44) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (45...49))
+        │       └── arguments: (length: 2)
+        │           ├── @ IntegerNode (location: (45...46))
+        │           └── @ IntegerNode (location: (48...49))
+        ├── @ ReturnNode (location: (50...69))
+        │   ├── keyword_loc: (50...56) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (57...69))
+        │       └── arguments: (length: 1)
+        │           └── @ IfNode (location: (57...69))
+        │               ├── if_keyword_loc: ∅
+        │               ├── predicate:
+        │               │   @ TrueNode (location: (57...61))
+        │               ├── statements:
+        │               │   @ StatementsNode (location: (64...65))
+        │               │   └── body: (length: 1)
+        │               │       └── @ IntegerNode (location: (64...65))
+        │               ├── consequent:
+        │               │   @ ElseNode (location: (66...69))
+        │               │   ├── else_keyword_loc: (66...67) = ":"
+        │               │   ├── statements:
+        │               │   │   @ StatementsNode (location: (68...69))
+        │               │   │   └── body: (length: 1)
+        │               │   │       └── @ IntegerNode (location: (68...69))
+        │               │   └── end_keyword_loc: ∅
+        │               └── end_keyword_loc: ∅
+        ├── @ BreakNode (location: (70...88))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (76...88))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IfNode (location: (76...88))
+        │   │           ├── if_keyword_loc: ∅
+        │   │           ├── predicate:
+        │   │           │   @ TrueNode (location: (76...80))
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (83...84))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (83...84))
+        │   │           ├── consequent:
+        │   │           │   @ ElseNode (location: (85...88))
+        │   │           │   ├── else_keyword_loc: (85...86) = ":"
+        │   │           │   ├── statements:
+        │   │           │   │   @ StatementsNode (location: (87...88))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ IntegerNode (location: (87...88))
+        │   │           │   └── end_keyword_loc: ∅
+        │   │           └── end_keyword_loc: ∅
+        │   └── keyword_loc: (70...75) = "break"
+        ├── @ NextNode (location: (89...106))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (94...106))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IfNode (location: (94...106))
+        │   │           ├── if_keyword_loc: ∅
+        │   │           ├── predicate:
+        │   │           │   @ TrueNode (location: (94...98))
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (101...102))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (101...102))
+        │   │           ├── consequent:
+        │   │           │   @ ElseNode (location: (103...106))
+        │   │           │   ├── else_keyword_loc: (103...104) = ":"
+        │   │           │   ├── statements:
+        │   │           │   │   @ StatementsNode (location: (105...106))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ IntegerNode (location: (105...106))
+        │   │           │   └── end_keyword_loc: ∅
+        │   │           └── end_keyword_loc: ∅
+        │   └── keyword_loc: (89...93) = "next"
+        └── @ ReturnNode (location: (107...144))
+            ├── keyword_loc: (107...113) = "return"
+            └── arguments:
+                @ ArgumentsNode (location: (114...144))
+                └── arguments: (length: 2)
+                    ├── @ TrueNode (location: (114...118))
+                    └── @ IfNode (location: (120...144))
+                        ├── if_keyword_loc: (120...122) = "if"
+                        ├── predicate:
+                        │   @ TrueNode (location: (123...127))
+                        ├── statements:
+                        │   @ StatementsNode (location: (130...131))
+                        │   └── body: (length: 1)
+                        │       └── @ IntegerNode (location: (130...131))
+                        ├── consequent:
+                        │   @ ElseNode (location: (132...144))
+                        │   ├── else_keyword_loc: (132...136) = "else"
+                        │   ├── statements:
+                        │   │   @ StatementsNode (location: (139...140))
+                        │   │   └── body: (length: 1)
+                        │   │       └── @ IntegerNode (location: (139...140))
+                        │   └── end_keyword_loc: (141...144) = "end"
+                        └── end_keyword_loc: (141...144) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/def.txt b/test/yarp/snapshots/unparser/corpus/literal/def.txt
index 9bb03d20f2..458a087408 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/def.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/def.txt
@@ -1,1053 +1,1165 @@
-ProgramNode(0...913)(
-  [],
-  StatementsNode(0...913)(
-    [DefNode(0...46)(
-       :foo,
-       (4...7),
-       nil,
-       nil,
-       BeginNode(10...46)(
-         nil,
-         StatementsNode(10...11)(
-           [CallNode(10...11)(nil, nil, (10...11), nil, nil, nil, nil, 2, "a")]
-         ),
-         RescueNode(12...22)(
-           (12...18),
-           [],
-           nil,
-           nil,
-           StatementsNode(21...22)(
-             [CallNode(21...22)(
-                nil,
-                nil,
-                (21...22),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "b"
-              )]
-           ),
-           nil
-         ),
-         ElseNode(23...38)(
-           (23...27),
-           StatementsNode(30...31)(
-             [CallNode(30...31)(
-                nil,
-                nil,
-                (30...31),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "c"
-              )]
-           ),
-           (32...38)
-         ),
-         EnsureNode(32...46)(
-           (32...38),
-           StatementsNode(41...42)(
-             [CallNode(41...42)(
-                nil,
-                nil,
-                (41...42),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "d"
-              )]
-           ),
-           (43...46)
-         ),
-         (43...46)
-       ),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (43...46)
-     ),
-     DefNode(48...103)(
-       :foo,
-       (52...55),
-       nil,
-       nil,
-       BeginNode(58...103)(
-         nil,
-         StatementsNode(58...68)(
-           [RescueModifierNode(58...68)(
-              CallNode(58...59)(
-                nil,
-                nil,
-                (58...59),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "a"
-              ),
-              (60...66),
-              CallNode(67...68)(
-                nil,
-                nil,
-                (67...68),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "b"
-              )
-            )]
-         ),
-         RescueNode(69...79)(
-           (69...75),
-           [],
-           nil,
-           nil,
-           StatementsNode(78...79)(
-             [CallNode(78...79)(
-                nil,
-                nil,
-                (78...79),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "b"
-              )]
-           ),
-           nil
-         ),
-         ElseNode(80...95)(
-           (80...84),
-           StatementsNode(87...88)(
-             [CallNode(87...88)(
-                nil,
-                nil,
-                (87...88),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "c"
-              )]
-           ),
-           (89...95)
-         ),
-         EnsureNode(89...103)(
-           (89...95),
-           StatementsNode(98...99)(
-             [CallNode(98...99)(
-                nil,
-                nil,
-                (98...99),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "d"
-              )]
-           ),
-           (100...103)
-         ),
-         (100...103)
-       ),
-       [],
-       (48...51),
-       nil,
-       nil,
-       nil,
-       nil,
-       (100...103)
-     ),
-     DefNode(105...128)(
-       :foo,
-       (109...112),
-       nil,
-       ParametersNode(113...123)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(113...117)(:bar, (113...117), nil),
-          KeywordParameterNode(119...123)(:baz, (119...123), nil)],
-         nil,
-         nil
-       ),
-       nil,
-       [:bar, :baz],
-       (105...108),
-       nil,
-       (112...113),
-       (123...124),
-       nil,
-       (125...128)
-     ),
-     DefNode(130...141)(
-       :foo,
-       (134...137),
-       nil,
-       nil,
-       nil,
-       [],
-       (130...133),
-       nil,
-       nil,
-       nil,
-       nil,
-       (138...141)
-     ),
-     DefNode(143...160)(
-       :foo,
-       (147...150),
-       nil,
-       nil,
-       StatementsNode(153...156)(
-         [CallNode(153...156)(
-            nil,
-            nil,
-            (153...156),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       [],
-       (143...146),
-       nil,
-       nil,
-       nil,
-       nil,
-       (157...160)
-     ),
-     DefNode(162...205)(
-       :foo,
-       (166...169),
-       nil,
-       nil,
-       BeginNode(172...205)(
-         nil,
-         StatementsNode(172...175)(
-           [CallNode(172...175)(
-              nil,
-              nil,
-              (172...175),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         RescueNode(176...188)(
-           (176...182),
-           [],
-           nil,
-           nil,
-           StatementsNode(185...188)(
-             [CallNode(185...188)(
-                nil,
-                nil,
-                (185...188),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           nil
-         ),
-         nil,
-         EnsureNode(189...205)(
-           (189...195),
-           StatementsNode(198...201)(
-             [CallNode(198...201)(
-                nil,
-                nil,
-                (198...201),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "baz"
-              )]
-           ),
-           (202...205)
-         ),
-         (202...205)
-       ),
-       [],
-       (162...165),
-       nil,
-       nil,
-       nil,
-       nil,
-       (202...205)
-     ),
-     DefNode(207...237)(
-       :foo,
-       (211...214),
-       nil,
-       nil,
-       BeginNode(217...237)(
-         nil,
-         StatementsNode(217...220)(
-           [CallNode(217...220)(
-              nil,
-              nil,
-              (217...220),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         nil,
-         nil,
-         EnsureNode(221...237)(
-           (221...227),
-           StatementsNode(230...233)(
-             [CallNode(230...233)(
-                nil,
-                nil,
-                (230...233),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "baz"
-              )]
-           ),
-           (234...237)
-         ),
-         (234...237)
-       ),
-       [],
-       (207...210),
-       nil,
-       nil,
-       nil,
-       nil,
-       (234...237)
-     ),
-     DefNode(239...269)(
-       :foo,
-       (243...246),
-       nil,
-       nil,
-       BeginNode(249...269)(
-         nil,
-         StatementsNode(249...252)(
-           [CallNode(249...252)(
-              nil,
-              nil,
-              (249...252),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         RescueNode(253...265)(
-           (253...259),
-           [],
-           nil,
-           nil,
-           StatementsNode(262...265)(
-             [CallNode(262...265)(
-                nil,
-                nil,
-                (262...265),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "baz"
-              )]
-           ),
-           nil
-         ),
-         nil,
-         nil,
-         (266...269)
-       ),
-       [],
-       (239...242),
-       nil,
-       nil,
-       nil,
-       nil,
-       (266...269)
-     ),
-     DefNode(271...293)(
-       :foo,
-       (275...278),
-       nil,
-       ParametersNode(279...282)(
-         [RequiredParameterNode(279...282)(:bar)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(286...289)([LocalVariableReadNode(286...289)(:bar, 0)]),
-       [:bar],
-       (271...274),
-       nil,
-       (278...279),
-       (282...283),
-       nil,
-       (290...293)
-     ),
-     DefNode(295...322)(
-       :foo,
-       (299...302),
-       nil,
-       ParametersNode(303...311)(
-         [RequiredParameterNode(303...306)(:bar),
-          RequiredParameterNode(308...311)(:baz)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(315...318)([LocalVariableReadNode(315...318)(:bar, 0)]),
-       [:bar, :baz],
-       (295...298),
-       nil,
-       (302...303),
-       (311...312),
-       nil,
-       (319...322)
-     ),
-     DefNode(324...351)(
-       :foo,
-       (328...331),
-       nil,
-       ParametersNode(332...340)(
-         [],
-         [OptionalParameterNode(332...340)(
-            :bar,
-            (332...335),
-            (336...337),
-            ParenthesesNode(338...340)(nil, (338...339), (339...340))
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(344...347)([LocalVariableReadNode(344...347)(:bar, 0)]),
-       [:bar],
-       (324...327),
-       nil,
-       (331...332),
-       (340...341),
-       nil,
-       (348...351)
-     ),
-     DefNode(353...382)(
-       :foo,
-       (357...360),
-       nil,
-       ParametersNode(361...377)(
-         [],
-         [OptionalParameterNode(361...377)(
-            :bar,
-            (361...364),
-            (365...366),
-            ParenthesesNode(367...377)(
-              StatementsNode(368...376)(
-                [CallNode(368...371)(
-                   nil,
-                   nil,
-                   (368...371),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "baz"
-                 ),
-                 NilNode(373...376)()]
-              ),
-              (367...368),
-              (376...377)
-            )
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:bar],
-       (353...356),
-       nil,
-       (360...361),
-       (377...378),
-       nil,
-       (379...382)
-     ),
-     DefNode(384...413)(
-       :foo,
-       (388...391),
-       nil,
-       ParametersNode(392...402)(
-         [],
-         [OptionalParameterNode(392...402)(
-            :bar,
-            (392...395),
-            (396...397),
-            TrueNode(398...402)()
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(406...409)([LocalVariableReadNode(406...409)(:bar, 0)]),
-       [:bar],
-       (384...387),
-       nil,
-       (391...392),
-       (402...403),
-       nil,
-       (410...413)
-     ),
-     DefNode(415...449)(
-       :foo,
-       (419...422),
-       nil,
-       ParametersNode(423...438)(
-         [RequiredParameterNode(423...426)(:bar)],
-         [OptionalParameterNode(428...438)(
-            :baz,
-            (428...431),
-            (432...433),
-            TrueNode(434...438)()
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(442...445)([LocalVariableReadNode(442...445)(:bar, 0)]),
-       [:bar, :baz],
-       (415...418),
-       nil,
-       (422...423),
-       (438...439),
-       nil,
-       (446...449)
-     ),
-     DefNode(451...470)(
-       :foo,
-       (455...458),
-       nil,
-       ParametersNode(459...465)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(459...465)(
-            :bar,
-            (459...463),
-            IntegerNode(464...465)()
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:bar],
-       (451...454),
-       nil,
-       (458...459),
-       (465...466),
-       nil,
-       (467...470)
-     ),
-     DefNode(472...493)(
-       :foo,
-       (476...479),
-       nil,
-       ParametersNode(480...488)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(480...488)(
-            :bar,
-            (480...484),
-            CallNode(485...488)(
-              nil,
-              nil,
-              (485...488),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:bar],
-       (472...475),
-       nil,
-       (479...480),
-       (488...489),
-       nil,
-       (490...493)
-     ),
-     DefNode(495...518)(
-       :foo,
-       (499...502),
-       nil,
-       ParametersNode(503...513)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(503...513)(
-            :bar,
-            (503...507),
-            CallNode(508...513)(
-              nil,
-              nil,
-              (508...511),
-              (511...512),
-              nil,
-              (512...513),
-              nil,
-              0,
-              "bar"
-            )
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:bar],
-       (495...498),
-       nil,
-       (502...503),
-       (513...514),
-       nil,
-       (515...518)
-     ),
-     DefNode(520...540)(
-       :foo,
-       (524...527),
-       nil,
-       ParametersNode(528...529)(
-         [],
-         [],
-         [],
-         RestParameterNode(528...529)(nil, nil, (528...529)),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(533...536)(
-         [CallNode(533...536)(
-            nil,
-            nil,
-            (533...536),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       [:*],
-       (520...523),
-       nil,
-       (527...528),
-       (529...530),
-       nil,
-       (537...540)
-     ),
-     DefNode(542...565)(
-       :foo,
-       (546...549),
-       nil,
-       ParametersNode(550...554)(
-         [],
-         [],
-         [],
-         RestParameterNode(550...554)(:bar, (551...554), (550...551)),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(558...561)([LocalVariableReadNode(558...561)(:bar, 0)]),
-       [:bar],
-       (542...545),
-       nil,
-       (549...550),
-       (554...555),
-       nil,
-       (562...565)
-     ),
-     DefNode(567...595)(
-       :foo,
-       (571...574),
-       nil,
-       ParametersNode(575...584)(
-         [RequiredParameterNode(575...578)(:bar)],
-         [],
-         [],
-         RestParameterNode(580...584)(:baz, (581...584), (580...581)),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(588...591)([LocalVariableReadNode(588...591)(:bar, 0)]),
-       [:bar, :baz],
-       (567...570),
-       nil,
-       (574...575),
-       (584...585),
-       nil,
-       (592...595)
-     ),
-     DefNode(597...632)(
-       :foo,
-       (601...604),
-       nil,
-       ParametersNode(605...621)(
-         [],
-         [OptionalParameterNode(605...615)(
-            :baz,
-            (605...608),
-            (609...610),
-            TrueNode(611...615)()
-          )],
-         [],
-         RestParameterNode(617...621)(:bor, (618...621), (617...618)),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(625...628)(
-         [CallNode(625...628)(
-            nil,
-            nil,
-            (625...628),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       [:baz, :bor],
-       (597...600),
-       nil,
-       (604...605),
-       (621...622),
-       nil,
-       (629...632)
-     ),
-     DefNode(634...677)(
-       :foo,
-       (638...641),
-       nil,
-       ParametersNode(642...666)(
-         [],
-         [OptionalParameterNode(642...652)(
-            :baz,
-            (642...645),
-            (646...647),
-            TrueNode(648...652)()
-          )],
-         [],
-         RestParameterNode(654...658)(:bor, (655...658), (654...655)),
-         [],
-         nil,
-         BlockParameterNode(660...666)(:block, (661...666), (660...661))
-       ),
-       StatementsNode(670...673)(
-         [CallNode(670...673)(
-            nil,
-            nil,
-            (670...673),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       [:baz, :bor, :block],
-       (634...637),
-       nil,
-       (641...642),
-       (666...667),
-       nil,
-       (674...677)
-     ),
-     DefNode(679...719)(
-       :foo,
-       (683...686),
-       nil,
-       ParametersNode(687...708)(
-         [RequiredParameterNode(687...690)(:bar)],
-         [OptionalParameterNode(692...702)(
-            :baz,
-            (692...695),
-            (696...697),
-            TrueNode(698...702)()
-          )],
-         [],
-         RestParameterNode(704...708)(:bor, (705...708), (704...705)),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(712...715)([LocalVariableReadNode(712...715)(:bar, 0)]),
-       [:bar, :baz, :bor],
-       (679...682),
-       nil,
-       (686...687),
-       (708...709),
-       nil,
-       (716...719)
-     ),
-     DefNode(721...746)(
-       :foo,
-       (725...728),
-       nil,
-       ParametersNode(729...735)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(729...735)(:block, (730...735), (729...730))
-       ),
-       StatementsNode(739...742)(
-         [CallNode(739...742)(
-            nil,
-            nil,
-            (739...742),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       [:block],
-       (721...724),
-       nil,
-       (728...729),
-       (735...736),
-       nil,
-       (743...746)
-     ),
-     DefNode(748...778)(
-       :foo,
-       (752...755),
-       nil,
-       ParametersNode(756...767)(
-         [RequiredParameterNode(756...759)(:bar)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(761...767)(:block, (762...767), (761...762))
-       ),
-       StatementsNode(771...774)([LocalVariableReadNode(771...774)(:bar, 0)]),
-       [:bar, :block],
-       (748...751),
-       nil,
-       (755...756),
-       (767...768),
-       nil,
-       (775...778)
-     ),
-     DefNode(780...803)(
-       :foo,
-       (784...787),
-       nil,
-       nil,
-       StatementsNode(790...799)(
-         [CallNode(790...793)(
-            nil,
-            nil,
-            (790...793),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          ),
-          CallNode(796...799)(
-            nil,
-            nil,
-            (796...799),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          )]
-       ),
-       [],
-       (780...783),
-       nil,
-       nil,
-       nil,
-       nil,
-       (800...803)
-     ),
-     DefNode(805...821)(
-       :f,
-       (809...810),
-       nil,
-       ParametersNode(811...816)(
-         [RequiredDestructuredParameterNode(811...816)(
-            [RequiredDestructuredParameterNode(812...815)(
-               [RequiredParameterNode(813...814)(:a)],
-               (812...813),
-               (814...815)
-             )],
-            (811...812),
-            (815...816)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (805...808),
-       nil,
-       (810...811),
-       (816...817),
-       nil,
-       (818...821)
-     ),
-     DefNode(823...854)(
-       :foo,
-       (827...830),
-       nil,
-       ParametersNode(831...849)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(831...835)(:bar, (831...835), nil),
-          KeywordParameterNode(837...849)(
-            :baz,
-            (837...841),
-            StringNode(842...849)(
-              (842...843),
-              (843...848),
-              (848...849),
-              "value"
-            )
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:bar, :baz],
-       (823...826),
-       nil,
-       (830...831),
-       (849...850),
-       nil,
-       (851...854)
-     ),
-     DefNode(856...896)(
-       :f,
-       (860...861),
-       nil,
-       nil,
-       StatementsNode(864...874)(
-         [InterpolatedStringNode(864...874)(
-            (864...874),
-            [StringNode(875...879)(nil, (875...879), nil, "    "),
-             EmbeddedStatementsNode(879...882)((879...881), nil, (881...882)),
-             StringNode(882...883)(nil, (882...883), nil, "\n")],
-            (883...893)
-          )]
-       ),
-       [],
-       (856...859),
-       nil,
-       nil,
-       nil,
-       nil,
-       (893...896)
-     ),
-     DefNode(898...913)(
-       :f,
-       (902...903),
-       nil,
-       nil,
-       StatementsNode(906...909)(
-         [StringNode(906...909)((906...908), (908...908), (908...909), "")]
-       ),
-       [],
-       (898...901),
-       nil,
-       nil,
-       nil,
-       nil,
-       (910...913)
-     )]
-  )
-)
+@ ProgramNode (location: (0...913))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...913))
+    └── body: (length: 30)
+        ├── @ DefNode (location: (0...46))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (10...46))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (10...11))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (10...11))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (10...11) = "a"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "a"
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (12...22))
+        │   │   │   ├── keyword_loc: (12...18) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (21...22))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (21...22))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (21...22) = "b"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "b"
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause:
+        │   │   │   @ ElseNode (location: (23...38))
+        │   │   │   ├── else_keyword_loc: (23...27) = "else"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (30...31))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (30...31))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (30...31) = "c"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "c"
+        │   │   │   └── end_keyword_loc: (32...38) = "ensure"
+        │   │   ├── ensure_clause:
+        │   │   │   @ EnsureNode (location: (32...46))
+        │   │   │   ├── ensure_keyword_loc: (32...38) = "ensure"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (41...42))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (41...42))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (41...42) = "d"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "d"
+        │   │   │   └── end_keyword_loc: (43...46) = "end"
+        │   │   └── end_keyword_loc: (43...46) = "end"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (43...46) = "end"
+        ├── @ DefNode (location: (48...103))
+        │   ├── name: :foo
+        │   ├── name_loc: (52...55) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (58...103))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (58...68))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ RescueModifierNode (location: (58...68))
+        │   │   │           ├── expression:
+        │   │   │           │   @ CallNode (location: (58...59))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (58...59) = "a"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "a"
+        │   │   │           ├── keyword_loc: (60...66) = "rescue"
+        │   │   │           └── rescue_expression:
+        │   │   │               @ CallNode (location: (67...68))
+        │   │   │               ├── receiver: ∅
+        │   │   │               ├── call_operator_loc: ∅
+        │   │   │               ├── message_loc: (67...68) = "b"
+        │   │   │               ├── opening_loc: ∅
+        │   │   │               ├── arguments: ∅
+        │   │   │               ├── closing_loc: ∅
+        │   │   │               ├── block: ∅
+        │   │   │               ├── flags: variable_call
+        │   │   │               └── name: "b"
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (69...79))
+        │   │   │   ├── keyword_loc: (69...75) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (78...79))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (78...79))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (78...79) = "b"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "b"
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause:
+        │   │   │   @ ElseNode (location: (80...95))
+        │   │   │   ├── else_keyword_loc: (80...84) = "else"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (87...88))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (87...88))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (87...88) = "c"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "c"
+        │   │   │   └── end_keyword_loc: (89...95) = "ensure"
+        │   │   ├── ensure_clause:
+        │   │   │   @ EnsureNode (location: (89...103))
+        │   │   │   ├── ensure_keyword_loc: (89...95) = "ensure"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (98...99))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (98...99))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (98...99) = "d"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "d"
+        │   │   │   └── end_keyword_loc: (100...103) = "end"
+        │   │   └── end_keyword_loc: (100...103) = "end"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (48...51) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (100...103) = "end"
+        ├── @ DefNode (location: (105...128))
+        │   ├── name: :foo
+        │   ├── name_loc: (109...112) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (113...123))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 2)
+        │   │   │   ├── @ KeywordParameterNode (location: (113...117))
+        │   │   │   │   ├── name: :bar
+        │   │   │   │   ├── name_loc: (113...117) = "bar:"
+        │   │   │   │   └── value: ∅
+        │   │   │   └── @ KeywordParameterNode (location: (119...123))
+        │   │   │       ├── name: :baz
+        │   │   │       ├── name_loc: (119...123) = "baz:"
+        │   │   │       └── value: ∅
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:bar, :baz]
+        │   ├── def_keyword_loc: (105...108) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (112...113) = "("
+        │   ├── rparen_loc: (123...124) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (125...128) = "end"
+        ├── @ DefNode (location: (130...141))
+        │   ├── name: :foo
+        │   ├── name_loc: (134...137) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (130...133) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (138...141) = "end"
+        ├── @ DefNode (location: (143...160))
+        │   ├── name: :foo
+        │   ├── name_loc: (147...150) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (153...156))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (153...156))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (153...156) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (143...146) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (157...160) = "end"
+        ├── @ DefNode (location: (162...205))
+        │   ├── name: :foo
+        │   ├── name_loc: (166...169) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (172...205))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (172...175))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (172...175))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (172...175) = "foo"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "foo"
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (176...188))
+        │   │   │   ├── keyword_loc: (176...182) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (185...188))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (185...188))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (185...188) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause: ∅
+        │   │   ├── ensure_clause:
+        │   │   │   @ EnsureNode (location: (189...205))
+        │   │   │   ├── ensure_keyword_loc: (189...195) = "ensure"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (198...201))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (198...201))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (198...201) = "baz"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "baz"
+        │   │   │   └── end_keyword_loc: (202...205) = "end"
+        │   │   └── end_keyword_loc: (202...205) = "end"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (162...165) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (202...205) = "end"
+        ├── @ DefNode (location: (207...237))
+        │   ├── name: :foo
+        │   ├── name_loc: (211...214) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (217...237))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (217...220))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (217...220))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (217...220) = "bar"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "bar"
+        │   │   ├── rescue_clause: ∅
+        │   │   ├── else_clause: ∅
+        │   │   ├── ensure_clause:
+        │   │   │   @ EnsureNode (location: (221...237))
+        │   │   │   ├── ensure_keyword_loc: (221...227) = "ensure"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (230...233))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (230...233))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (230...233) = "baz"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "baz"
+        │   │   │   └── end_keyword_loc: (234...237) = "end"
+        │   │   └── end_keyword_loc: (234...237) = "end"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (207...210) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (234...237) = "end"
+        ├── @ DefNode (location: (239...269))
+        │   ├── name: :foo
+        │   ├── name_loc: (243...246) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ BeginNode (location: (249...269))
+        │   │   ├── begin_keyword_loc: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (249...252))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (249...252))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (249...252) = "bar"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "bar"
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (253...265))
+        │   │   │   ├── keyword_loc: (253...259) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (262...265))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (262...265))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (262...265) = "baz"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "baz"
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause: ∅
+        │   │   ├── ensure_clause: ∅
+        │   │   └── end_keyword_loc: (266...269) = "end"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (239...242) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (266...269) = "end"
+        ├── @ DefNode (location: (271...293))
+        │   ├── name: :foo
+        │   ├── name_loc: (275...278) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (279...282))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (279...282))
+        │   │   │       └── name: :bar
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (286...289))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (286...289))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── locals: [:bar]
+        │   ├── def_keyword_loc: (271...274) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (278...279) = "("
+        │   ├── rparen_loc: (282...283) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (290...293) = "end"
+        ├── @ DefNode (location: (295...322))
+        │   ├── name: :foo
+        │   ├── name_loc: (299...302) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (303...311))
+        │   │   ├── requireds: (length: 2)
+        │   │   │   ├── @ RequiredParameterNode (location: (303...306))
+        │   │   │   │   └── name: :bar
+        │   │   │   └── @ RequiredParameterNode (location: (308...311))
+        │   │   │       └── name: :baz
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (315...318))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (315...318))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── locals: [:bar, :baz]
+        │   ├── def_keyword_loc: (295...298) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (302...303) = "("
+        │   ├── rparen_loc: (311...312) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (319...322) = "end"
+        ├── @ DefNode (location: (324...351))
+        │   ├── name: :foo
+        │   ├── name_loc: (328...331) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (332...340))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (332...340))
+        │   │   │       ├── name: :bar
+        │   │   │       ├── name_loc: (332...335) = "bar"
+        │   │   │       ├── operator_loc: (336...337) = "="
+        │   │   │       └── value:
+        │   │   │           @ ParenthesesNode (location: (338...340))
+        │   │   │           ├── body: ∅
+        │   │   │           ├── opening_loc: (338...339) = "("
+        │   │   │           └── closing_loc: (339...340) = ")"
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (344...347))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (344...347))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── locals: [:bar]
+        │   ├── def_keyword_loc: (324...327) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (331...332) = "("
+        │   ├── rparen_loc: (340...341) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (348...351) = "end"
+        ├── @ DefNode (location: (353...382))
+        │   ├── name: :foo
+        │   ├── name_loc: (357...360) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (361...377))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (361...377))
+        │   │   │       ├── name: :bar
+        │   │   │       ├── name_loc: (361...364) = "bar"
+        │   │   │       ├── operator_loc: (365...366) = "="
+        │   │   │       └── value:
+        │   │   │           @ ParenthesesNode (location: (367...377))
+        │   │   │           ├── body:
+        │   │   │           │   @ StatementsNode (location: (368...376))
+        │   │   │           │   └── body: (length: 2)
+        │   │   │           │       ├── @ CallNode (location: (368...371))
+        │   │   │           │       │   ├── receiver: ∅
+        │   │   │           │       │   ├── call_operator_loc: ∅
+        │   │   │           │       │   ├── message_loc: (368...371) = "baz"
+        │   │   │           │       │   ├── opening_loc: ∅
+        │   │   │           │       │   ├── arguments: ∅
+        │   │   │           │       │   ├── closing_loc: ∅
+        │   │   │           │       │   ├── block: ∅
+        │   │   │           │       │   ├── flags: variable_call
+        │   │   │           │       │   └── name: "baz"
+        │   │   │           │       └── @ NilNode (location: (373...376))
+        │   │   │           ├── opening_loc: (367...368) = "("
+        │   │   │           └── closing_loc: (376...377) = ")"
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:bar]
+        │   ├── def_keyword_loc: (353...356) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (360...361) = "("
+        │   ├── rparen_loc: (377...378) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (379...382) = "end"
+        ├── @ DefNode (location: (384...413))
+        │   ├── name: :foo
+        │   ├── name_loc: (388...391) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (392...402))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (392...402))
+        │   │   │       ├── name: :bar
+        │   │   │       ├── name_loc: (392...395) = "bar"
+        │   │   │       ├── operator_loc: (396...397) = "="
+        │   │   │       └── value:
+        │   │   │           @ TrueNode (location: (398...402))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (406...409))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (406...409))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── locals: [:bar]
+        │   ├── def_keyword_loc: (384...387) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (391...392) = "("
+        │   ├── rparen_loc: (402...403) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (410...413) = "end"
+        ├── @ DefNode (location: (415...449))
+        │   ├── name: :foo
+        │   ├── name_loc: (419...422) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (423...438))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (423...426))
+        │   │   │       └── name: :bar
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (428...438))
+        │   │   │       ├── name: :baz
+        │   │   │       ├── name_loc: (428...431) = "baz"
+        │   │   │       ├── operator_loc: (432...433) = "="
+        │   │   │       └── value:
+        │   │   │           @ TrueNode (location: (434...438))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (442...445))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (442...445))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── locals: [:bar, :baz]
+        │   ├── def_keyword_loc: (415...418) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (422...423) = "("
+        │   ├── rparen_loc: (438...439) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (446...449) = "end"
+        ├── @ DefNode (location: (451...470))
+        │   ├── name: :foo
+        │   ├── name_loc: (455...458) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (459...465))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (459...465))
+        │   │   │       ├── name: :bar
+        │   │   │       ├── name_loc: (459...463) = "bar:"
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (464...465))
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:bar]
+        │   ├── def_keyword_loc: (451...454) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (458...459) = "("
+        │   ├── rparen_loc: (465...466) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (467...470) = "end"
+        ├── @ DefNode (location: (472...493))
+        │   ├── name: :foo
+        │   ├── name_loc: (476...479) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (480...488))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (480...488))
+        │   │   │       ├── name: :bar
+        │   │   │       ├── name_loc: (480...484) = "bar:"
+        │   │   │       └── value:
+        │   │   │           @ CallNode (location: (485...488))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (485...488) = "baz"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "baz"
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:bar]
+        │   ├── def_keyword_loc: (472...475) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (479...480) = "("
+        │   ├── rparen_loc: (488...489) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (490...493) = "end"
+        ├── @ DefNode (location: (495...518))
+        │   ├── name: :foo
+        │   ├── name_loc: (499...502) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (503...513))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (503...513))
+        │   │   │       ├── name: :bar
+        │   │   │       ├── name_loc: (503...507) = "bar:"
+        │   │   │       └── value:
+        │   │   │           @ CallNode (location: (508...513))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (508...511) = "bar"
+        │   │   │           ├── opening_loc: (511...512) = "("
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: (512...513) = ")"
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "bar"
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:bar]
+        │   ├── def_keyword_loc: (495...498) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (502...503) = "("
+        │   ├── rparen_loc: (513...514) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (515...518) = "end"
+        ├── @ DefNode (location: (520...540))
+        │   ├── name: :foo
+        │   ├── name_loc: (524...527) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (528...529))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (528...529))
+        │   │   │   ├── name: nil
+        │   │   │   ├── name_loc: ∅
+        │   │   │   └── operator_loc: (528...529) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (533...536))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (533...536))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (533...536) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── locals: [:*]
+        │   ├── def_keyword_loc: (520...523) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (527...528) = "("
+        │   ├── rparen_loc: (529...530) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (537...540) = "end"
+        ├── @ DefNode (location: (542...565))
+        │   ├── name: :foo
+        │   ├── name_loc: (546...549) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (550...554))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (550...554))
+        │   │   │   ├── name: :bar
+        │   │   │   ├── name_loc: (551...554) = "bar"
+        │   │   │   └── operator_loc: (550...551) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (558...561))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (558...561))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── locals: [:bar]
+        │   ├── def_keyword_loc: (542...545) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (549...550) = "("
+        │   ├── rparen_loc: (554...555) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (562...565) = "end"
+        ├── @ DefNode (location: (567...595))
+        │   ├── name: :foo
+        │   ├── name_loc: (571...574) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (575...584))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (575...578))
+        │   │   │       └── name: :bar
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (580...584))
+        │   │   │   ├── name: :baz
+        │   │   │   ├── name_loc: (581...584) = "baz"
+        │   │   │   └── operator_loc: (580...581) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (588...591))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (588...591))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── locals: [:bar, :baz]
+        │   ├── def_keyword_loc: (567...570) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (574...575) = "("
+        │   ├── rparen_loc: (584...585) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (592...595) = "end"
+        ├── @ DefNode (location: (597...632))
+        │   ├── name: :foo
+        │   ├── name_loc: (601...604) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (605...621))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (605...615))
+        │   │   │       ├── name: :baz
+        │   │   │       ├── name_loc: (605...608) = "baz"
+        │   │   │       ├── operator_loc: (609...610) = "="
+        │   │   │       └── value:
+        │   │   │           @ TrueNode (location: (611...615))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (617...621))
+        │   │   │   ├── name: :bor
+        │   │   │   ├── name_loc: (618...621) = "bor"
+        │   │   │   └── operator_loc: (617...618) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (625...628))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (625...628))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (625...628) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── locals: [:baz, :bor]
+        │   ├── def_keyword_loc: (597...600) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (604...605) = "("
+        │   ├── rparen_loc: (621...622) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (629...632) = "end"
+        ├── @ DefNode (location: (634...677))
+        │   ├── name: :foo
+        │   ├── name_loc: (638...641) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (642...666))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (642...652))
+        │   │   │       ├── name: :baz
+        │   │   │       ├── name_loc: (642...645) = "baz"
+        │   │   │       ├── operator_loc: (646...647) = "="
+        │   │   │       └── value:
+        │   │   │           @ TrueNode (location: (648...652))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (654...658))
+        │   │   │   ├── name: :bor
+        │   │   │   ├── name_loc: (655...658) = "bor"
+        │   │   │   └── operator_loc: (654...655) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (660...666))
+        │   │       ├── name: :block
+        │   │       ├── name_loc: (661...666) = "block"
+        │   │       └── operator_loc: (660...661) = "&"
+        │   ├── body:
+        │   │   @ StatementsNode (location: (670...673))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (670...673))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (670...673) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── locals: [:baz, :bor, :block]
+        │   ├── def_keyword_loc: (634...637) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (641...642) = "("
+        │   ├── rparen_loc: (666...667) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (674...677) = "end"
+        ├── @ DefNode (location: (679...719))
+        │   ├── name: :foo
+        │   ├── name_loc: (683...686) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (687...708))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (687...690))
+        │   │   │       └── name: :bar
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (692...702))
+        │   │   │       ├── name: :baz
+        │   │   │       ├── name_loc: (692...695) = "baz"
+        │   │   │       ├── operator_loc: (696...697) = "="
+        │   │   │       └── value:
+        │   │   │           @ TrueNode (location: (698...702))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (704...708))
+        │   │   │   ├── name: :bor
+        │   │   │   ├── name_loc: (705...708) = "bor"
+        │   │   │   └── operator_loc: (704...705) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (712...715))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (712...715))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── locals: [:bar, :baz, :bor]
+        │   ├── def_keyword_loc: (679...682) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (686...687) = "("
+        │   ├── rparen_loc: (708...709) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (716...719) = "end"
+        ├── @ DefNode (location: (721...746))
+        │   ├── name: :foo
+        │   ├── name_loc: (725...728) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (729...735))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (729...735))
+        │   │       ├── name: :block
+        │   │       ├── name_loc: (730...735) = "block"
+        │   │       └── operator_loc: (729...730) = "&"
+        │   ├── body:
+        │   │   @ StatementsNode (location: (739...742))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (739...742))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (739...742) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── locals: [:block]
+        │   ├── def_keyword_loc: (721...724) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (728...729) = "("
+        │   ├── rparen_loc: (735...736) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (743...746) = "end"
+        ├── @ DefNode (location: (748...778))
+        │   ├── name: :foo
+        │   ├── name_loc: (752...755) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (756...767))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (756...759))
+        │   │   │       └── name: :bar
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (761...767))
+        │   │       ├── name: :block
+        │   │       ├── name_loc: (762...767) = "block"
+        │   │       └── operator_loc: (761...762) = "&"
+        │   ├── body:
+        │   │   @ StatementsNode (location: (771...774))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (771...774))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── locals: [:bar, :block]
+        │   ├── def_keyword_loc: (748...751) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (755...756) = "("
+        │   ├── rparen_loc: (767...768) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (775...778) = "end"
+        ├── @ DefNode (location: (780...803))
+        │   ├── name: :foo
+        │   ├── name_loc: (784...787) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (790...799))
+        │   │   └── body: (length: 2)
+        │   │       ├── @ CallNode (location: (790...793))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (790...793) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       └── @ CallNode (location: (796...799))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (796...799) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (780...783) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (800...803) = "end"
+        ├── @ DefNode (location: (805...821))
+        │   ├── name: :f
+        │   ├── name_loc: (809...810) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (811...816))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (811...816))
+        │   │   │       ├── parameters: (length: 1)
+        │   │   │       │   └── @ RequiredDestructuredParameterNode (location: (812...815))
+        │   │   │       │       ├── parameters: (length: 1)
+        │   │   │       │       │   └── @ RequiredParameterNode (location: (813...814))
+        │   │   │       │       │       └── name: :a
+        │   │   │       │       ├── opening_loc: (812...813) = "("
+        │   │   │       │       └── closing_loc: (814...815) = ")"
+        │   │   │       ├── opening_loc: (811...812) = "("
+        │   │   │       └── closing_loc: (815...816) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (805...808) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (810...811) = "("
+        │   ├── rparen_loc: (816...817) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (818...821) = "end"
+        ├── @ DefNode (location: (823...854))
+        │   ├── name: :foo
+        │   ├── name_loc: (827...830) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (831...849))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 2)
+        │   │   │   ├── @ KeywordParameterNode (location: (831...835))
+        │   │   │   │   ├── name: :bar
+        │   │   │   │   ├── name_loc: (831...835) = "bar:"
+        │   │   │   │   └── value: ∅
+        │   │   │   └── @ KeywordParameterNode (location: (837...849))
+        │   │   │       ├── name: :baz
+        │   │   │       ├── name_loc: (837...841) = "baz:"
+        │   │   │       └── value:
+        │   │   │           @ StringNode (location: (842...849))
+        │   │   │           ├── opening_loc: (842...843) = "\""
+        │   │   │           ├── content_loc: (843...848) = "value"
+        │   │   │           ├── closing_loc: (848...849) = "\""
+        │   │   │           └── unescaped: "value"
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:bar, :baz]
+        │   ├── def_keyword_loc: (823...826) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (830...831) = "("
+        │   ├── rparen_loc: (849...850) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (851...854) = "end"
+        ├── @ DefNode (location: (856...896))
+        │   ├── name: :f
+        │   ├── name_loc: (860...861) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (864...874))
+        │   │   └── body: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (864...874))
+        │   │           ├── opening_loc: (864...874) = "<<-HEREDOC"
+        │   │           ├── parts: (length: 3)
+        │   │           │   ├── @ StringNode (location: (875...879))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (875...879) = "    "
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "    "
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (879...882))
+        │   │           │   │   ├── opening_loc: (879...881) = "\#{"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── closing_loc: (881...882) = "}"
+        │   │           │   └── @ StringNode (location: (882...883))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (882...883) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (883...893) = "  HEREDOC\n"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (856...859) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (893...896) = "end"
+        └── @ DefNode (location: (898...913))
+            ├── name: :f
+            ├── name_loc: (902...903) = "f"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (906...909))
+            │   └── body: (length: 1)
+            │       └── @ StringNode (location: (906...909))
+            │           ├── opening_loc: (906...908) = "%("
+            │           ├── content_loc: (908...908) = ""
+            │           ├── closing_loc: (908...909) = ")"
+            │           └── unescaped: ""
+            ├── locals: []
+            ├── def_keyword_loc: (898...901) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (910...913) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/defined.txt b/test/yarp/snapshots/unparser/corpus/literal/defined.txt
index 58816ee742..5e36cb9955 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/defined.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/defined.txt
@@ -1,40 +1,48 @@
-ProgramNode(0...56)(
-  [:a, :b],
-  StatementsNode(0...56)(
-    [DefinedNode(0...14)(
-       (8...9),
-       InstanceVariableReadNode(9...13)(:@foo),
-       (13...14),
-       (0...8)
-     ),
-     DefinedNode(15...28)(
-       (23...24),
-       ConstantReadNode(24...27)(:Foo),
-       (27...28),
-       (15...23)
-     ),
-     DefinedNode(29...56)(
-       (37...38),
-       ParenthesesNode(38...55)(
-         StatementsNode(39...54)(
-           [MultiWriteNode(39...54)(
-              [LocalVariableTargetNode(40...41)(:a, 0),
-               LocalVariableTargetNode(43...44)(:b, 0)],
-              (39...40),
-              (44...45),
-              (46...47),
-              ArrayNode(48...54)(
-                [IntegerNode(49...50)(), IntegerNode(52...53)()],
-                (48...49),
-                (53...54)
-              )
-            )]
-         ),
-         (38...39),
-         (54...55)
-       ),
-       (55...56),
-       (29...37)
-     )]
-  )
-)
+@ ProgramNode (location: (0...56))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...56))
+    └── body: (length: 3)
+        ├── @ DefinedNode (location: (0...14))
+        │   ├── lparen_loc: (8...9) = "("
+        │   ├── value:
+        │   │   @ InstanceVariableReadNode (location: (9...13))
+        │   │   └── name: :@foo
+        │   ├── rparen_loc: (13...14) = ")"
+        │   └── keyword_loc: (0...8) = "defined?"
+        ├── @ DefinedNode (location: (15...28))
+        │   ├── lparen_loc: (23...24) = "("
+        │   ├── value:
+        │   │   @ ConstantReadNode (location: (24...27))
+        │   │   └── name: :Foo
+        │   ├── rparen_loc: (27...28) = ")"
+        │   └── keyword_loc: (15...23) = "defined?"
+        └── @ DefinedNode (location: (29...56))
+            ├── lparen_loc: (37...38) = "("
+            ├── value:
+            │   @ ParenthesesNode (location: (38...55))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (39...54))
+            │   │   └── body: (length: 1)
+            │   │       └── @ MultiWriteNode (location: (39...54))
+            │   │           ├── targets: (length: 2)
+            │   │           │   ├── @ LocalVariableTargetNode (location: (40...41))
+            │   │           │   │   ├── name: :a
+            │   │           │   │   └── depth: 0
+            │   │           │   └── @ LocalVariableTargetNode (location: (43...44))
+            │   │           │       ├── name: :b
+            │   │           │       └── depth: 0
+            │   │           ├── lparen_loc: (39...40) = "("
+            │   │           ├── rparen_loc: (44...45) = ")"
+            │   │           ├── operator_loc: (46...47) = "="
+            │   │           └── value:
+            │   │               @ ArrayNode (location: (48...54))
+            │   │               ├── elements: (length: 2)
+            │   │               │   ├── @ IntegerNode (location: (49...50))
+            │   │               │   └── @ IntegerNode (location: (52...53))
+            │   │               ├── opening_loc: (48...49) = "["
+            │   │               └── closing_loc: (53...54) = "]"
+            │   ├── opening_loc: (38...39) = "("
+            │   └── closing_loc: (54...55) = ")"
+            ├── rparen_loc: (55...56) = ")"
+            └── keyword_loc: (29...37) = "defined?"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/defs.txt b/test/yarp/snapshots/unparser/corpus/literal/defs.txt
index fdc08dcc59..52da4a8056 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/defs.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/defs.txt
@@ -1,307 +1,356 @@
-ProgramNode(0...266)(
-  [],
-  StatementsNode(0...266)(
-    [DefNode(0...16)(
-       :foo,
-       (9...12),
-       SelfNode(4...8)(),
-       nil,
-       nil,
-       [],
-       (0...3),
-       (8...9),
-       nil,
-       nil,
-       nil,
-       (13...16)
-     ),
-     DefNode(18...40)(
-       :foo,
-       (27...30),
-       SelfNode(22...26)(),
-       nil,
-       StatementsNode(33...36)(
-         [CallNode(33...36)(nil, nil, (33...36), nil, nil, nil, nil, 2, "bar")]
-       ),
-       [],
-       (18...21),
-       (26...27),
-       nil,
-       nil,
-       nil,
-       (37...40)
-     ),
-     DefNode(42...70)(
-       :foo,
-       (51...54),
-       SelfNode(46...50)(),
-       nil,
-       StatementsNode(57...66)(
-         [CallNode(57...60)(nil, nil, (57...60), nil, nil, nil, nil, 2, "bar"),
-          CallNode(63...66)(nil, nil, (63...66), nil, nil, nil, nil, 2, "baz")]
-       ),
-       [],
-       (42...45),
-       (50...51),
-       nil,
-       nil,
-       nil,
-       (67...70)
-     ),
-     DefNode(72...93)(
-       :bar,
-       (80...83),
-       ConstantReadNode(76...79)(:Foo),
-       nil,
-       StatementsNode(86...89)(
-         [CallNode(86...89)(nil, nil, (86...89), nil, nil, nil, nil, 2, "bar")]
-       ),
-       [],
-       (72...75),
-       (79...80),
-       nil,
-       nil,
-       nil,
-       (90...93)
-     ),
-     DefNode(95...128)(
-       :bar,
-       (115...118),
-       ParenthesesNode(99...114)(
-         CallNode(100...113)(
-           nil,
-           nil,
-           (100...103),
-           nil,
-           nil,
-           nil,
-           BlockNode(104...113)(
-             [:bar],
-             BlockParametersNode(106...111)(
-               ParametersNode(107...110)(
-                 [RequiredParameterNode(107...110)(:bar)],
-                 [],
-                 [],
-                 nil,
-                 [],
-                 nil,
-                 nil
-               ),
-               [],
-               (106...107),
-               (110...111)
-             ),
-             nil,
-             (104...105),
-             (112...113)
-           ),
-           0,
-           "foo"
-         ),
-         (99...100),
-         (113...114)
-       ),
-       nil,
-       StatementsNode(121...124)(
-         [CallNode(121...124)(
-            nil,
-            nil,
-            (121...124),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       [],
-       (95...98),
-       (114...115),
-       nil,
-       nil,
-       nil,
-       (125...128)
-     ),
-     DefNode(130...156)(
-       :bar,
-       (143...146),
-       ParenthesesNode(134...142)(
-         CallNode(135...141)(
-           nil,
-           nil,
-           (135...138),
-           (138...139),
-           ArgumentsNode(139...140)([IntegerNode(139...140)()]),
-           (140...141),
-           nil,
-           0,
-           "foo"
-         ),
-         (134...135),
-         (141...142)
-       ),
-       nil,
-       StatementsNode(149...152)(
-         [CallNode(149...152)(
-            nil,
-            nil,
-            (149...152),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       [],
-       (130...133),
-       (142...143),
-       nil,
-       nil,
-       nil,
-       (153...156)
-     ),
-     DefNode(158...190)(
-       :bar,
-       (177...180),
-       ParenthesesNode(162...176)(
-         CallNode(163...175)(
-           ConstantPathNode(163...171)(
-             ConstantReadNode(163...166)(:Foo),
-             ConstantReadNode(168...171)(:Bar),
-             (166...168)
-           ),
-           (171...172),
-           (172...175),
-           nil,
-           nil,
-           nil,
-           nil,
-           0,
-           "baz"
-         ),
-         (162...163),
-         (175...176)
-       ),
-       nil,
-       StatementsNode(183...186)(
-         [CallNode(183...186)(
-            nil,
-            nil,
-            (183...186),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          )]
-       ),
-       [],
-       (158...161),
-       (176...177),
-       nil,
-       nil,
-       nil,
-       (187...190)
-     ),
-     DefNode(192...220)(
-       :bar,
-       (207...210),
-       ParenthesesNode(196...206)(
-         ConstantPathNode(197...205)(
-           ConstantReadNode(197...200)(:Foo),
-           ConstantReadNode(202...205)(:Bar),
-           (200...202)
-         ),
-         (196...197),
-         (205...206)
-       ),
-       nil,
-       StatementsNode(213...216)(
-         [CallNode(213...216)(
-            nil,
-            nil,
-            (213...216),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          )]
-       ),
-       [],
-       (192...195),
-       (206...207),
-       nil,
-       nil,
-       nil,
-       (217...220)
-     ),
-     DefNode(222...243)(
-       :bar,
-       (230...233),
-       ConstantReadNode(226...229)(:Foo),
-       nil,
-       StatementsNode(236...239)(
-         [CallNode(236...239)(
-            nil,
-            nil,
-            (236...239),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          )]
-       ),
-       [],
-       (222...225),
-       (229...230),
-       nil,
-       nil,
-       nil,
-       (240...243)
-     ),
-     DefNode(245...266)(
-       :bar,
-       (253...256),
-       CallNode(249...252)(
-         nil,
-         nil,
-         (249...252),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       StatementsNode(259...262)(
-         [CallNode(259...262)(
-            nil,
-            nil,
-            (259...262),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          )]
-       ),
-       [],
-       (245...248),
-       (252...253),
-       nil,
-       nil,
-       nil,
-       (263...266)
-     )]
-  )
-)
+@ ProgramNode (location: (0...266))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...266))
+    └── body: (length: 10)
+        ├── @ DefNode (location: (0...16))
+        │   ├── name: :foo
+        │   ├── name_loc: (9...12) = "foo"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (4...8))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: (8...9) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (13...16) = "end"
+        ├── @ DefNode (location: (18...40))
+        │   ├── name: :foo
+        │   ├── name_loc: (27...30) = "foo"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (22...26))
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (33...36))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (33...36))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (33...36) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (18...21) = "def"
+        │   ├── operator_loc: (26...27) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (37...40) = "end"
+        ├── @ DefNode (location: (42...70))
+        │   ├── name: :foo
+        │   ├── name_loc: (51...54) = "foo"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (46...50))
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (57...66))
+        │   │   └── body: (length: 2)
+        │   │       ├── @ CallNode (location: (57...60))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (57...60) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       └── @ CallNode (location: (63...66))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (63...66) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (42...45) = "def"
+        │   ├── operator_loc: (50...51) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (67...70) = "end"
+        ├── @ DefNode (location: (72...93))
+        │   ├── name: :bar
+        │   ├── name_loc: (80...83) = "bar"
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (76...79))
+        │   │   └── name: :Foo
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (86...89))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (86...89))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (86...89) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (72...75) = "def"
+        │   ├── operator_loc: (79...80) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (90...93) = "end"
+        ├── @ DefNode (location: (95...128))
+        │   ├── name: :bar
+        │   ├── name_loc: (115...118) = "bar"
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (99...114))
+        │   │   ├── body:
+        │   │   │   @ CallNode (location: (100...113))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (100...103) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block:
+        │   │   │   │   @ BlockNode (location: (104...113))
+        │   │   │   │   ├── locals: [:bar]
+        │   │   │   │   ├── parameters:
+        │   │   │   │   │   @ BlockParametersNode (location: (106...111))
+        │   │   │   │   │   ├── parameters:
+        │   │   │   │   │   │   @ ParametersNode (location: (107...110))
+        │   │   │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   │   │   └── @ RequiredParameterNode (location: (107...110))
+        │   │   │   │   │   │   │       └── name: :bar
+        │   │   │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   │   │   ├── rest: ∅
+        │   │   │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   │   │   └── block: ∅
+        │   │   │   │   │   ├── locals: (length: 0)
+        │   │   │   │   │   ├── opening_loc: (106...107) = "|"
+        │   │   │   │   │   └── closing_loc: (110...111) = "|"
+        │   │   │   │   ├── body: ∅
+        │   │   │   │   ├── opening_loc: (104...105) = "{"
+        │   │   │   │   └── closing_loc: (112...113) = "}"
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "foo"
+        │   │   ├── opening_loc: (99...100) = "("
+        │   │   └── closing_loc: (113...114) = ")"
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (121...124))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (121...124))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (121...124) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (95...98) = "def"
+        │   ├── operator_loc: (114...115) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (125...128) = "end"
+        ├── @ DefNode (location: (130...156))
+        │   ├── name: :bar
+        │   ├── name_loc: (143...146) = "bar"
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (134...142))
+        │   │   ├── body:
+        │   │   │   @ CallNode (location: (135...141))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (135...138) = "foo"
+        │   │   │   ├── opening_loc: (138...139) = "("
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (139...140))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ IntegerNode (location: (139...140))
+        │   │   │   ├── closing_loc: (140...141) = ")"
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "foo"
+        │   │   ├── opening_loc: (134...135) = "("
+        │   │   └── closing_loc: (141...142) = ")"
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (149...152))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (149...152))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (149...152) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (130...133) = "def"
+        │   ├── operator_loc: (142...143) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (153...156) = "end"
+        ├── @ DefNode (location: (158...190))
+        │   ├── name: :bar
+        │   ├── name_loc: (177...180) = "bar"
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (162...176))
+        │   │   ├── body:
+        │   │   │   @ CallNode (location: (163...175))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ ConstantPathNode (location: (163...171))
+        │   │   │   │   ├── parent:
+        │   │   │   │   │   @ ConstantReadNode (location: (163...166))
+        │   │   │   │   │   └── name: :Foo
+        │   │   │   │   ├── child:
+        │   │   │   │   │   @ ConstantReadNode (location: (168...171))
+        │   │   │   │   │   └── name: :Bar
+        │   │   │   │   └── delimiter_loc: (166...168) = "::"
+        │   │   │   ├── call_operator_loc: (171...172) = "."
+        │   │   │   ├── message_loc: (172...175) = "baz"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "baz"
+        │   │   ├── opening_loc: (162...163) = "("
+        │   │   └── closing_loc: (175...176) = ")"
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (183...186))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (183...186))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (183...186) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (158...161) = "def"
+        │   ├── operator_loc: (176...177) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (187...190) = "end"
+        ├── @ DefNode (location: (192...220))
+        │   ├── name: :bar
+        │   ├── name_loc: (207...210) = "bar"
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (196...206))
+        │   │   ├── body:
+        │   │   │   @ ConstantPathNode (location: (197...205))
+        │   │   │   ├── parent:
+        │   │   │   │   @ ConstantReadNode (location: (197...200))
+        │   │   │   │   └── name: :Foo
+        │   │   │   ├── child:
+        │   │   │   │   @ ConstantReadNode (location: (202...205))
+        │   │   │   │   └── name: :Bar
+        │   │   │   └── delimiter_loc: (200...202) = "::"
+        │   │   ├── opening_loc: (196...197) = "("
+        │   │   └── closing_loc: (205...206) = ")"
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (213...216))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (213...216))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (213...216) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (192...195) = "def"
+        │   ├── operator_loc: (206...207) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (217...220) = "end"
+        ├── @ DefNode (location: (222...243))
+        │   ├── name: :bar
+        │   ├── name_loc: (230...233) = "bar"
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (226...229))
+        │   │   └── name: :Foo
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (236...239))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (236...239))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (236...239) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (222...225) = "def"
+        │   ├── operator_loc: (229...230) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (240...243) = "end"
+        └── @ DefNode (location: (245...266))
+            ├── name: :bar
+            ├── name_loc: (253...256) = "bar"
+            ├── receiver:
+            │   @ CallNode (location: (249...252))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (249...252) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (259...262))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (259...262))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (259...262) = "baz"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "baz"
+            ├── locals: []
+            ├── def_keyword_loc: (245...248) = "def"
+            ├── operator_loc: (252...253) = "."
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (263...266) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/dstr.txt b/test/yarp/snapshots/unparser/corpus/literal/dstr.txt
index 369e1491e5..695ad4786c 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/dstr.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/dstr.txt
@@ -1,205 +1,314 @@
-ProgramNode(0...299)(
-  [],
-  StatementsNode(0...299)(
-    [IfNode(0...20)(
-       (0...2),
-       TrueNode(3...7)(),
-       StatementsNode(10...16)(
-         [InterpolatedStringNode(10...16)(
-            (10...11),
-            [EmbeddedStatementsNode(11...14)((11...13), nil, (13...14)),
-             StringNode(14...15)(nil, (14...15), nil, "a")],
-            (15...16)
-          )]
-       ),
-       nil,
-       (17...20)
-     ),
-     IfNode(21...68)(
-       (21...23),
-       TrueNode(24...28)(),
-       StatementsNode(31...64)(
-         [InterpolatedStringNode(31...41)(
-            (31...41),
-            [StringNode(42...44)(nil, (42...44), nil, "a\n"),
-             EmbeddedStatementsNode(44...47)((44...46), nil, (46...47)),
-             StringNode(47...51)(nil, (47...51), nil, "a\n" + "b\n")],
-            (51...61)
-          ),
-          CallNode(63...64)(nil, nil, (63...64), nil, nil, nil, nil, 2, "x")]
-       ),
-       nil,
-       (65...68)
-     ),
-     InterpolatedStringNode(69...79)(
-       (69...79),
-       [StringNode(80...89)(nil, (80...89), nil, "\#{}\#{}\n"),
-        EmbeddedStatementsNode(89...92)((89...91), nil, (91...92)),
-        StringNode(92...93)(nil, (92...93), nil, "\n"),
-        EmbeddedStatementsNode(93...96)((93...95), nil, (95...96)),
-        StringNode(96...97)(nil, (96...97), nil, "\n"),
-        EmbeddedStatementsNode(97...100)((97...99), nil, (99...100)),
-        StringNode(100...101)(nil, (100...101), nil, "\n")],
-       (101...109)
-     ),
-     RescueModifierNode(109...130)(
-       InterpolatedStringNode(109...119)(
-         (109...119),
-         [EmbeddedStatementsNode(131...134)((131...133), nil, (133...134)),
-          StringNode(134...137)(nil, (134...137), nil, "\n" + "a\n")],
-         (137...145)
-       ),
-       (120...126),
-       NilNode(127...130)()
-     ),
-     InterpolatedStringNode(145...151)(
-       (145...146),
-       [StringNode(146...147)(nil, (146...147), nil, "a"),
-        EmbeddedVariableNode(147...150)(
-          (147...148),
-          NumberedReferenceReadNode(148...150)(1)
-        )],
-       (150...151)
-     ),
-     InterpolatedStringNode(152...158)(
-       (152...153),
-       [StringNode(153...154)(nil, (153...154), nil, "a"),
-        EmbeddedVariableNode(154...157)(
-          (154...155),
-          GlobalVariableReadNode(155...157)(:$a)
-        )],
-       (157...158)
-     ),
-     InterpolatedStringNode(159...165)(
-       (159...160),
-       [StringNode(160...161)(nil, (160...161), nil, "a"),
-        EmbeddedVariableNode(161...164)(
-          (161...162),
-          InstanceVariableReadNode(162...164)(:@a)
-        )],
-       (164...165)
-     ),
-     InterpolatedStringNode(166...173)(
-       (166...167),
-       [StringNode(167...168)(nil, (167...168), nil, "a"),
-        EmbeddedVariableNode(168...172)(
-          (168...169),
-          ClassVariableReadNode(169...172)(:@@a)
-        )],
-       (172...173)
-     ),
-     IfNode(174...225)(
-       (174...176),
-       TrueNode(177...181)(),
-       StatementsNode(184...201)(
-         [ReturnNode(184...201)(
-            (184...190),
-            ArgumentsNode(191...201)(
-              [InterpolatedStringNode(191...201)(
-                 (191...201),
-                 [StringNode(202...206)(nil, (202...206), nil, "    "),
-                  EmbeddedStatementsNode(206...211)(
-                    (206...208),
-                    StatementsNode(208...210)([IntegerNode(208...210)()]),
-                    (210...211)
-                  ),
-                  StringNode(211...212)(nil, (211...212), nil, "\n")],
-                 (212...222)
-               )]
-            )
-          )]
-       ),
-       nil,
-       (222...225)
-     ),
-     CallNode(226...241)(
-       nil,
-       nil,
-       (226...229),
-       (229...230),
-       ArgumentsNode(230...240)(
-         [InterpolatedStringNode(230...240)(
-            (230...240),
-            [StringNode(242...244)(nil, (242...244), nil, "  "),
-             EmbeddedStatementsNode(244...250)(
-               (244...246),
-               StatementsNode(246...249)(
-                 [CallNode(246...249)(
-                    nil,
-                    nil,
-                    (246...249),
-                    nil,
-                    nil,
-                    nil,
-                    nil,
-                    2,
-                    "bar"
-                  )]
-               ),
-               (249...250)
-             ),
-             StringNode(250...251)(nil, (250...251), nil, "\n")],
-            (251...259)
-          )]
-       ),
-       (240...241),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(259...299)(
-       nil,
-       nil,
-       (259...262),
-       (262...263),
-       ArgumentsNode(263...273)(
-         [InterpolatedStringNode(263...273)(
-            (263...273),
-            [StringNode(281...283)(nil, (281...283), nil, "  "),
-             EmbeddedStatementsNode(283...289)(
-               (283...285),
-               StatementsNode(285...288)(
-                 [CallNode(285...288)(
-                    nil,
-                    nil,
-                    (285...288),
-                    nil,
-                    nil,
-                    nil,
-                    nil,
-                    2,
-                    "bar"
-                  )]
-               ),
-               (288...289)
-             ),
-             StringNode(289...290)(nil, (289...290), nil, "\n")],
-            (290...298)
-          )]
-       ),
-       (273...274),
-       BlockNode(275...299)(
-         [:x],
-         BlockParametersNode(277...280)(
-           ParametersNode(278...279)(
-             [RequiredParameterNode(278...279)(:x)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (277...278),
-           (279...280)
-         ),
-         nil,
-         (275...276),
-         (298...299)
-       ),
-       0,
-       "foo"
-     )]
-  )
-)
+@ ProgramNode (location: (0...299))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...299))
+    └── body: (length: 11)
+        ├── @ IfNode (location: (0...20))
+        │   ├── if_keyword_loc: (0...2) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (3...7))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (10...16))
+        │   │   └── body: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (10...16))
+        │   │           ├── opening_loc: (10...11) = "\""
+        │   │           ├── parts: (length: 2)
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (11...14))
+        │   │           │   │   ├── opening_loc: (11...13) = "\#{"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── closing_loc: (13...14) = "}"
+        │   │           │   └── @ StringNode (location: (14...15))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (14...15) = "a"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "a"
+        │   │           └── closing_loc: (15...16) = "\""
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (17...20) = "end"
+        ├── @ IfNode (location: (21...68))
+        │   ├── if_keyword_loc: (21...23) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (24...28))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (31...64))
+        │   │   └── body: (length: 2)
+        │   │       ├── @ InterpolatedStringNode (location: (31...41))
+        │   │       │   ├── opening_loc: (31...41) = "<<-HEREDOC"
+        │   │       │   ├── parts: (length: 3)
+        │   │       │   │   ├── @ StringNode (location: (42...44))
+        │   │       │   │   │   ├── opening_loc: ∅
+        │   │       │   │   │   ├── content_loc: (42...44) = "a\n"
+        │   │       │   │   │   ├── closing_loc: ∅
+        │   │       │   │   │   └── unescaped: "a\n"
+        │   │       │   │   ├── @ EmbeddedStatementsNode (location: (44...47))
+        │   │       │   │   │   ├── opening_loc: (44...46) = "\#{"
+        │   │       │   │   │   ├── statements: ∅
+        │   │       │   │   │   └── closing_loc: (46...47) = "}"
+        │   │       │   │   └── @ StringNode (location: (47...51))
+        │   │       │   │       ├── opening_loc: ∅
+        │   │       │   │       ├── content_loc: (47...51) = "a\nb\n"
+        │   │       │   │       ├── closing_loc: ∅
+        │   │       │   │       └── unescaped: "a\nb\n"
+        │   │       │   └── closing_loc: (51...61) = "  HEREDOC\n"
+        │   │       └── @ CallNode (location: (63...64))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (63...64) = "x"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "x"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (65...68) = "end"
+        ├── @ InterpolatedStringNode (location: (69...79))
+        │   ├── opening_loc: (69...79) = "<<-HEREDOC"
+        │   ├── parts: (length: 7)
+        │   │   ├── @ StringNode (location: (80...89))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (80...89) = "\\\#{}\\\#{}\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "\#{}\#{}\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (89...92))
+        │   │   │   ├── opening_loc: (89...91) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (91...92) = "}"
+        │   │   ├── @ StringNode (location: (92...93))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (92...93) = "\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (93...96))
+        │   │   │   ├── opening_loc: (93...95) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (95...96) = "}"
+        │   │   ├── @ StringNode (location: (96...97))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (96...97) = "\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (97...100))
+        │   │   │   ├── opening_loc: (97...99) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (99...100) = "}"
+        │   │   └── @ StringNode (location: (100...101))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (100...101) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (101...109) = "HEREDOC\n"
+        ├── @ RescueModifierNode (location: (109...130))
+        │   ├── expression:
+        │   │   @ InterpolatedStringNode (location: (109...119))
+        │   │   ├── opening_loc: (109...119) = "<<-HEREDOC"
+        │   │   ├── parts: (length: 2)
+        │   │   │   ├── @ EmbeddedStatementsNode (location: (131...134))
+        │   │   │   │   ├── opening_loc: (131...133) = "\#{"
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── closing_loc: (133...134) = "}"
+        │   │   │   └── @ StringNode (location: (134...137))
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── content_loc: (134...137) = "\na\n"
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       └── unescaped: "\na\n"
+        │   │   └── closing_loc: (137...145) = "HEREDOC\n"
+        │   ├── keyword_loc: (120...126) = "rescue"
+        │   └── rescue_expression:
+        │       @ NilNode (location: (127...130))
+        ├── @ InterpolatedStringNode (location: (145...151))
+        │   ├── opening_loc: (145...146) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (146...147))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (146...147) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ EmbeddedVariableNode (location: (147...150))
+        │   │       ├── operator_loc: (147...148) = "#"
+        │   │       └── variable:
+        │   │           @ NumberedReferenceReadNode (location: (148...150))
+        │   │           └── number: 1
+        │   └── closing_loc: (150...151) = "\""
+        ├── @ InterpolatedStringNode (location: (152...158))
+        │   ├── opening_loc: (152...153) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (153...154))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (153...154) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ EmbeddedVariableNode (location: (154...157))
+        │   │       ├── operator_loc: (154...155) = "#"
+        │   │       └── variable:
+        │   │           @ GlobalVariableReadNode (location: (155...157))
+        │   │           └── name: :$a
+        │   └── closing_loc: (157...158) = "\""
+        ├── @ InterpolatedStringNode (location: (159...165))
+        │   ├── opening_loc: (159...160) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (160...161))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (160...161) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ EmbeddedVariableNode (location: (161...164))
+        │   │       ├── operator_loc: (161...162) = "#"
+        │   │       └── variable:
+        │   │           @ InstanceVariableReadNode (location: (162...164))
+        │   │           └── name: :@a
+        │   └── closing_loc: (164...165) = "\""
+        ├── @ InterpolatedStringNode (location: (166...173))
+        │   ├── opening_loc: (166...167) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (167...168))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (167...168) = "a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a"
+        │   │   └── @ EmbeddedVariableNode (location: (168...172))
+        │   │       ├── operator_loc: (168...169) = "#"
+        │   │       └── variable:
+        │   │           @ ClassVariableReadNode (location: (169...172))
+        │   │           └── name: :@@a
+        │   └── closing_loc: (172...173) = "\""
+        ├── @ IfNode (location: (174...225))
+        │   ├── if_keyword_loc: (174...176) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (177...181))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (184...201))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ReturnNode (location: (184...201))
+        │   │           ├── keyword_loc: (184...190) = "return"
+        │   │           └── arguments:
+        │   │               @ ArgumentsNode (location: (191...201))
+        │   │               └── arguments: (length: 1)
+        │   │                   └── @ InterpolatedStringNode (location: (191...201))
+        │   │                       ├── opening_loc: (191...201) = "<<-HEREDOC"
+        │   │                       ├── parts: (length: 3)
+        │   │                       │   ├── @ StringNode (location: (202...206))
+        │   │                       │   │   ├── opening_loc: ∅
+        │   │                       │   │   ├── content_loc: (202...206) = "    "
+        │   │                       │   │   ├── closing_loc: ∅
+        │   │                       │   │   └── unescaped: "    "
+        │   │                       │   ├── @ EmbeddedStatementsNode (location: (206...211))
+        │   │                       │   │   ├── opening_loc: (206...208) = "\#{"
+        │   │                       │   │   ├── statements:
+        │   │                       │   │   │   @ StatementsNode (location: (208...210))
+        │   │                       │   │   │   └── body: (length: 1)
+        │   │                       │   │   │       └── @ IntegerNode (location: (208...210))
+        │   │                       │   │   └── closing_loc: (210...211) = "}"
+        │   │                       │   └── @ StringNode (location: (211...212))
+        │   │                       │       ├── opening_loc: ∅
+        │   │                       │       ├── content_loc: (211...212) = "\n"
+        │   │                       │       ├── closing_loc: ∅
+        │   │                       │       └── unescaped: "\n"
+        │   │                       └── closing_loc: (212...222) = "  HEREDOC\n"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (222...225) = "end"
+        ├── @ CallNode (location: (226...241))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (226...229) = "foo"
+        │   ├── opening_loc: (229...230) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (230...240))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (230...240))
+        │   │           ├── opening_loc: (230...240) = "<<-HEREDOC"
+        │   │           ├── parts: (length: 3)
+        │   │           │   ├── @ StringNode (location: (242...244))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (242...244) = "  "
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "  "
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (244...250))
+        │   │           │   │   ├── opening_loc: (244...246) = "\#{"
+        │   │           │   │   ├── statements:
+        │   │           │   │   │   @ StatementsNode (location: (246...249))
+        │   │           │   │   │   └── body: (length: 1)
+        │   │           │   │   │       └── @ CallNode (location: (246...249))
+        │   │           │   │   │           ├── receiver: ∅
+        │   │           │   │   │           ├── call_operator_loc: ∅
+        │   │           │   │   │           ├── message_loc: (246...249) = "bar"
+        │   │           │   │   │           ├── opening_loc: ∅
+        │   │           │   │   │           ├── arguments: ∅
+        │   │           │   │   │           ├── closing_loc: ∅
+        │   │           │   │   │           ├── block: ∅
+        │   │           │   │   │           ├── flags: variable_call
+        │   │           │   │   │           └── name: "bar"
+        │   │           │   │   └── closing_loc: (249...250) = "}"
+        │   │           │   └── @ StringNode (location: (250...251))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (250...251) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (251...259) = "HEREDOC\n"
+        │   ├── closing_loc: (240...241) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        └── @ CallNode (location: (259...299))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (259...262) = "foo"
+            ├── opening_loc: (262...263) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (263...273))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedStringNode (location: (263...273))
+            │           ├── opening_loc: (263...273) = "<<-HEREDOC"
+            │           ├── parts: (length: 3)
+            │           │   ├── @ StringNode (location: (281...283))
+            │           │   │   ├── opening_loc: ∅
+            │           │   │   ├── content_loc: (281...283) = "  "
+            │           │   │   ├── closing_loc: ∅
+            │           │   │   └── unescaped: "  "
+            │           │   ├── @ EmbeddedStatementsNode (location: (283...289))
+            │           │   │   ├── opening_loc: (283...285) = "\#{"
+            │           │   │   ├── statements:
+            │           │   │   │   @ StatementsNode (location: (285...288))
+            │           │   │   │   └── body: (length: 1)
+            │           │   │   │       └── @ CallNode (location: (285...288))
+            │           │   │   │           ├── receiver: ∅
+            │           │   │   │           ├── call_operator_loc: ∅
+            │           │   │   │           ├── message_loc: (285...288) = "bar"
+            │           │   │   │           ├── opening_loc: ∅
+            │           │   │   │           ├── arguments: ∅
+            │           │   │   │           ├── closing_loc: ∅
+            │           │   │   │           ├── block: ∅
+            │           │   │   │           ├── flags: variable_call
+            │           │   │   │           └── name: "bar"
+            │           │   │   └── closing_loc: (288...289) = "}"
+            │           │   └── @ StringNode (location: (289...290))
+            │           │       ├── opening_loc: ∅
+            │           │       ├── content_loc: (289...290) = "\n"
+            │           │       ├── closing_loc: ∅
+            │           │       └── unescaped: "\n"
+            │           └── closing_loc: (290...298) = "HEREDOC\n"
+            ├── closing_loc: (273...274) = ")"
+            ├── block:
+            │   @ BlockNode (location: (275...299))
+            │   ├── locals: [:x]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (277...280))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (278...279))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (278...279))
+            │   │   │   │       └── name: :x
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (277...278) = "|"
+            │   │   └── closing_loc: (279...280) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (275...276) = "{"
+            │   └── closing_loc: (298...299) = "}"
+            ├── flags: 
+            └── name: "foo"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/empty.txt b/test/yarp/snapshots/unparser/corpus/literal/empty.txt
index bd3eaf5ff4..81b8a103ea 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/empty.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/empty.txt
@@ -1 +1,5 @@
-ProgramNode(0...0)([], StatementsNode(0...0)([]))
+@ ProgramNode (location: (0...0))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...0))
+    └── body: (length: 0)
diff --git a/test/yarp/snapshots/unparser/corpus/literal/empty_begin.txt b/test/yarp/snapshots/unparser/corpus/literal/empty_begin.txt
index d998f704cf..a47209cf78 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/empty_begin.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/empty_begin.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...2)(
-  [],
-  StatementsNode(0...2)([ParenthesesNode(0...2)(nil, (0...1), (1...2))])
-)
+@ ProgramNode (location: (0...2))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...2))
+    └── body: (length: 1)
+        └── @ ParenthesesNode (location: (0...2))
+            ├── body: ∅
+            ├── opening_loc: (0...1) = "("
+            └── closing_loc: (1...2) = ")"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/flipflop.txt b/test/yarp/snapshots/unparser/corpus/literal/flipflop.txt
index b08835a4c3..4d702a7fcc 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/flipflop.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/flipflop.txt
@@ -1,149 +1,179 @@
-ProgramNode(0...68)(
-  [],
-  StatementsNode(0...68)(
-    [IfNode(0...33)(
-       (0...2),
-       ParenthesesNode(3...23)(
-         StatementsNode(4...22)(
-           [FlipFlopNode(4...22)(
-              ParenthesesNode(4...12)(
-                StatementsNode(5...11)(
-                  [CallNode(5...11)(
-                     CallNode(5...6)(
-                       nil,
-                       nil,
-                       (5...6),
-                       nil,
-                       nil,
-                       nil,
-                       nil,
-                       2,
-                       "i"
-                     ),
-                     nil,
-                     (7...9),
-                     nil,
-                     ArgumentsNode(10...11)([IntegerNode(10...11)()]),
-                     nil,
-                     nil,
-                     0,
-                     "=="
-                   )]
-                ),
-                (4...5),
-                (11...12)
-              ),
-              ParenthesesNode(14...22)(
-                StatementsNode(15...21)(
-                  [CallNode(15...21)(
-                     CallNode(15...16)(
-                       nil,
-                       nil,
-                       (15...16),
-                       nil,
-                       nil,
-                       nil,
-                       nil,
-                       2,
-                       "i"
-                     ),
-                     nil,
-                     (17...19),
-                     nil,
-                     ArgumentsNode(20...21)([IntegerNode(20...21)()]),
-                     nil,
-                     nil,
-                     0,
-                     "=="
-                   )]
-                ),
-                (14...15),
-                (21...22)
-              ),
-              (12...14),
-              0
-            )]
-         ),
-         (3...4),
-         (22...23)
-       ),
-       StatementsNode(26...29)(
-         [CallNode(26...29)(nil, nil, (26...29), nil, nil, nil, nil, 2, "foo")]
-       ),
-       nil,
-       (30...33)
-     ),
-     IfNode(34...68)(
-       (34...36),
-       ParenthesesNode(37...58)(
-         StatementsNode(38...57)(
-           [FlipFlopNode(38...57)(
-              ParenthesesNode(38...46)(
-                StatementsNode(39...45)(
-                  [CallNode(39...45)(
-                     CallNode(39...40)(
-                       nil,
-                       nil,
-                       (39...40),
-                       nil,
-                       nil,
-                       nil,
-                       nil,
-                       2,
-                       "i"
-                     ),
-                     nil,
-                     (41...43),
-                     nil,
-                     ArgumentsNode(44...45)([IntegerNode(44...45)()]),
-                     nil,
-                     nil,
-                     0,
-                     "=="
-                   )]
-                ),
-                (38...39),
-                (45...46)
-              ),
-              ParenthesesNode(49...57)(
-                StatementsNode(50...56)(
-                  [CallNode(50...56)(
-                     CallNode(50...51)(
-                       nil,
-                       nil,
-                       (50...51),
-                       nil,
-                       nil,
-                       nil,
-                       nil,
-                       2,
-                       "i"
-                     ),
-                     nil,
-                     (52...54),
-                     nil,
-                     ArgumentsNode(55...56)([IntegerNode(55...56)()]),
-                     nil,
-                     nil,
-                     0,
-                     "=="
-                   )]
-                ),
-                (49...50),
-                (56...57)
-              ),
-              (46...49),
-              1
-            )]
-         ),
-         (37...38),
-         (57...58)
-       ),
-       StatementsNode(61...64)(
-         [CallNode(61...64)(nil, nil, (61...64), nil, nil, nil, nil, 2, "foo")]
-       ),
-       nil,
-       (65...68)
-     )]
-  )
-)
+@ ProgramNode (location: (0...68))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...68))
+    └── body: (length: 2)
+        ├── @ IfNode (location: (0...33))
+        │   ├── if_keyword_loc: (0...2) = "if"
+        │   ├── predicate:
+        │   │   @ ParenthesesNode (location: (3...23))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (4...22))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ FlipFlopNode (location: (4...22))
+        │   │   │           ├── left:
+        │   │   │           │   @ ParenthesesNode (location: (4...12))
+        │   │   │           │   ├── body:
+        │   │   │           │   │   @ StatementsNode (location: (5...11))
+        │   │   │           │   │   └── body: (length: 1)
+        │   │   │           │   │       └── @ CallNode (location: (5...11))
+        │   │   │           │   │           ├── receiver:
+        │   │   │           │   │           │   @ CallNode (location: (5...6))
+        │   │   │           │   │           │   ├── receiver: ∅
+        │   │   │           │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   │           │   ├── message_loc: (5...6) = "i"
+        │   │   │           │   │           │   ├── opening_loc: ∅
+        │   │   │           │   │           │   ├── arguments: ∅
+        │   │   │           │   │           │   ├── closing_loc: ∅
+        │   │   │           │   │           │   ├── block: ∅
+        │   │   │           │   │           │   ├── flags: variable_call
+        │   │   │           │   │           │   └── name: "i"
+        │   │   │           │   │           ├── call_operator_loc: ∅
+        │   │   │           │   │           ├── message_loc: (7...9) = "=="
+        │   │   │           │   │           ├── opening_loc: ∅
+        │   │   │           │   │           ├── arguments:
+        │   │   │           │   │           │   @ ArgumentsNode (location: (10...11))
+        │   │   │           │   │           │   └── arguments: (length: 1)
+        │   │   │           │   │           │       └── @ IntegerNode (location: (10...11))
+        │   │   │           │   │           ├── closing_loc: ∅
+        │   │   │           │   │           ├── block: ∅
+        │   │   │           │   │           ├── flags: 
+        │   │   │           │   │           └── name: "=="
+        │   │   │           │   ├── opening_loc: (4...5) = "("
+        │   │   │           │   └── closing_loc: (11...12) = ")"
+        │   │   │           ├── right:
+        │   │   │           │   @ ParenthesesNode (location: (14...22))
+        │   │   │           │   ├── body:
+        │   │   │           │   │   @ StatementsNode (location: (15...21))
+        │   │   │           │   │   └── body: (length: 1)
+        │   │   │           │   │       └── @ CallNode (location: (15...21))
+        │   │   │           │   │           ├── receiver:
+        │   │   │           │   │           │   @ CallNode (location: (15...16))
+        │   │   │           │   │           │   ├── receiver: ∅
+        │   │   │           │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   │           │   ├── message_loc: (15...16) = "i"
+        │   │   │           │   │           │   ├── opening_loc: ∅
+        │   │   │           │   │           │   ├── arguments: ∅
+        │   │   │           │   │           │   ├── closing_loc: ∅
+        │   │   │           │   │           │   ├── block: ∅
+        │   │   │           │   │           │   ├── flags: variable_call
+        │   │   │           │   │           │   └── name: "i"
+        │   │   │           │   │           ├── call_operator_loc: ∅
+        │   │   │           │   │           ├── message_loc: (17...19) = "=="
+        │   │   │           │   │           ├── opening_loc: ∅
+        │   │   │           │   │           ├── arguments:
+        │   │   │           │   │           │   @ ArgumentsNode (location: (20...21))
+        │   │   │           │   │           │   └── arguments: (length: 1)
+        │   │   │           │   │           │       └── @ IntegerNode (location: (20...21))
+        │   │   │           │   │           ├── closing_loc: ∅
+        │   │   │           │   │           ├── block: ∅
+        │   │   │           │   │           ├── flags: 
+        │   │   │           │   │           └── name: "=="
+        │   │   │           │   ├── opening_loc: (14...15) = "("
+        │   │   │           │   └── closing_loc: (21...22) = ")"
+        │   │   │           ├── operator_loc: (12...14) = ".."
+        │   │   │           └── flags: 
+        │   │   ├── opening_loc: (3...4) = "("
+        │   │   └── closing_loc: (22...23) = ")"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (26...29))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (26...29))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (26...29) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "foo"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (30...33) = "end"
+        └── @ IfNode (location: (34...68))
+            ├── if_keyword_loc: (34...36) = "if"
+            ├── predicate:
+            │   @ ParenthesesNode (location: (37...58))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (38...57))
+            │   │   └── body: (length: 1)
+            │   │       └── @ FlipFlopNode (location: (38...57))
+            │   │           ├── left:
+            │   │           │   @ ParenthesesNode (location: (38...46))
+            │   │           │   ├── body:
+            │   │           │   │   @ StatementsNode (location: (39...45))
+            │   │           │   │   └── body: (length: 1)
+            │   │           │   │       └── @ CallNode (location: (39...45))
+            │   │           │   │           ├── receiver:
+            │   │           │   │           │   @ CallNode (location: (39...40))
+            │   │           │   │           │   ├── receiver: ∅
+            │   │           │   │           │   ├── call_operator_loc: ∅
+            │   │           │   │           │   ├── message_loc: (39...40) = "i"
+            │   │           │   │           │   ├── opening_loc: ∅
+            │   │           │   │           │   ├── arguments: ∅
+            │   │           │   │           │   ├── closing_loc: ∅
+            │   │           │   │           │   ├── block: ∅
+            │   │           │   │           │   ├── flags: variable_call
+            │   │           │   │           │   └── name: "i"
+            │   │           │   │           ├── call_operator_loc: ∅
+            │   │           │   │           ├── message_loc: (41...43) = "=="
+            │   │           │   │           ├── opening_loc: ∅
+            │   │           │   │           ├── arguments:
+            │   │           │   │           │   @ ArgumentsNode (location: (44...45))
+            │   │           │   │           │   └── arguments: (length: 1)
+            │   │           │   │           │       └── @ IntegerNode (location: (44...45))
+            │   │           │   │           ├── closing_loc: ∅
+            │   │           │   │           ├── block: ∅
+            │   │           │   │           ├── flags: 
+            │   │           │   │           └── name: "=="
+            │   │           │   ├── opening_loc: (38...39) = "("
+            │   │           │   └── closing_loc: (45...46) = ")"
+            │   │           ├── right:
+            │   │           │   @ ParenthesesNode (location: (49...57))
+            │   │           │   ├── body:
+            │   │           │   │   @ StatementsNode (location: (50...56))
+            │   │           │   │   └── body: (length: 1)
+            │   │           │   │       └── @ CallNode (location: (50...56))
+            │   │           │   │           ├── receiver:
+            │   │           │   │           │   @ CallNode (location: (50...51))
+            │   │           │   │           │   ├── receiver: ∅
+            │   │           │   │           │   ├── call_operator_loc: ∅
+            │   │           │   │           │   ├── message_loc: (50...51) = "i"
+            │   │           │   │           │   ├── opening_loc: ∅
+            │   │           │   │           │   ├── arguments: ∅
+            │   │           │   │           │   ├── closing_loc: ∅
+            │   │           │   │           │   ├── block: ∅
+            │   │           │   │           │   ├── flags: variable_call
+            │   │           │   │           │   └── name: "i"
+            │   │           │   │           ├── call_operator_loc: ∅
+            │   │           │   │           ├── message_loc: (52...54) = "=="
+            │   │           │   │           ├── opening_loc: ∅
+            │   │           │   │           ├── arguments:
+            │   │           │   │           │   @ ArgumentsNode (location: (55...56))
+            │   │           │   │           │   └── arguments: (length: 1)
+            │   │           │   │           │       └── @ IntegerNode (location: (55...56))
+            │   │           │   │           ├── closing_loc: ∅
+            │   │           │   │           ├── block: ∅
+            │   │           │   │           ├── flags: 
+            │   │           │   │           └── name: "=="
+            │   │           │   ├── opening_loc: (49...50) = "("
+            │   │           │   └── closing_loc: (56...57) = ")"
+            │   │           ├── operator_loc: (46...49) = "..."
+            │   │           └── flags: exclude_end
+            │   ├── opening_loc: (37...38) = "("
+            │   └── closing_loc: (57...58) = ")"
+            ├── statements:
+            │   @ StatementsNode (location: (61...64))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (61...64))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (61...64) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "foo"
+            ├── consequent: ∅
+            └── end_keyword_loc: (65...68) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/for.txt b/test/yarp/snapshots/unparser/corpus/literal/for.txt
index 7ede529a81..aff0c7cd93 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/for.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/for.txt
@@ -1,122 +1,174 @@
-ProgramNode(0...119)(
-  [:a, :b],
-  StatementsNode(0...119)(
-    [CallNode(0...30)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...29)(
-         [ForNode(4...29)(
-            MultiTargetNode(8...9)(
-              [LocalVariableTargetNode(8...9)(:a, 0)],
-              nil,
-              nil
-            ),
-            CallNode(13...16)(
-              nil,
-              nil,
-              (13...16),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            ),
-            StatementsNode(22...25)(
-              [CallNode(22...25)(
-                 nil,
-                 nil,
-                 (22...25),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "baz"
-               )]
-            ),
-            (4...7),
-            (10...12),
-            (17...19),
-            (26...29)
-          )]
-       ),
-       (29...30),
-       nil,
-       0,
-       "bar"
-     ),
-     ForNode(31...56)(
-       MultiTargetNode(35...36)(
-         [LocalVariableTargetNode(35...36)(:a, 0)],
-         nil,
-         nil
-       ),
-       CallNode(40...43)(nil, nil, (40...43), nil, nil, nil, nil, 2, "bar"),
-       StatementsNode(49...52)(
-         [CallNode(49...52)(nil, nil, (49...52), nil, nil, nil, nil, 2, "baz")]
-       ),
-       (31...34),
-       (37...39),
-       (44...46),
-       (53...56)
-     ),
-     ForNode(57...88)(
-       MultiTargetNode(61...68)(
-         [LocalVariableTargetNode(62...63)(:a, 0),
-          SplatNode(65...67)(
-            (65...66),
-            LocalVariableTargetNode(66...67)(:b, 0)
-          )],
-         (61...62),
-         (67...68)
-       ),
-       CallNode(72...75)(nil, nil, (72...75), nil, nil, nil, nil, 2, "bar"),
-       StatementsNode(81...84)(
-         [CallNode(81...84)(nil, nil, (81...84), nil, nil, nil, nil, 2, "baz")]
-       ),
-       (57...60),
-       (69...71),
-       (76...78),
-       (85...88)
-     ),
-     ForNode(89...119)(
-       MultiTargetNode(93...99)(
-         [LocalVariableTargetNode(94...95)(:a, 0),
-          LocalVariableTargetNode(97...98)(:b, 0)],
-         (93...94),
-         (98...99)
-       ),
-       CallNode(103...106)(
-         nil,
-         nil,
-         (103...106),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "bar"
-       ),
-       StatementsNode(112...115)(
-         [CallNode(112...115)(
-            nil,
-            nil,
-            (112...115),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          )]
-       ),
-       (89...92),
-       (100...102),
-       (107...109),
-       (116...119)
-     )]
-  )
-)
+@ ProgramNode (location: (0...119))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...119))
+    └── body: (length: 4)
+        ├── @ CallNode (location: (0...30))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "bar"
+        │   ├── opening_loc: (3...4) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...29))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ForNode (location: (4...29))
+        │   │           ├── index:
+        │   │           │   @ MultiTargetNode (location: (8...9))
+        │   │           │   ├── targets: (length: 1)
+        │   │           │   │   └── @ LocalVariableTargetNode (location: (8...9))
+        │   │           │   │       ├── name: :a
+        │   │           │   │       └── depth: 0
+        │   │           │   ├── lparen_loc: ∅
+        │   │           │   └── rparen_loc: ∅
+        │   │           ├── collection:
+        │   │           │   @ CallNode (location: (13...16))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (13...16) = "bar"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "bar"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (22...25))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (22...25))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (22...25) = "baz"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "baz"
+        │   │           ├── for_keyword_loc: (4...7) = "for"
+        │   │           ├── in_keyword_loc: (10...12) = "in"
+        │   │           ├── do_keyword_loc: (17...19) = "do"
+        │   │           └── end_keyword_loc: (26...29) = "end"
+        │   ├── closing_loc: (29...30) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ ForNode (location: (31...56))
+        │   ├── index:
+        │   │   @ MultiTargetNode (location: (35...36))
+        │   │   ├── targets: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (35...36))
+        │   │   │       ├── name: :a
+        │   │   │       └── depth: 0
+        │   │   ├── lparen_loc: ∅
+        │   │   └── rparen_loc: ∅
+        │   ├── collection:
+        │   │   @ CallNode (location: (40...43))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (40...43) = "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "bar"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (49...52))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (49...52))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (49...52) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── for_keyword_loc: (31...34) = "for"
+        │   ├── in_keyword_loc: (37...39) = "in"
+        │   ├── do_keyword_loc: (44...46) = "do"
+        │   └── end_keyword_loc: (53...56) = "end"
+        ├── @ ForNode (location: (57...88))
+        │   ├── index:
+        │   │   @ MultiTargetNode (location: (61...68))
+        │   │   ├── targets: (length: 2)
+        │   │   │   ├── @ LocalVariableTargetNode (location: (62...63))
+        │   │   │   │   ├── name: :a
+        │   │   │   │   └── depth: 0
+        │   │   │   └── @ SplatNode (location: (65...67))
+        │   │   │       ├── operator_loc: (65...66) = "*"
+        │   │   │       └── expression:
+        │   │   │           @ LocalVariableTargetNode (location: (66...67))
+        │   │   │           ├── name: :b
+        │   │   │           └── depth: 0
+        │   │   ├── lparen_loc: (61...62) = "("
+        │   │   └── rparen_loc: (67...68) = ")"
+        │   ├── collection:
+        │   │   @ CallNode (location: (72...75))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (72...75) = "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "bar"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (81...84))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (81...84))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (81...84) = "baz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "baz"
+        │   ├── for_keyword_loc: (57...60) = "for"
+        │   ├── in_keyword_loc: (69...71) = "in"
+        │   ├── do_keyword_loc: (76...78) = "do"
+        │   └── end_keyword_loc: (85...88) = "end"
+        └── @ ForNode (location: (89...119))
+            ├── index:
+            │   @ MultiTargetNode (location: (93...99))
+            │   ├── targets: (length: 2)
+            │   │   ├── @ LocalVariableTargetNode (location: (94...95))
+            │   │   │   ├── name: :a
+            │   │   │   └── depth: 0
+            │   │   └── @ LocalVariableTargetNode (location: (97...98))
+            │   │       ├── name: :b
+            │   │       └── depth: 0
+            │   ├── lparen_loc: (93...94) = "("
+            │   └── rparen_loc: (98...99) = ")"
+            ├── collection:
+            │   @ CallNode (location: (103...106))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (103...106) = "bar"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "bar"
+            ├── statements:
+            │   @ StatementsNode (location: (112...115))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (112...115))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (112...115) = "baz"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "baz"
+            ├── for_keyword_loc: (89...92) = "for"
+            ├── in_keyword_loc: (100...102) = "in"
+            ├── do_keyword_loc: (107...109) = "do"
+            └── end_keyword_loc: (116...119) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/hookexe.txt b/test/yarp/snapshots/unparser/corpus/literal/hookexe.txt
index b97bd65ad1..2f171d8e0e 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/hookexe.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/hookexe.txt
@@ -1,22 +1,49 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [PreExecutionNode(0...15)(
-       StatementsNode(10...13)(
-         [CallNode(10...13)(nil, nil, (10...13), nil, nil, nil, nil, 2, "foo")]
-       ),
-       (0...5),
-       (6...7),
-       (14...15)
-     ),
-     CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "bar"),
-     PostExecutionNode(20...33)(
-       StatementsNode(28...31)(
-         [CallNode(28...31)(nil, nil, (28...31), nil, nil, nil, nil, 2, "baz")]
-       ),
-       (20...23),
-       (24...25),
-       (32...33)
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 3)
+        ├── @ PreExecutionNode (location: (0...15))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (10...13))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (10...13))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (10...13) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "foo"
+        │   ├── keyword_loc: (0...5) = "BEGIN"
+        │   ├── opening_loc: (6...7) = "{"
+        │   └── closing_loc: (14...15) = "}"
+        ├── @ CallNode (location: (16...19))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (16...19) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "bar"
+        └── @ PostExecutionNode (location: (20...33))
+            ├── statements:
+            │   @ StatementsNode (location: (28...31))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (28...31))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (28...31) = "baz"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "baz"
+            ├── keyword_loc: (20...23) = "END"
+            ├── opening_loc: (24...25) = "{"
+            └── closing_loc: (32...33) = "}"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/if.txt b/test/yarp/snapshots/unparser/corpus/literal/if.txt
index 610dac8d92..88cc011900 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/if.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/if.txt
@@ -1,203 +1,260 @@
-ProgramNode(0...246)(
-  [:foo, :pair],
-  StatementsNode(0...246)(
-    [IfNode(0...18)(
-       (0...2),
-       RegularExpressionNode(3...8)((3...4), (4...7), (7...8), "foo", 0),
-       StatementsNode(11...14)(
-         [CallNode(11...14)(nil, nil, (11...14), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       (15...18)
-     ),
-     IfNode(19...31)(
-       (19...21),
-       IntegerNode(22...23)(),
-       StatementsNode(26...27)([IntegerNode(26...27)()]),
-       nil,
-       (28...31)
-     ),
-     IfNode(32...53)(
-       (32...34),
-       IntegerNode(35...36)(),
-       StatementsNode(39...40)([IntegerNode(39...40)()]),
-       ElseNode(41...53)(
-         (41...45),
-         StatementsNode(48...49)([IntegerNode(48...49)()]),
-         (50...53)
-       ),
-       (50...53)
-     ),
-     UnlessNode(54...72)(
-       (54...60),
-       IntegerNode(61...62)(),
-       StatementsNode(65...68)([NilNode(65...68)()]),
-       nil,
-       (69...72)
-     ),
-     UnlessNode(73...89)(
-       (73...79),
-       IntegerNode(80...81)(),
-       StatementsNode(84...85)([IntegerNode(84...85)()]),
-       nil,
-       (86...89)
-     ),
-     IfNode(90...100)(
-       (90...92),
-       CallNode(93...96)(nil, nil, (93...96), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       nil,
-       (97...100)
-     ),
-     ModuleNode(102...133)(
-       [:foo],
-       (102...108),
-       ConstantReadNode(109...110)(:A),
-       StatementsNode(113...129)(
-         [IfNode(113...129)(
-            (123...125),
-            LocalVariableReadNode(126...129)(:foo, 0),
-            StatementsNode(113...122)(
-              [LocalVariableWriteNode(113...122)(
-                 :foo,
-                 0,
-                 (113...116),
-                 CallNode(119...122)(
-                   nil,
-                   nil,
-                   (119...122),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "bar"
-                 ),
-                 (117...118)
-               )]
-            ),
-            nil,
-            nil
-          )]
-       ),
-       (130...133),
-       :A
-     ),
-     ModuleNode(135...170)(
-       [:foo],
-       (135...141),
-       ConstantReadNode(142...143)(:B),
-       StatementsNode(146...166)(
-         [UnlessNode(146...166)(
-            (156...162),
-            LocalVariableReadNode(163...166)(:foo, 0),
-            StatementsNode(146...155)(
-              [LocalVariableWriteNode(146...155)(
-                 :foo,
-                 0,
-                 (146...149),
-                 CallNode(152...155)(
-                   nil,
-                   nil,
-                   (152...155),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "bar"
-                 ),
-                 (150...151)
-               )]
-            ),
-            nil,
-            nil
-          )]
-       ),
-       (167...170),
-       :B
-     ),
-     UnlessNode(171...197)(
-       (171...177),
-       CallNode(178...181)(
-         nil,
-         nil,
-         (178...181),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       StatementsNode(184...193)(
-         [LocalVariableWriteNode(184...193)(
-            :foo,
-            0,
-            (184...187),
-            CallNode(190...193)(
-              nil,
-              nil,
-              (190...193),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            ),
-            (188...189)
-          )]
-       ),
-       nil,
-       (194...197)
-     ),
-     IfNode(198...246)(
-       (198...200),
-       CallNode(201...222)(
-         nil,
-         nil,
-         (201...204),
-         nil,
-         nil,
-         nil,
-         BlockNode(205...222)(
-           [:pair],
-           BlockParametersNode(207...213)(
-             ParametersNode(208...212)(
-               [RequiredParameterNode(208...212)(:pair)],
-               [],
-               [],
-               nil,
-               [],
-               nil,
-               nil
-             ),
-             [],
-             (207...208),
-             (212...213)
-           ),
-           StatementsNode(216...220)(
-             [LocalVariableReadNode(216...220)(:pair, 0)]
-           ),
-           (205...206),
-           (221...222)
-         ),
-         0,
-         "foo"
-       ),
-       StatementsNode(225...242)(
-         [LocalVariableWriteNode(225...236)(
-            :pair,
-            0,
-            (225...229),
-            SymbolNode(232...236)((232...233), (233...236), nil, "foo"),
-            (230...231)
-          ),
-          LocalVariableReadNode(239...242)(:foo, 0)]
-       ),
-       nil,
-       (243...246)
-     )]
-  )
-)
+@ ProgramNode (location: (0...246))
+├── locals: [:foo, :pair]
+└── statements:
+    @ StatementsNode (location: (0...246))
+    └── body: (length: 10)
+        ├── @ IfNode (location: (0...18))
+        │   ├── if_keyword_loc: (0...2) = "if"
+        │   ├── predicate:
+        │   │   @ RegularExpressionNode (location: (3...8))
+        │   │   ├── opening_loc: (3...4) = "/"
+        │   │   ├── content_loc: (4...7) = "foo"
+        │   │   ├── closing_loc: (7...8) = "/"
+        │   │   ├── unescaped: "foo"
+        │   │   └── flags: 
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (11...14))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (11...14))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (11...14) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (15...18) = "end"
+        ├── @ IfNode (location: (19...31))
+        │   ├── if_keyword_loc: (19...21) = "if"
+        │   ├── predicate:
+        │   │   @ IntegerNode (location: (22...23))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (26...27))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (26...27))
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (28...31) = "end"
+        ├── @ IfNode (location: (32...53))
+        │   ├── if_keyword_loc: (32...34) = "if"
+        │   ├── predicate:
+        │   │   @ IntegerNode (location: (35...36))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (39...40))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (39...40))
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (41...53))
+        │   │   ├── else_keyword_loc: (41...45) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (48...49))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (48...49))
+        │   │   └── end_keyword_loc: (50...53) = "end"
+        │   └── end_keyword_loc: (50...53) = "end"
+        ├── @ UnlessNode (location: (54...72))
+        │   ├── keyword_loc: (54...60) = "unless"
+        │   ├── predicate:
+        │   │   @ IntegerNode (location: (61...62))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (65...68))
+        │   │   └── body: (length: 1)
+        │   │       └── @ NilNode (location: (65...68))
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (69...72) = "end"
+        ├── @ UnlessNode (location: (73...89))
+        │   ├── keyword_loc: (73...79) = "unless"
+        │   ├── predicate:
+        │   │   @ IntegerNode (location: (80...81))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (84...85))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (84...85))
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (86...89) = "end"
+        ├── @ IfNode (location: (90...100))
+        │   ├── if_keyword_loc: (90...92) = "if"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (93...96))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (93...96) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements: ∅
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (97...100) = "end"
+        ├── @ ModuleNode (location: (102...133))
+        │   ├── locals: [:foo]
+        │   ├── module_keyword_loc: (102...108) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (109...110))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (113...129))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IfNode (location: (113...129))
+        │   │           ├── if_keyword_loc: (123...125) = "if"
+        │   │           ├── predicate:
+        │   │           │   @ LocalVariableReadNode (location: (126...129))
+        │   │           │   ├── name: :foo
+        │   │           │   └── depth: 0
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (113...122))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ LocalVariableWriteNode (location: (113...122))
+        │   │           │           ├── name: :foo
+        │   │           │           ├── depth: 0
+        │   │           │           ├── name_loc: (113...116) = "foo"
+        │   │           │           ├── value:
+        │   │           │           │   @ CallNode (location: (119...122))
+        │   │           │           │   ├── receiver: ∅
+        │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │           │   ├── message_loc: (119...122) = "bar"
+        │   │           │           │   ├── opening_loc: ∅
+        │   │           │           │   ├── arguments: ∅
+        │   │           │           │   ├── closing_loc: ∅
+        │   │           │           │   ├── block: ∅
+        │   │           │           │   ├── flags: variable_call
+        │   │           │           │   └── name: "bar"
+        │   │           │           └── operator_loc: (117...118) = "="
+        │   │           ├── consequent: ∅
+        │   │           └── end_keyword_loc: ∅
+        │   ├── end_keyword_loc: (130...133) = "end"
+        │   └── name: :A
+        ├── @ ModuleNode (location: (135...170))
+        │   ├── locals: [:foo]
+        │   ├── module_keyword_loc: (135...141) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (142...143))
+        │   │   └── name: :B
+        │   ├── body:
+        │   │   @ StatementsNode (location: (146...166))
+        │   │   └── body: (length: 1)
+        │   │       └── @ UnlessNode (location: (146...166))
+        │   │           ├── keyword_loc: (156...162) = "unless"
+        │   │           ├── predicate:
+        │   │           │   @ LocalVariableReadNode (location: (163...166))
+        │   │           │   ├── name: :foo
+        │   │           │   └── depth: 0
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (146...155))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ LocalVariableWriteNode (location: (146...155))
+        │   │           │           ├── name: :foo
+        │   │           │           ├── depth: 0
+        │   │           │           ├── name_loc: (146...149) = "foo"
+        │   │           │           ├── value:
+        │   │           │           │   @ CallNode (location: (152...155))
+        │   │           │           │   ├── receiver: ∅
+        │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │           │   ├── message_loc: (152...155) = "bar"
+        │   │           │           │   ├── opening_loc: ∅
+        │   │           │           │   ├── arguments: ∅
+        │   │           │           │   ├── closing_loc: ∅
+        │   │           │           │   ├── block: ∅
+        │   │           │           │   ├── flags: variable_call
+        │   │           │           │   └── name: "bar"
+        │   │           │           └── operator_loc: (150...151) = "="
+        │   │           ├── consequent: ∅
+        │   │           └── end_keyword_loc: ∅
+        │   ├── end_keyword_loc: (167...170) = "end"
+        │   └── name: :B
+        ├── @ UnlessNode (location: (171...197))
+        │   ├── keyword_loc: (171...177) = "unless"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (178...181))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (178...181) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (184...193))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableWriteNode (location: (184...193))
+        │   │           ├── name: :foo
+        │   │           ├── depth: 0
+        │   │           ├── name_loc: (184...187) = "foo"
+        │   │           ├── value:
+        │   │           │   @ CallNode (location: (190...193))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (190...193) = "bar"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "bar"
+        │   │           └── operator_loc: (188...189) = "="
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (194...197) = "end"
+        └── @ IfNode (location: (198...246))
+            ├── if_keyword_loc: (198...200) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (201...222))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (201...204) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (205...222))
+            │   │   ├── locals: [:pair]
+            │   │   ├── parameters:
+            │   │   │   @ BlockParametersNode (location: (207...213))
+            │   │   │   ├── parameters:
+            │   │   │   │   @ ParametersNode (location: (208...212))
+            │   │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   │   └── @ RequiredParameterNode (location: (208...212))
+            │   │   │   │   │       └── name: :pair
+            │   │   │   │   ├── optionals: (length: 0)
+            │   │   │   │   ├── posts: (length: 0)
+            │   │   │   │   ├── rest: ∅
+            │   │   │   │   ├── keywords: (length: 0)
+            │   │   │   │   ├── keyword_rest: ∅
+            │   │   │   │   └── block: ∅
+            │   │   │   ├── locals: (length: 0)
+            │   │   │   ├── opening_loc: (207...208) = "|"
+            │   │   │   └── closing_loc: (212...213) = "|"
+            │   │   ├── body:
+            │   │   │   @ StatementsNode (location: (216...220))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ LocalVariableReadNode (location: (216...220))
+            │   │   │           ├── name: :pair
+            │   │   │           └── depth: 0
+            │   │   ├── opening_loc: (205...206) = "{"
+            │   │   └── closing_loc: (221...222) = "}"
+            │   ├── flags: 
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (225...242))
+            │   └── body: (length: 2)
+            │       ├── @ LocalVariableWriteNode (location: (225...236))
+            │       │   ├── name: :pair
+            │       │   ├── depth: 0
+            │       │   ├── name_loc: (225...229) = "pair"
+            │       │   ├── value:
+            │       │   │   @ SymbolNode (location: (232...236))
+            │       │   │   ├── opening_loc: (232...233) = ":"
+            │       │   │   ├── value_loc: (233...236) = "foo"
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   └── unescaped: "foo"
+            │       │   └── operator_loc: (230...231) = "="
+            │       └── @ LocalVariableReadNode (location: (239...242))
+            │           ├── name: :foo
+            │           └── depth: 0
+            ├── consequent: ∅
+            └── end_keyword_loc: (243...246) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/kwbegin.txt b/test/yarp/snapshots/unparser/corpus/literal/kwbegin.txt
index 79f4c36be6..5bc8b3583f 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/kwbegin.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/kwbegin.txt
@@ -1,376 +1,489 @@
-ProgramNode(0...530)(
-  [:foo, :bar, :exception],
-  StatementsNode(0...530)(
-    [BeginNode(0...16)(
-       (0...5),
-       nil,
-       RescueNode(6...12)((6...12), [], nil, nil, nil, nil),
-       nil,
-       nil,
-       (13...16)
-     ),
-     BeginNode(18...34)(
-       (18...23),
-       nil,
-       nil,
-       nil,
-       EnsureNode(24...34)((24...30), nil, (31...34)),
-       (31...34)
-     ),
-     BeginNode(36...49)(
-       (36...41),
-       StatementsNode(44...45)(
-         [CallNode(44...45)(nil, nil, (44...45), nil, nil, nil, nil, 2, "a")]
-       ),
-       nil,
-       nil,
-       nil,
-       (46...49)
-     ),
-     BeginNode(51...75)(
-       (51...56),
-       StatementsNode(59...60)(
-         [CallNode(59...60)(nil, nil, (59...60), nil, nil, nil, nil, 2, "a")]
-       ),
-       RescueNode(61...71)(
-         (61...67),
-         [],
-         nil,
-         nil,
-         StatementsNode(70...71)(
-           [CallNode(70...71)(nil, nil, (70...71), nil, nil, nil, nil, 2, "b")]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (72...75)
-     ),
-     BeginNode(77...105)(
-       (77...82),
-       StatementsNode(85...90)(
-         [CallNode(85...86)(nil, nil, (85...86), nil, nil, nil, nil, 2, "a"),
-          CallNode(89...90)(nil, nil, (89...90), nil, nil, nil, nil, 2, "b")]
-       ),
-       RescueNode(91...101)(
-         (91...97),
-         [],
-         nil,
-         nil,
-         StatementsNode(100...101)(
-           [CallNode(100...101)(
-              nil,
-              nil,
-              (100...101),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (102...105)
-     ),
-     BeginNode(107...125)(
-       (107...112),
-       nil,
-       RescueNode(113...121)(
-         (113...119),
-         [ConstantReadNode(120...121)(:A)],
-         nil,
-         nil,
-         nil,
-         nil
-       ),
-       nil,
-       nil,
-       (122...125)
-     ),
-     BeginNode(127...152)(
-       (127...132),
-       nil,
-       RescueNode(133...148)(
-         (133...139),
-         [ConstantReadNode(140...141)(:A)],
-         (142...144),
-         LocalVariableTargetNode(145...148)(:foo, 0),
-         nil,
-         nil
-       ),
-       nil,
-       nil,
-       (149...152)
-     ),
-     BeginNode(154...204)(
-       (154...159),
-       StatementsNode(162...163)(
-         [CallNode(162...163)(
-            nil,
-            nil,
-            (162...163),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(164...189)(
-         (164...170),
-         [ConstantReadNode(171...172)(:A)],
-         nil,
-         nil,
-         StatementsNode(175...176)(
-           [CallNode(175...176)(
-              nil,
-              nil,
-              (175...176),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         RescueNode(177...189)(
-           (177...183),
-           [ConstantReadNode(184...185)(:B)],
-           nil,
-           nil,
-           StatementsNode(188...189)(
-             [CallNode(188...189)(
-                nil,
-                nil,
-                (188...189),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "c"
-              )]
-           ),
-           nil
-         )
-       ),
-       nil,
-       EnsureNode(190...204)(
-         (190...196),
-         StatementsNode(199...200)(
-           [CallNode(199...200)(
-              nil,
-              nil,
-              (199...200),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "d"
-            )]
-         ),
-         (201...204)
-       ),
-       (201...204)
-     ),
-     BeginNode(206...273)(
-       (206...211),
-       StatementsNode(214...250)(
-         [BeginNode(214...250)(
-            (214...219),
-            StatementsNode(224...235)(
-              [LocalVariableReadNode(224...227)(:foo, 0),
-               CallNode(232...235)(
-                 nil,
-                 nil,
-                 (232...235),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "bar"
-               )]
-            ),
-            RescueNode(238...244)((238...244), [], nil, nil, nil, nil),
-            nil,
-            nil,
-            (247...250)
-          )]
-       ),
-       RescueNode(251...269)(
-         (251...257),
-         [],
-         nil,
-         nil,
-         StatementsNode(260...269)(
-           [CallNode(260...263)(
-              nil,
-              nil,
-              (260...263),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            ),
-            CallNode(266...269)(
-              nil,
-              nil,
-              (266...269),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (270...273)
-     ),
-     BeginNode(275...337)(
-       (275...280),
-       StatementsNode(283...316)(
-         [RescueModifierNode(283...316)(
-            CallNode(283...299)(
-              nil,
-              nil,
-              (283...288),
-              (288...289),
-              ArgumentsNode(289...298)(
-                [ConstantReadNode(289...298)(:Exception)]
-              ),
-              (298...299),
-              nil,
-              0,
-              "raise"
-            ),
-            (300...306),
-            LocalVariableWriteNode(307...316)(
-              :foo,
-              0,
-              (307...310),
-              CallNode(313...316)(
-                nil,
-                nil,
-                (313...316),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (311...312)
-            )
-          )]
-       ),
-       RescueNode(317...333)(
-         (317...323),
-         [ConstantReadNode(324...333)(:Exception)],
-         nil,
-         nil,
-         nil,
-         nil
-       ),
-       nil,
-       nil,
-       (334...337)
-     ),
-     BeginNode(339...374)(
-       (339...344),
-       StatementsNode(347...350)([LocalVariableReadNode(347...350)(:foo, 0)]),
-       RescueNode(351...370)(
-         (351...357),
-         [],
-         (358...360),
-         LocalVariableTargetNode(361...364)(:bar, 0),
-         StatementsNode(367...370)(
-           [LocalVariableReadNode(367...370)(:bar, 0)]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (371...374)
-     ),
-     BeginNode(376...428)(
-       (376...381),
-       StatementsNode(384...387)([LocalVariableReadNode(384...387)(:foo, 0)]),
-       RescueNode(388...424)(
-         (388...394),
-         [ConstantReadNode(395...404)(:Exception),
-          ConstantReadNode(406...411)(:Other)],
-         (412...414),
-         LocalVariableTargetNode(415...418)(:bar, 0),
-         StatementsNode(421...424)(
-           [LocalVariableReadNode(421...424)(:bar, 0)]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (425...428)
-     ),
-     BeginNode(430...487)(
-       (430...435),
-       StatementsNode(438...441)([LocalVariableReadNode(438...441)(:bar, 0)]),
-       RescueNode(442...483)(
-         (442...448),
-         [ConstantReadNode(449...458)(:SomeError),
-          SplatNode(460...464)(
-            (460...461),
-            LocalVariableReadNode(461...464)(:bar, 0)
-          )],
-         (465...467),
-         LocalVariableTargetNode(468...477)(:exception, 0),
-         StatementsNode(480...483)(
-           [CallNode(480...483)(
-              nil,
-              nil,
-              (480...483),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (484...487)
-     ),
-     SingletonClassNode(489...530)(
-       [],
-       (489...494),
-       (495...497),
-       SelfNode(498...502)(),
-       StatementsNode(505...526)(
-         [RescueModifierNode(505...526)(
-            UndefNode(505...515)(
-              [SymbolNode(511...515)((511...512), (512...515), nil, "bar")],
-              (505...510)
-            ),
-            (516...522),
-            NilNode(523...526)()
-          )]
-       ),
-       (527...530)
-     )]
-  )
-)
+@ ProgramNode (location: (0...530))
+├── locals: [:foo, :bar, :exception]
+└── statements:
+    @ StatementsNode (location: (0...530))
+    └── body: (length: 14)
+        ├── @ BeginNode (location: (0...16))
+        │   ├── begin_keyword_loc: (0...5) = "begin"
+        │   ├── statements: ∅
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (6...12))
+        │   │   ├── keyword_loc: (6...12) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements: ∅
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (13...16) = "end"
+        ├── @ BeginNode (location: (18...34))
+        │   ├── begin_keyword_loc: (18...23) = "begin"
+        │   ├── statements: ∅
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause:
+        │   │   @ EnsureNode (location: (24...34))
+        │   │   ├── ensure_keyword_loc: (24...30) = "ensure"
+        │   │   ├── statements: ∅
+        │   │   └── end_keyword_loc: (31...34) = "end"
+        │   └── end_keyword_loc: (31...34) = "end"
+        ├── @ BeginNode (location: (36...49))
+        │   ├── begin_keyword_loc: (36...41) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (44...45))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (44...45))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (44...45) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (46...49) = "end"
+        ├── @ BeginNode (location: (51...75))
+        │   ├── begin_keyword_loc: (51...56) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (59...60))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (59...60))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (59...60) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (61...71))
+        │   │   ├── keyword_loc: (61...67) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (70...71))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (70...71))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (70...71) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (72...75) = "end"
+        ├── @ BeginNode (location: (77...105))
+        │   ├── begin_keyword_loc: (77...82) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (85...90))
+        │   │   └── body: (length: 2)
+        │   │       ├── @ CallNode (location: (85...86))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (85...86) = "a"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "a"
+        │   │       └── @ CallNode (location: (89...90))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (89...90) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (91...101))
+        │   │   ├── keyword_loc: (91...97) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (100...101))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (100...101))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (100...101) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (102...105) = "end"
+        ├── @ BeginNode (location: (107...125))
+        │   ├── begin_keyword_loc: (107...112) = "begin"
+        │   ├── statements: ∅
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (113...121))
+        │   │   ├── keyword_loc: (113...119) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ ConstantReadNode (location: (120...121))
+        │   │   │       └── name: :A
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements: ∅
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (122...125) = "end"
+        ├── @ BeginNode (location: (127...152))
+        │   ├── begin_keyword_loc: (127...132) = "begin"
+        │   ├── statements: ∅
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (133...148))
+        │   │   ├── keyword_loc: (133...139) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ ConstantReadNode (location: (140...141))
+        │   │   │       └── name: :A
+        │   │   ├── operator_loc: (142...144) = "=>"
+        │   │   ├── reference:
+        │   │   │   @ LocalVariableTargetNode (location: (145...148))
+        │   │   │   ├── name: :foo
+        │   │   │   └── depth: 0
+        │   │   ├── statements: ∅
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (149...152) = "end"
+        ├── @ BeginNode (location: (154...204))
+        │   ├── begin_keyword_loc: (154...159) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (162...163))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (162...163))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (162...163) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (164...189))
+        │   │   ├── keyword_loc: (164...170) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ ConstantReadNode (location: (171...172))
+        │   │   │       └── name: :A
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (175...176))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (175...176))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (175...176) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent:
+        │   │       @ RescueNode (location: (177...189))
+        │   │       ├── keyword_loc: (177...183) = "rescue"
+        │   │       ├── exceptions: (length: 1)
+        │   │       │   └── @ ConstantReadNode (location: (184...185))
+        │   │       │       └── name: :B
+        │   │       ├── operator_loc: ∅
+        │   │       ├── reference: ∅
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (188...189))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ CallNode (location: (188...189))
+        │   │       │           ├── receiver: ∅
+        │   │       │           ├── call_operator_loc: ∅
+        │   │       │           ├── message_loc: (188...189) = "c"
+        │   │       │           ├── opening_loc: ∅
+        │   │       │           ├── arguments: ∅
+        │   │       │           ├── closing_loc: ∅
+        │   │       │           ├── block: ∅
+        │   │       │           ├── flags: variable_call
+        │   │       │           └── name: "c"
+        │   │       └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause:
+        │   │   @ EnsureNode (location: (190...204))
+        │   │   ├── ensure_keyword_loc: (190...196) = "ensure"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (199...200))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (199...200))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (199...200) = "d"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "d"
+        │   │   └── end_keyword_loc: (201...204) = "end"
+        │   └── end_keyword_loc: (201...204) = "end"
+        ├── @ BeginNode (location: (206...273))
+        │   ├── begin_keyword_loc: (206...211) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (214...250))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BeginNode (location: (214...250))
+        │   │           ├── begin_keyword_loc: (214...219) = "begin"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (224...235))
+        │   │           │   └── body: (length: 2)
+        │   │           │       ├── @ LocalVariableReadNode (location: (224...227))
+        │   │           │       │   ├── name: :foo
+        │   │           │       │   └── depth: 0
+        │   │           │       └── @ CallNode (location: (232...235))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (232...235) = "bar"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "bar"
+        │   │           ├── rescue_clause:
+        │   │           │   @ RescueNode (location: (238...244))
+        │   │           │   ├── keyword_loc: (238...244) = "rescue"
+        │   │           │   ├── exceptions: (length: 0)
+        │   │           │   ├── operator_loc: ∅
+        │   │           │   ├── reference: ∅
+        │   │           │   ├── statements: ∅
+        │   │           │   └── consequent: ∅
+        │   │           ├── else_clause: ∅
+        │   │           ├── ensure_clause: ∅
+        │   │           └── end_keyword_loc: (247...250) = "end"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (251...269))
+        │   │   ├── keyword_loc: (251...257) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (260...269))
+        │   │   │   └── body: (length: 2)
+        │   │   │       ├── @ CallNode (location: (260...263))
+        │   │   │       │   ├── receiver: ∅
+        │   │   │       │   ├── call_operator_loc: ∅
+        │   │   │       │   ├── message_loc: (260...263) = "baz"
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── arguments: ∅
+        │   │   │       │   ├── closing_loc: ∅
+        │   │   │       │   ├── block: ∅
+        │   │   │       │   ├── flags: variable_call
+        │   │   │       │   └── name: "baz"
+        │   │   │       └── @ CallNode (location: (266...269))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (266...269) = "bar"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "bar"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (270...273) = "end"
+        ├── @ BeginNode (location: (275...337))
+        │   ├── begin_keyword_loc: (275...280) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (283...316))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RescueModifierNode (location: (283...316))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (283...299))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (283...288) = "raise"
+        │   │           │   ├── opening_loc: (288...289) = "("
+        │   │           │   ├── arguments:
+        │   │           │   │   @ ArgumentsNode (location: (289...298))
+        │   │           │   │   └── arguments: (length: 1)
+        │   │           │   │       └── @ ConstantReadNode (location: (289...298))
+        │   │           │   │           └── name: :Exception
+        │   │           │   ├── closing_loc: (298...299) = ")"
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: 
+        │   │           │   └── name: "raise"
+        │   │           ├── keyword_loc: (300...306) = "rescue"
+        │   │           └── rescue_expression:
+        │   │               @ LocalVariableWriteNode (location: (307...316))
+        │   │               ├── name: :foo
+        │   │               ├── depth: 0
+        │   │               ├── name_loc: (307...310) = "foo"
+        │   │               ├── value:
+        │   │               │   @ CallNode (location: (313...316))
+        │   │               │   ├── receiver: ∅
+        │   │               │   ├── call_operator_loc: ∅
+        │   │               │   ├── message_loc: (313...316) = "bar"
+        │   │               │   ├── opening_loc: ∅
+        │   │               │   ├── arguments: ∅
+        │   │               │   ├── closing_loc: ∅
+        │   │               │   ├── block: ∅
+        │   │               │   ├── flags: variable_call
+        │   │               │   └── name: "bar"
+        │   │               └── operator_loc: (311...312) = "="
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (317...333))
+        │   │   ├── keyword_loc: (317...323) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ ConstantReadNode (location: (324...333))
+        │   │   │       └── name: :Exception
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements: ∅
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (334...337) = "end"
+        ├── @ BeginNode (location: (339...374))
+        │   ├── begin_keyword_loc: (339...344) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (347...350))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (347...350))
+        │   │           ├── name: :foo
+        │   │           └── depth: 0
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (351...370))
+        │   │   ├── keyword_loc: (351...357) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: (358...360) = "=>"
+        │   │   ├── reference:
+        │   │   │   @ LocalVariableTargetNode (location: (361...364))
+        │   │   │   ├── name: :bar
+        │   │   │   └── depth: 0
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (367...370))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableReadNode (location: (367...370))
+        │   │   │           ├── name: :bar
+        │   │   │           └── depth: 0
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (371...374) = "end"
+        ├── @ BeginNode (location: (376...428))
+        │   ├── begin_keyword_loc: (376...381) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (384...387))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (384...387))
+        │   │           ├── name: :foo
+        │   │           └── depth: 0
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (388...424))
+        │   │   ├── keyword_loc: (388...394) = "rescue"
+        │   │   ├── exceptions: (length: 2)
+        │   │   │   ├── @ ConstantReadNode (location: (395...404))
+        │   │   │   │   └── name: :Exception
+        │   │   │   └── @ ConstantReadNode (location: (406...411))
+        │   │   │       └── name: :Other
+        │   │   ├── operator_loc: (412...414) = "=>"
+        │   │   ├── reference:
+        │   │   │   @ LocalVariableTargetNode (location: (415...418))
+        │   │   │   ├── name: :bar
+        │   │   │   └── depth: 0
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (421...424))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableReadNode (location: (421...424))
+        │   │   │           ├── name: :bar
+        │   │   │           └── depth: 0
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (425...428) = "end"
+        ├── @ BeginNode (location: (430...487))
+        │   ├── begin_keyword_loc: (430...435) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (438...441))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (438...441))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (442...483))
+        │   │   ├── keyword_loc: (442...448) = "rescue"
+        │   │   ├── exceptions: (length: 2)
+        │   │   │   ├── @ ConstantReadNode (location: (449...458))
+        │   │   │   │   └── name: :SomeError
+        │   │   │   └── @ SplatNode (location: (460...464))
+        │   │   │       ├── operator_loc: (460...461) = "*"
+        │   │   │       └── expression:
+        │   │   │           @ LocalVariableReadNode (location: (461...464))
+        │   │   │           ├── name: :bar
+        │   │   │           └── depth: 0
+        │   │   ├── operator_loc: (465...467) = "=>"
+        │   │   ├── reference:
+        │   │   │   @ LocalVariableTargetNode (location: (468...477))
+        │   │   │   ├── name: :exception
+        │   │   │   └── depth: 0
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (480...483))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (480...483))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (480...483) = "baz"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "baz"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (484...487) = "end"
+        └── @ SingletonClassNode (location: (489...530))
+            ├── locals: []
+            ├── class_keyword_loc: (489...494) = "class"
+            ├── operator_loc: (495...497) = "<<"
+            ├── expression:
+            │   @ SelfNode (location: (498...502))
+            ├── body:
+            │   @ StatementsNode (location: (505...526))
+            │   └── body: (length: 1)
+            │       └── @ RescueModifierNode (location: (505...526))
+            │           ├── expression:
+            │           │   @ UndefNode (location: (505...515))
+            │           │   ├── names: (length: 1)
+            │           │   │   └── @ SymbolNode (location: (511...515))
+            │           │   │       ├── opening_loc: (511...512) = ":"
+            │           │   │       ├── value_loc: (512...515) = "bar"
+            │           │   │       ├── closing_loc: ∅
+            │           │   │       └── unescaped: "bar"
+            │           │   └── keyword_loc: (505...510) = "undef"
+            │           ├── keyword_loc: (516...522) = "rescue"
+            │           └── rescue_expression:
+            │               @ NilNode (location: (523...526))
+            └── end_keyword_loc: (527...530) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/lambda.txt b/test/yarp/snapshots/unparser/corpus/literal/lambda.txt
index 8c036bd70d..b4b478cad2 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/lambda.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/lambda.txt
@@ -1,120 +1,143 @@
-ProgramNode(0...80)(
-  [],
-  StatementsNode(0...80)(
-    [CallNode(0...10)(
-       nil,
-       nil,
-       (0...6),
-       nil,
-       nil,
-       nil,
-       BlockNode(7...10)([], nil, nil, (7...8), (9...10)),
-       0,
-       "lambda"
-     ),
-     CallNode(11...32)(
-       nil,
-       nil,
-       (11...17),
-       nil,
-       nil,
-       nil,
-       BlockNode(18...32)(
-         [:a, :b],
-         BlockParametersNode(20...26)(
-           ParametersNode(21...25)(
-             [RequiredParameterNode(21...22)(:a),
-              RequiredParameterNode(24...25)(:b)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (20...21),
-           (25...26)
-         ),
-         StatementsNode(29...30)([LocalVariableReadNode(29...30)(:a, 0)]),
-         (18...19),
-         (31...32)
-       ),
-       0,
-       "lambda"
-     ),
-     LambdaNode(33...41)(
-       [],
-       (33...35),
-       (38...39),
-       (40...41),
-       BlockParametersNode(35...37)(nil, [], (35...36), (36...37)),
-       nil
-     ),
-     LambdaNode(42...51)(
-       [:a],
-       (42...44),
-       (48...49),
-       (50...51),
-       BlockParametersNode(44...47)(
-         ParametersNode(45...46)(
-           [RequiredParameterNode(45...46)(:a)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (44...45),
-         (46...47)
-       ),
-       nil
-     ),
-     LambdaNode(52...64)(
-       [:a, :b],
-       (52...54),
-       (61...62),
-       (63...64),
-       BlockParametersNode(54...60)(
-         ParametersNode(55...59)(
-           [RequiredParameterNode(55...56)(:a),
-            RequiredParameterNode(58...59)(:b)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (54...55),
-         (59...60)
-       ),
-       nil
-     ),
-     LambdaNode(65...80)(
-       [:a, :b, :c],
-       (65...67),
-       (77...78),
-       (79...80),
-       BlockParametersNode(67...76)(
-         ParametersNode(68...72)(
-           [RequiredParameterNode(68...69)(:a),
-            RequiredParameterNode(71...72)(:b)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [BlockLocalVariableNode(74...75)(:c)],
-         (67...68),
-         (75...76)
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...80))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...80))
+    └── body: (length: 6)
+        ├── @ CallNode (location: (0...10))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...6) = "lambda"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (7...10))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (7...8) = "{"
+        │   │   └── closing_loc: (9...10) = "}"
+        │   ├── flags: 
+        │   └── name: "lambda"
+        ├── @ CallNode (location: (11...32))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (11...17) = "lambda"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (18...32))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (20...26))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (21...25))
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ RequiredParameterNode (location: (21...22))
+        │   │   │   │   │   │   └── name: :a
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (24...25))
+        │   │   │   │   │       └── name: :b
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (20...21) = "|"
+        │   │   │   └── closing_loc: (25...26) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (29...30))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableReadNode (location: (29...30))
+        │   │   │           ├── name: :a
+        │   │   │           └── depth: 0
+        │   │   ├── opening_loc: (18...19) = "{"
+        │   │   └── closing_loc: (31...32) = "}"
+        │   ├── flags: 
+        │   └── name: "lambda"
+        ├── @ LambdaNode (location: (33...41))
+        │   ├── locals: []
+        │   ├── operator_loc: (33...35) = "->"
+        │   ├── opening_loc: (38...39) = "{"
+        │   ├── closing_loc: (40...41) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (35...37))
+        │   │   ├── parameters: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (35...36) = "("
+        │   │   └── closing_loc: (36...37) = ")"
+        │   └── body: ∅
+        ├── @ LambdaNode (location: (42...51))
+        │   ├── locals: [:a]
+        │   ├── operator_loc: (42...44) = "->"
+        │   ├── opening_loc: (48...49) = "{"
+        │   ├── closing_loc: (50...51) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (44...47))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (45...46))
+        │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   └── @ RequiredParameterNode (location: (45...46))
+        │   │   │   │       └── name: :a
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (44...45) = "("
+        │   │   └── closing_loc: (46...47) = ")"
+        │   └── body: ∅
+        ├── @ LambdaNode (location: (52...64))
+        │   ├── locals: [:a, :b]
+        │   ├── operator_loc: (52...54) = "->"
+        │   ├── opening_loc: (61...62) = "{"
+        │   ├── closing_loc: (63...64) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (54...60))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (55...59))
+        │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   ├── @ RequiredParameterNode (location: (55...56))
+        │   │   │   │   │   └── name: :a
+        │   │   │   │   └── @ RequiredParameterNode (location: (58...59))
+        │   │   │   │       └── name: :b
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (54...55) = "("
+        │   │   └── closing_loc: (59...60) = ")"
+        │   └── body: ∅
+        └── @ LambdaNode (location: (65...80))
+            ├── locals: [:a, :b, :c]
+            ├── operator_loc: (65...67) = "->"
+            ├── opening_loc: (77...78) = "{"
+            ├── closing_loc: (79...80) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (67...76))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (68...72))
+            │   │   ├── requireds: (length: 2)
+            │   │   │   ├── @ RequiredParameterNode (location: (68...69))
+            │   │   │   │   └── name: :a
+            │   │   │   └── @ RequiredParameterNode (location: (71...72))
+            │   │   │       └── name: :b
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 0)
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 1)
+            │   │   └── @ BlockLocalVariableNode (location: (74...75))
+            │   │       └── name: :c
+            │   ├── opening_loc: (67...68) = "("
+            │   └── closing_loc: (75...76) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/unparser/corpus/literal/literal.txt b/test/yarp/snapshots/unparser/corpus/literal/literal.txt
index 0a77cb7fcc..a3dc82b091 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/literal.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/literal.txt
@@ -1,716 +1,1033 @@
-ProgramNode(0...916)(
-  [],
-  StatementsNode(0...916)(
-    [HashNode(0...38)(
-       (0...1),
-       [AssocNode(2...21)(
-          StringNode(2...7)((2...3), (3...6), (6...7), "foo"),
-          InterpolatedStringNode(11...21)(
-            (11...21),
-            [StringNode(39...41)(nil, (39...41), nil, "  "),
-             EmbeddedStatementsNode(41...44)((41...43), nil, (43...44)),
-             StringNode(44...45)(nil, (44...45), nil, "\n")],
-            (45...53)
-          ),
-          (8...10)
-        ),
-        AssocNode(23...36)(
-          StringNode(23...28)((23...24), (24...27), (27...28), "bar"),
-          SymbolNode(32...36)((32...33), (33...36), nil, "baz"),
-          (29...31)
-        )],
-       (37...38)
-     ),
-     HashNode(53...84)(
-       (53...54),
-       [AssocNode(55...67)(
-          StringNode(55...60)((55...56), (56...59), (59...60), "foo"),
-          StringNode(64...67)((64...66), (66...66), (66...67), ""),
-          (61...63)
-        ),
-        AssocNode(69...82)(
-          StringNode(69...74)((69...70), (70...73), (73...74), "bar"),
-          SymbolNode(78...82)((78...79), (79...82), nil, "baz"),
-          (75...77)
-        )],
-       (83...84)
-     ),
-     ArrayNode(85...97)(
-       [StringNode(86...91)((86...87), (87...90), (90...91), "foo"),
-        StringNode(93...96)((93...95), (95...95), (95...96), "")],
-       (85...86),
-       (96...97)
-     ),
-     CallNode(98...113)(
-       CallNode(98...111)(
-         nil,
-         nil,
-         (98...99),
-         (99...100),
-         ArgumentsNode(100...110)(
-           [InterpolatedStringNode(100...110)(
-              (100...110),
-              [StringNode(114...116)(nil, (114...116), nil, "  "),
-               EmbeddedStatementsNode(116...119)(
-                 (116...118),
-                 nil,
-                 (118...119)
-               ),
-               StringNode(119...120)(nil, (119...120), nil, "\n")],
-              (120...128)
-            )]
-         ),
-         (110...111),
-         nil,
-         0,
-         "a"
-       ),
-       (111...112),
-       (112...113),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     CallNode(128...136)(
-       CallNode(128...134)(
-         nil,
-         nil,
-         (128...129),
-         (129...130),
-         ArgumentsNode(130...133)(
-           [StringNode(130...133)((130...132), (132...132), (132...133), "")]
-         ),
-         (133...134),
-         nil,
-         0,
-         "a"
-       ),
-       (134...135),
-       (135...136),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     HashNode(137...167)(
-       (137...138),
-       [AssocNode(139...158)(
-          StringNode(139...144)((139...140), (140...143), (143...144), "foo"),
-          InterpolatedStringNode(148...158)(
-            (148...158),
-            [StringNode(168...170)(nil, (168...170), nil, "  "),
-             EmbeddedStatementsNode(170...173)((170...172), nil, (172...173)),
-             StringNode(173...174)(nil, (173...174), nil, "\n")],
-            (174...182)
-          ),
-          (145...147)
-        ),
-        AssocSplatNode(160...165)(
-          CallNode(162...165)(
-            nil,
-            nil,
-            (162...165),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          ),
-          (160...162)
-        )],
-       (166...167)
-     ),
-     HashNode(182...205)(
-       (182...183),
-       [AssocNode(184...196)(
-          StringNode(184...189)((184...185), (185...188), (188...189), "foo"),
-          StringNode(193...196)((193...195), (195...195), (195...196), ""),
-          (190...192)
-        ),
-        AssocSplatNode(198...203)(
-          CallNode(200...203)(
-            nil,
-            nil,
-            (200...203),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "baz"
-          ),
-          (198...200)
-        )],
-       (204...205)
-     ),
-     InterpolatedStringNode(206...220)(
-       (206...207),
-       [EmbeddedVariableNode(207...210)(
-          (207...208),
-          InstanceVariableReadNode(208...210)(:@a)
-        ),
-        StringNode(210...211)(nil, (210...211), nil, " "),
-        EmbeddedVariableNode(211...215)(
-          (211...212),
-          ClassVariableReadNode(212...215)(:@@a)
-        ),
-        StringNode(215...216)(nil, (215...216), nil, " "),
-        EmbeddedVariableNode(216...219)(
-          (216...217),
-          GlobalVariableReadNode(217...219)(:$a)
-        )],
-       (219...220)
-     ),
-     IntegerNode(221...222)(),
-     CallNode(223...226)(
-       IntegerNode(224...226)(),
-       nil,
-       (223...224),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "+@"
-     ),
-     IntegerNode(227...228)(),
-     IntegerNode(229...230)(),
-     RationalNode(231...233)(IntegerNode(231...232)()),
-     RationalNode(234...238)(FloatNode(234...237)()),
-     RationalNode(239...243)(FloatNode(239...242)()),
-     ImaginaryNode(244...246)(IntegerNode(244...245)()),
-     ImaginaryNode(247...250)(IntegerNode(247...249)()),
-     ImaginaryNode(251...255)(FloatNode(251...254)()),
-     ImaginaryNode(256...261)(FloatNode(256...260)()),
-     ImaginaryNode(262...294)(IntegerNode(262...293)()),
-     ImaginaryNode(295...298)(
-       RationalNode(295...297)(IntegerNode(295...296)())
-     ),
-     StringConcatNode(299...310)(
-       StringNode(299...304)((299...300), (300...303), (303...304), "foo"),
-       StringNode(305...310)((305...306), (306...309), (309...310), "bar")
-     ),
-     InterpolatedStringNode(311...326)(
-       (311...312),
-       [StringNode(312...319)(nil, (312...319), nil, "foobar "),
-        EmbeddedStatementsNode(319...325)(
-          (319...321),
-          StatementsNode(321...324)(
-            [CallNode(321...324)(
-               nil,
-               nil,
-               (321...324),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "baz"
-             )]
-          ),
-          (324...325)
-        )],
-       (325...326)
-     ),
-     InterpolatedStringNode(327...339)(
-       (327...328),
-       [StringNode(328...331)(nil, (328...331), nil, "foo"),
-        EmbeddedStatementsNode(331...335)(
-          (331...333),
-          StatementsNode(333...334)([IntegerNode(333...334)()]),
-          (334...335)
-        ),
-        StringNode(335...338)(nil, (335...338), nil, "bar")],
-       (338...339)
-     ),
-     InterpolatedStringNode(340...349)(
-       (340...341),
-       [StringNode(341...345)(nil, (341...345), nil, "\\\\"),
-        EmbeddedStatementsNode(345...348)((345...347), nil, (347...348))],
-       (348...349)
-     ),
-     InterpolatedStringNode(350...359)(
-       (350...351),
-       [EmbeddedStatementsNode(351...354)((351...353), nil, (353...354)),
-        StringNode(354...358)(nil, (354...358), nil, "\#{}")],
-       (358...359)
-     ),
-     InterpolatedStringNode(360...369)(
-       (360...361),
-       [StringNode(361...365)(nil, (361...365), nil, "\#{}"),
-        EmbeddedStatementsNode(365...368)((365...367), nil, (367...368))],
-       (368...369)
-     ),
-     StringNode(370...385)(
-       (370...371),
-       (371...384),
-       (384...385),
-       "foo\\\#{@bar}"
-     ),
-     StringNode(386...390)((386...387), (387...389), (389...390), "\""),
-     StringNode(391...400)((391...392), (392...399), (399...400), "foo bar"),
-     StringNode(401...411)(
-       (401...402),
-       (402...410),
-       (410...411),
-       "foo\n" + "bar"
-     ),
-     XStringNode(412...417)((412...413), (413...416), (416...417), "foo"),
-     InterpolatedXStringNode(418...430)(
-       (418...419),
-       [StringNode(419...422)(nil, (419...422), nil, "foo"),
-        EmbeddedStatementsNode(422...429)(
-          (422...424),
-          StatementsNode(424...428)(
-            [InstanceVariableReadNode(424...428)(:@bar)]
-          ),
-          (428...429)
-        )],
-       (429...430)
-     ),
-     XStringNode(431...434)((431...432), (432...433), (433...434), ")"),
-     XStringNode(435...439)((435...436), (436...438), (438...439), "`"),
-     XStringNode(440...443)((440...441), (441...442), (442...443), "\""),
-     SymbolNode(444...448)((444...445), (445...448), nil, "foo"),
-     SymbolNode(449...455)((449...451), (451...454), (454...455), "A B"),
-     SymbolNode(456...460)((456...457), (457...460), nil, "foo"),
-     SymbolNode(461...467)((461...463), (463...466), (466...467), "A B"),
-     SymbolNode(468...475)((468...470), (470...474), (474...475), "A\"B"),
-     SymbolNode(476...479)((476...478), (0...0), (478...479), ""),
-     RegularExpressionNode(480...485)(
-       (480...481),
-       (481...484),
-       (484...485),
-       "foo",
-       0
-     ),
-     RegularExpressionNode(486...514)(
-       (486...487),
-       (487...513),
-       (513...514),
-       "[^-+',./:@[:alnum:][]]+",
-       0
-     ),
-     InterpolatedRegularExpressionNode(515...527)(
-       (515...516),
-       [StringNode(516...519)(nil, (516...519), nil, "foo"),
-        EmbeddedStatementsNode(519...526)(
-          (519...521),
-          StatementsNode(521...525)(
-            [InstanceVariableReadNode(521...525)(:@bar)]
-          ),
-          (525...526)
-        )],
-       (526...527),
-       0
-     ),
-     InterpolatedRegularExpressionNode(528...543)(
-       (528...529),
-       [StringNode(529...532)(nil, (529...532), nil, "foo"),
-        EmbeddedStatementsNode(532...539)(
-          (532...534),
-          StatementsNode(534...538)(
-            [InstanceVariableReadNode(534...538)(:@bar)]
-          ),
-          (538...539)
-        )],
-       (539...543),
-       7
-     ),
-     InterpolatedRegularExpressionNode(544...557)(
-       (544...545),
-       [EmbeddedStatementsNode(545...556)(
-          (545...547),
-          StatementsNode(547...555)(
-            [StringNode(547...555)(
-               (547...548),
-               (548...554),
-               (554...555),
-               "\u0000"
-             )]
-          ),
-          (555...556)
-        )],
-       (556...557),
-       0
-     ),
-     RegularExpressionNode(558...562)(
-       (558...559),
-       (559...561),
-       (561...562),
-       "\n",
-       0
-     ),
-     RegularExpressionNode(563...567)(
-       (563...564),
-       (564...566),
-       (566...567),
-       "\n",
-       0
-     ),
-     RegularExpressionNode(568...573)(
-       (568...569),
-       (569...571),
-       (571...573),
-       "\n",
-       2
-     ),
-     RegularExpressionNode(574...581)(
-       (574...575),
-       (575...579),
-       (579...581),
-       "//",
-       2
-     ),
-     InterpolatedSymbolNode(582...597)(
-       (582...584),
-       [StringNode(584...587)(nil, (584...587), nil, "foo"),
-        EmbeddedStatementsNode(587...593)(
-          (587...589),
-          StatementsNode(589...592)(
-            [CallNode(589...592)(
-               nil,
-               nil,
-               (589...592),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          ),
-          (592...593)
-        ),
-        StringNode(593...596)(nil, (593...596), nil, "baz")],
-       (596...597)
-     ),
-     InterpolatedSymbolNode(598...609)(
-       (598...600),
-       [EmbeddedStatementsNode(600...608)(
-          (600...602),
-          StatementsNode(602...607)(
-            [StringNode(602...607)(
-               (602...603),
-               (603...606),
-               (606...607),
-               "foo"
-             )]
-          ),
-          (607...608)
-        )],
-       (608...609)
-     ),
-     RangeNode(610...624)(
-       ParenthesesNode(610...621)(
-         StatementsNode(611...620)(
-           [CallNode(611...620)(
-              FloatNode(611...614)(),
-              nil,
-              (615...616),
-              nil,
-              ArgumentsNode(617...620)([FloatNode(617...620)()]),
-              nil,
-              nil,
-              0,
-              "/"
-            )]
-         ),
-         (610...611),
-         (620...621)
-       ),
-       IntegerNode(623...624)(),
-       (621...623),
-       0
-     ),
-     RangeNode(625...639)(
-       IntegerNode(625...626)(),
-       ParenthesesNode(628...639)(
-         StatementsNode(629...638)(
-           [CallNode(629...638)(
-              FloatNode(629...632)(),
-              nil,
-              (633...634),
-              nil,
-              ArgumentsNode(635...638)([FloatNode(635...638)()]),
-              nil,
-              nil,
-              0,
-              "/"
-            )]
-         ),
-         (628...629),
-         (638...639)
-       ),
-       (626...628),
-       0
-     ),
-     RangeNode(640...656)(
-       ParenthesesNode(640...651)(
-         StatementsNode(641...650)(
-           [CallNode(641...650)(
-              FloatNode(641...644)(),
-              nil,
-              (645...646),
-              nil,
-              ArgumentsNode(647...650)([FloatNode(647...650)()]),
-              nil,
-              nil,
-              0,
-              "/"
-            )]
-         ),
-         (640...641),
-         (650...651)
-       ),
-       IntegerNode(653...656)(),
-       (651...653),
-       0
-     ),
-     FloatNode(657...661)(),
-     FloatNode(662...665)(),
-     ArrayNode(666...672)(
-       [IntegerNode(667...668)(), IntegerNode(670...671)()],
-       (666...667),
-       (671...672)
-     ),
-     ArrayNode(673...684)(
-       [IntegerNode(674...675)(),
-        ParenthesesNode(677...679)(nil, (677...678), (678...679)),
-        CallNode(681...683)(
-          nil,
-          nil,
-          (681...683),
-          nil,
-          nil,
-          nil,
-          nil,
-          2,
-          "n2"
-        )],
-       (673...674),
-       (683...684)
-     ),
-     ArrayNode(685...688)(
-       [IntegerNode(686...687)()],
-       (685...686),
-       (687...688)
-     ),
-     ArrayNode(689...691)([], (689...690), (690...691)),
-     ArrayNode(692...702)(
-       [IntegerNode(693...694)(),
-        SplatNode(696...701)(
-          (696...697),
-          InstanceVariableReadNode(697...701)(:@foo)
-        )],
-       (692...693),
-       (701...702)
-     ),
-     ArrayNode(703...713)(
-       [SplatNode(704...709)(
-          (704...705),
-          InstanceVariableReadNode(705...709)(:@foo)
-        ),
-        IntegerNode(711...712)()],
-       (703...704),
-       (712...713)
-     ),
-     ArrayNode(714...728)(
-       [SplatNode(715...720)(
-          (715...716),
-          InstanceVariableReadNode(716...720)(:@foo)
-        ),
-        SplatNode(722...727)(
-          (722...723),
-          InstanceVariableReadNode(723...727)(:@baz)
-        )],
-       (714...715),
-       (727...728)
-     ),
-     HashNode(729...731)((729...730), [], (730...731)),
-     HashNode(732...744)(
-       (732...733),
-       [AssocNode(734...742)(
-          ParenthesesNode(734...736)(nil, (734...735), (735...736)),
-          ParenthesesNode(740...742)(nil, (740...741), (741...742)),
-          (737...739)
-        )],
-       (743...744)
-     ),
-     HashNode(745...755)(
-       (745...746),
-       [AssocNode(747...753)(
-          IntegerNode(747...748)(),
-          IntegerNode(752...753)(),
-          (749...751)
-        )],
-       (754...755)
-     ),
-     HashNode(756...774)(
-       (756...757),
-       [AssocNode(758...764)(
-          IntegerNode(758...759)(),
-          IntegerNode(763...764)(),
-          (760...762)
-        ),
-        AssocNode(766...772)(
-          IntegerNode(766...767)(),
-          IntegerNode(771...772)(),
-          (768...770)
-        )],
-       (773...774)
-     ),
-     HashNode(775...802)(
-       (775...776),
-       [AssocNode(777...794)(
-          SymbolNode(777...779)(nil, (777...778), (778...779), "a"),
-          ParenthesesNode(780...794)(
-            StatementsNode(781...793)(
-              [RescueModifierNode(781...793)(
-                 IntegerNode(781...782)(),
-                 (783...789),
-                 CallNode(790...793)(
-                   nil,
-                   nil,
-                   (790...793),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "foo"
-                 )
-               )]
-            ),
-            (780...781),
-            (793...794)
-          ),
-          nil
-        ),
-        AssocNode(796...800)(
-          SymbolNode(796...798)(nil, (796...797), (797...798), "b"),
-          IntegerNode(799...800)(),
-          nil
-        )],
-       (801...802)
-     ),
-     HashNode(803...817)(
-       (803...804),
-       [AssocNode(805...809)(
-          SymbolNode(805...807)(nil, (805...806), (806...807), "a"),
-          IntegerNode(808...809)(),
-          nil
-        ),
-        AssocNode(811...815)(
-          SymbolNode(811...813)(nil, (811...812), (812...813), "b"),
-          IntegerNode(814...815)(),
-          nil
-        )],
-       (816...817)
-     ),
-     HashNode(818...827)(
-       (818...819),
-       [AssocNode(820...825)(
-          SymbolNode(820...822)(nil, (820...821), (821...822), "a"),
-          SymbolNode(823...825)((823...824), (824...825), nil, "a"),
-          nil
-        )],
-       (826...827)
-     ),
-     HashNode(828...843)(
-       (828...829),
-       [AssocNode(830...841)(
-          SymbolNode(830...836)((830...832), (832...835), (835...836), "a b"),
-          IntegerNode(840...841)(),
-          (837...839)
-        )],
-       (842...843)
-     ),
-     HashNode(844...856)(
-       (844...845),
-       [AssocNode(846...854)(
-          SymbolNode(846...849)((846...847), (847...849), nil, "-@"),
-          IntegerNode(853...854)(),
-          (850...852)
-        )],
-       (855...856)
-     ),
-     InterpolatedStringNode(857...869)(
-       (857...858),
-       [EmbeddedStatementsNode(858...861)((858...860), nil, (860...861)),
-        StringNode(861...862)(nil, (861...862), nil, "\n"),
-        EmbeddedStatementsNode(862...865)((862...864), nil, (864...865)),
-        StringNode(865...868)(nil, (865...868), nil, "\n" + "a")],
-       (868...869)
-     ),
-     CallNode(870...892)(
-       nil,
-       nil,
-       (870...873),
-       nil,
-       nil,
-       nil,
-       BlockNode(874...892)(
-         [],
-         nil,
-         StatementsNode(878...890)(
-           [InterpolatedStringNode(878...890)(
-              (878...879),
-              [EmbeddedStatementsNode(879...882)(
-                 (879...881),
-                 nil,
-                 (881...882)
-               ),
-               StringNode(882...883)(nil, (882...883), nil, "\n"),
-               EmbeddedStatementsNode(883...886)(
-                 (883...885),
-                 nil,
-                 (885...886)
-               ),
-               StringNode(886...889)(nil, (886...889), nil, "\n" + "a")],
-              (889...890)
-            )]
-         ),
-         (874...875),
-         (891...892)
-       ),
-       0,
-       "foo"
-     ),
-     SymbolNode(893...901)(
-       (893...895),
-       (895...900),
-       (900...901),
-       "a\\\n" + "b"
-     ),
-     InterpolatedXStringNode(902...916)(
-       (902...903),
-       [StringNode(903...907)(nil, (903...907), nil, "  x\n"),
-        EmbeddedStatementsNode(907...913)(
-          (907...909),
-          StatementsNode(909...912)(
-            [CallNode(909...912)(
-               nil,
-               nil,
-               (909...912),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "foo"
-             )]
-          ),
-          (912...913)
-        ),
-        StringNode(913...915)(nil, (913...915), nil, "\n" + "#")],
-       (915...916)
-     )]
-  )
-)
+@ ProgramNode (location: (0...916))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...916))
+    └── body: (length: 78)
+        ├── @ HashNode (location: (0...38))
+        │   ├── opening_loc: (0...1) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (2...21))
+        │   │   │   ├── key:
+        │   │   │   │   @ StringNode (location: (2...7))
+        │   │   │   │   ├── opening_loc: (2...3) = "\""
+        │   │   │   │   ├── content_loc: (3...6) = "foo"
+        │   │   │   │   ├── closing_loc: (6...7) = "\""
+        │   │   │   │   └── unescaped: "foo"
+        │   │   │   ├── value:
+        │   │   │   │   @ InterpolatedStringNode (location: (11...21))
+        │   │   │   │   ├── opening_loc: (11...21) = "<<-HEREDOC"
+        │   │   │   │   ├── parts: (length: 3)
+        │   │   │   │   │   ├── @ StringNode (location: (39...41))
+        │   │   │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   │   │   ├── content_loc: (39...41) = "  "
+        │   │   │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   │   │   └── unescaped: "  "
+        │   │   │   │   │   ├── @ EmbeddedStatementsNode (location: (41...44))
+        │   │   │   │   │   │   ├── opening_loc: (41...43) = "\#{"
+        │   │   │   │   │   │   ├── statements: ∅
+        │   │   │   │   │   │   └── closing_loc: (43...44) = "}"
+        │   │   │   │   │   └── @ StringNode (location: (44...45))
+        │   │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │   │       ├── content_loc: (44...45) = "\n"
+        │   │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │   │       └── unescaped: "\n"
+        │   │   │   │   └── closing_loc: (45...53) = "HEREDOC\n"
+        │   │   │   └── operator_loc: (8...10) = "=>"
+        │   │   └── @ AssocNode (location: (23...36))
+        │   │       ├── key:
+        │   │       │   @ StringNode (location: (23...28))
+        │   │       │   ├── opening_loc: (23...24) = "\""
+        │   │       │   ├── content_loc: (24...27) = "bar"
+        │   │       │   ├── closing_loc: (27...28) = "\""
+        │   │       │   └── unescaped: "bar"
+        │   │       ├── value:
+        │   │       │   @ SymbolNode (location: (32...36))
+        │   │       │   ├── opening_loc: (32...33) = ":"
+        │   │       │   ├── value_loc: (33...36) = "baz"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "baz"
+        │   │       └── operator_loc: (29...31) = "=>"
+        │   └── closing_loc: (37...38) = "}"
+        ├── @ HashNode (location: (53...84))
+        │   ├── opening_loc: (53...54) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (55...67))
+        │   │   │   ├── key:
+        │   │   │   │   @ StringNode (location: (55...60))
+        │   │   │   │   ├── opening_loc: (55...56) = "\""
+        │   │   │   │   ├── content_loc: (56...59) = "foo"
+        │   │   │   │   ├── closing_loc: (59...60) = "\""
+        │   │   │   │   └── unescaped: "foo"
+        │   │   │   ├── value:
+        │   │   │   │   @ StringNode (location: (64...67))
+        │   │   │   │   ├── opening_loc: (64...66) = "%("
+        │   │   │   │   ├── content_loc: (66...66) = ""
+        │   │   │   │   ├── closing_loc: (66...67) = ")"
+        │   │   │   │   └── unescaped: ""
+        │   │   │   └── operator_loc: (61...63) = "=>"
+        │   │   └── @ AssocNode (location: (69...82))
+        │   │       ├── key:
+        │   │       │   @ StringNode (location: (69...74))
+        │   │       │   ├── opening_loc: (69...70) = "\""
+        │   │       │   ├── content_loc: (70...73) = "bar"
+        │   │       │   ├── closing_loc: (73...74) = "\""
+        │   │       │   └── unescaped: "bar"
+        │   │       ├── value:
+        │   │       │   @ SymbolNode (location: (78...82))
+        │   │       │   ├── opening_loc: (78...79) = ":"
+        │   │       │   ├── value_loc: (79...82) = "baz"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "baz"
+        │   │       └── operator_loc: (75...77) = "=>"
+        │   └── closing_loc: (83...84) = "}"
+        ├── @ ArrayNode (location: (85...97))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ StringNode (location: (86...91))
+        │   │   │   ├── opening_loc: (86...87) = "\""
+        │   │   │   ├── content_loc: (87...90) = "foo"
+        │   │   │   ├── closing_loc: (90...91) = "\""
+        │   │   │   └── unescaped: "foo"
+        │   │   └── @ StringNode (location: (93...96))
+        │   │       ├── opening_loc: (93...95) = "%("
+        │   │       ├── content_loc: (95...95) = ""
+        │   │       ├── closing_loc: (95...96) = ")"
+        │   │       └── unescaped: ""
+        │   ├── opening_loc: (85...86) = "["
+        │   └── closing_loc: (96...97) = "]"
+        ├── @ CallNode (location: (98...113))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (98...111))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (98...99) = "a"
+        │   │   ├── opening_loc: (99...100) = "("
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (100...110))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ InterpolatedStringNode (location: (100...110))
+        │   │   │           ├── opening_loc: (100...110) = "<<-HEREDOC"
+        │   │   │           ├── parts: (length: 3)
+        │   │   │           │   ├── @ StringNode (location: (114...116))
+        │   │   │           │   │   ├── opening_loc: ∅
+        │   │   │           │   │   ├── content_loc: (114...116) = "  "
+        │   │   │           │   │   ├── closing_loc: ∅
+        │   │   │           │   │   └── unescaped: "  "
+        │   │   │           │   ├── @ EmbeddedStatementsNode (location: (116...119))
+        │   │   │           │   │   ├── opening_loc: (116...118) = "\#{"
+        │   │   │           │   │   ├── statements: ∅
+        │   │   │           │   │   └── closing_loc: (118...119) = "}"
+        │   │   │           │   └── @ StringNode (location: (119...120))
+        │   │   │           │       ├── opening_loc: ∅
+        │   │   │           │       ├── content_loc: (119...120) = "\n"
+        │   │   │           │       ├── closing_loc: ∅
+        │   │   │           │       └── unescaped: "\n"
+        │   │   │           └── closing_loc: (120...128) = "HEREDOC\n"
+        │   │   ├── closing_loc: (110...111) = ")"
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (111...112) = "."
+        │   ├── message_loc: (112...113) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (128...136))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (128...134))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (128...129) = "a"
+        │   │   ├── opening_loc: (129...130) = "("
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (130...133))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ StringNode (location: (130...133))
+        │   │   │           ├── opening_loc: (130...132) = "%("
+        │   │   │           ├── content_loc: (132...132) = ""
+        │   │   │           ├── closing_loc: (132...133) = ")"
+        │   │   │           └── unescaped: ""
+        │   │   ├── closing_loc: (133...134) = ")"
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (134...135) = "."
+        │   ├── message_loc: (135...136) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ HashNode (location: (137...167))
+        │   ├── opening_loc: (137...138) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (139...158))
+        │   │   │   ├── key:
+        │   │   │   │   @ StringNode (location: (139...144))
+        │   │   │   │   ├── opening_loc: (139...140) = "\""
+        │   │   │   │   ├── content_loc: (140...143) = "foo"
+        │   │   │   │   ├── closing_loc: (143...144) = "\""
+        │   │   │   │   └── unescaped: "foo"
+        │   │   │   ├── value:
+        │   │   │   │   @ InterpolatedStringNode (location: (148...158))
+        │   │   │   │   ├── opening_loc: (148...158) = "<<-HEREDOC"
+        │   │   │   │   ├── parts: (length: 3)
+        │   │   │   │   │   ├── @ StringNode (location: (168...170))
+        │   │   │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   │   │   ├── content_loc: (168...170) = "  "
+        │   │   │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   │   │   └── unescaped: "  "
+        │   │   │   │   │   ├── @ EmbeddedStatementsNode (location: (170...173))
+        │   │   │   │   │   │   ├── opening_loc: (170...172) = "\#{"
+        │   │   │   │   │   │   ├── statements: ∅
+        │   │   │   │   │   │   └── closing_loc: (172...173) = "}"
+        │   │   │   │   │   └── @ StringNode (location: (173...174))
+        │   │   │   │   │       ├── opening_loc: ∅
+        │   │   │   │   │       ├── content_loc: (173...174) = "\n"
+        │   │   │   │   │       ├── closing_loc: ∅
+        │   │   │   │   │       └── unescaped: "\n"
+        │   │   │   │   └── closing_loc: (174...182) = "HEREDOC\n"
+        │   │   │   └── operator_loc: (145...147) = "=>"
+        │   │   └── @ AssocSplatNode (location: (160...165))
+        │   │       ├── value:
+        │   │       │   @ CallNode (location: (162...165))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (162...165) = "baz"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "baz"
+        │   │       └── operator_loc: (160...162) = "**"
+        │   └── closing_loc: (166...167) = "}"
+        ├── @ HashNode (location: (182...205))
+        │   ├── opening_loc: (182...183) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (184...196))
+        │   │   │   ├── key:
+        │   │   │   │   @ StringNode (location: (184...189))
+        │   │   │   │   ├── opening_loc: (184...185) = "\""
+        │   │   │   │   ├── content_loc: (185...188) = "foo"
+        │   │   │   │   ├── closing_loc: (188...189) = "\""
+        │   │   │   │   └── unescaped: "foo"
+        │   │   │   ├── value:
+        │   │   │   │   @ StringNode (location: (193...196))
+        │   │   │   │   ├── opening_loc: (193...195) = "%("
+        │   │   │   │   ├── content_loc: (195...195) = ""
+        │   │   │   │   ├── closing_loc: (195...196) = ")"
+        │   │   │   │   └── unescaped: ""
+        │   │   │   └── operator_loc: (190...192) = "=>"
+        │   │   └── @ AssocSplatNode (location: (198...203))
+        │   │       ├── value:
+        │   │       │   @ CallNode (location: (200...203))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (200...203) = "baz"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "baz"
+        │   │       └── operator_loc: (198...200) = "**"
+        │   └── closing_loc: (204...205) = "}"
+        ├── @ InterpolatedStringNode (location: (206...220))
+        │   ├── opening_loc: (206...207) = "\""
+        │   ├── parts: (length: 5)
+        │   │   ├── @ EmbeddedVariableNode (location: (207...210))
+        │   │   │   ├── operator_loc: (207...208) = "#"
+        │   │   │   └── variable:
+        │   │   │       @ InstanceVariableReadNode (location: (208...210))
+        │   │   │       └── name: :@a
+        │   │   ├── @ StringNode (location: (210...211))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (210...211) = " "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: " "
+        │   │   ├── @ EmbeddedVariableNode (location: (211...215))
+        │   │   │   ├── operator_loc: (211...212) = "#"
+        │   │   │   └── variable:
+        │   │   │       @ ClassVariableReadNode (location: (212...215))
+        │   │   │       └── name: :@@a
+        │   │   ├── @ StringNode (location: (215...216))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (215...216) = " "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: " "
+        │   │   └── @ EmbeddedVariableNode (location: (216...219))
+        │   │       ├── operator_loc: (216...217) = "#"
+        │   │       └── variable:
+        │   │           @ GlobalVariableReadNode (location: (217...219))
+        │   │           └── name: :$a
+        │   └── closing_loc: (219...220) = "\""
+        ├── @ IntegerNode (location: (221...222))
+        ├── @ CallNode (location: (223...226))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (224...226))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (223...224) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+@"
+        ├── @ IntegerNode (location: (227...228))
+        ├── @ IntegerNode (location: (229...230))
+        ├── @ RationalNode (location: (231...233))
+        │   └── numeric:
+        │       @ IntegerNode (location: (231...232))
+        ├── @ RationalNode (location: (234...238))
+        │   └── numeric:
+        │       @ FloatNode (location: (234...237))
+        ├── @ RationalNode (location: (239...243))
+        │   └── numeric:
+        │       @ FloatNode (location: (239...242))
+        ├── @ ImaginaryNode (location: (244...246))
+        │   └── numeric:
+        │       @ IntegerNode (location: (244...245))
+        ├── @ ImaginaryNode (location: (247...250))
+        │   └── numeric:
+        │       @ IntegerNode (location: (247...249))
+        ├── @ ImaginaryNode (location: (251...255))
+        │   └── numeric:
+        │       @ FloatNode (location: (251...254))
+        ├── @ ImaginaryNode (location: (256...261))
+        │   └── numeric:
+        │       @ FloatNode (location: (256...260))
+        ├── @ ImaginaryNode (location: (262...294))
+        │   └── numeric:
+        │       @ IntegerNode (location: (262...293))
+        ├── @ ImaginaryNode (location: (295...298))
+        │   └── numeric:
+        │       @ RationalNode (location: (295...297))
+        │       └── numeric:
+        │           @ IntegerNode (location: (295...296))
+        ├── @ StringConcatNode (location: (299...310))
+        │   ├── left:
+        │   │   @ StringNode (location: (299...304))
+        │   │   ├── opening_loc: (299...300) = "\""
+        │   │   ├── content_loc: (300...303) = "foo"
+        │   │   ├── closing_loc: (303...304) = "\""
+        │   │   └── unescaped: "foo"
+        │   └── right:
+        │       @ StringNode (location: (305...310))
+        │       ├── opening_loc: (305...306) = "\""
+        │       ├── content_loc: (306...309) = "bar"
+        │       ├── closing_loc: (309...310) = "\""
+        │       └── unescaped: "bar"
+        ├── @ InterpolatedStringNode (location: (311...326))
+        │   ├── opening_loc: (311...312) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (312...319))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (312...319) = "foobar "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foobar "
+        │   │   └── @ EmbeddedStatementsNode (location: (319...325))
+        │   │       ├── opening_loc: (319...321) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (321...324))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ CallNode (location: (321...324))
+        │   │       │           ├── receiver: ∅
+        │   │       │           ├── call_operator_loc: ∅
+        │   │       │           ├── message_loc: (321...324) = "baz"
+        │   │       │           ├── opening_loc: ∅
+        │   │       │           ├── arguments: ∅
+        │   │       │           ├── closing_loc: ∅
+        │   │       │           ├── block: ∅
+        │   │       │           ├── flags: variable_call
+        │   │       │           └── name: "baz"
+        │   │       └── closing_loc: (324...325) = "}"
+        │   └── closing_loc: (325...326) = "\""
+        ├── @ InterpolatedStringNode (location: (327...339))
+        │   ├── opening_loc: (327...328) = "\""
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (328...331))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (328...331) = "foo"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── @ EmbeddedStatementsNode (location: (331...335))
+        │   │   │   ├── opening_loc: (331...333) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (333...334))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ IntegerNode (location: (333...334))
+        │   │   │   └── closing_loc: (334...335) = "}"
+        │   │   └── @ StringNode (location: (335...338))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (335...338) = "bar"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "bar"
+        │   └── closing_loc: (338...339) = "\""
+        ├── @ InterpolatedStringNode (location: (340...349))
+        │   ├── opening_loc: (340...341) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (341...345))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (341...345) = "\\\\\\\\"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "\\\\"
+        │   │   └── @ EmbeddedStatementsNode (location: (345...348))
+        │   │       ├── opening_loc: (345...347) = "\#{"
+        │   │       ├── statements: ∅
+        │   │       └── closing_loc: (347...348) = "}"
+        │   └── closing_loc: (348...349) = "\""
+        ├── @ InterpolatedStringNode (location: (350...359))
+        │   ├── opening_loc: (350...351) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ EmbeddedStatementsNode (location: (351...354))
+        │   │   │   ├── opening_loc: (351...353) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (353...354) = "}"
+        │   │   └── @ StringNode (location: (354...358))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (354...358) = "\\\#{}"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#{}"
+        │   └── closing_loc: (358...359) = "\""
+        ├── @ InterpolatedStringNode (location: (360...369))
+        │   ├── opening_loc: (360...361) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (361...365))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (361...365) = "\\\#{}"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "\#{}"
+        │   │   └── @ EmbeddedStatementsNode (location: (365...368))
+        │   │       ├── opening_loc: (365...367) = "\#{"
+        │   │       ├── statements: ∅
+        │   │       └── closing_loc: (367...368) = "}"
+        │   └── closing_loc: (368...369) = "\""
+        ├── @ StringNode (location: (370...385))
+        │   ├── opening_loc: (370...371) = "\""
+        │   ├── content_loc: (371...384) = "foo\\\\\\\#{@bar}"
+        │   ├── closing_loc: (384...385) = "\""
+        │   └── unescaped: "foo\\\#{@bar}"
+        ├── @ StringNode (location: (386...390))
+        │   ├── opening_loc: (386...387) = "\""
+        │   ├── content_loc: (387...389) = "\\\""
+        │   ├── closing_loc: (389...390) = "\""
+        │   └── unescaped: "\""
+        ├── @ StringNode (location: (391...400))
+        │   ├── opening_loc: (391...392) = "\""
+        │   ├── content_loc: (392...399) = "foo bar"
+        │   ├── closing_loc: (399...400) = "\""
+        │   └── unescaped: "foo bar"
+        ├── @ StringNode (location: (401...411))
+        │   ├── opening_loc: (401...402) = "\""
+        │   ├── content_loc: (402...410) = "foo\\nbar"
+        │   ├── closing_loc: (410...411) = "\""
+        │   └── unescaped: "foo\nbar"
+        ├── @ XStringNode (location: (412...417))
+        │   ├── opening_loc: (412...413) = "`"
+        │   ├── content_loc: (413...416) = "foo"
+        │   ├── closing_loc: (416...417) = "`"
+        │   └── unescaped: "foo"
+        ├── @ InterpolatedXStringNode (location: (418...430))
+        │   ├── opening_loc: (418...419) = "`"
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (419...422))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (419...422) = "foo"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo"
+        │   │   └── @ EmbeddedStatementsNode (location: (422...429))
+        │   │       ├── opening_loc: (422...424) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (424...428))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ InstanceVariableReadNode (location: (424...428))
+        │   │       │           └── name: :@bar
+        │   │       └── closing_loc: (428...429) = "}"
+        │   └── closing_loc: (429...430) = "`"
+        ├── @ XStringNode (location: (431...434))
+        │   ├── opening_loc: (431...432) = "`"
+        │   ├── content_loc: (432...433) = ")"
+        │   ├── closing_loc: (433...434) = "`"
+        │   └── unescaped: ")"
+        ├── @ XStringNode (location: (435...439))
+        │   ├── opening_loc: (435...436) = "`"
+        │   ├── content_loc: (436...438) = "\\`"
+        │   ├── closing_loc: (438...439) = "`"
+        │   └── unescaped: "`"
+        ├── @ XStringNode (location: (440...443))
+        │   ├── opening_loc: (440...441) = "`"
+        │   ├── content_loc: (441...442) = "\""
+        │   ├── closing_loc: (442...443) = "`"
+        │   └── unescaped: "\""
+        ├── @ SymbolNode (location: (444...448))
+        │   ├── opening_loc: (444...445) = ":"
+        │   ├── value_loc: (445...448) = "foo"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "foo"
+        ├── @ SymbolNode (location: (449...455))
+        │   ├── opening_loc: (449...451) = ":\""
+        │   ├── value_loc: (451...454) = "A B"
+        │   ├── closing_loc: (454...455) = "\""
+        │   └── unescaped: "A B"
+        ├── @ SymbolNode (location: (456...460))
+        │   ├── opening_loc: (456...457) = ":"
+        │   ├── value_loc: (457...460) = "foo"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "foo"
+        ├── @ SymbolNode (location: (461...467))
+        │   ├── opening_loc: (461...463) = ":\""
+        │   ├── value_loc: (463...466) = "A B"
+        │   ├── closing_loc: (466...467) = "\""
+        │   └── unescaped: "A B"
+        ├── @ SymbolNode (location: (468...475))
+        │   ├── opening_loc: (468...470) = ":\""
+        │   ├── value_loc: (470...474) = "A\\\"B"
+        │   ├── closing_loc: (474...475) = "\""
+        │   └── unescaped: "A\"B"
+        ├── @ SymbolNode (location: (476...479))
+        │   ├── opening_loc: (476...478) = ":\""
+        │   ├── value_loc: (0...0) = ""
+        │   ├── closing_loc: (478...479) = "\""
+        │   └── unescaped: ""
+        ├── @ RegularExpressionNode (location: (480...485))
+        │   ├── opening_loc: (480...481) = "/"
+        │   ├── content_loc: (481...484) = "foo"
+        │   ├── closing_loc: (484...485) = "/"
+        │   ├── unescaped: "foo"
+        │   └── flags: 
+        ├── @ RegularExpressionNode (location: (486...514))
+        │   ├── opening_loc: (486...487) = "/"
+        │   ├── content_loc: (487...513) = "[^-+',.\\/:@[:alnum:]\\[\\]]+"
+        │   ├── closing_loc: (513...514) = "/"
+        │   ├── unescaped: "[^-+',./:@[:alnum:][]]+"
+        │   └── flags: 
+        ├── @ InterpolatedRegularExpressionNode (location: (515...527))
+        │   ├── opening_loc: (515...516) = "/"
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (516...519))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (516...519) = "foo"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo"
+        │   │   └── @ EmbeddedStatementsNode (location: (519...526))
+        │   │       ├── opening_loc: (519...521) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (521...525))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ InstanceVariableReadNode (location: (521...525))
+        │   │       │           └── name: :@bar
+        │   │       └── closing_loc: (525...526) = "}"
+        │   ├── closing_loc: (526...527) = "/"
+        │   └── flags: 
+        ├── @ InterpolatedRegularExpressionNode (location: (528...543))
+        │   ├── opening_loc: (528...529) = "/"
+        │   ├── parts: (length: 2)
+        │   │   ├── @ StringNode (location: (529...532))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (529...532) = "foo"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo"
+        │   │   └── @ EmbeddedStatementsNode (location: (532...539))
+        │   │       ├── opening_loc: (532...534) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (534...538))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ InstanceVariableReadNode (location: (534...538))
+        │   │       │           └── name: :@bar
+        │   │       └── closing_loc: (538...539) = "}"
+        │   ├── closing_loc: (539...543) = "/imx"
+        │   └── flags: ignore_case, extended, multi_line
+        ├── @ InterpolatedRegularExpressionNode (location: (544...557))
+        │   ├── opening_loc: (544...545) = "/"
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedStatementsNode (location: (545...556))
+        │   │       ├── opening_loc: (545...547) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (547...555))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ StringNode (location: (547...555))
+        │   │       │           ├── opening_loc: (547...548) = "\""
+        │   │       │           ├── content_loc: (548...554) = "\\u0000"
+        │   │       │           ├── closing_loc: (554...555) = "\""
+        │   │       │           └── unescaped: "\u0000"
+        │   │       └── closing_loc: (555...556) = "}"
+        │   ├── closing_loc: (556...557) = "/"
+        │   └── flags: 
+        ├── @ RegularExpressionNode (location: (558...562))
+        │   ├── opening_loc: (558...559) = "/"
+        │   ├── content_loc: (559...561) = "\\n"
+        │   ├── closing_loc: (561...562) = "/"
+        │   ├── unescaped: "\n"
+        │   └── flags: 
+        ├── @ RegularExpressionNode (location: (563...567))
+        │   ├── opening_loc: (563...564) = "/"
+        │   ├── content_loc: (564...566) = "\\n"
+        │   ├── closing_loc: (566...567) = "/"
+        │   ├── unescaped: "\n"
+        │   └── flags: 
+        ├── @ RegularExpressionNode (location: (568...573))
+        │   ├── opening_loc: (568...569) = "/"
+        │   ├── content_loc: (569...571) = "\\n"
+        │   ├── closing_loc: (571...573) = "/x"
+        │   ├── unescaped: "\n"
+        │   └── flags: extended
+        ├── @ RegularExpressionNode (location: (574...581))
+        │   ├── opening_loc: (574...575) = "/"
+        │   ├── content_loc: (575...579) = "\\/\\/"
+        │   ├── closing_loc: (579...581) = "/x"
+        │   ├── unescaped: "//"
+        │   └── flags: extended
+        ├── @ InterpolatedSymbolNode (location: (582...597))
+        │   ├── opening_loc: (582...584) = ":\""
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (584...587))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (584...587) = "foo"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo"
+        │   │   ├── @ EmbeddedStatementsNode (location: (587...593))
+        │   │   │   ├── opening_loc: (587...589) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (589...592))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (589...592))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (589...592) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   └── closing_loc: (592...593) = "}"
+        │   │   └── @ StringNode (location: (593...596))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (593...596) = "baz"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "baz"
+        │   └── closing_loc: (596...597) = "\""
+        ├── @ InterpolatedSymbolNode (location: (598...609))
+        │   ├── opening_loc: (598...600) = ":\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedStatementsNode (location: (600...608))
+        │   │       ├── opening_loc: (600...602) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (602...607))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ StringNode (location: (602...607))
+        │   │       │           ├── opening_loc: (602...603) = "\""
+        │   │       │           ├── content_loc: (603...606) = "foo"
+        │   │       │           ├── closing_loc: (606...607) = "\""
+        │   │       │           └── unescaped: "foo"
+        │   │       └── closing_loc: (607...608) = "}"
+        │   └── closing_loc: (608...609) = "\""
+        ├── @ RangeNode (location: (610...624))
+        │   ├── left:
+        │   │   @ ParenthesesNode (location: (610...621))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (611...620))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (611...620))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ FloatNode (location: (611...614))
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (615...616) = "/"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (617...620))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ FloatNode (location: (617...620))
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "/"
+        │   │   ├── opening_loc: (610...611) = "("
+        │   │   └── closing_loc: (620...621) = ")"
+        │   ├── right:
+        │   │   @ IntegerNode (location: (623...624))
+        │   ├── operator_loc: (621...623) = ".."
+        │   └── flags: 
+        ├── @ RangeNode (location: (625...639))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (625...626))
+        │   ├── right:
+        │   │   @ ParenthesesNode (location: (628...639))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (629...638))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (629...638))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ FloatNode (location: (629...632))
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (633...634) = "/"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (635...638))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ FloatNode (location: (635...638))
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "/"
+        │   │   ├── opening_loc: (628...629) = "("
+        │   │   └── closing_loc: (638...639) = ")"
+        │   ├── operator_loc: (626...628) = ".."
+        │   └── flags: 
+        ├── @ RangeNode (location: (640...656))
+        │   ├── left:
+        │   │   @ ParenthesesNode (location: (640...651))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (641...650))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (641...650))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ FloatNode (location: (641...644))
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (645...646) = "/"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (647...650))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ FloatNode (location: (647...650))
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "/"
+        │   │   ├── opening_loc: (640...641) = "("
+        │   │   └── closing_loc: (650...651) = ")"
+        │   ├── right:
+        │   │   @ IntegerNode (location: (653...656))
+        │   ├── operator_loc: (651...653) = ".."
+        │   └── flags: 
+        ├── @ FloatNode (location: (657...661))
+        ├── @ FloatNode (location: (662...665))
+        ├── @ ArrayNode (location: (666...672))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ IntegerNode (location: (667...668))
+        │   │   └── @ IntegerNode (location: (670...671))
+        │   ├── opening_loc: (666...667) = "["
+        │   └── closing_loc: (671...672) = "]"
+        ├── @ ArrayNode (location: (673...684))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ IntegerNode (location: (674...675))
+        │   │   ├── @ ParenthesesNode (location: (677...679))
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (677...678) = "("
+        │   │   │   └── closing_loc: (678...679) = ")"
+        │   │   └── @ CallNode (location: (681...683))
+        │   │       ├── receiver: ∅
+        │   │       ├── call_operator_loc: ∅
+        │   │       ├── message_loc: (681...683) = "n2"
+        │   │       ├── opening_loc: ∅
+        │   │       ├── arguments: ∅
+        │   │       ├── closing_loc: ∅
+        │   │       ├── block: ∅
+        │   │       ├── flags: variable_call
+        │   │       └── name: "n2"
+        │   ├── opening_loc: (673...674) = "["
+        │   └── closing_loc: (683...684) = "]"
+        ├── @ ArrayNode (location: (685...688))
+        │   ├── elements: (length: 1)
+        │   │   └── @ IntegerNode (location: (686...687))
+        │   ├── opening_loc: (685...686) = "["
+        │   └── closing_loc: (687...688) = "]"
+        ├── @ ArrayNode (location: (689...691))
+        │   ├── elements: (length: 0)
+        │   ├── opening_loc: (689...690) = "["
+        │   └── closing_loc: (690...691) = "]"
+        ├── @ ArrayNode (location: (692...702))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ IntegerNode (location: (693...694))
+        │   │   └── @ SplatNode (location: (696...701))
+        │   │       ├── operator_loc: (696...697) = "*"
+        │   │       └── expression:
+        │   │           @ InstanceVariableReadNode (location: (697...701))
+        │   │           └── name: :@foo
+        │   ├── opening_loc: (692...693) = "["
+        │   └── closing_loc: (701...702) = "]"
+        ├── @ ArrayNode (location: (703...713))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ SplatNode (location: (704...709))
+        │   │   │   ├── operator_loc: (704...705) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ InstanceVariableReadNode (location: (705...709))
+        │   │   │       └── name: :@foo
+        │   │   └── @ IntegerNode (location: (711...712))
+        │   ├── opening_loc: (703...704) = "["
+        │   └── closing_loc: (712...713) = "]"
+        ├── @ ArrayNode (location: (714...728))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ SplatNode (location: (715...720))
+        │   │   │   ├── operator_loc: (715...716) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ InstanceVariableReadNode (location: (716...720))
+        │   │   │       └── name: :@foo
+        │   │   └── @ SplatNode (location: (722...727))
+        │   │       ├── operator_loc: (722...723) = "*"
+        │   │       └── expression:
+        │   │           @ InstanceVariableReadNode (location: (723...727))
+        │   │           └── name: :@baz
+        │   ├── opening_loc: (714...715) = "["
+        │   └── closing_loc: (727...728) = "]"
+        ├── @ HashNode (location: (729...731))
+        │   ├── opening_loc: (729...730) = "{"
+        │   ├── elements: (length: 0)
+        │   └── closing_loc: (730...731) = "}"
+        ├── @ HashNode (location: (732...744))
+        │   ├── opening_loc: (732...733) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (734...742))
+        │   │       ├── key:
+        │   │       │   @ ParenthesesNode (location: (734...736))
+        │   │       │   ├── body: ∅
+        │   │       │   ├── opening_loc: (734...735) = "("
+        │   │       │   └── closing_loc: (735...736) = ")"
+        │   │       ├── value:
+        │   │       │   @ ParenthesesNode (location: (740...742))
+        │   │       │   ├── body: ∅
+        │   │       │   ├── opening_loc: (740...741) = "("
+        │   │       │   └── closing_loc: (741...742) = ")"
+        │   │       └── operator_loc: (737...739) = "=>"
+        │   └── closing_loc: (743...744) = "}"
+        ├── @ HashNode (location: (745...755))
+        │   ├── opening_loc: (745...746) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (747...753))
+        │   │       ├── key:
+        │   │       │   @ IntegerNode (location: (747...748))
+        │   │       ├── value:
+        │   │       │   @ IntegerNode (location: (752...753))
+        │   │       └── operator_loc: (749...751) = "=>"
+        │   └── closing_loc: (754...755) = "}"
+        ├── @ HashNode (location: (756...774))
+        │   ├── opening_loc: (756...757) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (758...764))
+        │   │   │   ├── key:
+        │   │   │   │   @ IntegerNode (location: (758...759))
+        │   │   │   ├── value:
+        │   │   │   │   @ IntegerNode (location: (763...764))
+        │   │   │   └── operator_loc: (760...762) = "=>"
+        │   │   └── @ AssocNode (location: (766...772))
+        │   │       ├── key:
+        │   │       │   @ IntegerNode (location: (766...767))
+        │   │       ├── value:
+        │   │       │   @ IntegerNode (location: (771...772))
+        │   │       └── operator_loc: (768...770) = "=>"
+        │   └── closing_loc: (773...774) = "}"
+        ├── @ HashNode (location: (775...802))
+        │   ├── opening_loc: (775...776) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (777...794))
+        │   │   │   ├── key:
+        │   │   │   │   @ SymbolNode (location: (777...779))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── value_loc: (777...778) = "a"
+        │   │   │   │   ├── closing_loc: (778...779) = ":"
+        │   │   │   │   └── unescaped: "a"
+        │   │   │   ├── value:
+        │   │   │   │   @ ParenthesesNode (location: (780...794))
+        │   │   │   │   ├── body:
+        │   │   │   │   │   @ StatementsNode (location: (781...793))
+        │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │       └── @ RescueModifierNode (location: (781...793))
+        │   │   │   │   │           ├── expression:
+        │   │   │   │   │           │   @ IntegerNode (location: (781...782))
+        │   │   │   │   │           ├── keyword_loc: (783...789) = "rescue"
+        │   │   │   │   │           └── rescue_expression:
+        │   │   │   │   │               @ CallNode (location: (790...793))
+        │   │   │   │   │               ├── receiver: ∅
+        │   │   │   │   │               ├── call_operator_loc: ∅
+        │   │   │   │   │               ├── message_loc: (790...793) = "foo"
+        │   │   │   │   │               ├── opening_loc: ∅
+        │   │   │   │   │               ├── arguments: ∅
+        │   │   │   │   │               ├── closing_loc: ∅
+        │   │   │   │   │               ├── block: ∅
+        │   │   │   │   │               ├── flags: variable_call
+        │   │   │   │   │               └── name: "foo"
+        │   │   │   │   ├── opening_loc: (780...781) = "("
+        │   │   │   │   └── closing_loc: (793...794) = ")"
+        │   │   │   └── operator_loc: ∅
+        │   │   └── @ AssocNode (location: (796...800))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (796...798))
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── value_loc: (796...797) = "b"
+        │   │       │   ├── closing_loc: (797...798) = ":"
+        │   │       │   └── unescaped: "b"
+        │   │       ├── value:
+        │   │       │   @ IntegerNode (location: (799...800))
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (801...802) = "}"
+        ├── @ HashNode (location: (803...817))
+        │   ├── opening_loc: (803...804) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (805...809))
+        │   │   │   ├── key:
+        │   │   │   │   @ SymbolNode (location: (805...807))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── value_loc: (805...806) = "a"
+        │   │   │   │   ├── closing_loc: (806...807) = ":"
+        │   │   │   │   └── unescaped: "a"
+        │   │   │   ├── value:
+        │   │   │   │   @ IntegerNode (location: (808...809))
+        │   │   │   └── operator_loc: ∅
+        │   │   └── @ AssocNode (location: (811...815))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (811...813))
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── value_loc: (811...812) = "b"
+        │   │       │   ├── closing_loc: (812...813) = ":"
+        │   │       │   └── unescaped: "b"
+        │   │       ├── value:
+        │   │       │   @ IntegerNode (location: (814...815))
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (816...817) = "}"
+        ├── @ HashNode (location: (818...827))
+        │   ├── opening_loc: (818...819) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (820...825))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (820...822))
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── value_loc: (820...821) = "a"
+        │   │       │   ├── closing_loc: (821...822) = ":"
+        │   │       │   └── unescaped: "a"
+        │   │       ├── value:
+        │   │       │   @ SymbolNode (location: (823...825))
+        │   │       │   ├── opening_loc: (823...824) = ":"
+        │   │       │   ├── value_loc: (824...825) = "a"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "a"
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (826...827) = "}"
+        ├── @ HashNode (location: (828...843))
+        │   ├── opening_loc: (828...829) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (830...841))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (830...836))
+        │   │       │   ├── opening_loc: (830...832) = ":\""
+        │   │       │   ├── value_loc: (832...835) = "a b"
+        │   │       │   ├── closing_loc: (835...836) = "\""
+        │   │       │   └── unescaped: "a b"
+        │   │       ├── value:
+        │   │       │   @ IntegerNode (location: (840...841))
+        │   │       └── operator_loc: (837...839) = "=>"
+        │   └── closing_loc: (842...843) = "}"
+        ├── @ HashNode (location: (844...856))
+        │   ├── opening_loc: (844...845) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (846...854))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (846...849))
+        │   │       │   ├── opening_loc: (846...847) = ":"
+        │   │       │   ├── value_loc: (847...849) = "-@"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "-@"
+        │   │       ├── value:
+        │   │       │   @ IntegerNode (location: (853...854))
+        │   │       └── operator_loc: (850...852) = "=>"
+        │   └── closing_loc: (855...856) = "}"
+        ├── @ InterpolatedStringNode (location: (857...869))
+        │   ├── opening_loc: (857...858) = "\""
+        │   ├── parts: (length: 4)
+        │   │   ├── @ EmbeddedStatementsNode (location: (858...861))
+        │   │   │   ├── opening_loc: (858...860) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (860...861) = "}"
+        │   │   ├── @ StringNode (location: (861...862))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (861...862) = "\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (862...865))
+        │   │   │   ├── opening_loc: (862...864) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (864...865) = "}"
+        │   │   └── @ StringNode (location: (865...868))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (865...868) = "\\na"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\na"
+        │   └── closing_loc: (868...869) = "\""
+        ├── @ CallNode (location: (870...892))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (870...873) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (874...892))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (878...890))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ InterpolatedStringNode (location: (878...890))
+        │   │   │           ├── opening_loc: (878...879) = "\""
+        │   │   │           ├── parts: (length: 4)
+        │   │   │           │   ├── @ EmbeddedStatementsNode (location: (879...882))
+        │   │   │           │   │   ├── opening_loc: (879...881) = "\#{"
+        │   │   │           │   │   ├── statements: ∅
+        │   │   │           │   │   └── closing_loc: (881...882) = "}"
+        │   │   │           │   ├── @ StringNode (location: (882...883))
+        │   │   │           │   │   ├── opening_loc: ∅
+        │   │   │           │   │   ├── content_loc: (882...883) = "\n"
+        │   │   │           │   │   ├── closing_loc: ∅
+        │   │   │           │   │   └── unescaped: "\n"
+        │   │   │           │   ├── @ EmbeddedStatementsNode (location: (883...886))
+        │   │   │           │   │   ├── opening_loc: (883...885) = "\#{"
+        │   │   │           │   │   ├── statements: ∅
+        │   │   │           │   │   └── closing_loc: (885...886) = "}"
+        │   │   │           │   └── @ StringNode (location: (886...889))
+        │   │   │           │       ├── opening_loc: ∅
+        │   │   │           │       ├── content_loc: (886...889) = "\\na"
+        │   │   │           │       ├── closing_loc: ∅
+        │   │   │           │       └── unescaped: "\na"
+        │   │   │           └── closing_loc: (889...890) = "\""
+        │   │   ├── opening_loc: (874...875) = "{"
+        │   │   └── closing_loc: (891...892) = "}"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ SymbolNode (location: (893...901))
+        │   ├── opening_loc: (893...895) = ":\""
+        │   ├── value_loc: (895...900) = "a\\\\\nb"
+        │   ├── closing_loc: (900...901) = "\""
+        │   └── unescaped: "a\\\nb"
+        └── @ InterpolatedXStringNode (location: (902...916))
+            ├── opening_loc: (902...903) = "`"
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (903...907))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (903...907) = "  x\n"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "  x\n"
+            │   ├── @ EmbeddedStatementsNode (location: (907...913))
+            │   │   ├── opening_loc: (907...909) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (909...912))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (909...912))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (909...912) = "foo"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "foo"
+            │   │   └── closing_loc: (912...913) = "}"
+            │   └── @ StringNode (location: (913...915))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (913...915) = "\n#"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\n#"
+            └── closing_loc: (915...916) = "`"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/module.txt b/test/yarp/snapshots/unparser/corpus/literal/module.txt
index 355b57ac53..2ba439b4a8 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/module.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/module.txt
@@ -1,89 +1,105 @@
-ProgramNode(0...106)(
-  [],
-  StatementsNode(0...106)(
-    [ModuleNode(0...12)(
-       [],
-       (0...6),
-       ConstantReadNode(7...8)(:A),
-       nil,
-       (9...12),
-       :A
-     ),
-     ModuleNode(14...29)(
-       [],
-       (14...20),
-       ConstantPathNode(21...25)(
-         ConstantReadNode(21...22)(:A),
-         ConstantReadNode(24...25)(:B),
-         (22...24)
-       ),
-       nil,
-       (26...29),
-       :B
-     ),
-     ModuleNode(31...49)(
-       [],
-       (31...37),
-       ConstantPathNode(38...45)(
-         ConstantPathNode(38...42)(
-           ConstantReadNode(38...39)(:A),
-           ConstantReadNode(41...42)(:B),
-           (39...41)
-         ),
-         ConstantReadNode(44...45)(:C),
-         (42...44)
-       ),
-       nil,
-       (46...49),
-       :C
-     ),
-     ModuleNode(51...106)(
-       [],
-       (51...57),
-       ConstantReadNode(58...59)(:A),
-       StatementsNode(62...102)(
-         [CallNode(62...76)(
-            nil,
-            nil,
-            (62...69),
-            (69...70),
-            ArgumentsNode(70...75)(
-              [CallNode(70...75)(
-                 ConstantReadNode(70...71)(:B),
-                 (71...72),
-                 (72...75),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 0,
-                 "new"
-               )]
-            ),
-            (75...76),
-            nil,
-            0,
-            "include"
-          ),
-          DefNode(80...102)(
-            :foo,
-            (84...87),
-            nil,
-            nil,
-            StatementsNode(92...96)(
-              [SymbolNode(92...96)((92...93), (93...96), nil, "bar")]
-            ),
-            [],
-            (80...83),
-            nil,
-            nil,
-            nil,
-            nil,
-            (99...102)
-          )]
-       ),
-       (103...106),
-       :A
-     )]
-  )
-)
+@ ProgramNode (location: (0...106))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...106))
+    └── body: (length: 4)
+        ├── @ ModuleNode (location: (0...12))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (0...6) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (7...8))
+        │   │   └── name: :A
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (9...12) = "end"
+        │   └── name: :A
+        ├── @ ModuleNode (location: (14...29))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (14...20) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (21...25))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (21...22))
+        │   │   │   └── name: :A
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (24...25))
+        │   │   │   └── name: :B
+        │   │   └── delimiter_loc: (22...24) = "::"
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (26...29) = "end"
+        │   └── name: :B
+        ├── @ ModuleNode (location: (31...49))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (31...37) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (38...45))
+        │   │   ├── parent:
+        │   │   │   @ ConstantPathNode (location: (38...42))
+        │   │   │   ├── parent:
+        │   │   │   │   @ ConstantReadNode (location: (38...39))
+        │   │   │   │   └── name: :A
+        │   │   │   ├── child:
+        │   │   │   │   @ ConstantReadNode (location: (41...42))
+        │   │   │   │   └── name: :B
+        │   │   │   └── delimiter_loc: (39...41) = "::"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (44...45))
+        │   │   │   └── name: :C
+        │   │   └── delimiter_loc: (42...44) = "::"
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (46...49) = "end"
+        │   └── name: :C
+        └── @ ModuleNode (location: (51...106))
+            ├── locals: []
+            ├── module_keyword_loc: (51...57) = "module"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (58...59))
+            │   └── name: :A
+            ├── body:
+            │   @ StatementsNode (location: (62...102))
+            │   └── body: (length: 2)
+            │       ├── @ CallNode (location: (62...76))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (62...69) = "include"
+            │       │   ├── opening_loc: (69...70) = "("
+            │       │   ├── arguments:
+            │       │   │   @ ArgumentsNode (location: (70...75))
+            │       │   │   └── arguments: (length: 1)
+            │       │   │       └── @ CallNode (location: (70...75))
+            │       │   │           ├── receiver:
+            │       │   │           │   @ ConstantReadNode (location: (70...71))
+            │       │   │           │   └── name: :B
+            │       │   │           ├── call_operator_loc: (71...72) = "."
+            │       │   │           ├── message_loc: (72...75) = "new"
+            │       │   │           ├── opening_loc: ∅
+            │       │   │           ├── arguments: ∅
+            │       │   │           ├── closing_loc: ∅
+            │       │   │           ├── block: ∅
+            │       │   │           ├── flags: 
+            │       │   │           └── name: "new"
+            │       │   ├── closing_loc: (75...76) = ")"
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "include"
+            │       └── @ DefNode (location: (80...102))
+            │           ├── name: :foo
+            │           ├── name_loc: (84...87) = "foo"
+            │           ├── receiver: ∅
+            │           ├── parameters: ∅
+            │           ├── body:
+            │           │   @ StatementsNode (location: (92...96))
+            │           │   └── body: (length: 1)
+            │           │       └── @ SymbolNode (location: (92...96))
+            │           │           ├── opening_loc: (92...93) = ":"
+            │           │           ├── value_loc: (93...96) = "bar"
+            │           │           ├── closing_loc: ∅
+            │           │           └── unescaped: "bar"
+            │           ├── locals: []
+            │           ├── def_keyword_loc: (80...83) = "def"
+            │           ├── operator_loc: ∅
+            │           ├── lparen_loc: ∅
+            │           ├── rparen_loc: ∅
+            │           ├── equal_loc: ∅
+            │           └── end_keyword_loc: (99...102) = "end"
+            ├── end_keyword_loc: (103...106) = "end"
+            └── name: :A
diff --git a/test/yarp/snapshots/unparser/corpus/literal/opasgn.txt b/test/yarp/snapshots/unparser/corpus/literal/opasgn.txt
index 149bbc8b04..44f8c6827e 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/opasgn.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/opasgn.txt
@@ -1,408 +1,499 @@
-ProgramNode(0...233)(
-  [:a, :h],
-  StatementsNode(0...233)(
-    [LocalVariableOperatorWriteNode(0...6)(
-       (0...1),
-       (2...4),
-       IntegerNode(5...6)(),
-       :a,
-       :+,
-       0
-     ),
-     LocalVariableOperatorWriteNode(7...13)(
-       (7...8),
-       (9...11),
-       IntegerNode(12...13)(),
-       :a,
-       :-,
-       0
-     ),
-     LocalVariableOperatorWriteNode(14...21)(
-       (14...15),
-       (16...19),
-       IntegerNode(20...21)(),
-       :a,
-       :**,
-       0
-     ),
-     LocalVariableOperatorWriteNode(22...28)(
-       (22...23),
-       (24...26),
-       IntegerNode(27...28)(),
-       :a,
-       :*,
-       0
-     ),
-     LocalVariableOperatorWriteNode(29...35)(
-       (29...30),
-       (31...33),
-       IntegerNode(34...35)(),
-       :a,
-       :/,
-       0
-     ),
-     LocalVariableAndWriteNode(36...43)(
-       (36...37),
-       (38...41),
-       CallNode(42...43)(nil, nil, (42...43), nil, nil, nil, nil, 2, "b"),
-       :a,
-       0
-     ),
-     LocalVariableOrWriteNode(44...51)(
-       (44...45),
-       (46...49),
-       IntegerNode(50...51)(),
-       :a,
-       0
-     ),
-     CallNode(52...65)(
-       ParenthesesNode(52...61)(
-         StatementsNode(53...60)(
-           [LocalVariableOrWriteNode(53...60)(
-              (53...54),
-              (55...58),
-              IntegerNode(59...60)(),
-              :a,
-              0
-            )]
-         ),
-         (52...53),
-         (60...61)
-       ),
-       (61...62),
-       (62...65),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(66...83)(
-       ParenthesesNode(66...76)(
-         StatementsNode(67...75)(
-           [LocalVariableOrWriteNode(67...75)(
-              (67...68),
-              (69...72),
-              HashNode(73...75)((73...74), [], (74...75)),
-              :h,
-              0
-            )]
-         ),
-         (66...67),
-         (75...76)
-       ),
-       nil,
-       (76...79),
-       (76...77),
-       ArgumentsNode(77...83)(
-         [CallNode(77...78)(nil, nil, (77...78), nil, nil, nil, nil, 2, "k"),
-          CallNode(82...83)(nil, nil, (82...83), nil, nil, nil, nil, 2, "v")]
-       ),
-       (78...79),
-       nil,
-       0,
-       "[]="
-     ),
-     CallOperatorWriteNode(84...92)(
-       LocalVariableReadNode(84...85)(:a, 0),
-       (85...86),
-       (86...87),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       :+,
-       (88...90),
-       IntegerNode(91...92)()
-     ),
-     CallOperatorWriteNode(93...101)(
-       LocalVariableReadNode(93...94)(:a, 0),
-       (94...95),
-       (95...96),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       :-,
-       (97...99),
-       IntegerNode(100...101)()
-     ),
-     CallOperatorWriteNode(102...111)(
-       LocalVariableReadNode(102...103)(:a, 0),
-       (103...104),
-       (104...105),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       :**,
-       (106...109),
-       IntegerNode(110...111)()
-     ),
-     CallOperatorWriteNode(112...120)(
-       LocalVariableReadNode(112...113)(:a, 0),
-       (113...114),
-       (114...115),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       :*,
-       (116...118),
-       IntegerNode(119...120)()
-     ),
-     CallOperatorWriteNode(121...129)(
-       LocalVariableReadNode(121...122)(:a, 0),
-       (122...123),
-       (123...124),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       :/,
-       (125...127),
-       IntegerNode(128...129)()
-     ),
-     CallAndWriteNode(130...139)(
-       LocalVariableReadNode(130...131)(:a, 0),
-       (131...132),
-       (132...133),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       (134...137),
-       CallNode(138...139)(nil, nil, (138...139), nil, nil, nil, nil, 2, "b")
-     ),
-     CallOrWriteNode(140...149)(
-       LocalVariableReadNode(140...141)(:a, 0),
-       (141...142),
-       (142...143),
-       nil,
-       nil,
-       nil,
-       0,
-       "b",
-       "b=",
-       (144...147),
-       IntegerNode(148...149)()
-     ),
-     CallOperatorWriteNode(150...159)(
-       LocalVariableReadNode(150...151)(:a, 0),
-       nil,
-       (151...154),
-       (151...152),
-       ArgumentsNode(152...153)(
-         [CallNode(152...153)(
-            nil,
-            nil,
-            (152...153),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (153...154),
-       0,
-       "[]",
-       "[]=",
-       :+,
-       (155...157),
-       IntegerNode(158...159)()
-     ),
-     CallOperatorWriteNode(160...169)(
-       LocalVariableReadNode(160...161)(:a, 0),
-       nil,
-       (161...164),
-       (161...162),
-       ArgumentsNode(162...163)(
-         [CallNode(162...163)(
-            nil,
-            nil,
-            (162...163),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (163...164),
-       0,
-       "[]",
-       "[]=",
-       :-,
-       (165...167),
-       IntegerNode(168...169)()
-     ),
-     CallOperatorWriteNode(170...180)(
-       LocalVariableReadNode(170...171)(:a, 0),
-       nil,
-       (171...174),
-       (171...172),
-       ArgumentsNode(172...173)(
-         [CallNode(172...173)(
-            nil,
-            nil,
-            (172...173),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (173...174),
-       0,
-       "[]",
-       "[]=",
-       :**,
-       (175...178),
-       IntegerNode(179...180)()
-     ),
-     CallOperatorWriteNode(181...190)(
-       LocalVariableReadNode(181...182)(:a, 0),
-       nil,
-       (182...185),
-       (182...183),
-       ArgumentsNode(183...184)(
-         [CallNode(183...184)(
-            nil,
-            nil,
-            (183...184),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (184...185),
-       0,
-       "[]",
-       "[]=",
-       :*,
-       (186...188),
-       IntegerNode(189...190)()
-     ),
-     CallOperatorWriteNode(191...200)(
-       LocalVariableReadNode(191...192)(:a, 0),
-       nil,
-       (192...195),
-       (192...193),
-       ArgumentsNode(193...194)(
-         [CallNode(193...194)(
-            nil,
-            nil,
-            (193...194),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (194...195),
-       0,
-       "[]",
-       "[]=",
-       :/,
-       (196...198),
-       IntegerNode(199...200)()
-     ),
-     CallAndWriteNode(201...211)(
-       LocalVariableReadNode(201...202)(:a, 0),
-       nil,
-       (202...205),
-       (202...203),
-       ArgumentsNode(203...204)(
-         [CallNode(203...204)(
-            nil,
-            nil,
-            (203...204),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (204...205),
-       0,
-       "[]",
-       "[]=",
-       (206...209),
-       CallNode(210...211)(nil, nil, (210...211), nil, nil, nil, nil, 2, "b")
-     ),
-     CallOrWriteNode(212...222)(
-       LocalVariableReadNode(212...213)(:a, 0),
-       nil,
-       (213...216),
-       (213...214),
-       ArgumentsNode(214...215)(
-         [CallNode(214...215)(
-            nil,
-            nil,
-            (214...215),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (215...216),
-       0,
-       "[]",
-       "[]=",
-       (217...220),
-       IntegerNode(221...222)()
-     ),
-     CallOperatorWriteNode(223...233)(
-       CallNode(223...226)(
-         nil,
-         nil,
-         (223...226),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (226...227),
-       (227...228),
-       nil,
-       nil,
-       nil,
-       0,
-       "A",
-       "A=",
-       :+,
-       (229...231),
-       IntegerNode(232...233)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...233))
+├── locals: [:a, :h]
+└── statements:
+    @ StatementsNode (location: (0...233))
+    └── body: (length: 24)
+        ├── @ LocalVariableOperatorWriteNode (location: (0...6))
+        │   ├── name_loc: (0...1) = "a"
+        │   ├── operator_loc: (2...4) = "+="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (5...6))
+        │   ├── name: :a
+        │   ├── operator: :+
+        │   └── depth: 0
+        ├── @ LocalVariableOperatorWriteNode (location: (7...13))
+        │   ├── name_loc: (7...8) = "a"
+        │   ├── operator_loc: (9...11) = "-="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (12...13))
+        │   ├── name: :a
+        │   ├── operator: :-
+        │   └── depth: 0
+        ├── @ LocalVariableOperatorWriteNode (location: (14...21))
+        │   ├── name_loc: (14...15) = "a"
+        │   ├── operator_loc: (16...19) = "**="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (20...21))
+        │   ├── name: :a
+        │   ├── operator: :**
+        │   └── depth: 0
+        ├── @ LocalVariableOperatorWriteNode (location: (22...28))
+        │   ├── name_loc: (22...23) = "a"
+        │   ├── operator_loc: (24...26) = "*="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (27...28))
+        │   ├── name: :a
+        │   ├── operator: :*
+        │   └── depth: 0
+        ├── @ LocalVariableOperatorWriteNode (location: (29...35))
+        │   ├── name_loc: (29...30) = "a"
+        │   ├── operator_loc: (31...33) = "/="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (34...35))
+        │   ├── name: :a
+        │   ├── operator: :/
+        │   └── depth: 0
+        ├── @ LocalVariableAndWriteNode (location: (36...43))
+        │   ├── name_loc: (36...37) = "a"
+        │   ├── operator_loc: (38...41) = "&&="
+        │   ├── value:
+        │   │   @ CallNode (location: (42...43))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (42...43) = "b"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "b"
+        │   ├── name: :a
+        │   └── depth: 0
+        ├── @ LocalVariableOrWriteNode (location: (44...51))
+        │   ├── name_loc: (44...45) = "a"
+        │   ├── operator_loc: (46...49) = "||="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (50...51))
+        │   ├── name: :a
+        │   └── depth: 0
+        ├── @ CallNode (location: (52...65))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (52...61))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (53...60))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableOrWriteNode (location: (53...60))
+        │   │   │           ├── name_loc: (53...54) = "a"
+        │   │   │           ├── operator_loc: (55...58) = "||="
+        │   │   │           ├── value:
+        │   │   │           │   @ IntegerNode (location: (59...60))
+        │   │   │           ├── name: :a
+        │   │   │           └── depth: 0
+        │   │   ├── opening_loc: (52...53) = "("
+        │   │   └── closing_loc: (60...61) = ")"
+        │   ├── call_operator_loc: (61...62) = "."
+        │   ├── message_loc: (62...65) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (66...83))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (66...76))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (67...75))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableOrWriteNode (location: (67...75))
+        │   │   │           ├── name_loc: (67...68) = "h"
+        │   │   │           ├── operator_loc: (69...72) = "||="
+        │   │   │           ├── value:
+        │   │   │           │   @ HashNode (location: (73...75))
+        │   │   │           │   ├── opening_loc: (73...74) = "{"
+        │   │   │           │   ├── elements: (length: 0)
+        │   │   │           │   └── closing_loc: (74...75) = "}"
+        │   │   │           ├── name: :h
+        │   │   │           └── depth: 0
+        │   │   ├── opening_loc: (66...67) = "("
+        │   │   └── closing_loc: (75...76) = ")"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (76...79) = "[k]"
+        │   ├── opening_loc: (76...77) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (77...83))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (77...78))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (77...78) = "k"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "k"
+        │   │       └── @ CallNode (location: (82...83))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (82...83) = "v"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "v"
+        │   ├── closing_loc: (78...79) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallOperatorWriteNode (location: (84...92))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (84...85))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (85...86) = "."
+        │   ├── message_loc: (86...87) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "b"
+        │   ├── write_name: "b="
+        │   ├── operator: :+
+        │   ├── operator_loc: (88...90) = "+="
+        │   └── value:
+        │       @ IntegerNode (location: (91...92))
+        ├── @ CallOperatorWriteNode (location: (93...101))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (93...94))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (94...95) = "."
+        │   ├── message_loc: (95...96) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "b"
+        │   ├── write_name: "b="
+        │   ├── operator: :-
+        │   ├── operator_loc: (97...99) = "-="
+        │   └── value:
+        │       @ IntegerNode (location: (100...101))
+        ├── @ CallOperatorWriteNode (location: (102...111))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (102...103))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (103...104) = "."
+        │   ├── message_loc: (104...105) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "b"
+        │   ├── write_name: "b="
+        │   ├── operator: :**
+        │   ├── operator_loc: (106...109) = "**="
+        │   └── value:
+        │       @ IntegerNode (location: (110...111))
+        ├── @ CallOperatorWriteNode (location: (112...120))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (112...113))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (113...114) = "."
+        │   ├── message_loc: (114...115) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "b"
+        │   ├── write_name: "b="
+        │   ├── operator: :*
+        │   ├── operator_loc: (116...118) = "*="
+        │   └── value:
+        │       @ IntegerNode (location: (119...120))
+        ├── @ CallOperatorWriteNode (location: (121...129))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (121...122))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (122...123) = "."
+        │   ├── message_loc: (123...124) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "b"
+        │   ├── write_name: "b="
+        │   ├── operator: :/
+        │   ├── operator_loc: (125...127) = "/="
+        │   └── value:
+        │       @ IntegerNode (location: (128...129))
+        ├── @ CallAndWriteNode (location: (130...139))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (130...131))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (131...132) = "."
+        │   ├── message_loc: (132...133) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "b"
+        │   ├── write_name: "b="
+        │   ├── operator_loc: (134...137) = "&&="
+        │   └── value:
+        │       @ CallNode (location: (138...139))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (138...139) = "b"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "b"
+        ├── @ CallOrWriteNode (location: (140...149))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (140...141))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (141...142) = "."
+        │   ├── message_loc: (142...143) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "b"
+        │   ├── write_name: "b="
+        │   ├── operator_loc: (144...147) = "||="
+        │   └── value:
+        │       @ IntegerNode (location: (148...149))
+        ├── @ CallOperatorWriteNode (location: (150...159))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (150...151))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (151...154) = "[b]"
+        │   ├── opening_loc: (151...152) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (152...153))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (152...153))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (152...153) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── closing_loc: (153...154) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator: :+
+        │   ├── operator_loc: (155...157) = "+="
+        │   └── value:
+        │       @ IntegerNode (location: (158...159))
+        ├── @ CallOperatorWriteNode (location: (160...169))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (160...161))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (161...164) = "[b]"
+        │   ├── opening_loc: (161...162) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (162...163))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (162...163))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (162...163) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── closing_loc: (163...164) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator: :-
+        │   ├── operator_loc: (165...167) = "-="
+        │   └── value:
+        │       @ IntegerNode (location: (168...169))
+        ├── @ CallOperatorWriteNode (location: (170...180))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (170...171))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (171...174) = "[b]"
+        │   ├── opening_loc: (171...172) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (172...173))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (172...173))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (172...173) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── closing_loc: (173...174) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator: :**
+        │   ├── operator_loc: (175...178) = "**="
+        │   └── value:
+        │       @ IntegerNode (location: (179...180))
+        ├── @ CallOperatorWriteNode (location: (181...190))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (181...182))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (182...185) = "[b]"
+        │   ├── opening_loc: (182...183) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (183...184))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (183...184))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (183...184) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── closing_loc: (184...185) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator: :*
+        │   ├── operator_loc: (186...188) = "*="
+        │   └── value:
+        │       @ IntegerNode (location: (189...190))
+        ├── @ CallOperatorWriteNode (location: (191...200))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (191...192))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (192...195) = "[b]"
+        │   ├── opening_loc: (192...193) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (193...194))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (193...194))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (193...194) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── closing_loc: (194...195) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator: :/
+        │   ├── operator_loc: (196...198) = "/="
+        │   └── value:
+        │       @ IntegerNode (location: (199...200))
+        ├── @ CallAndWriteNode (location: (201...211))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (201...202))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (202...205) = "[b]"
+        │   ├── opening_loc: (202...203) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (203...204))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (203...204))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (203...204) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── closing_loc: (204...205) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator_loc: (206...209) = "&&="
+        │   └── value:
+        │       @ CallNode (location: (210...211))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (210...211) = "b"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "b"
+        ├── @ CallOrWriteNode (location: (212...222))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (212...213))
+        │   │   ├── name: :a
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (213...216) = "[b]"
+        │   ├── opening_loc: (213...214) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (214...215))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (214...215))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (214...215) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── closing_loc: (215...216) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator_loc: (217...220) = "||="
+        │   └── value:
+        │       @ IntegerNode (location: (221...222))
+        └── @ CallOperatorWriteNode (location: (223...233))
+            ├── receiver:
+            │   @ CallNode (location: (223...226))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (223...226) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: (226...227) = "."
+            ├── message_loc: (227...228) = "A"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: 
+            ├── read_name: "A"
+            ├── write_name: "A="
+            ├── operator: :+
+            ├── operator_loc: (229...231) = "+="
+            └── value:
+                @ IntegerNode (location: (232...233))
diff --git a/test/yarp/snapshots/unparser/corpus/literal/pattern.txt b/test/yarp/snapshots/unparser/corpus/literal/pattern.txt
index 2d6ec772f4..1b78ae3ff0 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/pattern.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/pattern.txt
@@ -1,291 +1,409 @@
-ProgramNode(0...408)(
-  [:a, :x, :y],
-  StatementsNode(0...408)(
-    [CaseNode(0...345)(
-       CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "foo"),
-       [InNode(9...38)(
-          ArrayPatternNode(12...26)(
-            ConstantReadNode(12...13)(:A),
-            [IntegerNode(14...15)(), IntegerNode(17...18)()],
-            SplatNode(20...22)(
-              (20...21),
-              LocalVariableTargetNode(21...22)(:a, 0)
-            ),
-            [IntegerNode(24...25)()],
-            (13...14),
-            (25...26)
-          ),
-          StatementsNode(34...38)([TrueNode(34...38)()]),
-          (9...11),
-          (27...31)
-        ),
-        InNode(39...59)(
-          ArrayPatternNode(42...50)(
-            nil,
-            [IntegerNode(43...44)(), IntegerNode(46...47)()],
-            nil,
-            [],
-            (42...43),
-            (49...50)
-          ),
-          StatementsNode(58...59)(
-            [CallNode(58...59)(
-               nil,
-               nil,
-               (58...59),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "y"
-             )]
-          ),
-          (39...41),
-          (51...55)
-        ),
-        InNode(60...80)(
-          HashPatternNode(63...68)(
-            ConstantReadNode(63...64)(:A),
-            [AssocNode(65...67)(
-               SymbolNode(65...67)(nil, (65...66), (66...67), "x"),
-               nil,
-               nil
-             )],
-            nil,
-            (64...65),
-            (67...68)
-          ),
-          StatementsNode(76...80)([TrueNode(76...80)()]),
-          (60...62),
-          (69...73)
-        ),
-        InNode(81...101)(
-          HashPatternNode(84...89)(
-            nil,
-            [AssocNode(85...88)(
-               AssocSplatNode(85...88)(
-                 LocalVariableTargetNode(87...88)(:a, 0),
-                 (85...87)
-               ),
-               nil,
-               nil
-             )],
-            nil,
-            (84...85),
-            (88...89)
-          ),
-          StatementsNode(97...101)([TrueNode(97...101)()]),
-          (81...83),
-          (90...94)
-        ),
-        InNode(102...127)(
-          IfNode(105...115)(
-            (108...110),
-            TrueNode(111...115)(),
-            StatementsNode(105...107)(
-              [HashPatternNode(105...107)(
-                 nil,
-                 [],
-                 nil,
-                 (105...106),
-                 (106...107)
-               )]
-            ),
-            nil,
-            nil
-          ),
-          StatementsNode(123...127)([TrueNode(123...127)()]),
-          (102...104),
-          (116...120)
-        ),
-        InNode(128...152)(
-          ArrayPatternNode(131...140)(
-            nil,
-            [LocalVariableTargetNode(132...133)(:x, 0),
-             LocalVariableTargetNode(135...136)(:y, 0)],
-            SplatNode(138...139)((138...139), nil),
-            [],
-            (131...132),
-            (139...140)
-          ),
-          StatementsNode(148...152)([TrueNode(148...152)()]),
-          (128...130),
-          (141...145)
-        ),
-        InNode(153...181)(
-          HashPatternNode(156...169)(
-            nil,
-            [AssocNode(157...161)(
-               SymbolNode(157...159)(nil, (157...158), (158...159), "a"),
-               IntegerNode(160...161)(),
-               nil
-             ),
-             AssocNode(163...168)(
-               SymbolNode(163...166)(nil, (163...165), (165...166), "aa"),
-               IntegerNode(167...168)(),
-               nil
-             )],
-            nil,
-            (156...157),
-            (168...169)
-          ),
-          StatementsNode(177...181)([TrueNode(177...181)()]),
-          (153...155),
-          (170...174)
-        ),
-        InNode(182...199)(
-          HashPatternNode(185...187)(nil, [], nil, (185...186), (186...187)),
-          StatementsNode(195...199)([TrueNode(195...199)()]),
-          (182...184),
-          (188...192)
-        ),
-        InNode(200...222)(
-          HashPatternNode(203...210)(
-            nil,
-            [AssocNode(204...209)(
-               NoKeywordsParameterNode(204...209)((204...206), (206...209)),
-               nil,
-               nil
-             )],
-            nil,
-            (203...204),
-            (209...210)
-          ),
-          StatementsNode(218...222)([TrueNode(218...222)()]),
-          (200...202),
-          (211...215)
-        ),
-        InNode(223...246)(
-          HashPatternNode(226...234)(
-            nil,
-            [AssocNode(227...233)(
-               SymbolNode(227...231)(
-                 (227...228),
-                 (228...229),
-                 (229...231),
-                 "a"
-               ),
-               IntegerNode(232...233)(),
-               nil
-             )],
-            nil,
-            (226...227),
-            (233...234)
-          ),
-          StatementsNode(242...246)([TrueNode(242...246)()]),
-          (223...225),
-          (235...239)
-        ),
-        InNode(247...267)(
-          AlternationPatternNode(250...255)(
-            IntegerNode(250...251)(),
-            IntegerNode(254...255)(),
-            (252...253)
-          ),
-          StatementsNode(263...267)([TrueNode(263...267)()]),
-          (247...249),
-          (256...260)
-        ),
-        InNode(268...289)(
-          CapturePatternNode(271...277)(
-            IntegerNode(271...272)(),
-            LocalVariableTargetNode(276...277)(:a, 0),
-            (273...275)
-          ),
-          StatementsNode(285...289)([TrueNode(285...289)()]),
-          (268...270),
-          (278...282)
-        ),
-        InNode(290...307)(
-          PinnedVariableNode(293...295)(
-            LocalVariableReadNode(294...295)(:x, 0),
-            (293...294)
-          ),
-          StatementsNode(303...307)([TrueNode(303...307)()]),
-          (290...292),
-          (296...300)
-        ),
-        InNode(308...312)(IntegerNode(311...312)(), nil, (308...310), nil),
-        InNode(313...329)(
-          IntegerNode(316...317)(),
-          StatementsNode(325...329)([TrueNode(325...329)()]),
-          (313...315),
-          (318...322)
-        )],
-       ElseNode(330...345)(
-         (330...334),
-         StatementsNode(337...341)([TrueNode(337...341)()]),
-         (342...345)
-       ),
-       (0...4),
-       (342...345)
-     ),
-     CaseNode(346...376)(
-       CallNode(351...354)(
-         nil,
-         nil,
-         (351...354),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(355...372)(
-          ArrayPatternNode(358...372)(
-            ConstantReadNode(358...359)(:A),
-            [IntegerNode(360...361)(), IntegerNode(363...364)()],
-            SplatNode(366...368)(
-              (366...367),
-              LocalVariableTargetNode(367...368)(:a, 0)
-            ),
-            [IntegerNode(370...371)()],
-            (359...360),
-            (371...372)
-          ),
-          nil,
-          (355...357),
-          nil
-        )],
-       nil,
-       (346...350),
-       (373...376)
-     ),
-     CaseNode(377...399)(
-       CallNode(382...385)(
-         nil,
-         nil,
-         (382...385),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       [InNode(386...390)(
-          ConstantReadNode(389...390)(:A),
-          nil,
-          (386...388),
-          nil
-        )],
-       ElseNode(391...399)((391...395), nil, (396...399)),
-       (377...381),
-       (396...399)
-     ),
-     MatchPredicateNode(400...408)(
-       IntegerNode(400...401)(),
-       ArrayPatternNode(405...408)(
-         nil,
-         [LocalVariableTargetNode(406...407)(:a, 0)],
-         nil,
-         [],
-         (405...406),
-         (407...408)
-       ),
-       (402...404)
-     )]
-  )
-)
+@ ProgramNode (location: (0...408))
+├── locals: [:a, :x, :y]
+└── statements:
+    @ StatementsNode (location: (0...408))
+    └── body: (length: 4)
+        ├── @ CaseNode (location: (0...345))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (5...8))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (5...8) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 15)
+        │   │   ├── @ InNode (location: (9...38))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ ArrayPatternNode (location: (12...26))
+        │   │   │   │   ├── constant:
+        │   │   │   │   │   @ ConstantReadNode (location: (12...13))
+        │   │   │   │   │   └── name: :A
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ IntegerNode (location: (14...15))
+        │   │   │   │   │   └── @ IntegerNode (location: (17...18))
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ SplatNode (location: (20...22))
+        │   │   │   │   │   ├── operator_loc: (20...21) = "*"
+        │   │   │   │   │   └── expression:
+        │   │   │   │   │       @ LocalVariableTargetNode (location: (21...22))
+        │   │   │   │   │       ├── name: :a
+        │   │   │   │   │       └── depth: 0
+        │   │   │   │   ├── posts: (length: 1)
+        │   │   │   │   │   └── @ IntegerNode (location: (24...25))
+        │   │   │   │   ├── opening_loc: (13...14) = "["
+        │   │   │   │   └── closing_loc: (25...26) = "]"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (34...38))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (34...38))
+        │   │   │   ├── in_loc: (9...11) = "in"
+        │   │   │   └── then_loc: (27...31) = "then"
+        │   │   ├── @ InNode (location: (39...59))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ ArrayPatternNode (location: (42...50))
+        │   │   │   │   ├── constant: ∅
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ IntegerNode (location: (43...44))
+        │   │   │   │   │   └── @ IntegerNode (location: (46...47))
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── opening_loc: (42...43) = "["
+        │   │   │   │   └── closing_loc: (49...50) = "]"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (58...59))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (58...59))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (58...59) = "y"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "y"
+        │   │   │   ├── in_loc: (39...41) = "in"
+        │   │   │   └── then_loc: (51...55) = "then"
+        │   │   ├── @ InNode (location: (60...80))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ HashPatternNode (location: (63...68))
+        │   │   │   │   ├── constant:
+        │   │   │   │   │   @ ConstantReadNode (location: (63...64))
+        │   │   │   │   │   └── name: :A
+        │   │   │   │   ├── assocs: (length: 1)
+        │   │   │   │   │   └── @ AssocNode (location: (65...67))
+        │   │   │   │   │       ├── key:
+        │   │   │   │   │       │   @ SymbolNode (location: (65...67))
+        │   │   │   │   │       │   ├── opening_loc: ∅
+        │   │   │   │   │       │   ├── value_loc: (65...66) = "x"
+        │   │   │   │   │       │   ├── closing_loc: (66...67) = ":"
+        │   │   │   │   │       │   └── unescaped: "x"
+        │   │   │   │   │       ├── value: ∅
+        │   │   │   │   │       └── operator_loc: ∅
+        │   │   │   │   ├── kwrest: ∅
+        │   │   │   │   ├── opening_loc: (64...65) = "("
+        │   │   │   │   └── closing_loc: (67...68) = ")"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (76...80))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (76...80))
+        │   │   │   ├── in_loc: (60...62) = "in"
+        │   │   │   └── then_loc: (69...73) = "then"
+        │   │   ├── @ InNode (location: (81...101))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ HashPatternNode (location: (84...89))
+        │   │   │   │   ├── constant: ∅
+        │   │   │   │   ├── assocs: (length: 1)
+        │   │   │   │   │   └── @ AssocNode (location: (85...88))
+        │   │   │   │   │       ├── key:
+        │   │   │   │   │       │   @ AssocSplatNode (location: (85...88))
+        │   │   │   │   │       │   ├── value:
+        │   │   │   │   │       │   │   @ LocalVariableTargetNode (location: (87...88))
+        │   │   │   │   │       │   │   ├── name: :a
+        │   │   │   │   │       │   │   └── depth: 0
+        │   │   │   │   │       │   └── operator_loc: (85...87) = "**"
+        │   │   │   │   │       ├── value: ∅
+        │   │   │   │   │       └── operator_loc: ∅
+        │   │   │   │   ├── kwrest: ∅
+        │   │   │   │   ├── opening_loc: (84...85) = "{"
+        │   │   │   │   └── closing_loc: (88...89) = "}"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (97...101))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (97...101))
+        │   │   │   ├── in_loc: (81...83) = "in"
+        │   │   │   └── then_loc: (90...94) = "then"
+        │   │   ├── @ InNode (location: (102...127))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ IfNode (location: (105...115))
+        │   │   │   │   ├── if_keyword_loc: (108...110) = "if"
+        │   │   │   │   ├── predicate:
+        │   │   │   │   │   @ TrueNode (location: (111...115))
+        │   │   │   │   ├── statements:
+        │   │   │   │   │   @ StatementsNode (location: (105...107))
+        │   │   │   │   │   └── body: (length: 1)
+        │   │   │   │   │       └── @ HashPatternNode (location: (105...107))
+        │   │   │   │   │           ├── constant: ∅
+        │   │   │   │   │           ├── assocs: (length: 0)
+        │   │   │   │   │           ├── kwrest: ∅
+        │   │   │   │   │           ├── opening_loc: (105...106) = "{"
+        │   │   │   │   │           └── closing_loc: (106...107) = "}"
+        │   │   │   │   ├── consequent: ∅
+        │   │   │   │   └── end_keyword_loc: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (123...127))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (123...127))
+        │   │   │   ├── in_loc: (102...104) = "in"
+        │   │   │   └── then_loc: (116...120) = "then"
+        │   │   ├── @ InNode (location: (128...152))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ ArrayPatternNode (location: (131...140))
+        │   │   │   │   ├── constant: ∅
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ LocalVariableTargetNode (location: (132...133))
+        │   │   │   │   │   │   ├── name: :x
+        │   │   │   │   │   │   └── depth: 0
+        │   │   │   │   │   └── @ LocalVariableTargetNode (location: (135...136))
+        │   │   │   │   │       ├── name: :y
+        │   │   │   │   │       └── depth: 0
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ SplatNode (location: (138...139))
+        │   │   │   │   │   ├── operator_loc: (138...139) = "*"
+        │   │   │   │   │   └── expression: ∅
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── opening_loc: (131...132) = "["
+        │   │   │   │   └── closing_loc: (139...140) = "]"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (148...152))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (148...152))
+        │   │   │   ├── in_loc: (128...130) = "in"
+        │   │   │   └── then_loc: (141...145) = "then"
+        │   │   ├── @ InNode (location: (153...181))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ HashPatternNode (location: (156...169))
+        │   │   │   │   ├── constant: ∅
+        │   │   │   │   ├── assocs: (length: 2)
+        │   │   │   │   │   ├── @ AssocNode (location: (157...161))
+        │   │   │   │   │   │   ├── key:
+        │   │   │   │   │   │   │   @ SymbolNode (location: (157...159))
+        │   │   │   │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   │   │   │   ├── value_loc: (157...158) = "a"
+        │   │   │   │   │   │   │   ├── closing_loc: (158...159) = ":"
+        │   │   │   │   │   │   │   └── unescaped: "a"
+        │   │   │   │   │   │   ├── value:
+        │   │   │   │   │   │   │   @ IntegerNode (location: (160...161))
+        │   │   │   │   │   │   └── operator_loc: ∅
+        │   │   │   │   │   └── @ AssocNode (location: (163...168))
+        │   │   │   │   │       ├── key:
+        │   │   │   │   │       │   @ SymbolNode (location: (163...166))
+        │   │   │   │   │       │   ├── opening_loc: ∅
+        │   │   │   │   │       │   ├── value_loc: (163...165) = "aa"
+        │   │   │   │   │       │   ├── closing_loc: (165...166) = ":"
+        │   │   │   │   │       │   └── unescaped: "aa"
+        │   │   │   │   │       ├── value:
+        │   │   │   │   │       │   @ IntegerNode (location: (167...168))
+        │   │   │   │   │       └── operator_loc: ∅
+        │   │   │   │   ├── kwrest: ∅
+        │   │   │   │   ├── opening_loc: (156...157) = "{"
+        │   │   │   │   └── closing_loc: (168...169) = "}"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (177...181))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (177...181))
+        │   │   │   ├── in_loc: (153...155) = "in"
+        │   │   │   └── then_loc: (170...174) = "then"
+        │   │   ├── @ InNode (location: (182...199))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ HashPatternNode (location: (185...187))
+        │   │   │   │   ├── constant: ∅
+        │   │   │   │   ├── assocs: (length: 0)
+        │   │   │   │   ├── kwrest: ∅
+        │   │   │   │   ├── opening_loc: (185...186) = "{"
+        │   │   │   │   └── closing_loc: (186...187) = "}"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (195...199))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (195...199))
+        │   │   │   ├── in_loc: (182...184) = "in"
+        │   │   │   └── then_loc: (188...192) = "then"
+        │   │   ├── @ InNode (location: (200...222))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ HashPatternNode (location: (203...210))
+        │   │   │   │   ├── constant: ∅
+        │   │   │   │   ├── assocs: (length: 1)
+        │   │   │   │   │   └── @ AssocNode (location: (204...209))
+        │   │   │   │   │       ├── key:
+        │   │   │   │   │       │   @ NoKeywordsParameterNode (location: (204...209))
+        │   │   │   │   │       │   ├── operator_loc: (204...206) = "**"
+        │   │   │   │   │       │   └── keyword_loc: (206...209) = "nil"
+        │   │   │   │   │       ├── value: ∅
+        │   │   │   │   │       └── operator_loc: ∅
+        │   │   │   │   ├── kwrest: ∅
+        │   │   │   │   ├── opening_loc: (203...204) = "{"
+        │   │   │   │   └── closing_loc: (209...210) = "}"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (218...222))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (218...222))
+        │   │   │   ├── in_loc: (200...202) = "in"
+        │   │   │   └── then_loc: (211...215) = "then"
+        │   │   ├── @ InNode (location: (223...246))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ HashPatternNode (location: (226...234))
+        │   │   │   │   ├── constant: ∅
+        │   │   │   │   ├── assocs: (length: 1)
+        │   │   │   │   │   └── @ AssocNode (location: (227...233))
+        │   │   │   │   │       ├── key:
+        │   │   │   │   │       │   @ SymbolNode (location: (227...231))
+        │   │   │   │   │       │   ├── opening_loc: (227...228) = "\""
+        │   │   │   │   │       │   ├── value_loc: (228...229) = "a"
+        │   │   │   │   │       │   ├── closing_loc: (229...231) = "\":"
+        │   │   │   │   │       │   └── unescaped: "a"
+        │   │   │   │   │       ├── value:
+        │   │   │   │   │       │   @ IntegerNode (location: (232...233))
+        │   │   │   │   │       └── operator_loc: ∅
+        │   │   │   │   ├── kwrest: ∅
+        │   │   │   │   ├── opening_loc: (226...227) = "{"
+        │   │   │   │   └── closing_loc: (233...234) = "}"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (242...246))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (242...246))
+        │   │   │   ├── in_loc: (223...225) = "in"
+        │   │   │   └── then_loc: (235...239) = "then"
+        │   │   ├── @ InNode (location: (247...267))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ AlternationPatternNode (location: (250...255))
+        │   │   │   │   ├── left:
+        │   │   │   │   │   @ IntegerNode (location: (250...251))
+        │   │   │   │   ├── right:
+        │   │   │   │   │   @ IntegerNode (location: (254...255))
+        │   │   │   │   └── operator_loc: (252...253) = "|"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (263...267))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (263...267))
+        │   │   │   ├── in_loc: (247...249) = "in"
+        │   │   │   └── then_loc: (256...260) = "then"
+        │   │   ├── @ InNode (location: (268...289))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ CapturePatternNode (location: (271...277))
+        │   │   │   │   ├── value:
+        │   │   │   │   │   @ IntegerNode (location: (271...272))
+        │   │   │   │   ├── target:
+        │   │   │   │   │   @ LocalVariableTargetNode (location: (276...277))
+        │   │   │   │   │   ├── name: :a
+        │   │   │   │   │   └── depth: 0
+        │   │   │   │   └── operator_loc: (273...275) = "=>"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (285...289))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (285...289))
+        │   │   │   ├── in_loc: (268...270) = "in"
+        │   │   │   └── then_loc: (278...282) = "then"
+        │   │   ├── @ InNode (location: (290...307))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ PinnedVariableNode (location: (293...295))
+        │   │   │   │   ├── variable:
+        │   │   │   │   │   @ LocalVariableReadNode (location: (294...295))
+        │   │   │   │   │   ├── name: :x
+        │   │   │   │   │   └── depth: 0
+        │   │   │   │   └── operator_loc: (293...294) = "^"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (303...307))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ TrueNode (location: (303...307))
+        │   │   │   ├── in_loc: (290...292) = "in"
+        │   │   │   └── then_loc: (296...300) = "then"
+        │   │   ├── @ InNode (location: (308...312))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ IntegerNode (location: (311...312))
+        │   │   │   ├── statements: ∅
+        │   │   │   ├── in_loc: (308...310) = "in"
+        │   │   │   └── then_loc: ∅
+        │   │   └── @ InNode (location: (313...329))
+        │   │       ├── pattern:
+        │   │       │   @ IntegerNode (location: (316...317))
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (325...329))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ TrueNode (location: (325...329))
+        │   │       ├── in_loc: (313...315) = "in"
+        │   │       └── then_loc: (318...322) = "then"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (330...345))
+        │   │   ├── else_keyword_loc: (330...334) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (337...341))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ TrueNode (location: (337...341))
+        │   │   └── end_keyword_loc: (342...345) = "end"
+        │   ├── case_keyword_loc: (0...4) = "case"
+        │   └── end_keyword_loc: (342...345) = "end"
+        ├── @ CaseNode (location: (346...376))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (351...354))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (351...354) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (355...372))
+        │   │       ├── pattern:
+        │   │       │   @ ArrayPatternNode (location: (358...372))
+        │   │       │   ├── constant:
+        │   │       │   │   @ ConstantReadNode (location: (358...359))
+        │   │       │   │   └── name: :A
+        │   │       │   ├── requireds: (length: 2)
+        │   │       │   │   ├── @ IntegerNode (location: (360...361))
+        │   │       │   │   └── @ IntegerNode (location: (363...364))
+        │   │       │   ├── rest:
+        │   │       │   │   @ SplatNode (location: (366...368))
+        │   │       │   │   ├── operator_loc: (366...367) = "*"
+        │   │       │   │   └── expression:
+        │   │       │   │       @ LocalVariableTargetNode (location: (367...368))
+        │   │       │   │       ├── name: :a
+        │   │       │   │       └── depth: 0
+        │   │       │   ├── posts: (length: 1)
+        │   │       │   │   └── @ IntegerNode (location: (370...371))
+        │   │       │   ├── opening_loc: (359...360) = "["
+        │   │       │   └── closing_loc: (371...372) = "]"
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (355...357) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (346...350) = "case"
+        │   └── end_keyword_loc: (373...376) = "end"
+        ├── @ CaseNode (location: (377...399))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (382...385))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (382...385) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 1)
+        │   │   └── @ InNode (location: (386...390))
+        │   │       ├── pattern:
+        │   │       │   @ ConstantReadNode (location: (389...390))
+        │   │       │   └── name: :A
+        │   │       ├── statements: ∅
+        │   │       ├── in_loc: (386...388) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (391...399))
+        │   │   ├── else_keyword_loc: (391...395) = "else"
+        │   │   ├── statements: ∅
+        │   │   └── end_keyword_loc: (396...399) = "end"
+        │   ├── case_keyword_loc: (377...381) = "case"
+        │   └── end_keyword_loc: (396...399) = "end"
+        └── @ MatchPredicateNode (location: (400...408))
+            ├── value:
+            │   @ IntegerNode (location: (400...401))
+            ├── pattern:
+            │   @ ArrayPatternNode (location: (405...408))
+            │   ├── constant: ∅
+            │   ├── requireds: (length: 1)
+            │   │   └── @ LocalVariableTargetNode (location: (406...407))
+            │   │       ├── name: :a
+            │   │       └── depth: 0
+            │   ├── rest: ∅
+            │   ├── posts: (length: 0)
+            │   ├── opening_loc: (405...406) = "["
+            │   └── closing_loc: (407...408) = "]"
+            └── operator_loc: (402...404) = "in"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/pragma.txt b/test/yarp/snapshots/unparser/corpus/literal/pragma.txt
index 86c1327433..e876c1f98d 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/pragma.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/pragma.txt
@@ -1,9 +1,19 @@
-ProgramNode(0...38)(
-  [],
-  StatementsNode(0...38)(
-    [SourceEncodingNode(0...12)(),
-     SourceFileNode(13...21)("unparser/corpus/literal/pragma.txt"),
-     SourceLineNode(22...30)(),
-     CallNode(31...38)(nil, nil, (31...38), nil, nil, nil, nil, 2, "__dir__")]
-  )
-)
+@ ProgramNode (location: (0...38))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...38))
+    └── body: (length: 4)
+        ├── @ SourceEncodingNode (location: (0...12))
+        ├── @ SourceFileNode (location: (13...21))
+        │   └── filepath: "unparser/corpus/literal/pragma.txt"
+        ├── @ SourceLineNode (location: (22...30))
+        └── @ CallNode (location: (31...38))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (31...38) = "__dir__"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "__dir__"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/range.txt b/test/yarp/snapshots/unparser/corpus/literal/range.txt
index ea2b362a32..1bc7dfdcff 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/range.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/range.txt
@@ -1,31 +1,43 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [ParenthesesNode(0...5)(
-       StatementsNode(1...4)(
-         [RangeNode(1...4)(IntegerNode(1...2)(), nil, (2...4), 0)]
-       ),
-       (0...1),
-       (4...5)
-     ),
-     RangeNode(6...10)(
-       IntegerNode(6...7)(),
-       IntegerNode(9...10)(),
-       (7...9),
-       0
-     ),
-     ParenthesesNode(11...17)(
-       StatementsNode(12...16)(
-         [RangeNode(12...16)(IntegerNode(12...13)(), nil, (13...16), 1)]
-       ),
-       (11...12),
-       (16...17)
-     ),
-     RangeNode(18...23)(
-       IntegerNode(18...19)(),
-       IntegerNode(22...23)(),
-       (19...22),
-       1
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 4)
+        ├── @ ParenthesesNode (location: (0...5))
+        │   ├── body:
+        │   │   @ StatementsNode (location: (1...4))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RangeNode (location: (1...4))
+        │   │           ├── left:
+        │   │           │   @ IntegerNode (location: (1...2))
+        │   │           ├── right: ∅
+        │   │           ├── operator_loc: (2...4) = ".."
+        │   │           └── flags: 
+        │   ├── opening_loc: (0...1) = "("
+        │   └── closing_loc: (4...5) = ")"
+        ├── @ RangeNode (location: (6...10))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (6...7))
+        │   ├── right:
+        │   │   @ IntegerNode (location: (9...10))
+        │   ├── operator_loc: (7...9) = ".."
+        │   └── flags: 
+        ├── @ ParenthesesNode (location: (11...17))
+        │   ├── body:
+        │   │   @ StatementsNode (location: (12...16))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RangeNode (location: (12...16))
+        │   │           ├── left:
+        │   │           │   @ IntegerNode (location: (12...13))
+        │   │           ├── right: ∅
+        │   │           ├── operator_loc: (13...16) = "..."
+        │   │           └── flags: exclude_end
+        │   ├── opening_loc: (11...12) = "("
+        │   └── closing_loc: (16...17) = ")"
+        └── @ RangeNode (location: (18...23))
+            ├── left:
+            │   @ IntegerNode (location: (18...19))
+            ├── right:
+            │   @ IntegerNode (location: (22...23))
+            ├── operator_loc: (19...22) = "..."
+            └── flags: exclude_end
diff --git a/test/yarp/snapshots/unparser/corpus/literal/rescue.txt b/test/yarp/snapshots/unparser/corpus/literal/rescue.txt
index 8898a6e1a0..c43ea6a6f0 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/rescue.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/rescue.txt
@@ -1,72 +1,99 @@
-ProgramNode(0...64)(
-  [:x],
-  StatementsNode(0...64)(
-    [RescueModifierNode(0...14)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (4...10),
-       CallNode(11...14)(nil, nil, (11...14), nil, nil, nil, nil, 2, "bar")
-     ),
-     RescueModifierNode(15...36)(
-       CallNode(15...18)(nil, nil, (15...18), nil, nil, nil, nil, 2, "foo"),
-       (19...25),
-       ReturnNode(26...36)(
-         (26...32),
-         ArgumentsNode(33...36)(
-           [CallNode(33...36)(
-              nil,
-              nil,
-              (33...36),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         )
-       )
-     ),
-     LocalVariableWriteNode(37...64)(
-       :x,
-       0,
-       (37...38),
-       ParenthesesNode(41...64)(
-         StatementsNode(42...63)(
-           [RescueModifierNode(42...63)(
-              CallNode(42...45)(
-                nil,
-                nil,
-                (42...45),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "foo"
-              ),
-              (46...52),
-              ReturnNode(53...63)(
-                (53...59),
-                ArgumentsNode(60...63)(
-                  [CallNode(60...63)(
-                     nil,
-                     nil,
-                     (60...63),
-                     nil,
-                     nil,
-                     nil,
-                     nil,
-                     2,
-                     "bar"
-                   )]
-                )
-              )
-            )]
-         ),
-         (41...42),
-         (63...64)
-       ),
-       (39...40)
-     )]
-  )
-)
+@ ProgramNode (location: (0...64))
+├── locals: [:x]
+└── statements:
+    @ StatementsNode (location: (0...64))
+    └── body: (length: 3)
+        ├── @ RescueModifierNode (location: (0...14))
+        │   ├── expression:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── keyword_loc: (4...10) = "rescue"
+        │   └── rescue_expression:
+        │       @ CallNode (location: (11...14))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (11...14) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        ├── @ RescueModifierNode (location: (15...36))
+        │   ├── expression:
+        │   │   @ CallNode (location: (15...18))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (15...18) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── keyword_loc: (19...25) = "rescue"
+        │   └── rescue_expression:
+        │       @ ReturnNode (location: (26...36))
+        │       ├── keyword_loc: (26...32) = "return"
+        │       └── arguments:
+        │           @ ArgumentsNode (location: (33...36))
+        │           └── arguments: (length: 1)
+        │               └── @ CallNode (location: (33...36))
+        │                   ├── receiver: ∅
+        │                   ├── call_operator_loc: ∅
+        │                   ├── message_loc: (33...36) = "bar"
+        │                   ├── opening_loc: ∅
+        │                   ├── arguments: ∅
+        │                   ├── closing_loc: ∅
+        │                   ├── block: ∅
+        │                   ├── flags: variable_call
+        │                   └── name: "bar"
+        └── @ LocalVariableWriteNode (location: (37...64))
+            ├── name: :x
+            ├── depth: 0
+            ├── name_loc: (37...38) = "x"
+            ├── value:
+            │   @ ParenthesesNode (location: (41...64))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (42...63))
+            │   │   └── body: (length: 1)
+            │   │       └── @ RescueModifierNode (location: (42...63))
+            │   │           ├── expression:
+            │   │           │   @ CallNode (location: (42...45))
+            │   │           │   ├── receiver: ∅
+            │   │           │   ├── call_operator_loc: ∅
+            │   │           │   ├── message_loc: (42...45) = "foo"
+            │   │           │   ├── opening_loc: ∅
+            │   │           │   ├── arguments: ∅
+            │   │           │   ├── closing_loc: ∅
+            │   │           │   ├── block: ∅
+            │   │           │   ├── flags: variable_call
+            │   │           │   └── name: "foo"
+            │   │           ├── keyword_loc: (46...52) = "rescue"
+            │   │           └── rescue_expression:
+            │   │               @ ReturnNode (location: (53...63))
+            │   │               ├── keyword_loc: (53...59) = "return"
+            │   │               └── arguments:
+            │   │                   @ ArgumentsNode (location: (60...63))
+            │   │                   └── arguments: (length: 1)
+            │   │                       └── @ CallNode (location: (60...63))
+            │   │                           ├── receiver: ∅
+            │   │                           ├── call_operator_loc: ∅
+            │   │                           ├── message_loc: (60...63) = "bar"
+            │   │                           ├── opening_loc: ∅
+            │   │                           ├── arguments: ∅
+            │   │                           ├── closing_loc: ∅
+            │   │                           ├── block: ∅
+            │   │                           ├── flags: variable_call
+            │   │                           └── name: "bar"
+            │   ├── opening_loc: (41...42) = "("
+            │   └── closing_loc: (63...64) = ")"
+            └── operator_loc: (39...40) = "="
diff --git a/test/yarp/snapshots/unparser/corpus/literal/send.txt b/test/yarp/snapshots/unparser/corpus/literal/send.txt
index 858101f5a3..caccabad61 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/send.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/send.txt
@@ -1,2052 +1,2113 @@
-ProgramNode(0...999)(
-  [],
-  StatementsNode(0...999)(
-    [ModuleNode(0...35)(
-       [:foo, :a, :_],
-       (0...6),
-       ConstantReadNode(7...8)(:A),
-       StatementsNode(11...31)(
-         [LocalVariableOrWriteNode(11...31)(
-            (11...14),
-            (15...18),
-            ParenthesesNode(19...31)(
-              StatementsNode(20...30)(
-                [MultiWriteNode(20...30)(
-                   [LocalVariableTargetNode(21...22)(:a, 0),
-                    LocalVariableTargetNode(24...25)(:_, 0)],
-                   (20...21),
-                   (25...26),
-                   (27...28),
-                   CallNode(29...30)(
-                     nil,
-                     nil,
-                     (29...30),
-                     nil,
-                     nil,
-                     nil,
-                     nil,
-                     2,
-                     "b"
-                   )
-                 )]
-              ),
-              (19...20),
-              (30...31)
-            ),
-            :foo,
-            0
-          )]
-       ),
-       (32...35),
-       :A
-     ),
-     ModuleNode(37...73)(
-       [:local],
-       (37...43),
-       ConstantReadNode(44...45)(:A),
-       StatementsNode(48...69)(
-         [LocalVariableWriteNode(48...57)(
-            :local,
-            0,
-            (48...53),
-            IntegerNode(56...57)(),
-            (54...55)
-          ),
-          CallNode(60...69)(
-            LocalVariableReadNode(60...65)(:local, 0),
-            (65...66),
-            (66...69),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       (70...73),
-       :A
-     ),
-     CallNode(74...89)(
-       ClassNode(74...85)(
-         [],
-         (74...79),
-         ConstantReadNode(80...81)(:A),
-         nil,
-         nil,
-         nil,
-         (82...85),
-         :A
-       ),
-       (85...86),
-       (86...89),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(90...106)(
-       ModuleNode(90...102)(
-         [],
-         (90...96),
-         ConstantReadNode(97...98)(:A),
-         nil,
-         (99...102),
-         :A
-       ),
-       (102...103),
-       (103...106),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(107...127)(
-       BeginNode(107...123)(
-         (107...112),
-         nil,
-         RescueNode(113...119)((113...119), [], nil, nil, nil, nil),
-         nil,
-         nil,
-         (120...123)
-       ),
-       (123...124),
-       (124...127),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(128...169)(
-       CaseNode(128...165)(
-         ParenthesesNode(133...152)(
-           StatementsNode(134...151)(
-             [DefNode(134...145)(
-                :foo,
-                (138...141),
-                nil,
-                nil,
-                nil,
-                [],
-                (134...137),
-                nil,
-                nil,
-                nil,
-                nil,
-                (142...145)
-              ),
-              SymbolNode(147...151)((147...148), (148...151), nil, "bar")]
-           ),
-           (133...134),
-           (151...152)
-         ),
-         [WhenNode(153...161)(
-            (153...157),
-            [CallNode(158...161)(
-               nil,
-               nil,
-               (158...161),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )],
-            nil
-          )],
-         nil,
-         (128...132),
-         (162...165)
-       ),
-       (165...166),
-       (166...169),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "baz"
-     ),
-     CallNode(170...195)(
-       CaseNode(170...191)(
-         CallNode(175...178)(
-           nil,
-           nil,
-           (175...178),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         [WhenNode(179...187)(
-            (179...183),
-            [CallNode(184...187)(
-               nil,
-               nil,
-               (184...187),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )],
-            nil
-          )],
-         nil,
-         (170...174),
-         (188...191)
-       ),
-       (191...192),
-       (192...195),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "baz"
-     ),
-     CallNode(196...217)(
-       SingletonClassNode(196...213)(
-         [],
-         (196...201),
-         (202...204),
-         SelfNode(205...209)(),
-         nil,
-         (210...213)
-       ),
-       (213...214),
-       (214...217),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(218...238)(
-       DefNode(218...234)(
-         :foo,
-         (227...230),
-         SelfNode(222...226)(),
-         nil,
-         nil,
-         [],
-         (218...221),
-         (226...227),
-         nil,
-         nil,
-         nil,
-         (231...234)
-       ),
-       (234...235),
-       (235...238),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(239...254)(
-       DefNode(239...250)(
-         :foo,
-         (243...246),
-         nil,
-         nil,
-         nil,
-         [],
-         (239...242),
-         nil,
-         nil,
-         nil,
-         nil,
-         (247...250)
-       ),
-       (250...251),
-       (251...254),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(255...272)(
-       UntilNode(255...268)(
-         (255...260),
-         (265...268),
-         CallNode(261...264)(
-           nil,
-           nil,
-           (261...264),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         nil,
-         0
-       ),
-       (268...269),
-       (269...272),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(273...290)(
-       WhileNode(273...286)(
-         (273...278),
-         (283...286),
-         CallNode(279...282)(
-           nil,
-           nil,
-           (279...282),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         nil,
-         0
-       ),
-       (286...287),
-       (287...290),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(291...303)(
-       CallNode(291...299)(
-         nil,
-         nil,
-         (291...295),
-         nil,
-         nil,
-         nil,
-         BlockNode(296...299)([], nil, nil, (296...297), (298...299)),
-         0,
-         "loop"
-       ),
-       (299...300),
-       (300...303),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(304...318)(
-       IfNode(304...314)(
-         (304...306),
-         CallNode(307...310)(
-           nil,
-           nil,
-           (307...310),
-           nil,
-           nil,
-           nil,
-           nil,
-           2,
-           "foo"
-         ),
-         nil,
-         nil,
-         (311...314)
-       ),
-       (314...315),
-       (315...318),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "baz"
-     ),
-     CallNode(319...338)(
-       ParenthesesNode(319...334)(
-         StatementsNode(320...333)(
-           [CallNode(320...333)(
-              RegularExpressionNode(320...325)(
-                (320...321),
-                (321...324),
-                (324...325),
-                "bar",
-                0
-              ),
-              nil,
-              (326...328),
-              nil,
-              ArgumentsNode(329...333)(
-                [SymbolNode(329...333)((329...330), (330...333), nil, "foo")]
-              ),
-              nil,
-              nil,
-              0,
-              "=~"
-            )]
-         ),
-         (319...320),
-         (333...334)
-       ),
-       (334...335),
-       (335...338),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(339...349)(
-       ParenthesesNode(339...345)(
-         StatementsNode(340...344)(
-           [RangeNode(340...344)(
-              IntegerNode(340...341)(),
-              IntegerNode(343...344)(),
-              (341...343),
-              0
-            )]
-         ),
-         (339...340),
-         (344...345)
-       ),
-       (345...346),
-       (346...349),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "max"
-     ),
-     CallNode(350...368)(
-       ParenthesesNode(350...364)(
-         StatementsNode(351...363)(
-           [CallNode(351...363)(
-              CallNode(351...354)(
-                nil,
-                nil,
-                (351...354),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "foo"
-              ),
-              nil,
-              (355...357),
-              nil,
-              ArgumentsNode(358...363)(
-                [RegularExpressionNode(358...363)(
-                   (358...359),
-                   (359...362),
-                   (362...363),
-                   "bar",
-                   0
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "=~"
-            )]
-         ),
-         (350...351),
-         (363...364)
-       ),
-       (364...365),
-       (365...368),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(369...382)(
-       RegularExpressionNode(369...374)(
-         (369...370),
-         (370...373),
-         (373...374),
-         "bar",
-         0
-       ),
-       nil,
-       (375...377),
-       nil,
-       ArgumentsNode(378...382)(
-         [SymbolNode(378...382)((378...379), (379...382), nil, "foo")]
-       ),
-       nil,
-       nil,
-       0,
-       "=~"
-     ),
-     CallNode(383...395)(
-       RegularExpressionNode(383...388)(
-         (383...384),
-         (384...387),
-         (387...388),
-         "bar",
-         0
-       ),
-       nil,
-       (389...391),
-       nil,
-       ArgumentsNode(392...395)(
-         [CallNode(392...395)(
-            nil,
-            nil,
-            (392...395),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "=~"
-     ),
-     RangeNode(396...404)(
-       IntegerNode(396...397)(),
-       CallNode(399...404)(
-         IntegerNode(399...400)(),
-         (400...401),
-         (401...404),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "max"
-       ),
-       (397...399),
-       0
-     ),
-     CallNode(405...410)(
-       ConstantReadNode(405...406)(:A),
-       (406...407),
-       (407...410),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(411...416)(
-       nil,
-       nil,
-       (411...414),
-       (414...415),
-       nil,
-       (415...416),
-       nil,
-       0,
-       "FOO"
-     ),
-     CallNode(417...421)(
-       CallNode(417...418)(nil, nil, (417...418), nil, nil, nil, nil, 2, "a"),
-       (418...420),
-       (420...421),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "b"
-     ),
-     CallNode(422...427)(
-       CallNode(422...423)(nil, nil, (422...423), nil, nil, nil, nil, 2, "a"),
-       (423...424),
-       (424...427),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(428...431)(nil, nil, (428...431), nil, nil, nil, nil, 2, "foo"),
-     CallNode(432...450)(
-       CallNode(432...435)(
-         nil,
-         nil,
-         (432...435),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (436...438),
-       nil,
-       ArgumentsNode(439...450)(
-         [ParenthesesNode(439...450)(
-            StatementsNode(440...449)(
-              [CallNode(440...449)(
-                 CallNode(440...443)(
-                   nil,
-                   nil,
-                   (440...443),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "bar"
-                 ),
-                 nil,
-                 (444...445),
-                 nil,
-                 ArgumentsNode(446...449)(
-                   [CallNode(446...449)(
-                      nil,
-                      nil,
-                      (446...449),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "baz"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "*"
-               )]
-            ),
-            (439...440),
-            (449...450)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "<<"
-     ),
-     CallNode(451...463)(
-       CallNode(451...454)(
-         nil,
-         nil,
-         (451...454),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (455...457),
-       nil,
-       ArgumentsNode(458...463)(
-         [RegularExpressionNode(458...463)(
-            (458...459),
-            (459...462),
-            (462...463),
-            "bar",
-            0
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "=~"
-     ),
-     CallNode(464...482)(
-       nil,
-       nil,
-       (464...467),
-       (467...468),
-       ArgumentsNode(468...481)(
-         [BlockArgumentNode(468...481)(
-            ParenthesesNode(469...481)(
-              StatementsNode(470...480)(
-                [OrNode(470...480)(
-                   CallNode(470...473)(
-                     nil,
-                     nil,
-                     (470...473),
-                     nil,
-                     nil,
-                     nil,
-                     nil,
-                     2,
-                     "foo"
-                   ),
-                   CallNode(477...480)(
-                     nil,
-                     nil,
-                     (477...480),
-                     nil,
-                     nil,
-                     nil,
-                     nil,
-                     2,
-                     "bar"
-                   ),
-                   (474...476)
-                 )]
-              ),
-              (469...470),
-              (480...481)
-            ),
-            (468...469)
-          )]
-       ),
-       (481...482),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(483...494)(
-       nil,
-       nil,
-       (483...486),
-       (486...487),
-       ArgumentsNode(487...493)(
-         [BlockArgumentNode(487...493)(
-            CallNode(488...493)(
-              nil,
-              nil,
-              (488...493),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "block"
-            ),
-            (487...488)
-          )]
-       ),
-       (493...494),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(495...513)(
-       nil,
-       nil,
-       (495...498),
-       (498...499),
-       ArgumentsNode(499...512)(
-         [SplatNode(499...504)(
-            (499...500),
-            CallNode(500...504)(
-              nil,
-              nil,
-              (500...504),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "args"
-            )
-          ),
-          BlockArgumentNode(506...512)(
-            CallNode(507...512)(
-              nil,
-              nil,
-              (507...512),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "block"
-            ),
-            (506...507)
-          )]
-       ),
-       (512...513),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(514...529)(
-       nil,
-       nil,
-       (514...517),
-       (517...518),
-       ArgumentsNode(518...528)(
-         [SplatNode(518...528)(
-            (518...519),
-            CallNode(519...528)(
-              nil,
-              nil,
-              (519...528),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "arguments"
-            )
-          )]
-       ),
-       (528...529),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(530...539)(
-       nil,
-       nil,
-       (530...533),
-       (533...534),
-       ArgumentsNode(534...538)(
-         [IntegerNode(534...535)(), IntegerNode(537...538)()]
-       ),
-       (538...539),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(540...548)(
-       nil,
-       nil,
-       (540...543),
-       (543...544),
-       ArgumentsNode(544...547)(
-         [CallNode(544...547)(
-            nil,
-            nil,
-            (544...547),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       (547...548),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(549...564)(
-       nil,
-       nil,
-       (549...552),
-       (552...553),
-       ArgumentsNode(553...563)(
-         [CallNode(553...556)(
-            nil,
-            nil,
-            (553...556),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          ),
-          SplatNode(558...563)(
-            (558...559),
-            CallNode(559...563)(
-              nil,
-              nil,
-              (559...563),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "args"
-            )
-          )]
-       ),
-       (563...564),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(565...582)(
-       nil,
-       nil,
-       (565...568),
-       (568...569),
-       ArgumentsNode(569...581)(
-         [CallNode(569...581)(
-            CallNode(569...572)(
-              nil,
-              nil,
-              (569...572),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            ),
-            nil,
-            (573...575),
-            nil,
-            ArgumentsNode(576...581)(
-              [RegularExpressionNode(576...581)(
-                 (576...577),
-                 (577...580),
-                 (580...581),
-                 "bar",
-                 0
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "=~"
-          )]
-       ),
-       (581...582),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(583...596)(
-       CallNode(583...586)(
-         nil,
-         nil,
-         (583...586),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (586...587),
-       (587...590),
-       (590...591),
-       ArgumentsNode(591...595)(
-         [BlockArgumentNode(591...595)(
-            CallNode(592...595)(
-              nil,
-              nil,
-              (592...595),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            ),
-            (591...592)
-          )]
-       ),
-       (595...596),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(597...623)(
-       CallNode(597...600)(
-         nil,
-         nil,
-         (597...600),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (600...601),
-       (601...604),
-       (604...605),
-       ArgumentsNode(605...622)(
-         [SplatNode(605...610)(
-            (605...606),
-            CallNode(606...610)(
-              nil,
-              nil,
-              (606...610),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "arga"
-            )
-          ),
-          CallNode(612...615)(
-            nil,
-            nil,
-            (612...615),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          ),
-          SplatNode(617...622)(
-            (617...618),
-            CallNode(618...622)(
-              nil,
-              nil,
-              (618...622),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "argb"
-            )
-          )]
-       ),
-       (622...623),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(624...638)(
-       CallNode(624...627)(
-         nil,
-         nil,
-         (624...627),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (627...628),
-       (628...631),
-       (631...632),
-       ArgumentsNode(632...637)(
-         [SplatNode(632...637)(
-            (632...633),
-            CallNode(633...637)(
-              nil,
-              nil,
-              (633...637),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "args"
-            )
-          )]
-       ),
-       (637...638),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(639...658)(
-       CallNode(639...642)(
-         nil,
-         nil,
-         (639...642),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (642...643),
-       (643...646),
-       (646...647),
-       ArgumentsNode(647...657)(
-         [SplatNode(647...652)(
-            (647...648),
-            CallNode(648...652)(
-              nil,
-              nil,
-              (648...652),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "args"
-            )
-          ),
-          CallNode(654...657)(
-            nil,
-            nil,
-            (654...657),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          )]
-       ),
-       (657...658),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(659...678)(
-       CallNode(659...662)(
-         nil,
-         nil,
-         (659...662),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (662...663),
-       (663...666),
-       (666...667),
-       ArgumentsNode(667...677)(
-         [SymbolNode(667...671)((667...668), (668...671), nil, "baz"),
-          BlockArgumentNode(673...677)(
-            CallNode(674...677)(
-              nil,
-              nil,
-              (674...677),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            ),
-            (673...674)
-          )]
-       ),
-       (677...678),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(679...696)(
-       CallNode(679...682)(
-         nil,
-         nil,
-         (679...682),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (682...683),
-       (683...686),
-       (686...687),
-       ArgumentsNode(687...695)(
-         [KeywordHashNode(687...695)(
-            [AssocNode(687...695)(
-               SymbolNode(687...691)(nil, (687...690), (690...691), "baz"),
-               CallNode(692...695)(
-                 nil,
-                 nil,
-                 (692...695),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "boz"
-               ),
-               nil
-             )]
-          )]
-       ),
-       (695...696),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(697...723)(
-       CallNode(697...700)(
-         nil,
-         nil,
-         (697...700),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (700...701),
-       (701...704),
-       (704...705),
-       ArgumentsNode(705...722)(
-         [CallNode(705...708)(
-            nil,
-            nil,
-            (705...708),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          ),
-          KeywordHashNode(710...722)(
-            [AssocNode(710...722)(
-               StringNode(710...715)(
-                 (710...711),
-                 (711...714),
-                 (714...715),
-                 "baz"
-               ),
-               CallNode(719...722)(
-                 nil,
-                 nil,
-                 (719...722),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "boz"
-               ),
-               (716...718)
-             )]
-          )]
-       ),
-       (722...723),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(724...743)(
-       CallNode(724...727)(
-         nil,
-         nil,
-         (724...727),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (727...728),
-       (728...731),
-       (731...732),
-       ArgumentsNode(732...742)(
-         [CallNode(732...735)(
-            nil,
-            nil,
-            (732...735),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          ),
-          SplatNode(737...742)(
-            (737...738),
-            CallNode(738...742)(
-              nil,
-              nil,
-              (738...742),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "args"
-            )
-          )]
-       ),
-       (742...743),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(744...771)(
-       CallNode(744...747)(
-         nil,
-         nil,
-         (744...747),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (747...748),
-       (748...751),
-       (751...752),
-       ArgumentsNode(752...770)(
-         [CallNode(752...755)(
-            nil,
-            nil,
-            (752...755),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          ),
-          SplatNode(757...762)(
-            (757...758),
-            CallNode(758...762)(
-              nil,
-              nil,
-              (758...762),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "args"
-            )
-          ),
-          BlockArgumentNode(764...770)(
-            CallNode(765...770)(
-              nil,
-              nil,
-              (765...770),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "block"
-            ),
-            (764...765)
-          )]
-       ),
-       (770...771),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(772...788)(
-       CallNode(772...775)(
-         nil,
-         nil,
-         (772...775),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (775...776),
-       (776...779),
-       (779...780),
-       ArgumentsNode(780...787)(
-         [CallNode(780...783)(
-            nil,
-            nil,
-            (780...783),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          ),
-          HashNode(785...787)((785...786), [], (786...787))]
-       ),
-       (787...788),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(789...815)(
-       CallNode(789...792)(
-         nil,
-         nil,
-         (789...792),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (792...793),
-       (793...796),
-       (796...797),
-       ArgumentsNode(797...814)(
-         [HashNode(797...809)(
-            (797...798),
-            [AssocNode(799...807)(
-               SymbolNode(799...803)(nil, (799...802), (802...803), "foo"),
-               CallNode(804...807)(
-                 nil,
-                 nil,
-                 (804...807),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "boz"
-               ),
-               nil
-             )],
-            (808...809)
-          ),
-          CallNode(811...814)(
-            nil,
-            nil,
-            (811...814),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "boz"
-          )]
-       ),
-       (814...815),
-       nil,
-       0,
-       "bar"
-     ),
-     CallNode(816...828)(
-       CallNode(816...819)(
-         nil,
-         nil,
-         (816...819),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (819...820),
-       (820...823),
-       nil,
-       ArgumentsNode(824...828)(
-         [SymbolNode(824...828)((824...825), (825...828), nil, "baz")]
-       ),
-       nil,
-       nil,
-       0,
-       "bar="
-     ),
-     CallNode(829...838)(
-       nil,
-       nil,
-       (829...832),
-       (832...833),
-       ArgumentsNode(833...837)(
-         [KeywordHashNode(833...837)(
-            [AssocNode(833...837)(
-               SymbolNode(833...835)(nil, (833...834), (834...835), "a"),
-               CallNode(836...837)(
-                 nil,
-                 nil,
-                 (836...837),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "b"
-               ),
-               nil
-             )]
-          )]
-       ),
-       (837...838),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(839...850)(
-       CallNode(839...842)(
-         nil,
-         nil,
-         (839...842),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (842...843),
-       (843...844),
-       (844...845),
-       ArgumentsNode(845...849)(
-         [KeywordHashNode(845...849)(
-            [AssocNode(845...849)(
-               SymbolNode(845...847)(nil, (845...846), (846...847), "a"),
-               CallNode(848...849)(
-                 nil,
-                 nil,
-                 (848...849),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "b"
-               ),
-               nil
-             )]
-          )]
-       ),
-       (849...850),
-       nil,
-       0,
-       "&"
-     ),
-     CallNode(851...861)(
-       CallNode(851...854)(
-         nil,
-         nil,
-         (851...854),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (854...855),
-       (855...856),
-       (856...857),
-       ArgumentsNode(857...860)(
-         [KeywordHashNode(857...860)(
-            [AssocSplatNode(857...860)(
-               CallNode(859...860)(
-                 nil,
-                 nil,
-                 (859...860),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "a"
-               ),
-               (857...859)
-             )]
-          )]
-       ),
-       (860...861),
-       nil,
-       0,
-       "&"
-     ),
-     CallNode(862...871)(
-       CallNode(862...865)(
-         nil,
-         nil,
-         (862...865),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (865...871),
-       (865...866),
-       ArgumentsNode(866...870)(
-         [SplatNode(866...870)(
-            (866...867),
-            CallNode(867...870)(
-              nil,
-              nil,
-              (867...870),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )
-          )]
-       ),
-       (870...871),
-       nil,
-       0,
-       "[]"
-     ),
-     CallNode(872...881)(
-       CallNode(872...875)(
-         nil,
-         nil,
-         (872...875),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (875...881),
-       (875...876),
-       ArgumentsNode(876...880)(
-         [IntegerNode(876...877)(), IntegerNode(879...880)()]
-       ),
-       (880...881),
-       nil,
-       0,
-       "[]"
-     ),
-     CallNode(882...887)(
-       CallNode(882...885)(
-         nil,
-         nil,
-         (882...885),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (885...887),
-       (885...886),
-       nil,
-       (886...887),
-       nil,
-       0,
-       "[]"
-     ),
-     CallNode(888...896)(
-       SelfNode(888...892)(),
-       (892...893),
-       (893...896),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(897...910)(
-       SelfNode(897...901)(),
-       (901...902),
-       (902...905),
-       nil,
-       ArgumentsNode(906...910)(
-         [SymbolNode(906...910)((906...907), (907...910), nil, "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "foo="
-     ),
-     CallNode(911...928)(
-       ParenthesesNode(911...918)(
-         StatementsNode(912...917)(
-           [CallNode(912...917)(
-              CallNode(912...913)(
-                nil,
-                nil,
-                (912...913),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "a"
-              ),
-              nil,
-              (914...915),
-              nil,
-              ArgumentsNode(916...917)(
-                [CallNode(916...917)(
-                   nil,
-                   nil,
-                   (916...917),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "b"
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "+"
-            )]
-         ),
-         (911...912),
-         (917...918)
-       ),
-       nil,
-       (919...920),
-       nil,
-       ArgumentsNode(921...928)(
-         [ParenthesesNode(921...928)(
-            StatementsNode(922...927)(
-              [CallNode(922...927)(
-                 CallNode(922...923)(
-                   nil,
-                   nil,
-                   (922...923),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "c"
-                 ),
-                 nil,
-                 (924...925),
-                 nil,
-                 ArgumentsNode(926...927)(
-                   [CallNode(926...927)(
-                      nil,
-                      nil,
-                      (926...927),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "-"
-               )]
-            ),
-            (921...922),
-            (927...928)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "/"
-     ),
-     CallNode(929...948)(
-       ParenthesesNode(929...936)(
-         StatementsNode(930...935)(
-           [CallNode(930...935)(
-              CallNode(930...931)(
-                nil,
-                nil,
-                (930...931),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "a"
-              ),
-              nil,
-              (932...933),
-              nil,
-              ArgumentsNode(934...935)(
-                [CallNode(934...935)(
-                   nil,
-                   nil,
-                   (934...935),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "b"
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "+"
-            )]
-         ),
-         (929...930),
-         (935...936)
-       ),
-       nil,
-       (937...938),
-       nil,
-       ArgumentsNode(939...948)(
-         [CallNode(939...948)(
-            CallNode(939...940)(
-              nil,
-              nil,
-              (939...940),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "c"
-            ),
-            (940...941),
-            (941...942),
-            (942...943),
-            ArgumentsNode(943...947)(
-              [CallNode(943...944)(
-                 nil,
-                 nil,
-                 (943...944),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "e"
-               ),
-               CallNode(946...947)(
-                 nil,
-                 nil,
-                 (946...947),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "f"
-               )]
-            ),
-            (947...948),
-            nil,
-            0,
-            "-"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "/"
-     ),
-     CallNode(949...966)(
-       ParenthesesNode(949...956)(
-         StatementsNode(950...955)(
-           [CallNode(950...955)(
-              CallNode(950...951)(
-                nil,
-                nil,
-                (950...951),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "a"
-              ),
-              nil,
-              (952...953),
-              nil,
-              ArgumentsNode(954...955)(
-                [CallNode(954...955)(
-                   nil,
-                   nil,
-                   (954...955),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "b"
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "+"
-            )]
-         ),
-         (949...950),
-         (955...956)
-       ),
-       nil,
-       (957...958),
-       nil,
-       ArgumentsNode(959...966)(
-         [CallNode(959...966)(
-            CallNode(959...960)(
-              nil,
-              nil,
-              (959...960),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "c"
-            ),
-            (960...961),
-            (961...962),
-            (962...963),
-            ArgumentsNode(963...965)(
-              [SplatNode(963...965)(
-                 (963...964),
-                 CallNode(964...965)(
-                   nil,
-                   nil,
-                   (964...965),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "f"
-                 )
-               )]
-            ),
-            (965...966),
-            nil,
-            0,
-            "-"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "/"
-     ),
-     CallNode(967...975)(
-       nil,
-       nil,
-       (967...968),
-       (968...969),
-       ArgumentsNode(969...974)(
-         [KeywordHashNode(969...974)(
-            [AssocSplatNode(969...974)(
-               CallNode(971...974)(
-                 nil,
-                 nil,
-                 (971...974),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               ),
-               (969...971)
-             )]
-          )]
-       ),
-       (974...975),
-       nil,
-       0,
-       "x"
-     ),
-     CallNode(976...982)(
-       CallNode(976...979)(
-         nil,
-         nil,
-         (976...979),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (979...981),
-       (981...982),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "!"
-     ),
-     CallNode(983...991)(
-       CallNode(983...986)(
-         nil,
-         nil,
-         (983...986),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       (986...987),
-       (987...988),
-       (988...989),
-       ArgumentsNode(989...990)(
-         [CallNode(989...990)(
-            nil,
-            nil,
-            (989...990),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (990...991),
-       nil,
-       0,
-       "~"
-     ),
-     CallNode(992...999)(
-       CallNode(992...993)(nil, nil, (992...993), nil, nil, nil, nil, 2, "a"),
-       (993...995),
-       (995...996),
-       (996...997),
-       ArgumentsNode(997...998)(
-         [CallNode(997...998)(
-            nil,
-            nil,
-            (997...998),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (998...999),
-       nil,
-       1,
-       "+"
-     )]
-  )
-)
+@ ProgramNode (location: (0...999))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...999))
+    └── body: (length: 62)
+        ├── @ ModuleNode (location: (0...35))
+        │   ├── locals: [:foo, :a, :_]
+        │   ├── module_keyword_loc: (0...6) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (7...8))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (11...31))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableOrWriteNode (location: (11...31))
+        │   │           ├── name_loc: (11...14) = "foo"
+        │   │           ├── operator_loc: (15...18) = "||="
+        │   │           ├── value:
+        │   │           │   @ ParenthesesNode (location: (19...31))
+        │   │           │   ├── body:
+        │   │           │   │   @ StatementsNode (location: (20...30))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ MultiWriteNode (location: (20...30))
+        │   │           │   │           ├── targets: (length: 2)
+        │   │           │   │           │   ├── @ LocalVariableTargetNode (location: (21...22))
+        │   │           │   │           │   │   ├── name: :a
+        │   │           │   │           │   │   └── depth: 0
+        │   │           │   │           │   └── @ LocalVariableTargetNode (location: (24...25))
+        │   │           │   │           │       ├── name: :_
+        │   │           │   │           │       └── depth: 0
+        │   │           │   │           ├── lparen_loc: (20...21) = "("
+        │   │           │   │           ├── rparen_loc: (25...26) = ")"
+        │   │           │   │           ├── operator_loc: (27...28) = "="
+        │   │           │   │           └── value:
+        │   │           │   │               @ CallNode (location: (29...30))
+        │   │           │   │               ├── receiver: ∅
+        │   │           │   │               ├── call_operator_loc: ∅
+        │   │           │   │               ├── message_loc: (29...30) = "b"
+        │   │           │   │               ├── opening_loc: ∅
+        │   │           │   │               ├── arguments: ∅
+        │   │           │   │               ├── closing_loc: ∅
+        │   │           │   │               ├── block: ∅
+        │   │           │   │               ├── flags: variable_call
+        │   │           │   │               └── name: "b"
+        │   │           │   ├── opening_loc: (19...20) = "("
+        │   │           │   └── closing_loc: (30...31) = ")"
+        │   │           ├── name: :foo
+        │   │           └── depth: 0
+        │   ├── end_keyword_loc: (32...35) = "end"
+        │   └── name: :A
+        ├── @ ModuleNode (location: (37...73))
+        │   ├── locals: [:local]
+        │   ├── module_keyword_loc: (37...43) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (44...45))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (48...69))
+        │   │   └── body: (length: 2)
+        │   │       ├── @ LocalVariableWriteNode (location: (48...57))
+        │   │       │   ├── name: :local
+        │   │       │   ├── depth: 0
+        │   │       │   ├── name_loc: (48...53) = "local"
+        │   │       │   ├── value:
+        │   │       │   │   @ IntegerNode (location: (56...57))
+        │   │       │   └── operator_loc: (54...55) = "="
+        │   │       └── @ CallNode (location: (60...69))
+        │   │           ├── receiver:
+        │   │           │   @ LocalVariableReadNode (location: (60...65))
+        │   │           │   ├── name: :local
+        │   │           │   └── depth: 0
+        │   │           ├── call_operator_loc: (65...66) = "."
+        │   │           ├── message_loc: (66...69) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── end_keyword_loc: (70...73) = "end"
+        │   └── name: :A
+        ├── @ CallNode (location: (74...89))
+        │   ├── receiver:
+        │   │   @ ClassNode (location: (74...85))
+        │   │   ├── locals: []
+        │   │   ├── class_keyword_loc: (74...79) = "class"
+        │   │   ├── constant_path:
+        │   │   │   @ ConstantReadNode (location: (80...81))
+        │   │   │   └── name: :A
+        │   │   ├── inheritance_operator_loc: ∅
+        │   │   ├── superclass: ∅
+        │   │   ├── body: ∅
+        │   │   ├── end_keyword_loc: (82...85) = "end"
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (85...86) = "."
+        │   ├── message_loc: (86...89) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (90...106))
+        │   ├── receiver:
+        │   │   @ ModuleNode (location: (90...102))
+        │   │   ├── locals: []
+        │   │   ├── module_keyword_loc: (90...96) = "module"
+        │   │   ├── constant_path:
+        │   │   │   @ ConstantReadNode (location: (97...98))
+        │   │   │   └── name: :A
+        │   │   ├── body: ∅
+        │   │   ├── end_keyword_loc: (99...102) = "end"
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (102...103) = "."
+        │   ├── message_loc: (103...106) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (107...127))
+        │   ├── receiver:
+        │   │   @ BeginNode (location: (107...123))
+        │   │   ├── begin_keyword_loc: (107...112) = "begin"
+        │   │   ├── statements: ∅
+        │   │   ├── rescue_clause:
+        │   │   │   @ RescueNode (location: (113...119))
+        │   │   │   ├── keyword_loc: (113...119) = "rescue"
+        │   │   │   ├── exceptions: (length: 0)
+        │   │   │   ├── operator_loc: ∅
+        │   │   │   ├── reference: ∅
+        │   │   │   ├── statements: ∅
+        │   │   │   └── consequent: ∅
+        │   │   ├── else_clause: ∅
+        │   │   ├── ensure_clause: ∅
+        │   │   └── end_keyword_loc: (120...123) = "end"
+        │   ├── call_operator_loc: (123...124) = "."
+        │   ├── message_loc: (124...127) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (128...169))
+        │   ├── receiver:
+        │   │   @ CaseNode (location: (128...165))
+        │   │   ├── predicate:
+        │   │   │   @ ParenthesesNode (location: (133...152))
+        │   │   │   ├── body:
+        │   │   │   │   @ StatementsNode (location: (134...151))
+        │   │   │   │   └── body: (length: 2)
+        │   │   │   │       ├── @ DefNode (location: (134...145))
+        │   │   │   │       │   ├── name: :foo
+        │   │   │   │       │   ├── name_loc: (138...141) = "foo"
+        │   │   │   │       │   ├── receiver: ∅
+        │   │   │   │       │   ├── parameters: ∅
+        │   │   │   │       │   ├── body: ∅
+        │   │   │   │       │   ├── locals: []
+        │   │   │   │       │   ├── def_keyword_loc: (134...137) = "def"
+        │   │   │   │       │   ├── operator_loc: ∅
+        │   │   │   │       │   ├── lparen_loc: ∅
+        │   │   │   │       │   ├── rparen_loc: ∅
+        │   │   │   │       │   ├── equal_loc: ∅
+        │   │   │   │       │   └── end_keyword_loc: (142...145) = "end"
+        │   │   │   │       └── @ SymbolNode (location: (147...151))
+        │   │   │   │           ├── opening_loc: (147...148) = ":"
+        │   │   │   │           ├── value_loc: (148...151) = "bar"
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           └── unescaped: "bar"
+        │   │   │   ├── opening_loc: (133...134) = "("
+        │   │   │   └── closing_loc: (151...152) = ")"
+        │   │   ├── conditions: (length: 1)
+        │   │   │   └── @ WhenNode (location: (153...161))
+        │   │   │       ├── keyword_loc: (153...157) = "when"
+        │   │   │       ├── conditions: (length: 1)
+        │   │   │       │   └── @ CallNode (location: (158...161))
+        │   │   │       │       ├── receiver: ∅
+        │   │   │       │       ├── call_operator_loc: ∅
+        │   │   │       │       ├── message_loc: (158...161) = "bar"
+        │   │   │       │       ├── opening_loc: ∅
+        │   │   │       │       ├── arguments: ∅
+        │   │   │       │       ├── closing_loc: ∅
+        │   │   │       │       ├── block: ∅
+        │   │   │       │       ├── flags: variable_call
+        │   │   │       │       └── name: "bar"
+        │   │   │       └── statements: ∅
+        │   │   ├── consequent: ∅
+        │   │   ├── case_keyword_loc: (128...132) = "case"
+        │   │   └── end_keyword_loc: (162...165) = "end"
+        │   ├── call_operator_loc: (165...166) = "."
+        │   ├── message_loc: (166...169) = "baz"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "baz"
+        ├── @ CallNode (location: (170...195))
+        │   ├── receiver:
+        │   │   @ CaseNode (location: (170...191))
+        │   │   ├── predicate:
+        │   │   │   @ CallNode (location: (175...178))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (175...178) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── conditions: (length: 1)
+        │   │   │   └── @ WhenNode (location: (179...187))
+        │   │   │       ├── keyword_loc: (179...183) = "when"
+        │   │   │       ├── conditions: (length: 1)
+        │   │   │       │   └── @ CallNode (location: (184...187))
+        │   │   │       │       ├── receiver: ∅
+        │   │   │       │       ├── call_operator_loc: ∅
+        │   │   │       │       ├── message_loc: (184...187) = "bar"
+        │   │   │       │       ├── opening_loc: ∅
+        │   │   │       │       ├── arguments: ∅
+        │   │   │       │       ├── closing_loc: ∅
+        │   │   │       │       ├── block: ∅
+        │   │   │       │       ├── flags: variable_call
+        │   │   │       │       └── name: "bar"
+        │   │   │       └── statements: ∅
+        │   │   ├── consequent: ∅
+        │   │   ├── case_keyword_loc: (170...174) = "case"
+        │   │   └── end_keyword_loc: (188...191) = "end"
+        │   ├── call_operator_loc: (191...192) = "."
+        │   ├── message_loc: (192...195) = "baz"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "baz"
+        ├── @ CallNode (location: (196...217))
+        │   ├── receiver:
+        │   │   @ SingletonClassNode (location: (196...213))
+        │   │   ├── locals: []
+        │   │   ├── class_keyword_loc: (196...201) = "class"
+        │   │   ├── operator_loc: (202...204) = "<<"
+        │   │   ├── expression:
+        │   │   │   @ SelfNode (location: (205...209))
+        │   │   ├── body: ∅
+        │   │   └── end_keyword_loc: (210...213) = "end"
+        │   ├── call_operator_loc: (213...214) = "."
+        │   ├── message_loc: (214...217) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (218...238))
+        │   ├── receiver:
+        │   │   @ DefNode (location: (218...234))
+        │   │   ├── name: :foo
+        │   │   ├── name_loc: (227...230) = "foo"
+        │   │   ├── receiver:
+        │   │   │   @ SelfNode (location: (222...226))
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── locals: []
+        │   │   ├── def_keyword_loc: (218...221) = "def"
+        │   │   ├── operator_loc: (226...227) = "."
+        │   │   ├── lparen_loc: ∅
+        │   │   ├── rparen_loc: ∅
+        │   │   ├── equal_loc: ∅
+        │   │   └── end_keyword_loc: (231...234) = "end"
+        │   ├── call_operator_loc: (234...235) = "."
+        │   ├── message_loc: (235...238) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (239...254))
+        │   ├── receiver:
+        │   │   @ DefNode (location: (239...250))
+        │   │   ├── name: :foo
+        │   │   ├── name_loc: (243...246) = "foo"
+        │   │   ├── receiver: ∅
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── locals: []
+        │   │   ├── def_keyword_loc: (239...242) = "def"
+        │   │   ├── operator_loc: ∅
+        │   │   ├── lparen_loc: ∅
+        │   │   ├── rparen_loc: ∅
+        │   │   ├── equal_loc: ∅
+        │   │   └── end_keyword_loc: (247...250) = "end"
+        │   ├── call_operator_loc: (250...251) = "."
+        │   ├── message_loc: (251...254) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (255...272))
+        │   ├── receiver:
+        │   │   @ UntilNode (location: (255...268))
+        │   │   ├── keyword_loc: (255...260) = "until"
+        │   │   ├── closing_loc: (265...268) = "end"
+        │   │   ├── predicate:
+        │   │   │   @ CallNode (location: (261...264))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (261...264) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── statements: ∅
+        │   │   └── flags: 
+        │   ├── call_operator_loc: (268...269) = "."
+        │   ├── message_loc: (269...272) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (273...290))
+        │   ├── receiver:
+        │   │   @ WhileNode (location: (273...286))
+        │   │   ├── keyword_loc: (273...278) = "while"
+        │   │   ├── closing_loc: (283...286) = "end"
+        │   │   ├── predicate:
+        │   │   │   @ CallNode (location: (279...282))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (279...282) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── statements: ∅
+        │   │   └── flags: 
+        │   ├── call_operator_loc: (286...287) = "."
+        │   ├── message_loc: (287...290) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (291...303))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (291...299))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (291...295) = "loop"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (296...299))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (296...297) = "{"
+        │   │   │   └── closing_loc: (298...299) = "}"
+        │   │   ├── flags: 
+        │   │   └── name: "loop"
+        │   ├── call_operator_loc: (299...300) = "."
+        │   ├── message_loc: (300...303) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (304...318))
+        │   ├── receiver:
+        │   │   @ IfNode (location: (304...314))
+        │   │   ├── if_keyword_loc: (304...306) = "if"
+        │   │   ├── predicate:
+        │   │   │   @ CallNode (location: (307...310))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (307...310) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── statements: ∅
+        │   │   ├── consequent: ∅
+        │   │   └── end_keyword_loc: (311...314) = "end"
+        │   ├── call_operator_loc: (314...315) = "."
+        │   ├── message_loc: (315...318) = "baz"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "baz"
+        ├── @ CallNode (location: (319...338))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (319...334))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (320...333))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (320...333))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ RegularExpressionNode (location: (320...325))
+        │   │   │           │   ├── opening_loc: (320...321) = "/"
+        │   │   │           │   ├── content_loc: (321...324) = "bar"
+        │   │   │           │   ├── closing_loc: (324...325) = "/"
+        │   │   │           │   ├── unescaped: "bar"
+        │   │   │           │   └── flags: 
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (326...328) = "=~"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (329...333))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ SymbolNode (location: (329...333))
+        │   │   │           │           ├── opening_loc: (329...330) = ":"
+        │   │   │           │           ├── value_loc: (330...333) = "foo"
+        │   │   │           │           ├── closing_loc: ∅
+        │   │   │           │           └── unescaped: "foo"
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "=~"
+        │   │   ├── opening_loc: (319...320) = "("
+        │   │   └── closing_loc: (333...334) = ")"
+        │   ├── call_operator_loc: (334...335) = "."
+        │   ├── message_loc: (335...338) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (339...349))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (339...345))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (340...344))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ RangeNode (location: (340...344))
+        │   │   │           ├── left:
+        │   │   │           │   @ IntegerNode (location: (340...341))
+        │   │   │           ├── right:
+        │   │   │           │   @ IntegerNode (location: (343...344))
+        │   │   │           ├── operator_loc: (341...343) = ".."
+        │   │   │           └── flags: 
+        │   │   ├── opening_loc: (339...340) = "("
+        │   │   └── closing_loc: (344...345) = ")"
+        │   ├── call_operator_loc: (345...346) = "."
+        │   ├── message_loc: (346...349) = "max"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "max"
+        ├── @ CallNode (location: (350...368))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (350...364))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (351...363))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (351...363))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ CallNode (location: (351...354))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (351...354) = "foo"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "foo"
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (355...357) = "=~"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (358...363))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ RegularExpressionNode (location: (358...363))
+        │   │   │           │           ├── opening_loc: (358...359) = "/"
+        │   │   │           │           ├── content_loc: (359...362) = "bar"
+        │   │   │           │           ├── closing_loc: (362...363) = "/"
+        │   │   │           │           ├── unescaped: "bar"
+        │   │   │           │           └── flags: 
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "=~"
+        │   │   ├── opening_loc: (350...351) = "("
+        │   │   └── closing_loc: (363...364) = ")"
+        │   ├── call_operator_loc: (364...365) = "."
+        │   ├── message_loc: (365...368) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (369...382))
+        │   ├── receiver:
+        │   │   @ RegularExpressionNode (location: (369...374))
+        │   │   ├── opening_loc: (369...370) = "/"
+        │   │   ├── content_loc: (370...373) = "bar"
+        │   │   ├── closing_loc: (373...374) = "/"
+        │   │   ├── unescaped: "bar"
+        │   │   └── flags: 
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (375...377) = "=~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (378...382))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SymbolNode (location: (378...382))
+        │   │           ├── opening_loc: (378...379) = ":"
+        │   │           ├── value_loc: (379...382) = "foo"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "foo"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=~"
+        ├── @ CallNode (location: (383...395))
+        │   ├── receiver:
+        │   │   @ RegularExpressionNode (location: (383...388))
+        │   │   ├── opening_loc: (383...384) = "/"
+        │   │   ├── content_loc: (384...387) = "bar"
+        │   │   ├── closing_loc: (387...388) = "/"
+        │   │   ├── unescaped: "bar"
+        │   │   └── flags: 
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (389...391) = "=~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (392...395))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (392...395))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (392...395) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "foo"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=~"
+        ├── @ RangeNode (location: (396...404))
+        │   ├── left:
+        │   │   @ IntegerNode (location: (396...397))
+        │   ├── right:
+        │   │   @ CallNode (location: (399...404))
+        │   │   ├── receiver:
+        │   │   │   @ IntegerNode (location: (399...400))
+        │   │   ├── call_operator_loc: (400...401) = "."
+        │   │   ├── message_loc: (401...404) = "max"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "max"
+        │   ├── operator_loc: (397...399) = ".."
+        │   └── flags: 
+        ├── @ CallNode (location: (405...410))
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (405...406))
+        │   │   └── name: :A
+        │   ├── call_operator_loc: (406...407) = "."
+        │   ├── message_loc: (407...410) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (411...416))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (411...414) = "FOO"
+        │   ├── opening_loc: (414...415) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (415...416) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "FOO"
+        ├── @ CallNode (location: (417...421))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (417...418))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (417...418) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (418...420) = "&."
+        │   ├── message_loc: (420...421) = "b"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: safe_navigation
+        │   └── name: "b"
+        ├── @ CallNode (location: (422...427))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (422...423))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (422...423) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (423...424) = "."
+        │   ├── message_loc: (424...427) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (428...431))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (428...431) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "foo"
+        ├── @ CallNode (location: (432...450))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (432...435))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (432...435) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (436...438) = "<<"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (439...450))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (439...450))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (440...449))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (440...449))
+        │   │           │           ├── receiver:
+        │   │           │           │   @ CallNode (location: (440...443))
+        │   │           │           │   ├── receiver: ∅
+        │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │           │   ├── message_loc: (440...443) = "bar"
+        │   │           │           │   ├── opening_loc: ∅
+        │   │           │           │   ├── arguments: ∅
+        │   │           │           │   ├── closing_loc: ∅
+        │   │           │           │   ├── block: ∅
+        │   │           │           │   ├── flags: variable_call
+        │   │           │           │   └── name: "bar"
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (444...445) = "*"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments:
+        │   │           │           │   @ ArgumentsNode (location: (446...449))
+        │   │           │           │   └── arguments: (length: 1)
+        │   │           │           │       └── @ CallNode (location: (446...449))
+        │   │           │           │           ├── receiver: ∅
+        │   │           │           │           ├── call_operator_loc: ∅
+        │   │           │           │           ├── message_loc: (446...449) = "baz"
+        │   │           │           │           ├── opening_loc: ∅
+        │   │           │           │           ├── arguments: ∅
+        │   │           │           │           ├── closing_loc: ∅
+        │   │           │           │           ├── block: ∅
+        │   │           │           │           ├── flags: variable_call
+        │   │           │           │           └── name: "baz"
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "*"
+        │   │           ├── opening_loc: (439...440) = "("
+        │   │           └── closing_loc: (449...450) = ")"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<<"
+        ├── @ CallNode (location: (451...463))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (451...454))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (451...454) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (455...457) = "=~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (458...463))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ RegularExpressionNode (location: (458...463))
+        │   │           ├── opening_loc: (458...459) = "/"
+        │   │           ├── content_loc: (459...462) = "bar"
+        │   │           ├── closing_loc: (462...463) = "/"
+        │   │           ├── unescaped: "bar"
+        │   │           └── flags: 
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=~"
+        ├── @ CallNode (location: (464...482))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (464...467) = "foo"
+        │   ├── opening_loc: (467...468) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (468...481))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ BlockArgumentNode (location: (468...481))
+        │   │           ├── expression:
+        │   │           │   @ ParenthesesNode (location: (469...481))
+        │   │           │   ├── body:
+        │   │           │   │   @ StatementsNode (location: (470...480))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ OrNode (location: (470...480))
+        │   │           │   │           ├── left:
+        │   │           │   │           │   @ CallNode (location: (470...473))
+        │   │           │   │           │   ├── receiver: ∅
+        │   │           │   │           │   ├── call_operator_loc: ∅
+        │   │           │   │           │   ├── message_loc: (470...473) = "foo"
+        │   │           │   │           │   ├── opening_loc: ∅
+        │   │           │   │           │   ├── arguments: ∅
+        │   │           │   │           │   ├── closing_loc: ∅
+        │   │           │   │           │   ├── block: ∅
+        │   │           │   │           │   ├── flags: variable_call
+        │   │           │   │           │   └── name: "foo"
+        │   │           │   │           ├── right:
+        │   │           │   │           │   @ CallNode (location: (477...480))
+        │   │           │   │           │   ├── receiver: ∅
+        │   │           │   │           │   ├── call_operator_loc: ∅
+        │   │           │   │           │   ├── message_loc: (477...480) = "bar"
+        │   │           │   │           │   ├── opening_loc: ∅
+        │   │           │   │           │   ├── arguments: ∅
+        │   │           │   │           │   ├── closing_loc: ∅
+        │   │           │   │           │   ├── block: ∅
+        │   │           │   │           │   ├── flags: variable_call
+        │   │           │   │           │   └── name: "bar"
+        │   │           │   │           └── operator_loc: (474...476) = "||"
+        │   │           │   ├── opening_loc: (469...470) = "("
+        │   │           │   └── closing_loc: (480...481) = ")"
+        │   │           └── operator_loc: (468...469) = "&"
+        │   ├── closing_loc: (481...482) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (483...494))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (483...486) = "foo"
+        │   ├── opening_loc: (486...487) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (487...493))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ BlockArgumentNode (location: (487...493))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (488...493))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (488...493) = "block"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "block"
+        │   │           └── operator_loc: (487...488) = "&"
+        │   ├── closing_loc: (493...494) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (495...513))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (495...498) = "foo"
+        │   ├── opening_loc: (498...499) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (499...512))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SplatNode (location: (499...504))
+        │   │       │   ├── operator_loc: (499...500) = "*"
+        │   │       │   └── expression:
+        │   │       │       @ CallNode (location: (500...504))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (500...504) = "args"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "args"
+        │   │       └── @ BlockArgumentNode (location: (506...512))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (507...512))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (507...512) = "block"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "block"
+        │   │           └── operator_loc: (506...507) = "&"
+        │   ├── closing_loc: (512...513) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (514...529))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (514...517) = "foo"
+        │   ├── opening_loc: (517...518) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (518...528))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SplatNode (location: (518...528))
+        │   │           ├── operator_loc: (518...519) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (519...528))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (519...528) = "arguments"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "arguments"
+        │   ├── closing_loc: (528...529) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (530...539))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (530...533) = "foo"
+        │   ├── opening_loc: (533...534) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (534...538))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ IntegerNode (location: (534...535))
+        │   │       └── @ IntegerNode (location: (537...538))
+        │   ├── closing_loc: (538...539) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (540...548))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (540...543) = "foo"
+        │   ├── opening_loc: (543...544) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (544...547))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (544...547))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (544...547) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: (547...548) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (549...564))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (549...552) = "foo"
+        │   ├── opening_loc: (552...553) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (553...563))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (553...556))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (553...556) = "bar"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "bar"
+        │   │       └── @ SplatNode (location: (558...563))
+        │   │           ├── operator_loc: (558...559) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (559...563))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (559...563) = "args"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "args"
+        │   ├── closing_loc: (563...564) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (565...582))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (565...568) = "foo"
+        │   ├── opening_loc: (568...569) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (569...581))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (569...581))
+        │   │           ├── receiver:
+        │   │           │   @ CallNode (location: (569...572))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (569...572) = "foo"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "foo"
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (573...575) = "=~"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (576...581))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ RegularExpressionNode (location: (576...581))
+        │   │           │           ├── opening_loc: (576...577) = "/"
+        │   │           │           ├── content_loc: (577...580) = "bar"
+        │   │           │           ├── closing_loc: (580...581) = "/"
+        │   │           │           ├── unescaped: "bar"
+        │   │           │           └── flags: 
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "=~"
+        │   ├── closing_loc: (581...582) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (583...596))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (583...586))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (583...586) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (586...587) = "."
+        │   ├── message_loc: (587...590) = "bar"
+        │   ├── opening_loc: (590...591) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (591...595))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ BlockArgumentNode (location: (591...595))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (592...595))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (592...595) = "baz"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "baz"
+        │   │           └── operator_loc: (591...592) = "&"
+        │   ├── closing_loc: (595...596) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (597...623))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (597...600))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (597...600) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (600...601) = "."
+        │   ├── message_loc: (601...604) = "bar"
+        │   ├── opening_loc: (604...605) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (605...622))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ SplatNode (location: (605...610))
+        │   │       │   ├── operator_loc: (605...606) = "*"
+        │   │       │   └── expression:
+        │   │       │       @ CallNode (location: (606...610))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (606...610) = "arga"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "arga"
+        │   │       ├── @ CallNode (location: (612...615))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (612...615) = "foo"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "foo"
+        │   │       └── @ SplatNode (location: (617...622))
+        │   │           ├── operator_loc: (617...618) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (618...622))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (618...622) = "argb"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "argb"
+        │   ├── closing_loc: (622...623) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (624...638))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (624...627))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (624...627) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (627...628) = "."
+        │   ├── message_loc: (628...631) = "bar"
+        │   ├── opening_loc: (631...632) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (632...637))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SplatNode (location: (632...637))
+        │   │           ├── operator_loc: (632...633) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (633...637))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (633...637) = "args"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "args"
+        │   ├── closing_loc: (637...638) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (639...658))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (639...642))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (639...642) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (642...643) = "."
+        │   ├── message_loc: (643...646) = "bar"
+        │   ├── opening_loc: (646...647) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (647...657))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SplatNode (location: (647...652))
+        │   │       │   ├── operator_loc: (647...648) = "*"
+        │   │       │   └── expression:
+        │   │       │       @ CallNode (location: (648...652))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (648...652) = "args"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "args"
+        │   │       └── @ CallNode (location: (654...657))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (654...657) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "foo"
+        │   ├── closing_loc: (657...658) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (659...678))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (659...662))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (659...662) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (662...663) = "."
+        │   ├── message_loc: (663...666) = "bar"
+        │   ├── opening_loc: (666...667) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (667...677))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (667...671))
+        │   │       │   ├── opening_loc: (667...668) = ":"
+        │   │       │   ├── value_loc: (668...671) = "baz"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "baz"
+        │   │       └── @ BlockArgumentNode (location: (673...677))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (674...677))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (674...677) = "baz"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "baz"
+        │   │           └── operator_loc: (673...674) = "&"
+        │   ├── closing_loc: (677...678) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (679...696))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (679...682))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (679...682) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (682...683) = "."
+        │   ├── message_loc: (683...686) = "bar"
+        │   ├── opening_loc: (686...687) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (687...695))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (687...695))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (687...695))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (687...691))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (687...690) = "baz"
+        │   │                   │   ├── closing_loc: (690...691) = ":"
+        │   │                   │   └── unescaped: "baz"
+        │   │                   ├── value:
+        │   │                   │   @ CallNode (location: (692...695))
+        │   │                   │   ├── receiver: ∅
+        │   │                   │   ├── call_operator_loc: ∅
+        │   │                   │   ├── message_loc: (692...695) = "boz"
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── arguments: ∅
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   ├── block: ∅
+        │   │                   │   ├── flags: variable_call
+        │   │                   │   └── name: "boz"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: (695...696) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (697...723))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (697...700))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (697...700) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (700...701) = "."
+        │   ├── message_loc: (701...704) = "bar"
+        │   ├── opening_loc: (704...705) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (705...722))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (705...708))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (705...708) = "foo"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "foo"
+        │   │       └── @ KeywordHashNode (location: (710...722))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (710...722))
+        │   │                   ├── key:
+        │   │                   │   @ StringNode (location: (710...715))
+        │   │                   │   ├── opening_loc: (710...711) = "\""
+        │   │                   │   ├── content_loc: (711...714) = "baz"
+        │   │                   │   ├── closing_loc: (714...715) = "\""
+        │   │                   │   └── unescaped: "baz"
+        │   │                   ├── value:
+        │   │                   │   @ CallNode (location: (719...722))
+        │   │                   │   ├── receiver: ∅
+        │   │                   │   ├── call_operator_loc: ∅
+        │   │                   │   ├── message_loc: (719...722) = "boz"
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── arguments: ∅
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   ├── block: ∅
+        │   │                   │   ├── flags: variable_call
+        │   │                   │   └── name: "boz"
+        │   │                   └── operator_loc: (716...718) = "=>"
+        │   ├── closing_loc: (722...723) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (724...743))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (724...727))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (724...727) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (727...728) = "."
+        │   ├── message_loc: (728...731) = "bar"
+        │   ├── opening_loc: (731...732) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (732...742))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (732...735))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (732...735) = "foo"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "foo"
+        │   │       └── @ SplatNode (location: (737...742))
+        │   │           ├── operator_loc: (737...738) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (738...742))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (738...742) = "args"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "args"
+        │   ├── closing_loc: (742...743) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (744...771))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (744...747))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (744...747) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (747...748) = "."
+        │   ├── message_loc: (748...751) = "bar"
+        │   ├── opening_loc: (751...752) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (752...770))
+        │   │   └── arguments: (length: 3)
+        │   │       ├── @ CallNode (location: (752...755))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (752...755) = "foo"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "foo"
+        │   │       ├── @ SplatNode (location: (757...762))
+        │   │       │   ├── operator_loc: (757...758) = "*"
+        │   │       │   └── expression:
+        │   │       │       @ CallNode (location: (758...762))
+        │   │       │       ├── receiver: ∅
+        │   │       │       ├── call_operator_loc: ∅
+        │   │       │       ├── message_loc: (758...762) = "args"
+        │   │       │       ├── opening_loc: ∅
+        │   │       │       ├── arguments: ∅
+        │   │       │       ├── closing_loc: ∅
+        │   │       │       ├── block: ∅
+        │   │       │       ├── flags: variable_call
+        │   │       │       └── name: "args"
+        │   │       └── @ BlockArgumentNode (location: (764...770))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (765...770))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (765...770) = "block"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "block"
+        │   │           └── operator_loc: (764...765) = "&"
+        │   ├── closing_loc: (770...771) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (772...788))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (772...775))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (772...775) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (775...776) = "."
+        │   ├── message_loc: (776...779) = "bar"
+        │   ├── opening_loc: (779...780) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (780...787))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (780...783))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (780...783) = "foo"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "foo"
+        │   │       └── @ HashNode (location: (785...787))
+        │   │           ├── opening_loc: (785...786) = "{"
+        │   │           ├── elements: (length: 0)
+        │   │           └── closing_loc: (786...787) = "}"
+        │   ├── closing_loc: (787...788) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (789...815))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (789...792))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (789...792) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (792...793) = "."
+        │   ├── message_loc: (793...796) = "bar"
+        │   ├── opening_loc: (796...797) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (797...814))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ HashNode (location: (797...809))
+        │   │       │   ├── opening_loc: (797...798) = "{"
+        │   │       │   ├── elements: (length: 1)
+        │   │       │   │   └── @ AssocNode (location: (799...807))
+        │   │       │   │       ├── key:
+        │   │       │   │       │   @ SymbolNode (location: (799...803))
+        │   │       │   │       │   ├── opening_loc: ∅
+        │   │       │   │       │   ├── value_loc: (799...802) = "foo"
+        │   │       │   │       │   ├── closing_loc: (802...803) = ":"
+        │   │       │   │       │   └── unescaped: "foo"
+        │   │       │   │       ├── value:
+        │   │       │   │       │   @ CallNode (location: (804...807))
+        │   │       │   │       │   ├── receiver: ∅
+        │   │       │   │       │   ├── call_operator_loc: ∅
+        │   │       │   │       │   ├── message_loc: (804...807) = "boz"
+        │   │       │   │       │   ├── opening_loc: ∅
+        │   │       │   │       │   ├── arguments: ∅
+        │   │       │   │       │   ├── closing_loc: ∅
+        │   │       │   │       │   ├── block: ∅
+        │   │       │   │       │   ├── flags: variable_call
+        │   │       │   │       │   └── name: "boz"
+        │   │       │   │       └── operator_loc: ∅
+        │   │       │   └── closing_loc: (808...809) = "}"
+        │   │       └── @ CallNode (location: (811...814))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (811...814) = "boz"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "boz"
+        │   ├── closing_loc: (814...815) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar"
+        ├── @ CallNode (location: (816...828))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (816...819))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (816...819) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (819...820) = "."
+        │   ├── message_loc: (820...823) = "bar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (824...828))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SymbolNode (location: (824...828))
+        │   │           ├── opening_loc: (824...825) = ":"
+        │   │           ├── value_loc: (825...828) = "baz"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "baz"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "bar="
+        ├── @ CallNode (location: (829...838))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (829...832) = "foo"
+        │   ├── opening_loc: (832...833) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (833...837))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (833...837))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (833...837))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (833...835))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (833...834) = "a"
+        │   │                   │   ├── closing_loc: (834...835) = ":"
+        │   │                   │   └── unescaped: "a"
+        │   │                   ├── value:
+        │   │                   │   @ CallNode (location: (836...837))
+        │   │                   │   ├── receiver: ∅
+        │   │                   │   ├── call_operator_loc: ∅
+        │   │                   │   ├── message_loc: (836...837) = "b"
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── arguments: ∅
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   ├── block: ∅
+        │   │                   │   ├── flags: variable_call
+        │   │                   │   └── name: "b"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: (837...838) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (839...850))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (839...842))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (839...842) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (842...843) = "."
+        │   ├── message_loc: (843...844) = "&"
+        │   ├── opening_loc: (844...845) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (845...849))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (845...849))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (845...849))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (845...847))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (845...846) = "a"
+        │   │                   │   ├── closing_loc: (846...847) = ":"
+        │   │                   │   └── unescaped: "a"
+        │   │                   ├── value:
+        │   │                   │   @ CallNode (location: (848...849))
+        │   │                   │   ├── receiver: ∅
+        │   │                   │   ├── call_operator_loc: ∅
+        │   │                   │   ├── message_loc: (848...849) = "b"
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── arguments: ∅
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   ├── block: ∅
+        │   │                   │   ├── flags: variable_call
+        │   │                   │   └── name: "b"
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: (849...850) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "&"
+        ├── @ CallNode (location: (851...861))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (851...854))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (851...854) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (854...855) = "."
+        │   ├── message_loc: (855...856) = "&"
+        │   ├── opening_loc: (856...857) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (857...860))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (857...860))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocSplatNode (location: (857...860))
+        │   │                   ├── value:
+        │   │                   │   @ CallNode (location: (859...860))
+        │   │                   │   ├── receiver: ∅
+        │   │                   │   ├── call_operator_loc: ∅
+        │   │                   │   ├── message_loc: (859...860) = "a"
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── arguments: ∅
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   ├── block: ∅
+        │   │                   │   ├── flags: variable_call
+        │   │                   │   └── name: "a"
+        │   │                   └── operator_loc: (857...859) = "**"
+        │   ├── closing_loc: (860...861) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "&"
+        ├── @ CallNode (location: (862...871))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (862...865))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (862...865) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (865...871) = "[*baz]"
+        │   ├── opening_loc: (865...866) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (866...870))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SplatNode (location: (866...870))
+        │   │           ├── operator_loc: (866...867) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (867...870))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (867...870) = "baz"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "baz"
+        │   ├── closing_loc: (870...871) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ CallNode (location: (872...881))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (872...875))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (872...875) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (875...881) = "[1, 2]"
+        │   ├── opening_loc: (875...876) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (876...880))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ IntegerNode (location: (876...877))
+        │   │       └── @ IntegerNode (location: (879...880))
+        │   ├── closing_loc: (880...881) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ CallNode (location: (882...887))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (882...885))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (882...885) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (885...887) = "[]"
+        │   ├── opening_loc: (885...886) = "["
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (886...887) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ CallNode (location: (888...896))
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (888...892))
+        │   ├── call_operator_loc: (892...893) = "."
+        │   ├── message_loc: (893...896) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (897...910))
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (897...901))
+        │   ├── call_operator_loc: (901...902) = "."
+        │   ├── message_loc: (902...905) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (906...910))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SymbolNode (location: (906...910))
+        │   │           ├── opening_loc: (906...907) = ":"
+        │   │           ├── value_loc: (907...910) = "bar"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo="
+        ├── @ CallNode (location: (911...928))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (911...918))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (912...917))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (912...917))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ CallNode (location: (912...913))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (912...913) = "a"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "a"
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (914...915) = "+"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (916...917))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ CallNode (location: (916...917))
+        │   │   │           │           ├── receiver: ∅
+        │   │   │           │           ├── call_operator_loc: ∅
+        │   │   │           │           ├── message_loc: (916...917) = "b"
+        │   │   │           │           ├── opening_loc: ∅
+        │   │   │           │           ├── arguments: ∅
+        │   │   │           │           ├── closing_loc: ∅
+        │   │   │           │           ├── block: ∅
+        │   │   │           │           ├── flags: variable_call
+        │   │   │           │           └── name: "b"
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "+"
+        │   │   ├── opening_loc: (911...912) = "("
+        │   │   └── closing_loc: (917...918) = ")"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (919...920) = "/"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (921...928))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (921...928))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (922...927))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (922...927))
+        │   │           │           ├── receiver:
+        │   │           │           │   @ CallNode (location: (922...923))
+        │   │           │           │   ├── receiver: ∅
+        │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │           │   ├── message_loc: (922...923) = "c"
+        │   │           │           │   ├── opening_loc: ∅
+        │   │           │           │   ├── arguments: ∅
+        │   │           │           │   ├── closing_loc: ∅
+        │   │           │           │   ├── block: ∅
+        │   │           │           │   ├── flags: variable_call
+        │   │           │           │   └── name: "c"
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (924...925) = "-"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments:
+        │   │           │           │   @ ArgumentsNode (location: (926...927))
+        │   │           │           │   └── arguments: (length: 1)
+        │   │           │           │       └── @ CallNode (location: (926...927))
+        │   │           │           │           ├── receiver: ∅
+        │   │           │           │           ├── call_operator_loc: ∅
+        │   │           │           │           ├── message_loc: (926...927) = "d"
+        │   │           │           │           ├── opening_loc: ∅
+        │   │           │           │           ├── arguments: ∅
+        │   │           │           │           ├── closing_loc: ∅
+        │   │           │           │           ├── block: ∅
+        │   │           │           │           ├── flags: variable_call
+        │   │           │           │           └── name: "d"
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "-"
+        │   │           ├── opening_loc: (921...922) = "("
+        │   │           └── closing_loc: (927...928) = ")"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "/"
+        ├── @ CallNode (location: (929...948))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (929...936))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (930...935))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (930...935))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ CallNode (location: (930...931))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (930...931) = "a"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "a"
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (932...933) = "+"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (934...935))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ CallNode (location: (934...935))
+        │   │   │           │           ├── receiver: ∅
+        │   │   │           │           ├── call_operator_loc: ∅
+        │   │   │           │           ├── message_loc: (934...935) = "b"
+        │   │   │           │           ├── opening_loc: ∅
+        │   │   │           │           ├── arguments: ∅
+        │   │   │           │           ├── closing_loc: ∅
+        │   │   │           │           ├── block: ∅
+        │   │   │           │           ├── flags: variable_call
+        │   │   │           │           └── name: "b"
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "+"
+        │   │   ├── opening_loc: (929...930) = "("
+        │   │   └── closing_loc: (935...936) = ")"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (937...938) = "/"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (939...948))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (939...948))
+        │   │           ├── receiver:
+        │   │           │   @ CallNode (location: (939...940))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (939...940) = "c"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "c"
+        │   │           ├── call_operator_loc: (940...941) = "."
+        │   │           ├── message_loc: (941...942) = "-"
+        │   │           ├── opening_loc: (942...943) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (943...947))
+        │   │           │   └── arguments: (length: 2)
+        │   │           │       ├── @ CallNode (location: (943...944))
+        │   │           │       │   ├── receiver: ∅
+        │   │           │       │   ├── call_operator_loc: ∅
+        │   │           │       │   ├── message_loc: (943...944) = "e"
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── arguments: ∅
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   ├── block: ∅
+        │   │           │       │   ├── flags: variable_call
+        │   │           │       │   └── name: "e"
+        │   │           │       └── @ CallNode (location: (946...947))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (946...947) = "f"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "f"
+        │   │           ├── closing_loc: (947...948) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "-"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "/"
+        ├── @ CallNode (location: (949...966))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (949...956))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (950...955))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (950...955))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ CallNode (location: (950...951))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (950...951) = "a"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "a"
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (952...953) = "+"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (954...955))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ CallNode (location: (954...955))
+        │   │   │           │           ├── receiver: ∅
+        │   │   │           │           ├── call_operator_loc: ∅
+        │   │   │           │           ├── message_loc: (954...955) = "b"
+        │   │   │           │           ├── opening_loc: ∅
+        │   │   │           │           ├── arguments: ∅
+        │   │   │           │           ├── closing_loc: ∅
+        │   │   │           │           ├── block: ∅
+        │   │   │           │           ├── flags: variable_call
+        │   │   │           │           └── name: "b"
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "+"
+        │   │   ├── opening_loc: (949...950) = "("
+        │   │   └── closing_loc: (955...956) = ")"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (957...958) = "/"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (959...966))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (959...966))
+        │   │           ├── receiver:
+        │   │           │   @ CallNode (location: (959...960))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (959...960) = "c"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "c"
+        │   │           ├── call_operator_loc: (960...961) = "."
+        │   │           ├── message_loc: (961...962) = "-"
+        │   │           ├── opening_loc: (962...963) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (963...965))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ SplatNode (location: (963...965))
+        │   │           │           ├── operator_loc: (963...964) = "*"
+        │   │           │           └── expression:
+        │   │           │               @ CallNode (location: (964...965))
+        │   │           │               ├── receiver: ∅
+        │   │           │               ├── call_operator_loc: ∅
+        │   │           │               ├── message_loc: (964...965) = "f"
+        │   │           │               ├── opening_loc: ∅
+        │   │           │               ├── arguments: ∅
+        │   │           │               ├── closing_loc: ∅
+        │   │           │               ├── block: ∅
+        │   │           │               ├── flags: variable_call
+        │   │           │               └── name: "f"
+        │   │           ├── closing_loc: (965...966) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "-"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "/"
+        ├── @ CallNode (location: (967...975))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (967...968) = "x"
+        │   ├── opening_loc: (968...969) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (969...974))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (969...974))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocSplatNode (location: (969...974))
+        │   │                   ├── value:
+        │   │                   │   @ CallNode (location: (971...974))
+        │   │                   │   ├── receiver: ∅
+        │   │                   │   ├── call_operator_loc: ∅
+        │   │                   │   ├── message_loc: (971...974) = "foo"
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── arguments: ∅
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   ├── block: ∅
+        │   │                   │   ├── flags: variable_call
+        │   │                   │   └── name: "foo"
+        │   │                   └── operator_loc: (969...971) = "**"
+        │   ├── closing_loc: (974...975) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "x"
+        ├── @ CallNode (location: (976...982))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (976...979))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (976...979) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (979...981) = "&."
+        │   ├── message_loc: (981...982) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: safe_navigation
+        │   └── name: "!"
+        ├── @ CallNode (location: (983...991))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (983...986))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (983...986) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (986...987) = "."
+        │   ├── message_loc: (987...988) = "~"
+        │   ├── opening_loc: (988...989) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (989...990))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (989...990))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (989...990) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── closing_loc: (990...991) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "~"
+        └── @ CallNode (location: (992...999))
+            ├── receiver:
+            │   @ CallNode (location: (992...993))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (992...993) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (993...995) = "&."
+            ├── message_loc: (995...996) = "+"
+            ├── opening_loc: (996...997) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (997...998))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (997...998))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (997...998) = "b"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "b"
+            ├── closing_loc: (998...999) = ")"
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "+"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/since/27.txt b/test/yarp/snapshots/unparser/corpus/literal/since/27.txt
index f8709ae21a..89d675c5fd 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/since/27.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/since/27.txt
@@ -1,44 +1,58 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [LambdaNode(0...16)(
-       [],
-       (0...2),
-       (3...4),
-       (15...16),
-       nil,
-       StatementsNode(7...14)(
-         [CallNode(7...14)(
-            CallNode(7...9)(nil, nil, (7...9), nil, nil, nil, nil, 2, "_1"),
-            nil,
-            (10...11),
-            nil,
-            ArgumentsNode(12...14)(
-              [CallNode(12...14)(
-                 nil,
-                 nil,
-                 (12...14),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "_2"
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       )
-     ),
-     ParenthesesNode(17...22)(
-       StatementsNode(18...21)(
-         [RangeNode(18...21)(nil, IntegerNode(20...21)(), (18...20), 0)]
-       ),
-       (17...18),
-       (21...22)
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 2)
+        ├── @ LambdaNode (location: (0...16))
+        │   ├── locals: []
+        │   ├── operator_loc: (0...2) = "->"
+        │   ├── opening_loc: (3...4) = "{"
+        │   ├── closing_loc: (15...16) = "}"
+        │   ├── parameters: ∅
+        │   └── body:
+        │       @ StatementsNode (location: (7...14))
+        │       └── body: (length: 1)
+        │           └── @ CallNode (location: (7...14))
+        │               ├── receiver:
+        │               │   @ CallNode (location: (7...9))
+        │               │   ├── receiver: ∅
+        │               │   ├── call_operator_loc: ∅
+        │               │   ├── message_loc: (7...9) = "_1"
+        │               │   ├── opening_loc: ∅
+        │               │   ├── arguments: ∅
+        │               │   ├── closing_loc: ∅
+        │               │   ├── block: ∅
+        │               │   ├── flags: variable_call
+        │               │   └── name: "_1"
+        │               ├── call_operator_loc: ∅
+        │               ├── message_loc: (10...11) = "+"
+        │               ├── opening_loc: ∅
+        │               ├── arguments:
+        │               │   @ ArgumentsNode (location: (12...14))
+        │               │   └── arguments: (length: 1)
+        │               │       └── @ CallNode (location: (12...14))
+        │               │           ├── receiver: ∅
+        │               │           ├── call_operator_loc: ∅
+        │               │           ├── message_loc: (12...14) = "_2"
+        │               │           ├── opening_loc: ∅
+        │               │           ├── arguments: ∅
+        │               │           ├── closing_loc: ∅
+        │               │           ├── block: ∅
+        │               │           ├── flags: variable_call
+        │               │           └── name: "_2"
+        │               ├── closing_loc: ∅
+        │               ├── block: ∅
+        │               ├── flags: 
+        │               └── name: "+"
+        └── @ ParenthesesNode (location: (17...22))
+            ├── body:
+            │   @ StatementsNode (location: (18...21))
+            │   └── body: (length: 1)
+            │       └── @ RangeNode (location: (18...21))
+            │           ├── left: ∅
+            │           ├── right:
+            │           │   @ IntegerNode (location: (20...21))
+            │           ├── operator_loc: (18...20) = ".."
+            │           └── flags: 
+            ├── opening_loc: (17...18) = "("
+            └── closing_loc: (21...22) = ")"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/since/30.txt b/test/yarp/snapshots/unparser/corpus/literal/since/30.txt
index 4aba767795..f1f200e42e 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/since/30.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/since/30.txt
@@ -1,56 +1,78 @@
-ProgramNode(0...51)(
-  [:a, :foo],
-  StatementsNode(0...51)(
-    [MatchRequiredNode(0...8)(
-       IntegerNode(0...1)(),
-       ArrayPatternNode(5...8)(
-         nil,
-         [LocalVariableTargetNode(6...7)(:a, 0)],
-         nil,
-         [],
-         (5...6),
-         (7...8)
-       ),
-       (2...4)
-     ),
-     MatchRequiredNode(9...17)(
-       IntegerNode(9...10)(),
-       ArrayPatternNode(14...17)(
-         nil,
-         [],
-         SplatNode(15...16)((15...16), nil),
-         [],
-         (14...15),
-         (16...17)
-       ),
-       (11...13)
-     ),
-     MatchPredicateNode(18...33)(
-       IntegerNode(18...19)(),
-       FindPatternNode(23...33)(
-         nil,
-         SplatNode(24...25)((24...25), nil),
-         [IntegerNode(27...29)()],
-         SplatNode(31...32)((31...32), nil),
-         (23...24),
-         (32...33)
-       ),
-       (20...22)
-     ),
-     MatchPredicateNode(34...51)(
-       IntegerNode(34...35)(),
-       FindPatternNode(39...51)(
-         nil,
-         SplatNode(40...41)((40...41), nil),
-         [LocalVariableTargetNode(43...44)(:a, 0)],
-         SplatNode(46...50)(
-           (46...47),
-           LocalVariableTargetNode(47...50)(:foo, 0)
-         ),
-         (39...40),
-         (50...51)
-       ),
-       (36...38)
-     )]
-  )
-)
+@ ProgramNode (location: (0...51))
+├── locals: [:a, :foo]
+└── statements:
+    @ StatementsNode (location: (0...51))
+    └── body: (length: 4)
+        ├── @ MatchRequiredNode (location: (0...8))
+        │   ├── value:
+        │   │   @ IntegerNode (location: (0...1))
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (5...8))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (6...7))
+        │   │   │       ├── name: :a
+        │   │   │       └── depth: 0
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (5...6) = "["
+        │   │   └── closing_loc: (7...8) = "]"
+        │   └── operator_loc: (2...4) = "=>"
+        ├── @ MatchRequiredNode (location: (9...17))
+        │   ├── value:
+        │   │   @ IntegerNode (location: (9...10))
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (14...17))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ SplatNode (location: (15...16))
+        │   │   │   ├── operator_loc: (15...16) = "*"
+        │   │   │   └── expression: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (14...15) = "["
+        │   │   └── closing_loc: (16...17) = "]"
+        │   └── operator_loc: (11...13) = "=>"
+        ├── @ MatchPredicateNode (location: (18...33))
+        │   ├── value:
+        │   │   @ IntegerNode (location: (18...19))
+        │   ├── pattern:
+        │   │   @ FindPatternNode (location: (23...33))
+        │   │   ├── constant: ∅
+        │   │   ├── left:
+        │   │   │   @ SplatNode (location: (24...25))
+        │   │   │   ├── operator_loc: (24...25) = "*"
+        │   │   │   └── expression: ∅
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ IntegerNode (location: (27...29))
+        │   │   ├── right:
+        │   │   │   @ SplatNode (location: (31...32))
+        │   │   │   ├── operator_loc: (31...32) = "*"
+        │   │   │   └── expression: ∅
+        │   │   ├── opening_loc: (23...24) = "["
+        │   │   └── closing_loc: (32...33) = "]"
+        │   └── operator_loc: (20...22) = "in"
+        └── @ MatchPredicateNode (location: (34...51))
+            ├── value:
+            │   @ IntegerNode (location: (34...35))
+            ├── pattern:
+            │   @ FindPatternNode (location: (39...51))
+            │   ├── constant: ∅
+            │   ├── left:
+            │   │   @ SplatNode (location: (40...41))
+            │   │   ├── operator_loc: (40...41) = "*"
+            │   │   └── expression: ∅
+            │   ├── requireds: (length: 1)
+            │   │   └── @ LocalVariableTargetNode (location: (43...44))
+            │   │       ├── name: :a
+            │   │       └── depth: 0
+            │   ├── right:
+            │   │   @ SplatNode (location: (46...50))
+            │   │   ├── operator_loc: (46...47) = "*"
+            │   │   └── expression:
+            │   │       @ LocalVariableTargetNode (location: (47...50))
+            │   │       ├── name: :foo
+            │   │       └── depth: 0
+            │   ├── opening_loc: (39...40) = "["
+            │   └── closing_loc: (50...51) = "]"
+            └── operator_loc: (36...38) = "in"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/since/31.txt b/test/yarp/snapshots/unparser/corpus/literal/since/31.txt
index c5f903bbeb..1e5872a9f0 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/since/31.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/since/31.txt
@@ -1,77 +1,91 @@
-ProgramNode(0...51)(
-  [],
-  StatementsNode(0...51)(
-    [DefNode(0...23)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...9)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(8...9)(nil, nil, (8...9))
-       ),
-       StatementsNode(13...19)(
-         [CallNode(13...19)(
-            nil,
-            nil,
-            (13...16),
-            (16...17),
-            ArgumentsNode(17...18)(
-              [BlockArgumentNode(17...18)(nil, (17...18))]
-            ),
-            (18...19),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:&],
-       (0...3),
-       nil,
-       (7...8),
-       (9...10),
-       nil,
-       (20...23)
-     ),
-     DefNode(25...51)(
-       :foo,
-       (29...32),
-       nil,
-       ParametersNode(33...37)(
-         [RequiredParameterNode(33...34)(:a)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(36...37)(nil, nil, (36...37))
-       ),
-       StatementsNode(41...47)(
-         [CallNode(41...47)(
-            nil,
-            nil,
-            (41...44),
-            (44...45),
-            ArgumentsNode(45...46)(
-              [BlockArgumentNode(45...46)(nil, (45...46))]
-            ),
-            (46...47),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:a, :&],
-       (25...28),
-       nil,
-       (32...33),
-       (37...38),
-       nil,
-       (48...51)
-     )]
-  )
-)
+@ ProgramNode (location: (0...51))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...51))
+    └── body: (length: 2)
+        ├── @ DefNode (location: (0...23))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (8...9))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (8...9))
+        │   │       ├── name: nil
+        │   │       ├── name_loc: ∅
+        │   │       └── operator_loc: (8...9) = "&"
+        │   ├── body:
+        │   │   @ StatementsNode (location: (13...19))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (13...19))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (13...16) = "bar"
+        │   │           ├── opening_loc: (16...17) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (17...18))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ BlockArgumentNode (location: (17...18))
+        │   │           │           ├── expression: ∅
+        │   │           │           └── operator_loc: (17...18) = "&"
+        │   │           ├── closing_loc: (18...19) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── locals: [:&]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (7...8) = "("
+        │   ├── rparen_loc: (9...10) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (20...23) = "end"
+        └── @ DefNode (location: (25...51))
+            ├── name: :foo
+            ├── name_loc: (29...32) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (33...37))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (33...34))
+            │   │       └── name: :a
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block:
+            │       @ BlockParameterNode (location: (36...37))
+            │       ├── name: nil
+            │       ├── name_loc: ∅
+            │       └── operator_loc: (36...37) = "&"
+            ├── body:
+            │   @ StatementsNode (location: (41...47))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (41...47))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (41...44) = "bar"
+            │           ├── opening_loc: (44...45) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (45...46))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ BlockArgumentNode (location: (45...46))
+            │           │           ├── expression: ∅
+            │           │           └── operator_loc: (45...46) = "&"
+            │           ├── closing_loc: (46...47) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:a, :&]
+            ├── def_keyword_loc: (25...28) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (32...33) = "("
+            ├── rparen_loc: (37...38) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (48...51) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/since/32.txt b/test/yarp/snapshots/unparser/corpus/literal/since/32.txt
index b6335ced86..5f534209dc 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/since/32.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/since/32.txt
@@ -1,81 +1,101 @@
-ProgramNode(0...90)(
-  [],
-  StatementsNode(0...90)(
-    [DefNode(0...45)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...20)(
-         [RequiredParameterNode(8...16)(:argument)],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(18...20)(nil, nil, (18...20)),
-         nil
-       ),
-       StatementsNode(24...41)(
-         [CallNode(24...41)(
-            nil,
-            nil,
-            (24...27),
-            (27...28),
-            ArgumentsNode(28...40)(
-              [LocalVariableReadNode(28...36)(:argument, 0),
-               KeywordHashNode(38...40)(
-                 [AssocSplatNode(38...40)(nil, (38...40))]
-               )]
-            ),
-            (40...41),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:argument, :**],
-       (0...3),
-       nil,
-       (7...8),
-       (20...21),
-       nil,
-       (42...45)
-     ),
-     DefNode(47...90)(
-       :foo,
-       (51...54),
-       nil,
-       ParametersNode(55...66)(
-         [RequiredParameterNode(55...63)(:argument)],
-         [],
-         [],
-         RestParameterNode(65...66)(nil, nil, (65...66)),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(70...86)(
-         [CallNode(70...86)(
-            nil,
-            nil,
-            (70...73),
-            (73...74),
-            ArgumentsNode(74...85)(
-              [LocalVariableReadNode(74...82)(:argument, 0),
-               SplatNode(84...85)((84...85), nil)]
-            ),
-            (85...86),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:argument, :*],
-       (47...50),
-       nil,
-       (54...55),
-       (66...67),
-       nil,
-       (87...90)
-     )]
-  )
-)
+@ ProgramNode (location: (0...90))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...90))
+    └── body: (length: 2)
+        ├── @ DefNode (location: (0...45))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (8...20))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (8...16))
+        │   │   │       └── name: :argument
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ KeywordRestParameterNode (location: (18...20))
+        │   │   │   ├── name: nil
+        │   │   │   ├── name_loc: ∅
+        │   │   │   └── operator_loc: (18...20) = "**"
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (24...41))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (24...41))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (24...27) = "bar"
+        │   │           ├── opening_loc: (27...28) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (28...40))
+        │   │           │   └── arguments: (length: 2)
+        │   │           │       ├── @ LocalVariableReadNode (location: (28...36))
+        │   │           │       │   ├── name: :argument
+        │   │           │       │   └── depth: 0
+        │   │           │       └── @ KeywordHashNode (location: (38...40))
+        │   │           │           └── elements: (length: 1)
+        │   │           │               └── @ AssocSplatNode (location: (38...40))
+        │   │           │                   ├── value: ∅
+        │   │           │                   └── operator_loc: (38...40) = "**"
+        │   │           ├── closing_loc: (40...41) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── locals: [:argument, :**]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (7...8) = "("
+        │   ├── rparen_loc: (20...21) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (42...45) = "end"
+        └── @ DefNode (location: (47...90))
+            ├── name: :foo
+            ├── name_loc: (51...54) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (55...66))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (55...63))
+            │   │       └── name: :argument
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest:
+            │   │   @ RestParameterNode (location: (65...66))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (65...66) = "*"
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (70...86))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (70...86))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (70...73) = "bar"
+            │           ├── opening_loc: (73...74) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (74...85))
+            │           │   └── arguments: (length: 2)
+            │           │       ├── @ LocalVariableReadNode (location: (74...82))
+            │           │       │   ├── name: :argument
+            │           │       │   └── depth: 0
+            │           │       └── @ SplatNode (location: (84...85))
+            │           │           ├── operator_loc: (84...85) = "*"
+            │           │           └── expression: ∅
+            │           ├── closing_loc: (85...86) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:argument, :*]
+            ├── def_keyword_loc: (47...50) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (54...55) = "("
+            ├── rparen_loc: (66...67) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (87...90) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/singletons.txt b/test/yarp/snapshots/unparser/corpus/literal/singletons.txt
index 53cc92e636..c98f09fed0 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/singletons.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/singletons.txt
@@ -1,9 +1,9 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [FalseNode(0...5)(),
-     NilNode(6...9)(),
-     SelfNode(10...14)(),
-     TrueNode(15...19)()]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 4)
+        ├── @ FalseNode (location: (0...5))
+        ├── @ NilNode (location: (6...9))
+        ├── @ SelfNode (location: (10...14))
+        └── @ TrueNode (location: (15...19))
diff --git a/test/yarp/snapshots/unparser/corpus/literal/super.txt b/test/yarp/snapshots/unparser/corpus/literal/super.txt
index 191e0a5b91..a3c9d24931 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/super.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/super.txt
@@ -1,239 +1,273 @@
-ProgramNode(0...159)(
-  [],
-  StatementsNode(0...159)(
-    [ForwardingSuperNode(0...5)(nil),
-     SuperNode(6...13)((6...11), (11...12), nil, (12...13), nil),
-     SuperNode(14...22)(
-       (14...19),
-       (19...20),
-       ArgumentsNode(20...21)(
-         [CallNode(20...21)(nil, nil, (20...21), nil, nil, nil, nil, 2, "a")]
-       ),
-       (21...22),
-       nil
-     ),
-     SuperNode(23...34)(
-       (23...28),
-       (28...29),
-       ArgumentsNode(29...33)(
-         [CallNode(29...30)(nil, nil, (29...30), nil, nil, nil, nil, 2, "a"),
-          CallNode(32...33)(nil, nil, (32...33), nil, nil, nil, nil, 2, "b")]
-       ),
-       (33...34),
-       nil
-     ),
-     SuperNode(35...48)(
-       (35...40),
-       (40...41),
-       ArgumentsNode(41...47)(
-         [BlockArgumentNode(41...47)(
-            CallNode(42...47)(
-              nil,
-              nil,
-              (42...47),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "block"
-            ),
-            (41...42)
-          )]
-       ),
-       (47...48),
-       nil
-     ),
-     SuperNode(49...65)(
-       (49...54),
-       (54...55),
-       ArgumentsNode(55...64)(
-         [CallNode(55...56)(nil, nil, (55...56), nil, nil, nil, nil, 2, "a"),
-          BlockArgumentNode(58...64)(
-            CallNode(59...64)(
-              nil,
-              nil,
-              (59...64),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "block"
-            ),
-            (58...59)
-          )]
-       ),
-       (64...65),
-       nil
-     ),
-     SuperNode(66...84)(
-       (66...71),
-       (71...72),
-       ArgumentsNode(72...83)(
-         [CallNode(72...83)(
-            nil,
-            nil,
-            (72...73),
-            nil,
-            nil,
-            nil,
-            BlockNode(74...83)(
-              [],
-              nil,
-              StatementsNode(78...81)(
-                [CallNode(78...81)(
-                   nil,
-                   nil,
-                   (78...81),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "foo"
-                 )]
-              ),
-              (74...75),
-              (82...83)
-            ),
-            0,
-            "a"
-          )]
-       ),
-       (83...84),
-       nil
-     ),
-     ForwardingSuperNode(85...100)(
-       BlockNode(91...100)(
-         [],
-         nil,
-         StatementsNode(95...98)(
-           [CallNode(95...98)(
-              nil,
-              nil,
-              (95...98),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         (91...92),
-         (99...100)
-       )
-     ),
-     SuperNode(101...119)(
-       (101...106),
-       (106...107),
-       ArgumentsNode(107...108)(
-         [CallNode(107...108)(
-            nil,
-            nil,
-            (107...108),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       (108...109),
-       BlockNode(110...119)(
-         [],
-         nil,
-         StatementsNode(114...117)(
-           [CallNode(114...117)(
-              nil,
-              nil,
-              (114...117),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         (110...111),
-         (118...119)
-       )
-     ),
-     SuperNode(120...137)(
-       (120...125),
-       (125...126),
-       nil,
-       (126...127),
-       BlockNode(128...137)(
-         [],
-         nil,
-         StatementsNode(132...135)(
-           [CallNode(132...135)(
-              nil,
-              nil,
-              (132...135),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         (128...129),
-         (136...137)
-       )
-     ),
-     SuperNode(138...159)(
-       (138...143),
-       (143...144),
-       ArgumentsNode(144...148)(
-         [CallNode(144...145)(
-            nil,
-            nil,
-            (144...145),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          ),
-          CallNode(147...148)(
-            nil,
-            nil,
-            (147...148),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          )]
-       ),
-       (148...149),
-       BlockNode(150...159)(
-         [],
-         nil,
-         StatementsNode(154...157)(
-           [CallNode(154...157)(
-              nil,
-              nil,
-              (154...157),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         (150...151),
-         (158...159)
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...159))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...159))
+    └── body: (length: 11)
+        ├── @ ForwardingSuperNode (location: (0...5))
+        │   └── block: ∅
+        ├── @ SuperNode (location: (6...13))
+        │   ├── keyword_loc: (6...11) = "super"
+        │   ├── lparen_loc: (11...12) = "("
+        │   ├── arguments: ∅
+        │   ├── rparen_loc: (12...13) = ")"
+        │   └── block: ∅
+        ├── @ SuperNode (location: (14...22))
+        │   ├── keyword_loc: (14...19) = "super"
+        │   ├── lparen_loc: (19...20) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (20...21))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (20...21))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (20...21) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rparen_loc: (21...22) = ")"
+        │   └── block: ∅
+        ├── @ SuperNode (location: (23...34))
+        │   ├── keyword_loc: (23...28) = "super"
+        │   ├── lparen_loc: (28...29) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (29...33))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (29...30))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (29...30) = "a"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "a"
+        │   │       └── @ CallNode (location: (32...33))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (32...33) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── rparen_loc: (33...34) = ")"
+        │   └── block: ∅
+        ├── @ SuperNode (location: (35...48))
+        │   ├── keyword_loc: (35...40) = "super"
+        │   ├── lparen_loc: (40...41) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (41...47))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ BlockArgumentNode (location: (41...47))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (42...47))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (42...47) = "block"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "block"
+        │   │           └── operator_loc: (41...42) = "&"
+        │   ├── rparen_loc: (47...48) = ")"
+        │   └── block: ∅
+        ├── @ SuperNode (location: (49...65))
+        │   ├── keyword_loc: (49...54) = "super"
+        │   ├── lparen_loc: (54...55) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (55...64))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (55...56))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (55...56) = "a"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "a"
+        │   │       └── @ BlockArgumentNode (location: (58...64))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (59...64))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (59...64) = "block"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "block"
+        │   │           └── operator_loc: (58...59) = "&"
+        │   ├── rparen_loc: (64...65) = ")"
+        │   └── block: ∅
+        ├── @ SuperNode (location: (66...84))
+        │   ├── keyword_loc: (66...71) = "super"
+        │   ├── lparen_loc: (71...72) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (72...83))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (72...83))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (72...73) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (74...83))
+        │   │           │   ├── locals: []
+        │   │           │   ├── parameters: ∅
+        │   │           │   ├── body:
+        │   │           │   │   @ StatementsNode (location: (78...81))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ CallNode (location: (78...81))
+        │   │           │   │           ├── receiver: ∅
+        │   │           │   │           ├── call_operator_loc: ∅
+        │   │           │   │           ├── message_loc: (78...81) = "foo"
+        │   │           │   │           ├── opening_loc: ∅
+        │   │           │   │           ├── arguments: ∅
+        │   │           │   │           ├── closing_loc: ∅
+        │   │           │   │           ├── block: ∅
+        │   │           │   │           ├── flags: variable_call
+        │   │           │   │           └── name: "foo"
+        │   │           │   ├── opening_loc: (74...75) = "{"
+        │   │           │   └── closing_loc: (82...83) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "a"
+        │   ├── rparen_loc: (83...84) = ")"
+        │   └── block: ∅
+        ├── @ ForwardingSuperNode (location: (85...100))
+        │   └── block:
+        │       @ BlockNode (location: (91...100))
+        │       ├── locals: []
+        │       ├── parameters: ∅
+        │       ├── body:
+        │       │   @ StatementsNode (location: (95...98))
+        │       │   └── body: (length: 1)
+        │       │       └── @ CallNode (location: (95...98))
+        │       │           ├── receiver: ∅
+        │       │           ├── call_operator_loc: ∅
+        │       │           ├── message_loc: (95...98) = "foo"
+        │       │           ├── opening_loc: ∅
+        │       │           ├── arguments: ∅
+        │       │           ├── closing_loc: ∅
+        │       │           ├── block: ∅
+        │       │           ├── flags: variable_call
+        │       │           └── name: "foo"
+        │       ├── opening_loc: (91...92) = "{"
+        │       └── closing_loc: (99...100) = "}"
+        ├── @ SuperNode (location: (101...119))
+        │   ├── keyword_loc: (101...106) = "super"
+        │   ├── lparen_loc: (106...107) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (107...108))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (107...108))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (107...108) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rparen_loc: (108...109) = ")"
+        │   └── block:
+        │       @ BlockNode (location: (110...119))
+        │       ├── locals: []
+        │       ├── parameters: ∅
+        │       ├── body:
+        │       │   @ StatementsNode (location: (114...117))
+        │       │   └── body: (length: 1)
+        │       │       └── @ CallNode (location: (114...117))
+        │       │           ├── receiver: ∅
+        │       │           ├── call_operator_loc: ∅
+        │       │           ├── message_loc: (114...117) = "foo"
+        │       │           ├── opening_loc: ∅
+        │       │           ├── arguments: ∅
+        │       │           ├── closing_loc: ∅
+        │       │           ├── block: ∅
+        │       │           ├── flags: variable_call
+        │       │           └── name: "foo"
+        │       ├── opening_loc: (110...111) = "{"
+        │       └── closing_loc: (118...119) = "}"
+        ├── @ SuperNode (location: (120...137))
+        │   ├── keyword_loc: (120...125) = "super"
+        │   ├── lparen_loc: (125...126) = "("
+        │   ├── arguments: ∅
+        │   ├── rparen_loc: (126...127) = ")"
+        │   └── block:
+        │       @ BlockNode (location: (128...137))
+        │       ├── locals: []
+        │       ├── parameters: ∅
+        │       ├── body:
+        │       │   @ StatementsNode (location: (132...135))
+        │       │   └── body: (length: 1)
+        │       │       └── @ CallNode (location: (132...135))
+        │       │           ├── receiver: ∅
+        │       │           ├── call_operator_loc: ∅
+        │       │           ├── message_loc: (132...135) = "foo"
+        │       │           ├── opening_loc: ∅
+        │       │           ├── arguments: ∅
+        │       │           ├── closing_loc: ∅
+        │       │           ├── block: ∅
+        │       │           ├── flags: variable_call
+        │       │           └── name: "foo"
+        │       ├── opening_loc: (128...129) = "{"
+        │       └── closing_loc: (136...137) = "}"
+        └── @ SuperNode (location: (138...159))
+            ├── keyword_loc: (138...143) = "super"
+            ├── lparen_loc: (143...144) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (144...148))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (144...145))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (144...145) = "a"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "a"
+            │       └── @ CallNode (location: (147...148))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (147...148) = "b"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "b"
+            ├── rparen_loc: (148...149) = ")"
+            └── block:
+                @ BlockNode (location: (150...159))
+                ├── locals: []
+                ├── parameters: ∅
+                ├── body:
+                │   @ StatementsNode (location: (154...157))
+                │   └── body: (length: 1)
+                │       └── @ CallNode (location: (154...157))
+                │           ├── receiver: ∅
+                │           ├── call_operator_loc: ∅
+                │           ├── message_loc: (154...157) = "foo"
+                │           ├── opening_loc: ∅
+                │           ├── arguments: ∅
+                │           ├── closing_loc: ∅
+                │           ├── block: ∅
+                │           ├── flags: variable_call
+                │           └── name: "foo"
+                ├── opening_loc: (150...151) = "{"
+                └── closing_loc: (158...159) = "}"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/unary.txt b/test/yarp/snapshots/unparser/corpus/literal/unary.txt
index d4279a4222..beeaf6724d 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/unary.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/unary.txt
@@ -1,217 +1,242 @@
-ProgramNode(0...54)(
-  [],
-  StatementsNode(0...54)(
-    [CallNode(0...2)(
-       IntegerNode(1...2)(),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(3...8)(
-       ParenthesesNode(4...8)(
-         StatementsNode(5...7)(
-           [CallNode(5...7)(
-              IntegerNode(6...7)(),
-              nil,
-              (5...6),
-              nil,
-              nil,
-              nil,
-              nil,
-              0,
-              "!"
-            )]
-         ),
-         (4...5),
-         (7...8)
-       ),
-       nil,
-       (3...4),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(9...25)(
-       ParenthesesNode(10...25)(
-         StatementsNode(11...24)(
-           [CallNode(11...24)(
-              ParenthesesNode(12...24)(
-                StatementsNode(13...23)(
-                  [OrNode(13...23)(
-                     CallNode(13...16)(
-                       nil,
-                       nil,
-                       (13...16),
-                       nil,
-                       nil,
-                       nil,
-                       nil,
-                       2,
-                       "foo"
-                     ),
-                     CallNode(20...23)(
-                       nil,
-                       nil,
-                       (20...23),
-                       nil,
-                       nil,
-                       nil,
-                       nil,
-                       2,
-                       "bar"
-                     ),
-                     (17...19)
-                   )]
-                ),
-                (12...13),
-                (23...24)
-              ),
-              nil,
-              (11...12),
-              nil,
-              nil,
-              nil,
-              nil,
-              0,
-              "!"
-            )]
-         ),
-         (10...11),
-         (24...25)
-       ),
-       nil,
-       (9...10),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(26...35)(
-       CallNode(27...35)(
-         ParenthesesNode(27...31)(
-           StatementsNode(28...30)(
-             [CallNode(28...30)(
-                IntegerNode(29...30)(),
-                nil,
-                (28...29),
-                nil,
-                nil,
-                nil,
-                nil,
-                0,
-                "!"
-              )]
-           ),
-           (27...28),
-           (30...31)
-         ),
-         (31...32),
-         (32...35),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "baz"
-       ),
-       nil,
-       (26...27),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(36...38)(
-       CallNode(37...38)(nil, nil, (37...38), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (36...37),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "~"
-     ),
-     CallNode(39...41)(
-       CallNode(40...41)(nil, nil, (40...41), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (39...40),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "-@"
-     ),
-     CallNode(42...44)(
-       CallNode(43...44)(nil, nil, (43...44), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (42...43),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "+@"
-     ),
-     CallNode(45...54)(
-       CallNode(46...54)(
-         ParenthesesNode(46...50)(
-           StatementsNode(47...49)(
-             [CallNode(47...49)(
-                CallNode(48...49)(
-                  nil,
-                  nil,
-                  (48...49),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "a"
-                ),
-                nil,
-                (47...48),
-                nil,
-                nil,
-                nil,
-                nil,
-                0,
-                "-@"
-              )]
-           ),
-           (46...47),
-           (49...50)
-         ),
-         (50...51),
-         (51...54),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "foo"
-       ),
-       nil,
-       (45...46),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "-@"
-     )]
-  )
-)
+@ ProgramNode (location: (0...54))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...54))
+    └── body: (length: 8)
+        ├── @ CallNode (location: (0...2))
+        │   ├── receiver:
+        │   │   @ IntegerNode (location: (1...2))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (3...8))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (4...8))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (5...7))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (5...7))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ IntegerNode (location: (6...7))
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (5...6) = "!"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "!"
+        │   │   ├── opening_loc: (4...5) = "("
+        │   │   └── closing_loc: (7...8) = ")"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (3...4) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (9...25))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (10...25))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (11...24))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (11...24))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ ParenthesesNode (location: (12...24))
+        │   │   │           │   ├── body:
+        │   │   │           │   │   @ StatementsNode (location: (13...23))
+        │   │   │           │   │   └── body: (length: 1)
+        │   │   │           │   │       └── @ OrNode (location: (13...23))
+        │   │   │           │   │           ├── left:
+        │   │   │           │   │           │   @ CallNode (location: (13...16))
+        │   │   │           │   │           │   ├── receiver: ∅
+        │   │   │           │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   │           │   ├── message_loc: (13...16) = "foo"
+        │   │   │           │   │           │   ├── opening_loc: ∅
+        │   │   │           │   │           │   ├── arguments: ∅
+        │   │   │           │   │           │   ├── closing_loc: ∅
+        │   │   │           │   │           │   ├── block: ∅
+        │   │   │           │   │           │   ├── flags: variable_call
+        │   │   │           │   │           │   └── name: "foo"
+        │   │   │           │   │           ├── right:
+        │   │   │           │   │           │   @ CallNode (location: (20...23))
+        │   │   │           │   │           │   ├── receiver: ∅
+        │   │   │           │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   │           │   ├── message_loc: (20...23) = "bar"
+        │   │   │           │   │           │   ├── opening_loc: ∅
+        │   │   │           │   │           │   ├── arguments: ∅
+        │   │   │           │   │           │   ├── closing_loc: ∅
+        │   │   │           │   │           │   ├── block: ∅
+        │   │   │           │   │           │   ├── flags: variable_call
+        │   │   │           │   │           │   └── name: "bar"
+        │   │   │           │   │           └── operator_loc: (17...19) = "||"
+        │   │   │           │   ├── opening_loc: (12...13) = "("
+        │   │   │           │   └── closing_loc: (23...24) = ")"
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (11...12) = "!"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "!"
+        │   │   ├── opening_loc: (10...11) = "("
+        │   │   └── closing_loc: (24...25) = ")"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (9...10) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (26...35))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (27...35))
+        │   │   ├── receiver:
+        │   │   │   @ ParenthesesNode (location: (27...31))
+        │   │   │   ├── body:
+        │   │   │   │   @ StatementsNode (location: (28...30))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (28...30))
+        │   │   │   │           ├── receiver:
+        │   │   │   │           │   @ IntegerNode (location: (29...30))
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (28...29) = "!"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: 
+        │   │   │   │           └── name: "!"
+        │   │   │   ├── opening_loc: (27...28) = "("
+        │   │   │   └── closing_loc: (30...31) = ")"
+        │   │   ├── call_operator_loc: (31...32) = "."
+        │   │   ├── message_loc: (32...35) = "baz"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "baz"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (26...27) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (36...38))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (37...38))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (37...38) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (36...37) = "~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "~"
+        ├── @ CallNode (location: (39...41))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (40...41))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (40...41) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (39...40) = "-"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "-@"
+        ├── @ CallNode (location: (42...44))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (43...44))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (43...44) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (42...43) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+@"
+        └── @ CallNode (location: (45...54))
+            ├── receiver:
+            │   @ CallNode (location: (46...54))
+            │   ├── receiver:
+            │   │   @ ParenthesesNode (location: (46...50))
+            │   │   ├── body:
+            │   │   │   @ StatementsNode (location: (47...49))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (47...49))
+            │   │   │           ├── receiver:
+            │   │   │           │   @ CallNode (location: (48...49))
+            │   │   │           │   ├── receiver: ∅
+            │   │   │           │   ├── call_operator_loc: ∅
+            │   │   │           │   ├── message_loc: (48...49) = "a"
+            │   │   │           │   ├── opening_loc: ∅
+            │   │   │           │   ├── arguments: ∅
+            │   │   │           │   ├── closing_loc: ∅
+            │   │   │           │   ├── block: ∅
+            │   │   │           │   ├── flags: variable_call
+            │   │   │           │   └── name: "a"
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (47...48) = "-"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: 
+            │   │   │           └── name: "-@"
+            │   │   ├── opening_loc: (46...47) = "("
+            │   │   └── closing_loc: (49...50) = ")"
+            │   ├── call_operator_loc: (50...51) = "."
+            │   ├── message_loc: (51...54) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (45...46) = "-"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "-@"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/undef.txt b/test/yarp/snapshots/unparser/corpus/literal/undef.txt
index 30e513d19e..755517ce3b 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/undef.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/undef.txt
@@ -1,14 +1,26 @@
-ProgramNode(0...27)(
-  [],
-  StatementsNode(0...27)(
-    [UndefNode(0...10)(
-       [SymbolNode(6...10)((6...7), (7...10), nil, "foo")],
-       (0...5)
-     ),
-     UndefNode(11...27)(
-       [SymbolNode(17...21)((17...18), (18...21), nil, "foo"),
-        SymbolNode(23...27)((23...24), (24...27), nil, "bar")],
-       (11...16)
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 2)
+        ├── @ UndefNode (location: (0...10))
+        │   ├── names: (length: 1)
+        │   │   └── @ SymbolNode (location: (6...10))
+        │   │       ├── opening_loc: (6...7) = ":"
+        │   │       ├── value_loc: (7...10) = "foo"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "foo"
+        │   └── keyword_loc: (0...5) = "undef"
+        └── @ UndefNode (location: (11...27))
+            ├── names: (length: 2)
+            │   ├── @ SymbolNode (location: (17...21))
+            │   │   ├── opening_loc: (17...18) = ":"
+            │   │   ├── value_loc: (18...21) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   └── @ SymbolNode (location: (23...27))
+            │       ├── opening_loc: (23...24) = ":"
+            │       ├── value_loc: (24...27) = "bar"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "bar"
+            └── keyword_loc: (11...16) = "undef"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/variables.txt b/test/yarp/snapshots/unparser/corpus/literal/variables.txt
index f012dc900c..6ac9bd673d 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/variables.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/variables.txt
@@ -1,31 +1,52 @@
-ProgramNode(0...66)(
-  [],
-  StatementsNode(0...66)(
-    [CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-     InstanceVariableReadNode(2...4)(:@a),
-     ClassVariableReadNode(5...8)(:@@a),
-     GlobalVariableReadNode(9...11)(:$a),
-     NumberedReferenceReadNode(12...14)(1),
-     BackReferenceReadNode(15...17)(),
-     ConstantReadNode(18...23)(:CONST),
-     ConstantPathNode(24...37)(
-       ConstantReadNode(24...30)(:SCOPED),
-       ConstantReadNode(32...37)(:CONST),
-       (30...32)
-     ),
-     ConstantPathNode(38...48)(
-       nil,
-       ConstantReadNode(40...48)(:TOPLEVEL),
-       (38...40)
-     ),
-     ConstantPathNode(49...66)(
-       ConstantPathNode(49...59)(
-         nil,
-         ConstantReadNode(51...59)(:TOPLEVEL),
-         (49...51)
-       ),
-       ConstantReadNode(61...66)(:CONST),
-       (59...61)
-     )]
-  )
-)
+@ ProgramNode (location: (0...66))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...66))
+    └── body: (length: 10)
+        ├── @ CallNode (location: (0...1))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "a"
+        ├── @ InstanceVariableReadNode (location: (2...4))
+        │   └── name: :@a
+        ├── @ ClassVariableReadNode (location: (5...8))
+        │   └── name: :@@a
+        ├── @ GlobalVariableReadNode (location: (9...11))
+        │   └── name: :$a
+        ├── @ NumberedReferenceReadNode (location: (12...14))
+        │   └── number: 1
+        ├── @ BackReferenceReadNode (location: (15...17))
+        ├── @ ConstantReadNode (location: (18...23))
+        │   └── name: :CONST
+        ├── @ ConstantPathNode (location: (24...37))
+        │   ├── parent:
+        │   │   @ ConstantReadNode (location: (24...30))
+        │   │   └── name: :SCOPED
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (32...37))
+        │   │   └── name: :CONST
+        │   └── delimiter_loc: (30...32) = "::"
+        ├── @ ConstantPathNode (location: (38...48))
+        │   ├── parent: ∅
+        │   ├── child:
+        │   │   @ ConstantReadNode (location: (40...48))
+        │   │   └── name: :TOPLEVEL
+        │   └── delimiter_loc: (38...40) = "::"
+        └── @ ConstantPathNode (location: (49...66))
+            ├── parent:
+            │   @ ConstantPathNode (location: (49...59))
+            │   ├── parent: ∅
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (51...59))
+            │   │   └── name: :TOPLEVEL
+            │   └── delimiter_loc: (49...51) = "::"
+            ├── child:
+            │   @ ConstantReadNode (location: (61...66))
+            │   └── name: :CONST
+            └── delimiter_loc: (59...61) = "::"
diff --git a/test/yarp/snapshots/unparser/corpus/literal/while.txt b/test/yarp/snapshots/unparser/corpus/literal/while.txt
index f6dc399041..ac34701c8d 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/while.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/while.txt
@@ -1,648 +1,694 @@
-ProgramNode(0...620)(
-  [:x],
-  StatementsNode(0...620)(
-    [ModuleNode(0...68)(
-       [],
-       (0...6),
-       ConstantReadNode(7...8)(:A),
-       StatementsNode(11...64)(
-         [CallNode(11...64)(
-            nil,
-            nil,
-            (11...14),
-            nil,
-            nil,
-            nil,
-            BlockNode(15...64)(
-              [:bar, :foo],
-              BlockParametersNode(17...22)(
-                ParametersNode(18...21)(
-                  [RequiredParameterNode(18...21)(:bar)],
-                  [],
-                  [],
-                  nil,
-                  [],
-                  nil,
-                  nil
-                ),
-                [],
-                (17...18),
-                (21...22)
-              ),
-              StatementsNode(27...60)(
-                [WhileNode(27...60)(
-                   (27...32),
-                   (57...60),
-                   CallNode(33...36)(
-                     nil,
-                     nil,
-                     (33...36),
-                     nil,
-                     nil,
-                     nil,
-                     nil,
-                     2,
-                     "foo"
-                   ),
-                   StatementsNode(43...52)(
-                     [LocalVariableWriteNode(43...52)(
-                        :foo,
-                        0,
-                        (43...46),
-                        LocalVariableReadNode(49...52)(:bar, 0),
-                        (47...48)
-                      )]
-                   ),
-                   0
-                 )]
-              ),
-              (15...16),
-              (63...64)
-            ),
-            0,
-            "foo"
-          )]
-       ),
-       (65...68),
-       :A
-     ),
-     DefNode(70...110)(
-       :foo,
-       (74...77),
-       nil,
-       nil,
-       StatementsNode(80...106)(
-         [WhileNode(80...106)(
-            (90...95),
-            nil,
-            CallNode(96...106)(
-              LocalVariableReadNode(96...99)(:foo, 0),
-              nil,
-              (100...102),
-              nil,
-              ArgumentsNode(103...106)(
-                [CallNode(103...106)(
-                   nil,
-                   nil,
-                   (103...106),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "baz"
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "!="
-            ),
-            StatementsNode(80...89)(
-              [LocalVariableWriteNode(80...89)(
-                 :foo,
-                 0,
-                 (80...83),
-                 CallNode(86...89)(
-                   nil,
-                   nil,
-                   (86...89),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "bar"
-                 ),
-                 (84...85)
-               )]
-            ),
-            0
-          )]
-       ),
-       [:foo],
-       (70...73),
-       nil,
-       nil,
-       nil,
-       nil,
-       (107...110)
-     ),
-     ModuleNode(112...146)(
-       [:foo],
-       (112...118),
-       ConstantReadNode(119...120)(:A),
-       StatementsNode(123...142)(
-         [WhileNode(123...142)(
-            (133...138),
-            nil,
-            LocalVariableReadNode(139...142)(:foo, 0),
-            StatementsNode(123...132)(
-              [LocalVariableWriteNode(123...132)(
-                 :foo,
-                 0,
-                 (123...126),
-                 CallNode(129...132)(
-                   nil,
-                   nil,
-                   (129...132),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "bar"
-                 ),
-                 (127...128)
-               )]
-            ),
-            0
-          )]
-       ),
-       (143...146),
-       :A
-     ),
-     ModuleNode(148...182)(
-       [:foo],
-       (148...154),
-       ConstantReadNode(155...156)(:A),
-       StatementsNode(159...178)(
-         [UntilNode(159...178)(
-            (169...174),
-            nil,
-            LocalVariableReadNode(175...178)(:foo, 0),
-            StatementsNode(159...168)(
-              [LocalVariableWriteNode(159...168)(
-                 :foo,
-                 0,
-                 (159...162),
-                 CallNode(165...168)(
-                   nil,
-                   nil,
-                   (165...168),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "bar"
-                 ),
-                 (163...164)
-               )]
-            ),
-            0
-          )]
-       ),
-       (179...182),
-       :A
-     ),
-     ModuleNode(184...228)(
-       [:foo],
-       (184...190),
-       ConstantReadNode(191...192)(:A),
-       StatementsNode(195...224)(
-         [WhileNode(195...224)(
-            (195...200),
-            (221...224),
-            CallNode(201...204)(
-              nil,
-              nil,
-              (201...204),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            ),
-            StatementsNode(209...218)(
-              [LocalVariableWriteNode(209...218)(
-                 :foo,
-                 0,
-                 (209...212),
-                 CallNode(215...218)(
-                   nil,
-                   nil,
-                   (215...218),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "bar"
-                 ),
-                 (213...214)
-               )]
-            ),
-            0
-          )]
-       ),
-       (225...228),
-       :A
-     ),
-     ModuleNode(230...299)(
-       [],
-       (230...236),
-       ConstantReadNode(237...238)(:A),
-       StatementsNode(241...295)(
-         [CallNode(241...295)(
-            nil,
-            nil,
-            (241...245),
-            nil,
-            nil,
-            nil,
-            BlockNode(246...295)(
-              [:baz, :foo],
-              BlockParametersNode(248...253)(
-                ParametersNode(249...252)(
-                  [RequiredParameterNode(249...252)(:baz)],
-                  [],
-                  [],
-                  nil,
-                  [],
-                  nil,
-                  nil
-                ),
-                [],
-                (248...249),
-                (252...253)
-              ),
-              StatementsNode(258...291)(
-                [WhileNode(258...291)(
-                   (258...263),
-                   (288...291),
-                   CallNode(264...267)(
-                     nil,
-                     nil,
-                     (264...267),
-                     nil,
-                     nil,
-                     nil,
-                     nil,
-                     2,
-                     "foo"
-                   ),
-                   StatementsNode(274...283)(
-                     [LocalVariableWriteNode(274...283)(
-                        :foo,
-                        0,
-                        (274...277),
-                        CallNode(280...283)(
-                          nil,
-                          nil,
-                          (280...283),
-                          nil,
-                          nil,
-                          nil,
-                          nil,
-                          2,
-                          "bar"
-                        ),
-                        (278...279)
-                      )]
-                   ),
-                   0
-                 )]
-              ),
-              (246...247),
-              (294...295)
-            ),
-            0,
-            "each"
-          )]
-       ),
-       (296...299),
-       :A
-     ),
-     ModuleNode(301...370)(
-       [],
-       (301...307),
-       ConstantReadNode(308...309)(:A),
-       StatementsNode(312...366)(
-         [CallNode(312...366)(
-            nil,
-            nil,
-            (312...316),
-            nil,
-            nil,
-            nil,
-            BlockNode(317...366)(
-              [:foo],
-              BlockParametersNode(319...324)(
-                ParametersNode(320...323)(
-                  [RequiredParameterNode(320...323)(:foo)],
-                  [],
-                  [],
-                  nil,
-                  [],
-                  nil,
-                  nil
-                ),
-                [],
-                (319...320),
-                (323...324)
-              ),
-              StatementsNode(329...362)(
-                [WhileNode(329...362)(
-                   (329...334),
-                   (359...362),
-                   LocalVariableReadNode(335...338)(:foo, 0),
-                   StatementsNode(345...354)(
-                     [LocalVariableWriteNode(345...354)(
-                        :foo,
-                        0,
-                        (345...348),
-                        CallNode(351...354)(
-                          nil,
-                          nil,
-                          (351...354),
-                          nil,
-                          nil,
-                          nil,
-                          nil,
-                          2,
-                          "bar"
-                        ),
-                        (349...350)
-                      )]
-                   ),
-                   0
-                 )]
-              ),
-              (317...318),
-              (365...366)
-            ),
-            0,
-            "each"
-          )]
-       ),
-       (367...370),
-       :A
-     ),
-     LocalVariableWriteNode(371...402)(
-       :x,
-       0,
-       (371...372),
-       ParenthesesNode(375...402)(
-         StatementsNode(376...401)(
-           [WhileNode(376...401)(
-              (392...397),
-              nil,
-              CallNode(398...401)(
-                nil,
-                nil,
-                (398...401),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "baz"
-              ),
-              StatementsNode(376...391)(
-                [BeginNode(376...391)(
-                   (376...381),
-                   StatementsNode(384...387)(
-                     [CallNode(384...387)(
-                        nil,
-                        nil,
-                        (384...387),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "foo"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   nil,
-                   (388...391)
-                 )]
-              ),
-              1
-            )]
-         ),
-         (375...376),
-         (401...402)
-       ),
-       (373...374)
-     ),
-     WhileNode(403...428)(
-       (419...424),
-       nil,
-       CallNode(425...428)(
-         nil,
-         nil,
-         (425...428),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "baz"
-       ),
-       StatementsNode(403...418)(
-         [BeginNode(403...418)(
-            (403...408),
-            StatementsNode(411...414)(
-              [CallNode(411...414)(
-                 nil,
-                 nil,
-                 (411...414),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               )]
-            ),
-            nil,
-            nil,
-            nil,
-            (415...418)
-          )]
-       ),
-       1
-     ),
-     UntilNode(429...460)(
-       (451...456),
-       nil,
-       CallNode(457...460)(
-         nil,
-         nil,
-         (457...460),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "baz"
-       ),
-       StatementsNode(429...450)(
-         [BeginNode(429...450)(
-            (429...434),
-            StatementsNode(437...446)(
-              [CallNode(437...440)(
-                 nil,
-                 nil,
-                 (437...440),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               ),
-               CallNode(443...446)(
-                 nil,
-                 nil,
-                 (443...446),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "bar"
-               )]
-            ),
-            nil,
-            nil,
-            nil,
-            (447...450)
-          )]
-       ),
-       1
-     ),
-     WhileNode(461...492)(
-       (483...488),
-       nil,
-       CallNode(489...492)(
-         nil,
-         nil,
-         (489...492),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "baz"
-       ),
-       StatementsNode(461...482)(
-         [BeginNode(461...482)(
-            (461...466),
-            StatementsNode(469...478)(
-              [CallNode(469...472)(
-                 nil,
-                 nil,
-                 (469...472),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               ),
-               CallNode(475...478)(
-                 nil,
-                 nil,
-                 (475...478),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "bar"
-               )]
-            ),
-            nil,
-            nil,
-            nil,
-            (479...482)
-          )]
-       ),
-       1
-     ),
-     WhileNode(493...508)(
-       (493...498),
-       (505...508),
-       FalseNode(499...504)(),
-       nil,
-       0
-     ),
-     WhileNode(509...528)(
-       (509...514),
-       (525...528),
-       FalseNode(515...520)(),
-       StatementsNode(523...524)([IntegerNode(523...524)()]),
-       0
-     ),
-     WhileNode(529...556)(
-       (529...534),
-       (553...556),
-       ParenthesesNode(535...544)(
-         StatementsNode(536...543)(
-           [CallNode(536...543)(
-              nil,
-              nil,
-              (536...539),
-              nil,
-              nil,
-              nil,
-              BlockNode(540...543)([], nil, nil, (540...541), (542...543)),
-              0,
-              "foo"
-            )]
-         ),
-         (535...536),
-         (543...544)
-       ),
-       StatementsNode(547...552)(
-         [SymbolNode(547...552)((547...548), (548...552), nil, "body")]
-       ),
-       0
-     ),
-     UntilNode(557...572)(
-       (557...562),
-       (569...572),
-       FalseNode(563...568)(),
-       nil,
-       0
-     ),
-     UntilNode(573...592)(
-       (573...578),
-       (589...592),
-       FalseNode(579...584)(),
-       StatementsNode(587...588)([IntegerNode(587...588)()]),
-       0
-     ),
-     UntilNode(593...620)(
-       (593...598),
-       (617...620),
-       ParenthesesNode(599...608)(
-         StatementsNode(600...607)(
-           [CallNode(600...607)(
-              nil,
-              nil,
-              (600...603),
-              nil,
-              nil,
-              nil,
-              BlockNode(604...607)([], nil, nil, (604...605), (606...607)),
-              0,
-              "foo"
-            )]
-         ),
-         (599...600),
-         (607...608)
-       ),
-       StatementsNode(611...616)(
-         [SymbolNode(611...616)((611...612), (612...616), nil, "body")]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...620))
+├── locals: [:x]
+└── statements:
+    @ StatementsNode (location: (0...620))
+    └── body: (length: 17)
+        ├── @ ModuleNode (location: (0...68))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (0...6) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (7...8))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (11...64))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (11...64))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (11...14) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (15...64))
+        │   │           │   ├── locals: [:bar, :foo]
+        │   │           │   ├── parameters:
+        │   │           │   │   @ BlockParametersNode (location: (17...22))
+        │   │           │   │   ├── parameters:
+        │   │           │   │   │   @ ParametersNode (location: (18...21))
+        │   │           │   │   │   ├── requireds: (length: 1)
+        │   │           │   │   │   │   └── @ RequiredParameterNode (location: (18...21))
+        │   │           │   │   │   │       └── name: :bar
+        │   │           │   │   │   ├── optionals: (length: 0)
+        │   │           │   │   │   ├── posts: (length: 0)
+        │   │           │   │   │   ├── rest: ∅
+        │   │           │   │   │   ├── keywords: (length: 0)
+        │   │           │   │   │   ├── keyword_rest: ∅
+        │   │           │   │   │   └── block: ∅
+        │   │           │   │   ├── locals: (length: 0)
+        │   │           │   │   ├── opening_loc: (17...18) = "|"
+        │   │           │   │   └── closing_loc: (21...22) = "|"
+        │   │           │   ├── body:
+        │   │           │   │   @ StatementsNode (location: (27...60))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ WhileNode (location: (27...60))
+        │   │           │   │           ├── keyword_loc: (27...32) = "while"
+        │   │           │   │           ├── closing_loc: (57...60) = "end"
+        │   │           │   │           ├── predicate:
+        │   │           │   │           │   @ CallNode (location: (33...36))
+        │   │           │   │           │   ├── receiver: ∅
+        │   │           │   │           │   ├── call_operator_loc: ∅
+        │   │           │   │           │   ├── message_loc: (33...36) = "foo"
+        │   │           │   │           │   ├── opening_loc: ∅
+        │   │           │   │           │   ├── arguments: ∅
+        │   │           │   │           │   ├── closing_loc: ∅
+        │   │           │   │           │   ├── block: ∅
+        │   │           │   │           │   ├── flags: variable_call
+        │   │           │   │           │   └── name: "foo"
+        │   │           │   │           ├── statements:
+        │   │           │   │           │   @ StatementsNode (location: (43...52))
+        │   │           │   │           │   └── body: (length: 1)
+        │   │           │   │           │       └── @ LocalVariableWriteNode (location: (43...52))
+        │   │           │   │           │           ├── name: :foo
+        │   │           │   │           │           ├── depth: 0
+        │   │           │   │           │           ├── name_loc: (43...46) = "foo"
+        │   │           │   │           │           ├── value:
+        │   │           │   │           │           │   @ LocalVariableReadNode (location: (49...52))
+        │   │           │   │           │           │   ├── name: :bar
+        │   │           │   │           │           │   └── depth: 0
+        │   │           │   │           │           └── operator_loc: (47...48) = "="
+        │   │           │   │           └── flags: 
+        │   │           │   ├── opening_loc: (15...16) = "{"
+        │   │           │   └── closing_loc: (63...64) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "foo"
+        │   ├── end_keyword_loc: (65...68) = "end"
+        │   └── name: :A
+        ├── @ DefNode (location: (70...110))
+        │   ├── name: :foo
+        │   ├── name_loc: (74...77) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (80...106))
+        │   │   └── body: (length: 1)
+        │   │       └── @ WhileNode (location: (80...106))
+        │   │           ├── keyword_loc: (90...95) = "while"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── predicate:
+        │   │           │   @ CallNode (location: (96...106))
+        │   │           │   ├── receiver:
+        │   │           │   │   @ LocalVariableReadNode (location: (96...99))
+        │   │           │   │   ├── name: :foo
+        │   │           │   │   └── depth: 0
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (100...102) = "!="
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments:
+        │   │           │   │   @ ArgumentsNode (location: (103...106))
+        │   │           │   │   └── arguments: (length: 1)
+        │   │           │   │       └── @ CallNode (location: (103...106))
+        │   │           │   │           ├── receiver: ∅
+        │   │           │   │           ├── call_operator_loc: ∅
+        │   │           │   │           ├── message_loc: (103...106) = "baz"
+        │   │           │   │           ├── opening_loc: ∅
+        │   │           │   │           ├── arguments: ∅
+        │   │           │   │           ├── closing_loc: ∅
+        │   │           │   │           ├── block: ∅
+        │   │           │   │           ├── flags: variable_call
+        │   │           │   │           └── name: "baz"
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: 
+        │   │           │   └── name: "!="
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (80...89))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ LocalVariableWriteNode (location: (80...89))
+        │   │           │           ├── name: :foo
+        │   │           │           ├── depth: 0
+        │   │           │           ├── name_loc: (80...83) = "foo"
+        │   │           │           ├── value:
+        │   │           │           │   @ CallNode (location: (86...89))
+        │   │           │           │   ├── receiver: ∅
+        │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │           │   ├── message_loc: (86...89) = "bar"
+        │   │           │           │   ├── opening_loc: ∅
+        │   │           │           │   ├── arguments: ∅
+        │   │           │           │   ├── closing_loc: ∅
+        │   │           │           │   ├── block: ∅
+        │   │           │           │   ├── flags: variable_call
+        │   │           │           │   └── name: "bar"
+        │   │           │           └── operator_loc: (84...85) = "="
+        │   │           └── flags: 
+        │   ├── locals: [:foo]
+        │   ├── def_keyword_loc: (70...73) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (107...110) = "end"
+        ├── @ ModuleNode (location: (112...146))
+        │   ├── locals: [:foo]
+        │   ├── module_keyword_loc: (112...118) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (119...120))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (123...142))
+        │   │   └── body: (length: 1)
+        │   │       └── @ WhileNode (location: (123...142))
+        │   │           ├── keyword_loc: (133...138) = "while"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── predicate:
+        │   │           │   @ LocalVariableReadNode (location: (139...142))
+        │   │           │   ├── name: :foo
+        │   │           │   └── depth: 0
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (123...132))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ LocalVariableWriteNode (location: (123...132))
+        │   │           │           ├── name: :foo
+        │   │           │           ├── depth: 0
+        │   │           │           ├── name_loc: (123...126) = "foo"
+        │   │           │           ├── value:
+        │   │           │           │   @ CallNode (location: (129...132))
+        │   │           │           │   ├── receiver: ∅
+        │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │           │   ├── message_loc: (129...132) = "bar"
+        │   │           │           │   ├── opening_loc: ∅
+        │   │           │           │   ├── arguments: ∅
+        │   │           │           │   ├── closing_loc: ∅
+        │   │           │           │   ├── block: ∅
+        │   │           │           │   ├── flags: variable_call
+        │   │           │           │   └── name: "bar"
+        │   │           │           └── operator_loc: (127...128) = "="
+        │   │           └── flags: 
+        │   ├── end_keyword_loc: (143...146) = "end"
+        │   └── name: :A
+        ├── @ ModuleNode (location: (148...182))
+        │   ├── locals: [:foo]
+        │   ├── module_keyword_loc: (148...154) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (155...156))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (159...178))
+        │   │   └── body: (length: 1)
+        │   │       └── @ UntilNode (location: (159...178))
+        │   │           ├── keyword_loc: (169...174) = "until"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── predicate:
+        │   │           │   @ LocalVariableReadNode (location: (175...178))
+        │   │           │   ├── name: :foo
+        │   │           │   └── depth: 0
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (159...168))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ LocalVariableWriteNode (location: (159...168))
+        │   │           │           ├── name: :foo
+        │   │           │           ├── depth: 0
+        │   │           │           ├── name_loc: (159...162) = "foo"
+        │   │           │           ├── value:
+        │   │           │           │   @ CallNode (location: (165...168))
+        │   │           │           │   ├── receiver: ∅
+        │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │           │   ├── message_loc: (165...168) = "bar"
+        │   │           │           │   ├── opening_loc: ∅
+        │   │           │           │   ├── arguments: ∅
+        │   │           │           │   ├── closing_loc: ∅
+        │   │           │           │   ├── block: ∅
+        │   │           │           │   ├── flags: variable_call
+        │   │           │           │   └── name: "bar"
+        │   │           │           └── operator_loc: (163...164) = "="
+        │   │           └── flags: 
+        │   ├── end_keyword_loc: (179...182) = "end"
+        │   └── name: :A
+        ├── @ ModuleNode (location: (184...228))
+        │   ├── locals: [:foo]
+        │   ├── module_keyword_loc: (184...190) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (191...192))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (195...224))
+        │   │   └── body: (length: 1)
+        │   │       └── @ WhileNode (location: (195...224))
+        │   │           ├── keyword_loc: (195...200) = "while"
+        │   │           ├── closing_loc: (221...224) = "end"
+        │   │           ├── predicate:
+        │   │           │   @ CallNode (location: (201...204))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (201...204) = "foo"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "foo"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (209...218))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ LocalVariableWriteNode (location: (209...218))
+        │   │           │           ├── name: :foo
+        │   │           │           ├── depth: 0
+        │   │           │           ├── name_loc: (209...212) = "foo"
+        │   │           │           ├── value:
+        │   │           │           │   @ CallNode (location: (215...218))
+        │   │           │           │   ├── receiver: ∅
+        │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │           │   ├── message_loc: (215...218) = "bar"
+        │   │           │           │   ├── opening_loc: ∅
+        │   │           │           │   ├── arguments: ∅
+        │   │           │           │   ├── closing_loc: ∅
+        │   │           │           │   ├── block: ∅
+        │   │           │           │   ├── flags: variable_call
+        │   │           │           │   └── name: "bar"
+        │   │           │           └── operator_loc: (213...214) = "="
+        │   │           └── flags: 
+        │   ├── end_keyword_loc: (225...228) = "end"
+        │   └── name: :A
+        ├── @ ModuleNode (location: (230...299))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (230...236) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (237...238))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (241...295))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (241...295))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (241...245) = "each"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (246...295))
+        │   │           │   ├── locals: [:baz, :foo]
+        │   │           │   ├── parameters:
+        │   │           │   │   @ BlockParametersNode (location: (248...253))
+        │   │           │   │   ├── parameters:
+        │   │           │   │   │   @ ParametersNode (location: (249...252))
+        │   │           │   │   │   ├── requireds: (length: 1)
+        │   │           │   │   │   │   └── @ RequiredParameterNode (location: (249...252))
+        │   │           │   │   │   │       └── name: :baz
+        │   │           │   │   │   ├── optionals: (length: 0)
+        │   │           │   │   │   ├── posts: (length: 0)
+        │   │           │   │   │   ├── rest: ∅
+        │   │           │   │   │   ├── keywords: (length: 0)
+        │   │           │   │   │   ├── keyword_rest: ∅
+        │   │           │   │   │   └── block: ∅
+        │   │           │   │   ├── locals: (length: 0)
+        │   │           │   │   ├── opening_loc: (248...249) = "|"
+        │   │           │   │   └── closing_loc: (252...253) = "|"
+        │   │           │   ├── body:
+        │   │           │   │   @ StatementsNode (location: (258...291))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ WhileNode (location: (258...291))
+        │   │           │   │           ├── keyword_loc: (258...263) = "while"
+        │   │           │   │           ├── closing_loc: (288...291) = "end"
+        │   │           │   │           ├── predicate:
+        │   │           │   │           │   @ CallNode (location: (264...267))
+        │   │           │   │           │   ├── receiver: ∅
+        │   │           │   │           │   ├── call_operator_loc: ∅
+        │   │           │   │           │   ├── message_loc: (264...267) = "foo"
+        │   │           │   │           │   ├── opening_loc: ∅
+        │   │           │   │           │   ├── arguments: ∅
+        │   │           │   │           │   ├── closing_loc: ∅
+        │   │           │   │           │   ├── block: ∅
+        │   │           │   │           │   ├── flags: variable_call
+        │   │           │   │           │   └── name: "foo"
+        │   │           │   │           ├── statements:
+        │   │           │   │           │   @ StatementsNode (location: (274...283))
+        │   │           │   │           │   └── body: (length: 1)
+        │   │           │   │           │       └── @ LocalVariableWriteNode (location: (274...283))
+        │   │           │   │           │           ├── name: :foo
+        │   │           │   │           │           ├── depth: 0
+        │   │           │   │           │           ├── name_loc: (274...277) = "foo"
+        │   │           │   │           │           ├── value:
+        │   │           │   │           │           │   @ CallNode (location: (280...283))
+        │   │           │   │           │           │   ├── receiver: ∅
+        │   │           │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │   │           │           │   ├── message_loc: (280...283) = "bar"
+        │   │           │   │           │           │   ├── opening_loc: ∅
+        │   │           │   │           │           │   ├── arguments: ∅
+        │   │           │   │           │           │   ├── closing_loc: ∅
+        │   │           │   │           │           │   ├── block: ∅
+        │   │           │   │           │           │   ├── flags: variable_call
+        │   │           │   │           │           │   └── name: "bar"
+        │   │           │   │           │           └── operator_loc: (278...279) = "="
+        │   │           │   │           └── flags: 
+        │   │           │   ├── opening_loc: (246...247) = "{"
+        │   │           │   └── closing_loc: (294...295) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "each"
+        │   ├── end_keyword_loc: (296...299) = "end"
+        │   └── name: :A
+        ├── @ ModuleNode (location: (301...370))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (301...307) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (308...309))
+        │   │   └── name: :A
+        │   ├── body:
+        │   │   @ StatementsNode (location: (312...366))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (312...366))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (312...316) = "each"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (317...366))
+        │   │           │   ├── locals: [:foo]
+        │   │           │   ├── parameters:
+        │   │           │   │   @ BlockParametersNode (location: (319...324))
+        │   │           │   │   ├── parameters:
+        │   │           │   │   │   @ ParametersNode (location: (320...323))
+        │   │           │   │   │   ├── requireds: (length: 1)
+        │   │           │   │   │   │   └── @ RequiredParameterNode (location: (320...323))
+        │   │           │   │   │   │       └── name: :foo
+        │   │           │   │   │   ├── optionals: (length: 0)
+        │   │           │   │   │   ├── posts: (length: 0)
+        │   │           │   │   │   ├── rest: ∅
+        │   │           │   │   │   ├── keywords: (length: 0)
+        │   │           │   │   │   ├── keyword_rest: ∅
+        │   │           │   │   │   └── block: ∅
+        │   │           │   │   ├── locals: (length: 0)
+        │   │           │   │   ├── opening_loc: (319...320) = "|"
+        │   │           │   │   └── closing_loc: (323...324) = "|"
+        │   │           │   ├── body:
+        │   │           │   │   @ StatementsNode (location: (329...362))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ WhileNode (location: (329...362))
+        │   │           │   │           ├── keyword_loc: (329...334) = "while"
+        │   │           │   │           ├── closing_loc: (359...362) = "end"
+        │   │           │   │           ├── predicate:
+        │   │           │   │           │   @ LocalVariableReadNode (location: (335...338))
+        │   │           │   │           │   ├── name: :foo
+        │   │           │   │           │   └── depth: 0
+        │   │           │   │           ├── statements:
+        │   │           │   │           │   @ StatementsNode (location: (345...354))
+        │   │           │   │           │   └── body: (length: 1)
+        │   │           │   │           │       └── @ LocalVariableWriteNode (location: (345...354))
+        │   │           │   │           │           ├── name: :foo
+        │   │           │   │           │           ├── depth: 0
+        │   │           │   │           │           ├── name_loc: (345...348) = "foo"
+        │   │           │   │           │           ├── value:
+        │   │           │   │           │           │   @ CallNode (location: (351...354))
+        │   │           │   │           │           │   ├── receiver: ∅
+        │   │           │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │   │           │           │   ├── message_loc: (351...354) = "bar"
+        │   │           │   │           │           │   ├── opening_loc: ∅
+        │   │           │   │           │           │   ├── arguments: ∅
+        │   │           │   │           │           │   ├── closing_loc: ∅
+        │   │           │   │           │           │   ├── block: ∅
+        │   │           │   │           │           │   ├── flags: variable_call
+        │   │           │   │           │           │   └── name: "bar"
+        │   │           │   │           │           └── operator_loc: (349...350) = "="
+        │   │           │   │           └── flags: 
+        │   │           │   ├── opening_loc: (317...318) = "{"
+        │   │           │   └── closing_loc: (365...366) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "each"
+        │   ├── end_keyword_loc: (367...370) = "end"
+        │   └── name: :A
+        ├── @ LocalVariableWriteNode (location: (371...402))
+        │   ├── name: :x
+        │   ├── depth: 0
+        │   ├── name_loc: (371...372) = "x"
+        │   ├── value:
+        │   │   @ ParenthesesNode (location: (375...402))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (376...401))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ WhileNode (location: (376...401))
+        │   │   │           ├── keyword_loc: (392...397) = "while"
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── predicate:
+        │   │   │           │   @ CallNode (location: (398...401))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (398...401) = "baz"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "baz"
+        │   │   │           ├── statements:
+        │   │   │           │   @ StatementsNode (location: (376...391))
+        │   │   │           │   └── body: (length: 1)
+        │   │   │           │       └── @ BeginNode (location: (376...391))
+        │   │   │           │           ├── begin_keyword_loc: (376...381) = "begin"
+        │   │   │           │           ├── statements:
+        │   │   │           │           │   @ StatementsNode (location: (384...387))
+        │   │   │           │           │   └── body: (length: 1)
+        │   │   │           │           │       └── @ CallNode (location: (384...387))
+        │   │   │           │           │           ├── receiver: ∅
+        │   │   │           │           │           ├── call_operator_loc: ∅
+        │   │   │           │           │           ├── message_loc: (384...387) = "foo"
+        │   │   │           │           │           ├── opening_loc: ∅
+        │   │   │           │           │           ├── arguments: ∅
+        │   │   │           │           │           ├── closing_loc: ∅
+        │   │   │           │           │           ├── block: ∅
+        │   │   │           │           │           ├── flags: variable_call
+        │   │   │           │           │           └── name: "foo"
+        │   │   │           │           ├── rescue_clause: ∅
+        │   │   │           │           ├── else_clause: ∅
+        │   │   │           │           ├── ensure_clause: ∅
+        │   │   │           │           └── end_keyword_loc: (388...391) = "end"
+        │   │   │           └── flags: begin_modifier
+        │   │   ├── opening_loc: (375...376) = "("
+        │   │   └── closing_loc: (401...402) = ")"
+        │   └── operator_loc: (373...374) = "="
+        ├── @ WhileNode (location: (403...428))
+        │   ├── keyword_loc: (419...424) = "while"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (425...428))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (425...428) = "baz"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "baz"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (403...418))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BeginNode (location: (403...418))
+        │   │           ├── begin_keyword_loc: (403...408) = "begin"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (411...414))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (411...414))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (411...414) = "foo"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "foo"
+        │   │           ├── rescue_clause: ∅
+        │   │           ├── else_clause: ∅
+        │   │           ├── ensure_clause: ∅
+        │   │           └── end_keyword_loc: (415...418) = "end"
+        │   └── flags: begin_modifier
+        ├── @ UntilNode (location: (429...460))
+        │   ├── keyword_loc: (451...456) = "until"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (457...460))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (457...460) = "baz"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "baz"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (429...450))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BeginNode (location: (429...450))
+        │   │           ├── begin_keyword_loc: (429...434) = "begin"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (437...446))
+        │   │           │   └── body: (length: 2)
+        │   │           │       ├── @ CallNode (location: (437...440))
+        │   │           │       │   ├── receiver: ∅
+        │   │           │       │   ├── call_operator_loc: ∅
+        │   │           │       │   ├── message_loc: (437...440) = "foo"
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── arguments: ∅
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   ├── block: ∅
+        │   │           │       │   ├── flags: variable_call
+        │   │           │       │   └── name: "foo"
+        │   │           │       └── @ CallNode (location: (443...446))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (443...446) = "bar"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "bar"
+        │   │           ├── rescue_clause: ∅
+        │   │           ├── else_clause: ∅
+        │   │           ├── ensure_clause: ∅
+        │   │           └── end_keyword_loc: (447...450) = "end"
+        │   └── flags: begin_modifier
+        ├── @ WhileNode (location: (461...492))
+        │   ├── keyword_loc: (483...488) = "while"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (489...492))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (489...492) = "baz"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "baz"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (461...482))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BeginNode (location: (461...482))
+        │   │           ├── begin_keyword_loc: (461...466) = "begin"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (469...478))
+        │   │           │   └── body: (length: 2)
+        │   │           │       ├── @ CallNode (location: (469...472))
+        │   │           │       │   ├── receiver: ∅
+        │   │           │       │   ├── call_operator_loc: ∅
+        │   │           │       │   ├── message_loc: (469...472) = "foo"
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── arguments: ∅
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   ├── block: ∅
+        │   │           │       │   ├── flags: variable_call
+        │   │           │       │   └── name: "foo"
+        │   │           │       └── @ CallNode (location: (475...478))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (475...478) = "bar"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments: ∅
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: variable_call
+        │   │           │           └── name: "bar"
+        │   │           ├── rescue_clause: ∅
+        │   │           ├── else_clause: ∅
+        │   │           ├── ensure_clause: ∅
+        │   │           └── end_keyword_loc: (479...482) = "end"
+        │   └── flags: begin_modifier
+        ├── @ WhileNode (location: (493...508))
+        │   ├── keyword_loc: (493...498) = "while"
+        │   ├── closing_loc: (505...508) = "end"
+        │   ├── predicate:
+        │   │   @ FalseNode (location: (499...504))
+        │   ├── statements: ∅
+        │   └── flags: 
+        ├── @ WhileNode (location: (509...528))
+        │   ├── keyword_loc: (509...514) = "while"
+        │   ├── closing_loc: (525...528) = "end"
+        │   ├── predicate:
+        │   │   @ FalseNode (location: (515...520))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (523...524))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (523...524))
+        │   └── flags: 
+        ├── @ WhileNode (location: (529...556))
+        │   ├── keyword_loc: (529...534) = "while"
+        │   ├── closing_loc: (553...556) = "end"
+        │   ├── predicate:
+        │   │   @ ParenthesesNode (location: (535...544))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (536...543))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (536...543))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (536...539) = "foo"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block:
+        │   │   │           │   @ BlockNode (location: (540...543))
+        │   │   │           │   ├── locals: []
+        │   │   │           │   ├── parameters: ∅
+        │   │   │           │   ├── body: ∅
+        │   │   │           │   ├── opening_loc: (540...541) = "{"
+        │   │   │           │   └── closing_loc: (542...543) = "}"
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "foo"
+        │   │   ├── opening_loc: (535...536) = "("
+        │   │   └── closing_loc: (543...544) = ")"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (547...552))
+        │   │   └── body: (length: 1)
+        │   │       └── @ SymbolNode (location: (547...552))
+        │   │           ├── opening_loc: (547...548) = ":"
+        │   │           ├── value_loc: (548...552) = "body"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "body"
+        │   └── flags: 
+        ├── @ UntilNode (location: (557...572))
+        │   ├── keyword_loc: (557...562) = "until"
+        │   ├── closing_loc: (569...572) = "end"
+        │   ├── predicate:
+        │   │   @ FalseNode (location: (563...568))
+        │   ├── statements: ∅
+        │   └── flags: 
+        ├── @ UntilNode (location: (573...592))
+        │   ├── keyword_loc: (573...578) = "until"
+        │   ├── closing_loc: (589...592) = "end"
+        │   ├── predicate:
+        │   │   @ FalseNode (location: (579...584))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (587...588))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (587...588))
+        │   └── flags: 
+        └── @ UntilNode (location: (593...620))
+            ├── keyword_loc: (593...598) = "until"
+            ├── closing_loc: (617...620) = "end"
+            ├── predicate:
+            │   @ ParenthesesNode (location: (599...608))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (600...607))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (600...607))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (600...603) = "foo"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block:
+            │   │           │   @ BlockNode (location: (604...607))
+            │   │           │   ├── locals: []
+            │   │           │   ├── parameters: ∅
+            │   │           │   ├── body: ∅
+            │   │           │   ├── opening_loc: (604...605) = "{"
+            │   │           │   └── closing_loc: (606...607) = "}"
+            │   │           ├── flags: 
+            │   │           └── name: "foo"
+            │   ├── opening_loc: (599...600) = "("
+            │   └── closing_loc: (607...608) = ")"
+            ├── statements:
+            │   @ StatementsNode (location: (611...616))
+            │   └── body: (length: 1)
+            │       └── @ SymbolNode (location: (611...616))
+            │           ├── opening_loc: (611...612) = ":"
+            │           ├── value_loc: (612...616) = "body"
+            │           ├── closing_loc: ∅
+            │           └── unescaped: "body"
+            └── flags: 
diff --git a/test/yarp/snapshots/unparser/corpus/literal/yield.txt b/test/yarp/snapshots/unparser/corpus/literal/yield.txt
index 4ccd79e2dd..52f50f1275 100644
--- a/test/yarp/snapshots/unparser/corpus/literal/yield.txt
+++ b/test/yarp/snapshots/unparser/corpus/literal/yield.txt
@@ -1,23 +1,54 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [YieldNode(0...5)((0...5), nil, nil, nil),
-     YieldNode(6...14)(
-       (6...11),
-       (11...12),
-       ArgumentsNode(12...13)(
-         [CallNode(12...13)(nil, nil, (12...13), nil, nil, nil, nil, 2, "a")]
-       ),
-       (13...14)
-     ),
-     YieldNode(15...26)(
-       (15...20),
-       (20...21),
-       ArgumentsNode(21...25)(
-         [CallNode(21...22)(nil, nil, (21...22), nil, nil, nil, nil, 2, "a"),
-          CallNode(24...25)(nil, nil, (24...25), nil, nil, nil, nil, 2, "b")]
-       ),
-       (25...26)
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 3)
+        ├── @ YieldNode (location: (0...5))
+        │   ├── keyword_loc: (0...5) = "yield"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments: ∅
+        │   └── rparen_loc: ∅
+        ├── @ YieldNode (location: (6...14))
+        │   ├── keyword_loc: (6...11) = "yield"
+        │   ├── lparen_loc: (11...12) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (12...13))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (12...13))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (12...13) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   └── rparen_loc: (13...14) = ")"
+        └── @ YieldNode (location: (15...26))
+            ├── keyword_loc: (15...20) = "yield"
+            ├── lparen_loc: (20...21) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (21...25))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (21...22))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (21...22) = "a"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "a"
+            │       └── @ CallNode (location: (24...25))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (24...25) = "b"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "b"
+            └── rparen_loc: (25...26) = ")"
diff --git a/test/yarp/snapshots/unparser/corpus/semantic/and.txt b/test/yarp/snapshots/unparser/corpus/semantic/and.txt
index de40267054..4af92c1e96 100644
--- a/test/yarp/snapshots/unparser/corpus/semantic/and.txt
+++ b/test/yarp/snapshots/unparser/corpus/semantic/and.txt
@@ -1,77 +1,233 @@
-ProgramNode(0...77)(
-  [],
-  StatementsNode(0...77)(
-    [OrNode(0...14)(
-       RangeNode(0...5)(
-         CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-         CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "b"),
-         (1...4),
-         1
-       ),
-       RangeNode(9...14)(
-         CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "c"),
-         CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "d"),
-         (10...13),
-         1
-       ),
-       (6...8)
-     ),
-     AndNode(15...30)(
-       RangeNode(15...20)(
-         CallNode(15...16)(nil, nil, (15...16), nil, nil, nil, nil, 2, "a"),
-         CallNode(19...20)(nil, nil, (19...20), nil, nil, nil, nil, 2, "b"),
-         (16...19),
-         1
-       ),
-       RangeNode(25...30)(
-         CallNode(25...26)(nil, nil, (25...26), nil, nil, nil, nil, 2, "c"),
-         CallNode(29...30)(nil, nil, (29...30), nil, nil, nil, nil, 2, "d"),
-         (26...29),
-         1
-       ),
-       (21...24)
-     ),
-     IfNode(32...53)(
-       (32...34),
-       OrNode(35...49)(
-         FlipFlopNode(35...40)(
-           CallNode(35...36)(nil, nil, (35...36), nil, nil, nil, nil, 2, "a"),
-           CallNode(39...40)(nil, nil, (39...40), nil, nil, nil, nil, 2, "b"),
-           (36...39),
-           1
-         ),
-         FlipFlopNode(44...49)(
-           CallNode(44...45)(nil, nil, (44...45), nil, nil, nil, nil, 2, "c"),
-           CallNode(48...49)(nil, nil, (48...49), nil, nil, nil, nil, 2, "d"),
-           (45...48),
-           1
-         ),
-         (41...43)
-       ),
-       nil,
-       nil,
-       (50...53)
-     ),
-     IfNode(55...77)(
-       (55...57),
-       AndNode(58...73)(
-         FlipFlopNode(58...63)(
-           CallNode(58...59)(nil, nil, (58...59), nil, nil, nil, nil, 2, "a"),
-           CallNode(62...63)(nil, nil, (62...63), nil, nil, nil, nil, 2, "b"),
-           (59...62),
-           1
-         ),
-         FlipFlopNode(68...73)(
-           CallNode(68...69)(nil, nil, (68...69), nil, nil, nil, nil, 2, "c"),
-           CallNode(72...73)(nil, nil, (72...73), nil, nil, nil, nil, 2, "d"),
-           (69...72),
-           1
-         ),
-         (64...67)
-       ),
-       nil,
-       nil,
-       (74...77)
-     )]
-  )
-)
+@ ProgramNode (location: (0...77))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...77))
+    └── body: (length: 4)
+        ├── @ OrNode (location: (0...14))
+        │   ├── left:
+        │   │   @ RangeNode (location: (0...5))
+        │   │   ├── left:
+        │   │   │   @ CallNode (location: (0...1))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (0...1) = "a"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "a"
+        │   │   ├── right:
+        │   │   │   @ CallNode (location: (4...5))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (4...5) = "b"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "b"
+        │   │   ├── operator_loc: (1...4) = "..."
+        │   │   └── flags: exclude_end
+        │   ├── right:
+        │   │   @ RangeNode (location: (9...14))
+        │   │   ├── left:
+        │   │   │   @ CallNode (location: (9...10))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (9...10) = "c"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "c"
+        │   │   ├── right:
+        │   │   │   @ CallNode (location: (13...14))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (13...14) = "d"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "d"
+        │   │   ├── operator_loc: (10...13) = "..."
+        │   │   └── flags: exclude_end
+        │   └── operator_loc: (6...8) = "or"
+        ├── @ AndNode (location: (15...30))
+        │   ├── left:
+        │   │   @ RangeNode (location: (15...20))
+        │   │   ├── left:
+        │   │   │   @ CallNode (location: (15...16))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (15...16) = "a"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "a"
+        │   │   ├── right:
+        │   │   │   @ CallNode (location: (19...20))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (19...20) = "b"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "b"
+        │   │   ├── operator_loc: (16...19) = "..."
+        │   │   └── flags: exclude_end
+        │   ├── right:
+        │   │   @ RangeNode (location: (25...30))
+        │   │   ├── left:
+        │   │   │   @ CallNode (location: (25...26))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (25...26) = "c"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "c"
+        │   │   ├── right:
+        │   │   │   @ CallNode (location: (29...30))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (29...30) = "d"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "d"
+        │   │   ├── operator_loc: (26...29) = "..."
+        │   │   └── flags: exclude_end
+        │   └── operator_loc: (21...24) = "and"
+        ├── @ IfNode (location: (32...53))
+        │   ├── if_keyword_loc: (32...34) = "if"
+        │   ├── predicate:
+        │   │   @ OrNode (location: (35...49))
+        │   │   ├── left:
+        │   │   │   @ FlipFlopNode (location: (35...40))
+        │   │   │   ├── left:
+        │   │   │   │   @ CallNode (location: (35...36))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (35...36) = "a"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "a"
+        │   │   │   ├── right:
+        │   │   │   │   @ CallNode (location: (39...40))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (39...40) = "b"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "b"
+        │   │   │   ├── operator_loc: (36...39) = "..."
+        │   │   │   └── flags: exclude_end
+        │   │   ├── right:
+        │   │   │   @ FlipFlopNode (location: (44...49))
+        │   │   │   ├── left:
+        │   │   │   │   @ CallNode (location: (44...45))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (44...45) = "c"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "c"
+        │   │   │   ├── right:
+        │   │   │   │   @ CallNode (location: (48...49))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (48...49) = "d"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "d"
+        │   │   │   ├── operator_loc: (45...48) = "..."
+        │   │   │   └── flags: exclude_end
+        │   │   └── operator_loc: (41...43) = "or"
+        │   ├── statements: ∅
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (50...53) = "end"
+        └── @ IfNode (location: (55...77))
+            ├── if_keyword_loc: (55...57) = "if"
+            ├── predicate:
+            │   @ AndNode (location: (58...73))
+            │   ├── left:
+            │   │   @ FlipFlopNode (location: (58...63))
+            │   │   ├── left:
+            │   │   │   @ CallNode (location: (58...59))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (58...59) = "a"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "a"
+            │   │   ├── right:
+            │   │   │   @ CallNode (location: (62...63))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (62...63) = "b"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "b"
+            │   │   ├── operator_loc: (59...62) = "..."
+            │   │   └── flags: exclude_end
+            │   ├── right:
+            │   │   @ FlipFlopNode (location: (68...73))
+            │   │   ├── left:
+            │   │   │   @ CallNode (location: (68...69))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (68...69) = "c"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "c"
+            │   │   ├── right:
+            │   │   │   @ CallNode (location: (72...73))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (72...73) = "d"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "d"
+            │   │   ├── operator_loc: (69...72) = "..."
+            │   │   └── flags: exclude_end
+            │   └── operator_loc: (64...67) = "and"
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (74...77) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/semantic/block.txt b/test/yarp/snapshots/unparser/corpus/semantic/block.txt
index 1652494897..992c9cfac8 100644
--- a/test/yarp/snapshots/unparser/corpus/semantic/block.txt
+++ b/test/yarp/snapshots/unparser/corpus/semantic/block.txt
@@ -1,165 +1,193 @@
-ProgramNode(0...148)(
-  [],
-  StatementsNode(0...148)(
-    [CallNode(0...10)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       nil,
-       nil,
-       BlockNode(4...10)([], nil, nil, (4...6), (7...10)),
-       0,
-       "foo"
-     ),
-     CallNode(12...29)(
-       nil,
-       nil,
-       (12...15),
-       nil,
-       nil,
-       nil,
-       BlockNode(16...29)(
-         [],
-         nil,
-         BeginNode(19...29)(
-           nil,
-           nil,
-           RescueNode(19...25)((19...25), [], nil, nil, nil, nil),
-           nil,
-           nil,
-           (26...29)
-         ),
-         (16...18),
-         (26...29)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(31...64)(
-       nil,
-       nil,
-       (31...34),
-       nil,
-       nil,
-       nil,
-       BlockNode(35...64)(
-         [],
-         nil,
-         StatementsNode(40...60)(
-           [RescueModifierNode(40...54)(
-              NilNode(40...43)(),
-              (44...50),
-              NilNode(51...54)()
-            ),
-            NilNode(57...60)()]
-         ),
-         (35...37),
-         (61...64)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(66...80)(
-       nil,
-       nil,
-       (66...69),
-       nil,
-       nil,
-       nil,
-       BlockNode(70...80)(
-         [:a],
-         BlockParametersNode(73...76)(
-           ParametersNode(74...75)(
-             [RequiredParameterNode(74...75)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (73...74),
-           (75...76)
-         ),
-         nil,
-         (70...72),
-         (77...80)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(82...116)(
-       nil,
-       nil,
-       (82...85),
-       (85...86),
-       ArgumentsNode(86...92)(
-         [InterpolatedStringNode(86...92)(
-            (86...92),
-            [StringNode(101...105)(nil, (101...105), nil, "  b\n")],
-            (105...109)
-          )]
-       ),
-       (92...93),
-       BlockNode(94...116)(
-         [:a],
-         BlockParametersNode(97...100)(
-           ParametersNode(98...99)(
-             [RequiredParameterNode(98...99)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (97...98),
-           (99...100)
-         ),
-         StatementsNode(111...112)([LocalVariableReadNode(111...112)(:a, 0)]),
-         (94...96),
-         (113...116)
-       ),
-       0,
-       "foo"
-     ),
-     CallNode(118...148)(
-       nil,
-       nil,
-       (118...121),
-       (121...122),
-       ArgumentsNode(122...128)(
-         [InterpolatedStringNode(122...128)(
-            (122...128),
-            [StringNode(133...137)(nil, (133...137), nil, "  b\n")],
-            (137...141)
-          )]
-       ),
-       (128...129),
-       BlockNode(130...148)(
-         [],
-         nil,
-         StatementsNode(143...144)(
-           [CallNode(143...144)(
-              nil,
-              nil,
-              (143...144),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "a"
-            )]
-         ),
-         (130...132),
-         (145...148)
-       ),
-       0,
-       "foo"
-     )]
-  )
-)
+@ ProgramNode (location: (0...148))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...148))
+    └── body: (length: 6)
+        ├── @ CallNode (location: (0...10))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (4...10))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (4...6) = "do"
+        │   │   └── closing_loc: (7...10) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (12...29))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (12...15) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (16...29))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ BeginNode (location: (19...29))
+        │   │   │   ├── begin_keyword_loc: ∅
+        │   │   │   ├── statements: ∅
+        │   │   │   ├── rescue_clause:
+        │   │   │   │   @ RescueNode (location: (19...25))
+        │   │   │   │   ├── keyword_loc: (19...25) = "rescue"
+        │   │   │   │   ├── exceptions: (length: 0)
+        │   │   │   │   ├── operator_loc: ∅
+        │   │   │   │   ├── reference: ∅
+        │   │   │   │   ├── statements: ∅
+        │   │   │   │   └── consequent: ∅
+        │   │   │   ├── else_clause: ∅
+        │   │   │   ├── ensure_clause: ∅
+        │   │   │   └── end_keyword_loc: (26...29) = "end"
+        │   │   ├── opening_loc: (16...18) = "do"
+        │   │   └── closing_loc: (26...29) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (31...64))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (31...34) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (35...64))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (40...60))
+        │   │   │   └── body: (length: 2)
+        │   │   │       ├── @ RescueModifierNode (location: (40...54))
+        │   │   │       │   ├── expression:
+        │   │   │       │   │   @ NilNode (location: (40...43))
+        │   │   │       │   ├── keyword_loc: (44...50) = "rescue"
+        │   │   │       │   └── rescue_expression:
+        │   │   │       │       @ NilNode (location: (51...54))
+        │   │   │       └── @ NilNode (location: (57...60))
+        │   │   ├── opening_loc: (35...37) = "do"
+        │   │   └── closing_loc: (61...64) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (66...80))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (66...69) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (70...80))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (73...76))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (74...75))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (74...75))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (73...74) = "|"
+        │   │   │   └── closing_loc: (75...76) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (70...72) = "do"
+        │   │   └── closing_loc: (77...80) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (82...116))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (82...85) = "foo"
+        │   ├── opening_loc: (85...86) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (86...92))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (86...92))
+        │   │           ├── opening_loc: (86...92) = "<<-DOC"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (101...105))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (101...105) = "  b\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "  b\n"
+        │   │           └── closing_loc: (105...109) = "DOC\n"
+        │   ├── closing_loc: (92...93) = ")"
+        │   ├── block:
+        │   │   @ BlockNode (location: (94...116))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (97...100))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (98...99))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (98...99))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (97...98) = "|"
+        │   │   │   └── closing_loc: (99...100) = "|"
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (111...112))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableReadNode (location: (111...112))
+        │   │   │           ├── name: :a
+        │   │   │           └── depth: 0
+        │   │   ├── opening_loc: (94...96) = "do"
+        │   │   └── closing_loc: (113...116) = "end"
+        │   ├── flags: 
+        │   └── name: "foo"
+        └── @ CallNode (location: (118...148))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (118...121) = "foo"
+            ├── opening_loc: (121...122) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (122...128))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedStringNode (location: (122...128))
+            │           ├── opening_loc: (122...128) = "<<-DOC"
+            │           ├── parts: (length: 1)
+            │           │   └── @ StringNode (location: (133...137))
+            │           │       ├── opening_loc: ∅
+            │           │       ├── content_loc: (133...137) = "  b\n"
+            │           │       ├── closing_loc: ∅
+            │           │       └── unescaped: "  b\n"
+            │           └── closing_loc: (137...141) = "DOC\n"
+            ├── closing_loc: (128...129) = ")"
+            ├── block:
+            │   @ BlockNode (location: (130...148))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (143...144))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (143...144))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (143...144) = "a"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "a"
+            │   ├── opening_loc: (130...132) = "do"
+            │   └── closing_loc: (145...148) = "end"
+            ├── flags: 
+            └── name: "foo"
diff --git a/test/yarp/snapshots/unparser/corpus/semantic/def.txt b/test/yarp/snapshots/unparser/corpus/semantic/def.txt
index 428b7138cb..ec9b9fb4df 100644
--- a/test/yarp/snapshots/unparser/corpus/semantic/def.txt
+++ b/test/yarp/snapshots/unparser/corpus/semantic/def.txt
@@ -1,79 +1,89 @@
-ProgramNode(0...55)(
-  [],
-  StatementsNode(0...55)(
-    [DefNode(0...21)(
-       :foo,
-       (4...7),
-       nil,
-       nil,
-       StatementsNode(10...17)(
-         [ParenthesesNode(10...17)(
-            StatementsNode(11...16)(
-              [CallNode(11...16)(
-                 CallNode(11...12)(
-                   nil,
-                   nil,
-                   (11...12),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "a"
-                 ),
-                 nil,
-                 (13...14),
-                 nil,
-                 ArgumentsNode(15...16)(
-                   [CallNode(15...16)(
-                      nil,
-                      nil,
-                      (15...16),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "b"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "-"
-               )]
-            ),
-            (10...11),
-            (16...17)
-          )]
-       ),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (18...21)
-     ),
-     DefNode(23...55)(
-       :foo,
-       (27...30),
-       nil,
-       nil,
-       StatementsNode(33...51)(
-         [RescueModifierNode(33...51)(
-            CallNode(33...34)(nil, nil, (33...34), nil, nil, nil, nil, 2, "a"),
-            (35...41),
-            ConstantReadNode(42...51)(:Exception)
-          )]
-       ),
-       [],
-       (23...26),
-       nil,
-       nil,
-       nil,
-       nil,
-       (52...55)
-     )]
-  )
-)
+@ ProgramNode (location: (0...55))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...55))
+    └── body: (length: 2)
+        ├── @ DefNode (location: (0...21))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (10...17))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (10...17))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (11...16))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (11...16))
+        │   │           │           ├── receiver:
+        │   │           │           │   @ CallNode (location: (11...12))
+        │   │           │           │   ├── receiver: ∅
+        │   │           │           │   ├── call_operator_loc: ∅
+        │   │           │           │   ├── message_loc: (11...12) = "a"
+        │   │           │           │   ├── opening_loc: ∅
+        │   │           │           │   ├── arguments: ∅
+        │   │           │           │   ├── closing_loc: ∅
+        │   │           │           │   ├── block: ∅
+        │   │           │           │   ├── flags: variable_call
+        │   │           │           │   └── name: "a"
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (13...14) = "-"
+        │   │           │           ├── opening_loc: ∅
+        │   │           │           ├── arguments:
+        │   │           │           │   @ ArgumentsNode (location: (15...16))
+        │   │           │           │   └── arguments: (length: 1)
+        │   │           │           │       └── @ CallNode (location: (15...16))
+        │   │           │           │           ├── receiver: ∅
+        │   │           │           │           ├── call_operator_loc: ∅
+        │   │           │           │           ├── message_loc: (15...16) = "b"
+        │   │           │           │           ├── opening_loc: ∅
+        │   │           │           │           ├── arguments: ∅
+        │   │           │           │           ├── closing_loc: ∅
+        │   │           │           │           ├── block: ∅
+        │   │           │           │           ├── flags: variable_call
+        │   │           │           │           └── name: "b"
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "-"
+        │   │           ├── opening_loc: (10...11) = "("
+        │   │           └── closing_loc: (16...17) = ")"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (18...21) = "end"
+        └── @ DefNode (location: (23...55))
+            ├── name: :foo
+            ├── name_loc: (27...30) = "foo"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (33...51))
+            │   └── body: (length: 1)
+            │       └── @ RescueModifierNode (location: (33...51))
+            │           ├── expression:
+            │           │   @ CallNode (location: (33...34))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (33...34) = "a"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "a"
+            │           ├── keyword_loc: (35...41) = "rescue"
+            │           └── rescue_expression:
+            │               @ ConstantReadNode (location: (42...51))
+            │               └── name: :Exception
+            ├── locals: []
+            ├── def_keyword_loc: (23...26) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (52...55) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/semantic/dstr.txt b/test/yarp/snapshots/unparser/corpus/semantic/dstr.txt
index 8edb0134b1..080b3ab847 100644
--- a/test/yarp/snapshots/unparser/corpus/semantic/dstr.txt
+++ b/test/yarp/snapshots/unparser/corpus/semantic/dstr.txt
@@ -1,256 +1,520 @@
-ProgramNode(0...608)(
-  [],
-  StatementsNode(0...608)(
-    [InterpolatedStringNode(0...5)((0...5), [], (6...10)),
-     InterpolatedStringNode(11...18)((11...18), [], (19...23)),
-     InterpolatedStringNode(24...30)((24...30), [], (31...35)),
-     InterpolatedStringNode(36...44)((36...44), [], (45...49)),
-     InterpolatedStringNode(50...55)(
-       (50...55),
-       [StringNode(56...60)(nil, (56...60), nil, "  a\n")],
-       (60...64)
-     ),
-     InterpolatedStringNode(65...72)(
-       (65...72),
-       [StringNode(73...77)(nil, (73...77), nil, "  a\n")],
-       (77...81)
-     ),
-     InterpolatedStringNode(82...87)(
-       (82...87),
-       [StringNode(88...94)(nil, (88...94), nil, "  a\n" + "  "),
-        EmbeddedStatementsNode(94...97)((94...96), nil, (96...97)),
-        StringNode(97...98)(nil, (97...98), nil, "\n")],
-       (98...102)
-     ),
-     InterpolatedStringNode(103...109)(
-       (103...109),
-       [StringNode(110...116)(nil, (110...116), nil, "a\n"),
-        EmbeddedStatementsNode(116...119)((116...118), nil, (118...119)),
-        StringNode(119...120)(nil, (119...120), nil, "\n")],
-       (120...124)
-     ),
-     InterpolatedStringNode(125...131)(
-       (125...131),
-       [StringNode(132...138)(nil, (132...138), nil, "a\n"),
-        EmbeddedStatementsNode(138...141)((138...140), nil, (140...141)),
-        StringNode(141...146)(nil, (141...146), nil, "\n" + "b\n")],
-       (146...150)
-     ),
-     InterpolatedStringNode(151...157)(
-       (151...157),
-       [StringNode(158...168)(nil, (158...168), nil, "a\n" + "  b\n")],
-       (168...172)
-     ),
-     InterpolatedStringNode(173...180)(
-       (173...180),
-       [StringNode(181...186)(nil, (181...186), nil, "a\n" + "\n" + "b\n")],
-       (186...190)
-     ),
-     InterpolatedStringNode(191...198)(
-       (191...198),
-       [StringNode(199...206)(nil, (199...206), nil, " a\n" + "\n" + " b\n")],
-       (206...210)
-     ),
-     InterpolatedStringNode(211...218)(
-       (211...218),
-       [StringNode(219...225)(nil, (219...225), nil, " a\\nb\n")],
-       (225...229)
-     ),
-     InterpolatedStringNode(230...235)(
-       (230...235),
-       [EmbeddedStatementsNode(236...239)((236...238), nil, (238...239)),
-        StringNode(239...242)(nil, (239...242), nil, "a\n" + " "),
-        EmbeddedStatementsNode(242...245)((242...244), nil, (244...245)),
-        StringNode(245...247)(nil, (245...247), nil, "a\n")],
-       (247...251)
-     ),
-     InterpolatedStringNode(252...257)(
-       (252...257),
-       [StringNode(258...260)(nil, (258...260), nil, "  "),
-        EmbeddedStatementsNode(260...263)((260...262), nil, (262...263)),
-        StringNode(263...271)(nil, (263...271), nil, "\n" + "  \#{}\n")],
-       (271...275)
-     ),
-     InterpolatedStringNode(276...281)(
-       (276...281),
-       [StringNode(282...284)(nil, (282...284), nil, " a"),
-        EmbeddedStatementsNode(284...287)((284...286), nil, (286...287)),
-        StringNode(287...292)(nil, (287...292), nil, "b\n" + " c\n")],
-       (292...296)
-     ),
-     InterpolatedStringNode(297...303)(
-       (297...303),
-       [EmbeddedStatementsNode(306...309)((306...308), nil, (308...309)),
-        StringNode(309...310)(nil, (309...310), nil, "\n")],
-       (310...314)
-     ),
-     IfNode(315...349)(
-       (315...317),
-       TrueNode(318...322)(),
-       StatementsNode(325...331)(
-         [InterpolatedStringNode(325...331)(
-            (325...331),
-            [EmbeddedStatementsNode(336...339)((336...338), nil, (338...339)),
-             StringNode(339...340)(nil, (339...340), nil, "\n")],
-            (340...346)
-          )]
-       ),
-       nil,
-       (346...349)
-     ),
-     IfNode(351...386)(
-       (351...353),
-       TrueNode(354...358)(),
-       StatementsNode(361...367)(
-         [InterpolatedStringNode(361...367)(
-            (361...367),
-            [StringNode(368...373)(nil, (368...373), nil, "b"),
-             EmbeddedStatementsNode(373...376)((373...375), nil, (375...376)),
-             StringNode(376...377)(nil, (376...377), nil, "\n")],
-            (377...383)
-          )]
-       ),
-       nil,
-       (383...386)
-     ),
-     IfNode(388...423)(
-       (388...390),
-       TrueNode(391...395)(),
-       StatementsNode(398...404)(
-         [InterpolatedStringNode(398...404)(
-            (398...404),
-            [EmbeddedStatementsNode(409...412)((409...411), nil, (411...412)),
-             StringNode(412...414)(nil, (412...414), nil, "a\n")],
-            (414...420)
-          )]
-       ),
-       nil,
-       (420...423)
-     ),
-     IfNode(425...464)(
-       (425...427),
-       TrueNode(428...432)(),
-       StatementsNode(435...443)(
-         [InterpolatedStringNode(435...443)(
-            (435...443),
-            [StringNode(444...455)(
-               nil,
-               (444...455),
-               nil,
-               "   a\n" + "\n" + "   b\n"
-             )],
-            (455...461)
-          )]
-       ),
-       nil,
-       (461...464)
-     ),
-     InterpolatedStringNode(466...472)(
-       (466...467),
-       [EmbeddedStatementsNode(467...470)((467...469), nil, (469...470)),
-        StringNode(470...471)(nil, (470...471), nil, "a")],
-       (471...472)
-     ),
-     InterpolatedStringNode(474...486)(
-       (474...476),
-       [StringNode(476...479)(nil, (476...479), nil, "\n" + "\""),
-        EmbeddedStatementsNode(479...482)((479...481), nil, (481...482)),
-        StringNode(482...485)(nil, (482...485), nil, "\"\n")],
-       (485...486)
-     ),
-     InterpolatedStringNode(488...502)(
-       (488...491),
-       [StringNode(491...495)(nil, (491...495), nil, "-\n" + "\""),
-        EmbeddedStatementsNode(495...498)((495...497), nil, (497...498)),
-        StringNode(498...501)(nil, (498...501), nil, "\"\n")],
-       (501...502)
-     ),
-     InterpolatedStringNode(504...513)(
-       (504...505),
-       [StringNode(505...507)(nil, (505...507), nil, "a\n"),
-        EmbeddedStatementsNode(507...510)((507...509), nil, (509...510)),
-        StringNode(510...512)(nil, (510...512), nil, "\n" + "b")],
-       (512...513)
-     ),
-     InterpolatedStringNode(515...525)(
-       (515...516),
-       [StringNode(516...519)(nil, (516...519), nil, "a\n"),
-        EmbeddedStatementsNode(519...522)((519...521), nil, (521...522)),
-        StringNode(522...524)(nil, (522...524), nil, "\n" + "b")],
-       (524...525)
-     ),
-     InterpolatedStringNode(527...537)(
-       (527...528),
-       [StringNode(528...530)(nil, (528...530), nil, "a\n"),
-        EmbeddedStatementsNode(530...533)((530...532), nil, (532...533)),
-        StringNode(533...536)(nil, (533...536), nil, "\n" + "b")],
-       (536...537)
-     ),
-     StringConcatNode(539...550)(
-       StringNode(539...542)((539...540), (540...541), (541...542), "a"),
-       InterpolatedStringNode(545...550)(
-         (545...546),
-         [EmbeddedStatementsNode(546...549)((546...548), nil, (548...549))],
-         (549...550)
-       )
-     ),
-     StringConcatNode(552...560)(
-       StringConcatNode(552...557)(
-         StringNode(552...554)((552...553), (553...553), (553...554), ""),
-         StringNode(555...557)((555...556), (556...556), (556...557), "")
-       ),
-       StringNode(558...560)((558...559), (559...559), (559...560), "")
-     ),
-     StringConcatNode(562...574)(
-       InterpolatedStringNode(562...570)(
-         (562...563),
-         [StringNode(563...564)(nil, (563...564), nil, "a"),
-          EmbeddedStatementsNode(564...569)(
-            (564...566),
-            StatementsNode(566...568)(
-              [InstanceVariableReadNode(566...568)(:@a)]
-            ),
-            (568...569)
-          )],
-         (569...570)
-       ),
-       StringNode(571...574)((571...572), (572...573), (573...574), "b")
-     ),
-     StringConcatNode(575...585)(
-       InterpolatedStringNode(575...581)(
-         (575...576),
-         [StringNode(576...577)(nil, (576...577), nil, "a"),
-          EmbeddedVariableNode(577...580)(
-            (577...578),
-            InstanceVariableReadNode(578...580)(:@a)
-          )],
-         (580...581)
-       ),
-       StringNode(582...585)((582...583), (583...584), (584...585), "b")
-     ),
-     StringConcatNode(586...596)(
-       InterpolatedStringNode(586...592)(
-         (586...587),
-         [StringNode(587...588)(nil, (587...588), nil, "a"),
-          EmbeddedVariableNode(588...591)(
-            (588...589),
-            GlobalVariableReadNode(589...591)(:$a)
-          )],
-         (591...592)
-       ),
-       StringNode(593...596)((593...594), (594...595), (595...596), "b")
-     ),
-     StringConcatNode(597...608)(
-       InterpolatedStringNode(597...604)(
-         (597...598),
-         [StringNode(598...599)(nil, (598...599), nil, "a"),
-          EmbeddedVariableNode(599...603)(
-            (599...600),
-            ClassVariableReadNode(600...603)(:@@a)
-          )],
-         (603...604)
-       ),
-       StringNode(605...608)((605...606), (606...607), (607...608), "b")
-     )]
-  )
-)
+@ ProgramNode (location: (0...608))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...608))
+    └── body: (length: 33)
+        ├── @ InterpolatedStringNode (location: (0...5))
+        │   ├── opening_loc: (0...5) = "<<DOC"
+        │   ├── parts: (length: 0)
+        │   └── closing_loc: (6...10) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (11...18))
+        │   ├── opening_loc: (11...18) = "<<'DOC'"
+        │   ├── parts: (length: 0)
+        │   └── closing_loc: (19...23) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (24...30))
+        │   ├── opening_loc: (24...30) = "<<~DOC"
+        │   ├── parts: (length: 0)
+        │   └── closing_loc: (31...35) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (36...44))
+        │   ├── opening_loc: (36...44) = "<<~'DOC'"
+        │   ├── parts: (length: 0)
+        │   └── closing_loc: (45...49) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (50...55))
+        │   ├── opening_loc: (50...55) = "<<DOC"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (56...60))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (56...60) = "  a\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "  a\n"
+        │   └── closing_loc: (60...64) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (65...72))
+        │   ├── opening_loc: (65...72) = "<<'DOC'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (73...77))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (73...77) = "  a\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "  a\n"
+        │   └── closing_loc: (77...81) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (82...87))
+        │   ├── opening_loc: (82...87) = "<<DOC"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (88...94))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (88...94) = "  a\n  "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "  a\n  "
+        │   │   ├── @ EmbeddedStatementsNode (location: (94...97))
+        │   │   │   ├── opening_loc: (94...96) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (96...97) = "}"
+        │   │   └── @ StringNode (location: (97...98))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (97...98) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (98...102) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (103...109))
+        │   ├── opening_loc: (103...109) = "<<~DOC"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (110...116))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (110...116) = "  a\n  "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (116...119))
+        │   │   │   ├── opening_loc: (116...118) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (118...119) = "}"
+        │   │   └── @ StringNode (location: (119...120))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (119...120) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (120...124) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (125...131))
+        │   ├── opening_loc: (125...131) = "<<~DOC"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (132...138))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (132...138) = "  a\n  "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (138...141))
+        │   │   │   ├── opening_loc: (138...140) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (140...141) = "}"
+        │   │   └── @ StringNode (location: (141...146))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (141...146) = "\n  b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\nb\n"
+        │   └── closing_loc: (146...150) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (151...157))
+        │   ├── opening_loc: (151...157) = "<<~DOC"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (158...168))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (158...168) = "  a\n    b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n  b\n"
+        │   └── closing_loc: (168...172) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (173...180))
+        │   ├── opening_loc: (173...180) = "<<'DOC'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (181...186))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (181...186) = "a\n\nb\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n\nb\n"
+        │   └── closing_loc: (186...190) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (191...198))
+        │   ├── opening_loc: (191...198) = "<<'DOC'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (199...206))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (199...206) = " a\n\n b\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: " a\n\n b\n"
+        │   └── closing_loc: (206...210) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (211...218))
+        │   ├── opening_loc: (211...218) = "<<'DOC'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (219...225))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (219...225) = " a\\nb\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: " a\\nb\n"
+        │   └── closing_loc: (225...229) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (230...235))
+        │   ├── opening_loc: (230...235) = "<<DOC"
+        │   ├── parts: (length: 4)
+        │   │   ├── @ EmbeddedStatementsNode (location: (236...239))
+        │   │   │   ├── opening_loc: (236...238) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (238...239) = "}"
+        │   │   ├── @ StringNode (location: (239...242))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (239...242) = "a\n "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a\n "
+        │   │   ├── @ EmbeddedStatementsNode (location: (242...245))
+        │   │   │   ├── opening_loc: (242...244) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (244...245) = "}"
+        │   │   └── @ StringNode (location: (245...247))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (245...247) = "a\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\n"
+        │   └── closing_loc: (247...251) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (252...257))
+        │   ├── opening_loc: (252...257) = "<<DOC"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (258...260))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (258...260) = "  "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "  "
+        │   │   ├── @ EmbeddedStatementsNode (location: (260...263))
+        │   │   │   ├── opening_loc: (260...262) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (262...263) = "}"
+        │   │   └── @ StringNode (location: (263...271))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (263...271) = "\n  \\\#{}\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n  \#{}\n"
+        │   └── closing_loc: (271...275) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (276...281))
+        │   ├── opening_loc: (276...281) = "<<DOC"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (282...284))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (282...284) = " a"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: " a"
+        │   │   ├── @ EmbeddedStatementsNode (location: (284...287))
+        │   │   │   ├── opening_loc: (284...286) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (286...287) = "}"
+        │   │   └── @ StringNode (location: (287...292))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (287...292) = "b\n c\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "b\n c\n"
+        │   └── closing_loc: (292...296) = "DOC\n"
+        ├── @ InterpolatedStringNode (location: (297...303))
+        │   ├── opening_loc: (297...303) = "<<~DOC"
+        │   ├── parts: (length: 2)
+        │   │   ├── @ EmbeddedStatementsNode (location: (306...309))
+        │   │   │   ├── opening_loc: (306...308) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (308...309) = "}"
+        │   │   └── @ StringNode (location: (309...310))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (309...310) = "\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\n"
+        │   └── closing_loc: (310...314) = "DOC\n"
+        ├── @ IfNode (location: (315...349))
+        │   ├── if_keyword_loc: (315...317) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (318...322))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (325...331))
+        │   │   └── body: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (325...331))
+        │   │           ├── opening_loc: (325...331) = "<<~DOC"
+        │   │           ├── parts: (length: 2)
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (336...339))
+        │   │           │   │   ├── opening_loc: (336...338) = "\#{"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── closing_loc: (338...339) = "}"
+        │   │           │   └── @ StringNode (location: (339...340))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (339...340) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (340...346) = "  DOC\n"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (346...349) = "end"
+        ├── @ IfNode (location: (351...386))
+        │   ├── if_keyword_loc: (351...353) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (354...358))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (361...367))
+        │   │   └── body: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (361...367))
+        │   │           ├── opening_loc: (361...367) = "<<~DOC"
+        │   │           ├── parts: (length: 3)
+        │   │           │   ├── @ StringNode (location: (368...373))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (368...373) = "    b"
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "b"
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (373...376))
+        │   │           │   │   ├── opening_loc: (373...375) = "\#{"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── closing_loc: (375...376) = "}"
+        │   │           │   └── @ StringNode (location: (376...377))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (376...377) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (377...383) = "  DOC\n"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (383...386) = "end"
+        ├── @ IfNode (location: (388...423))
+        │   ├── if_keyword_loc: (388...390) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (391...395))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (398...404))
+        │   │   └── body: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (398...404))
+        │   │           ├── opening_loc: (398...404) = "<<~DOC"
+        │   │           ├── parts: (length: 2)
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (409...412))
+        │   │           │   │   ├── opening_loc: (409...411) = "\#{"
+        │   │           │   │   ├── statements: ∅
+        │   │           │   │   └── closing_loc: (411...412) = "}"
+        │   │           │   └── @ StringNode (location: (412...414))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (412...414) = "a\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "a\n"
+        │   │           └── closing_loc: (414...420) = "  DOC\n"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (420...423) = "end"
+        ├── @ IfNode (location: (425...464))
+        │   ├── if_keyword_loc: (425...427) = "if"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (428...432))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (435...443))
+        │   │   └── body: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (435...443))
+        │   │           ├── opening_loc: (435...443) = "<<-'DOC'"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (444...455))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (444...455) = "   a\n\n   b\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "   a\n\n   b\n"
+        │   │           └── closing_loc: (455...461) = "  DOC\n"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (461...464) = "end"
+        ├── @ InterpolatedStringNode (location: (466...472))
+        │   ├── opening_loc: (466...467) = "\""
+        │   ├── parts: (length: 2)
+        │   │   ├── @ EmbeddedStatementsNode (location: (467...470))
+        │   │   │   ├── opening_loc: (467...469) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (469...470) = "}"
+        │   │   └── @ StringNode (location: (470...471))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (470...471) = "a"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a"
+        │   └── closing_loc: (471...472) = "\""
+        ├── @ InterpolatedStringNode (location: (474...486))
+        │   ├── opening_loc: (474...476) = "%("
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (476...479))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (476...479) = "\\n\""
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "\n\""
+        │   │   ├── @ EmbeddedStatementsNode (location: (479...482))
+        │   │   │   ├── opening_loc: (479...481) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (481...482) = "}"
+        │   │   └── @ StringNode (location: (482...485))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (482...485) = "\"\\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\"\n"
+        │   └── closing_loc: (485...486) = ")"
+        ├── @ InterpolatedStringNode (location: (488...502))
+        │   ├── opening_loc: (488...491) = "%Q("
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (491...495))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (491...495) = "-\\n\""
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "-\n\""
+        │   │   ├── @ EmbeddedStatementsNode (location: (495...498))
+        │   │   │   ├── opening_loc: (495...497) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (497...498) = "}"
+        │   │   └── @ StringNode (location: (498...501))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (498...501) = "\"\\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\"\n"
+        │   └── closing_loc: (501...502) = ")"
+        ├── @ InterpolatedStringNode (location: (504...513))
+        │   ├── opening_loc: (504...505) = "\""
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (505...507))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (505...507) = "a\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (507...510))
+        │   │   │   ├── opening_loc: (507...509) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (509...510) = "}"
+        │   │   └── @ StringNode (location: (510...512))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (510...512) = "\nb"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\nb"
+        │   └── closing_loc: (512...513) = "\""
+        ├── @ InterpolatedStringNode (location: (515...525))
+        │   ├── opening_loc: (515...516) = "\""
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (516...519))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (516...519) = "a\\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (519...522))
+        │   │   │   ├── opening_loc: (519...521) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (521...522) = "}"
+        │   │   └── @ StringNode (location: (522...524))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (522...524) = "\nb"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\nb"
+        │   └── closing_loc: (524...525) = "\""
+        ├── @ InterpolatedStringNode (location: (527...537))
+        │   ├── opening_loc: (527...528) = "\""
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (528...530))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (528...530) = "a\n"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "a\n"
+        │   │   ├── @ EmbeddedStatementsNode (location: (530...533))
+        │   │   │   ├── opening_loc: (530...532) = "\#{"
+        │   │   │   ├── statements: ∅
+        │   │   │   └── closing_loc: (532...533) = "}"
+        │   │   └── @ StringNode (location: (533...536))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (533...536) = "\\nb"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\nb"
+        │   └── closing_loc: (536...537) = "\""
+        ├── @ StringConcatNode (location: (539...550))
+        │   ├── left:
+        │   │   @ StringNode (location: (539...542))
+        │   │   ├── opening_loc: (539...540) = "'"
+        │   │   ├── content_loc: (540...541) = "a"
+        │   │   ├── closing_loc: (541...542) = "'"
+        │   │   └── unescaped: "a"
+        │   └── right:
+        │       @ InterpolatedStringNode (location: (545...550))
+        │       ├── opening_loc: (545...546) = "\""
+        │       ├── parts: (length: 1)
+        │       │   └── @ EmbeddedStatementsNode (location: (546...549))
+        │       │       ├── opening_loc: (546...548) = "\#{"
+        │       │       ├── statements: ∅
+        │       │       └── closing_loc: (548...549) = "}"
+        │       └── closing_loc: (549...550) = "\""
+        ├── @ StringConcatNode (location: (552...560))
+        │   ├── left:
+        │   │   @ StringConcatNode (location: (552...557))
+        │   │   ├── left:
+        │   │   │   @ StringNode (location: (552...554))
+        │   │   │   ├── opening_loc: (552...553) = "\""
+        │   │   │   ├── content_loc: (553...553) = ""
+        │   │   │   ├── closing_loc: (553...554) = "\""
+        │   │   │   └── unescaped: ""
+        │   │   └── right:
+        │   │       @ StringNode (location: (555...557))
+        │   │       ├── opening_loc: (555...556) = "\""
+        │   │       ├── content_loc: (556...556) = ""
+        │   │       ├── closing_loc: (556...557) = "\""
+        │   │       └── unescaped: ""
+        │   └── right:
+        │       @ StringNode (location: (558...560))
+        │       ├── opening_loc: (558...559) = "\""
+        │       ├── content_loc: (559...559) = ""
+        │       ├── closing_loc: (559...560) = "\""
+        │       └── unescaped: ""
+        ├── @ StringConcatNode (location: (562...574))
+        │   ├── left:
+        │   │   @ InterpolatedStringNode (location: (562...570))
+        │   │   ├── opening_loc: (562...563) = "\""
+        │   │   ├── parts: (length: 2)
+        │   │   │   ├── @ StringNode (location: (563...564))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── content_loc: (563...564) = "a"
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   └── unescaped: "a"
+        │   │   │   └── @ EmbeddedStatementsNode (location: (564...569))
+        │   │   │       ├── opening_loc: (564...566) = "\#{"
+        │   │   │       ├── statements:
+        │   │   │       │   @ StatementsNode (location: (566...568))
+        │   │   │       │   └── body: (length: 1)
+        │   │   │       │       └── @ InstanceVariableReadNode (location: (566...568))
+        │   │   │       │           └── name: :@a
+        │   │   │       └── closing_loc: (568...569) = "}"
+        │   │   └── closing_loc: (569...570) = "\""
+        │   └── right:
+        │       @ StringNode (location: (571...574))
+        │       ├── opening_loc: (571...572) = "\""
+        │       ├── content_loc: (572...573) = "b"
+        │       ├── closing_loc: (573...574) = "\""
+        │       └── unescaped: "b"
+        ├── @ StringConcatNode (location: (575...585))
+        │   ├── left:
+        │   │   @ InterpolatedStringNode (location: (575...581))
+        │   │   ├── opening_loc: (575...576) = "\""
+        │   │   ├── parts: (length: 2)
+        │   │   │   ├── @ StringNode (location: (576...577))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── content_loc: (576...577) = "a"
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   └── unescaped: "a"
+        │   │   │   └── @ EmbeddedVariableNode (location: (577...580))
+        │   │   │       ├── operator_loc: (577...578) = "#"
+        │   │   │       └── variable:
+        │   │   │           @ InstanceVariableReadNode (location: (578...580))
+        │   │   │           └── name: :@a
+        │   │   └── closing_loc: (580...581) = "\""
+        │   └── right:
+        │       @ StringNode (location: (582...585))
+        │       ├── opening_loc: (582...583) = "\""
+        │       ├── content_loc: (583...584) = "b"
+        │       ├── closing_loc: (584...585) = "\""
+        │       └── unescaped: "b"
+        ├── @ StringConcatNode (location: (586...596))
+        │   ├── left:
+        │   │   @ InterpolatedStringNode (location: (586...592))
+        │   │   ├── opening_loc: (586...587) = "\""
+        │   │   ├── parts: (length: 2)
+        │   │   │   ├── @ StringNode (location: (587...588))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── content_loc: (587...588) = "a"
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   └── unescaped: "a"
+        │   │   │   └── @ EmbeddedVariableNode (location: (588...591))
+        │   │   │       ├── operator_loc: (588...589) = "#"
+        │   │   │       └── variable:
+        │   │   │           @ GlobalVariableReadNode (location: (589...591))
+        │   │   │           └── name: :$a
+        │   │   └── closing_loc: (591...592) = "\""
+        │   └── right:
+        │       @ StringNode (location: (593...596))
+        │       ├── opening_loc: (593...594) = "\""
+        │       ├── content_loc: (594...595) = "b"
+        │       ├── closing_loc: (595...596) = "\""
+        │       └── unescaped: "b"
+        └── @ StringConcatNode (location: (597...608))
+            ├── left:
+            │   @ InterpolatedStringNode (location: (597...604))
+            │   ├── opening_loc: (597...598) = "\""
+            │   ├── parts: (length: 2)
+            │   │   ├── @ StringNode (location: (598...599))
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── content_loc: (598...599) = "a"
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   └── unescaped: "a"
+            │   │   └── @ EmbeddedVariableNode (location: (599...603))
+            │   │       ├── operator_loc: (599...600) = "#"
+            │   │       └── variable:
+            │   │           @ ClassVariableReadNode (location: (600...603))
+            │   │           └── name: :@@a
+            │   └── closing_loc: (603...604) = "\""
+            └── right:
+                @ StringNode (location: (605...608))
+                ├── opening_loc: (605...606) = "\""
+                ├── content_loc: (606...607) = "b"
+                ├── closing_loc: (607...608) = "\""
+                └── unescaped: "b"
diff --git a/test/yarp/snapshots/unparser/corpus/semantic/kwbegin.txt b/test/yarp/snapshots/unparser/corpus/semantic/kwbegin.txt
index 231ed767cf..1e5e882713 100644
--- a/test/yarp/snapshots/unparser/corpus/semantic/kwbegin.txt
+++ b/test/yarp/snapshots/unparser/corpus/semantic/kwbegin.txt
@@ -1,184 +1,259 @@
-ProgramNode(0...215)(
-  [],
-  StatementsNode(0...215)(
-    [BeginNode(0...16)(
-       (0...5),
-       nil,
-       RescueNode(6...12)((6...12), [], nil, nil, nil, nil),
-       nil,
-       nil,
-       (13...16)
-     ),
-     BeginNode(18...39)(
-       (18...23),
-       nil,
-       RescueNode(24...30)((24...30), [], nil, nil, nil, nil),
-       ElseNode(31...39)((31...35), nil, (36...39)),
-       nil,
-       (36...39)
-     ),
-     BeginNode(41...54)(
-       (41...46),
-       StatementsNode(49...50)(
-         [CallNode(49...50)(nil, nil, (49...50), nil, nil, nil, nil, 2, "a")]
-       ),
-       nil,
-       nil,
-       nil,
-       (51...54)
-     ),
-     BeginNode(56...80)(
-       (56...61),
-       StatementsNode(64...65)(
-         [CallNode(64...65)(nil, nil, (64...65), nil, nil, nil, nil, 2, "a")]
-       ),
-       RescueNode(66...76)(
-         (66...72),
-         [],
-         nil,
-         nil,
-         StatementsNode(75...76)(
-           [CallNode(75...76)(nil, nil, (75...76), nil, nil, nil, nil, 2, "b")]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (77...80)
-     ),
-     BeginNode(82...110)(
-       (82...87),
-       StatementsNode(90...95)(
-         [CallNode(90...91)(nil, nil, (90...91), nil, nil, nil, nil, 2, "a"),
-          CallNode(94...95)(nil, nil, (94...95), nil, nil, nil, nil, 2, "b")]
-       ),
-       RescueNode(96...106)(
-         (96...102),
-         [],
-         nil,
-         nil,
-         StatementsNode(105...106)(
-           [CallNode(105...106)(
-              nil,
-              nil,
-              (105...106),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (107...110)
-     ),
-     BeginNode(112...135)(
-       (112...117),
-       nil,
-       RescueNode(118...126)(
-         (118...124),
-         [ConstantReadNode(125...126)(:A)],
-         nil,
-         nil,
-         nil,
-         nil
-       ),
-       ElseNode(127...135)((127...131), nil, (132...135)),
-       nil,
-       (132...135)
-     ),
-     BeginNode(137...163)(
-       (137...142),
-       nil,
-       RescueNode(144...152)(
-         (144...150),
-         [ConstantReadNode(151...152)(:A)],
-         nil,
-         nil,
-         nil,
-         nil
-       ),
-       ElseNode(154...163)((154...158), nil, (160...163)),
-       nil,
-       (160...163)
-     ),
-     BeginNode(165...215)(
-       (165...170),
-       StatementsNode(173...174)(
-         [CallNode(173...174)(
-            nil,
-            nil,
-            (173...174),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          )]
-       ),
-       RescueNode(175...200)(
-         (175...181),
-         [ConstantReadNode(182...183)(:A)],
-         nil,
-         nil,
-         StatementsNode(186...187)(
-           [CallNode(186...187)(
-              nil,
-              nil,
-              (186...187),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "b"
-            )]
-         ),
-         RescueNode(188...200)(
-           (188...194),
-           [ConstantReadNode(195...196)(:B)],
-           nil,
-           nil,
-           StatementsNode(199...200)(
-             [CallNode(199...200)(
-                nil,
-                nil,
-                (199...200),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "c"
-              )]
-           ),
-           nil
-         )
-       ),
-       nil,
-       EnsureNode(201...215)(
-         (201...207),
-         StatementsNode(210...211)(
-           [CallNode(210...211)(
-              nil,
-              nil,
-              (210...211),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "d"
-            )]
-         ),
-         (212...215)
-       ),
-       (212...215)
-     )]
-  )
-)
+@ ProgramNode (location: (0...215))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...215))
+    └── body: (length: 8)
+        ├── @ BeginNode (location: (0...16))
+        │   ├── begin_keyword_loc: (0...5) = "begin"
+        │   ├── statements: ∅
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (6...12))
+        │   │   ├── keyword_loc: (6...12) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements: ∅
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (13...16) = "end"
+        ├── @ BeginNode (location: (18...39))
+        │   ├── begin_keyword_loc: (18...23) = "begin"
+        │   ├── statements: ∅
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (24...30))
+        │   │   ├── keyword_loc: (24...30) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements: ∅
+        │   │   └── consequent: ∅
+        │   ├── else_clause:
+        │   │   @ ElseNode (location: (31...39))
+        │   │   ├── else_keyword_loc: (31...35) = "else"
+        │   │   ├── statements: ∅
+        │   │   └── end_keyword_loc: (36...39) = "end"
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (36...39) = "end"
+        ├── @ BeginNode (location: (41...54))
+        │   ├── begin_keyword_loc: (41...46) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (49...50))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (49...50))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (49...50) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (51...54) = "end"
+        ├── @ BeginNode (location: (56...80))
+        │   ├── begin_keyword_loc: (56...61) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (64...65))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (64...65))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (64...65) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (66...76))
+        │   │   ├── keyword_loc: (66...72) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (75...76))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (75...76))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (75...76) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (77...80) = "end"
+        ├── @ BeginNode (location: (82...110))
+        │   ├── begin_keyword_loc: (82...87) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (90...95))
+        │   │   └── body: (length: 2)
+        │   │       ├── @ CallNode (location: (90...91))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (90...91) = "a"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "a"
+        │   │       └── @ CallNode (location: (94...95))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (94...95) = "b"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "b"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (96...106))
+        │   │   ├── keyword_loc: (96...102) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (105...106))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (105...106))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (105...106) = "b"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "b"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (107...110) = "end"
+        ├── @ BeginNode (location: (112...135))
+        │   ├── begin_keyword_loc: (112...117) = "begin"
+        │   ├── statements: ∅
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (118...126))
+        │   │   ├── keyword_loc: (118...124) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ ConstantReadNode (location: (125...126))
+        │   │   │       └── name: :A
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements: ∅
+        │   │   └── consequent: ∅
+        │   ├── else_clause:
+        │   │   @ ElseNode (location: (127...135))
+        │   │   ├── else_keyword_loc: (127...131) = "else"
+        │   │   ├── statements: ∅
+        │   │   └── end_keyword_loc: (132...135) = "end"
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (132...135) = "end"
+        ├── @ BeginNode (location: (137...163))
+        │   ├── begin_keyword_loc: (137...142) = "begin"
+        │   ├── statements: ∅
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (144...152))
+        │   │   ├── keyword_loc: (144...150) = "rescue"
+        │   │   ├── exceptions: (length: 1)
+        │   │   │   └── @ ConstantReadNode (location: (151...152))
+        │   │   │       └── name: :A
+        │   │   ├── operator_loc: ∅
+        │   │   ├── reference: ∅
+        │   │   ├── statements: ∅
+        │   │   └── consequent: ∅
+        │   ├── else_clause:
+        │   │   @ ElseNode (location: (154...163))
+        │   │   ├── else_keyword_loc: (154...158) = "else"
+        │   │   ├── statements: ∅
+        │   │   └── end_keyword_loc: (160...163) = "end"
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (160...163) = "end"
+        └── @ BeginNode (location: (165...215))
+            ├── begin_keyword_loc: (165...170) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (173...174))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (173...174))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (173...174) = "a"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "a"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (175...200))
+            │   ├── keyword_loc: (175...181) = "rescue"
+            │   ├── exceptions: (length: 1)
+            │   │   └── @ ConstantReadNode (location: (182...183))
+            │   │       └── name: :A
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (186...187))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (186...187))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (186...187) = "b"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "b"
+            │   └── consequent:
+            │       @ RescueNode (location: (188...200))
+            │       ├── keyword_loc: (188...194) = "rescue"
+            │       ├── exceptions: (length: 1)
+            │       │   └── @ ConstantReadNode (location: (195...196))
+            │       │       └── name: :B
+            │       ├── operator_loc: ∅
+            │       ├── reference: ∅
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (199...200))
+            │       │   └── body: (length: 1)
+            │       │       └── @ CallNode (location: (199...200))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (199...200) = "c"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments: ∅
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: variable_call
+            │       │           └── name: "c"
+            │       └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause:
+            │   @ EnsureNode (location: (201...215))
+            │   ├── ensure_keyword_loc: (201...207) = "ensure"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (210...211))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (210...211))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (210...211) = "d"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "d"
+            │   └── end_keyword_loc: (212...215) = "end"
+            └── end_keyword_loc: (212...215) = "end"
diff --git a/test/yarp/snapshots/unparser/corpus/semantic/literal.txt b/test/yarp/snapshots/unparser/corpus/semantic/literal.txt
index 5e18c54da4..b62f513516 100644
--- a/test/yarp/snapshots/unparser/corpus/semantic/literal.txt
+++ b/test/yarp/snapshots/unparser/corpus/semantic/literal.txt
@@ -1,63 +1,87 @@
-ProgramNode(0...131)(
-  [],
-  StatementsNode(0...131)(
-    [RationalNode(0...4)(FloatNode(0...3)()),
-     RationalNode(5...8)(IntegerNode(5...7)()),
-     IntegerNode(9...12)(),
-     IntegerNode(13...18)(),
-     FloatNode(19...23)(),
-     FloatNode(24...38)(),
-     FloatNode(39...54)(),
-     StringNode(55...57)((55...56), (56...57), nil, "c"),
-     RegularExpressionNode(58...63)((58...61), (61...62), (62...63), "/", 0),
-     RegularExpressionNode(64...70)((64...67), (67...69), (69...70), ")", 0),
-     InterpolatedRegularExpressionNode(71...85)(
-       (71...74),
-       [EmbeddedStatementsNode(74...81)(
-          (74...76),
-          StatementsNode(76...80)([InstanceVariableReadNode(76...80)(:@bar)]),
-          (80...81)
-        ),
-        StringNode(81...84)(nil, (81...84), nil, "baz")],
-       (84...85),
-       0
-     ),
-     FloatNode(86...102)(),
-     FloatNode(103...120)(),
-     CallNode(121...131)(
-       nil,
-       nil,
-       (121...122),
-       (122...123),
-       ArgumentsNode(123...130)(
-         [CallNode(123...130)(
-            nil,
-            nil,
-            (123...126),
-            nil,
-            ArgumentsNode(127...130)(
-              [CallNode(127...130)(
-                 nil,
-                 nil,
-                 (127...130),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "bar"
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "foo"
-          )]
-       ),
-       (130...131),
-       nil,
-       0,
-       "w"
-     )]
-  )
-)
+@ ProgramNode (location: (0...131))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...131))
+    └── body: (length: 14)
+        ├── @ RationalNode (location: (0...4))
+        │   └── numeric:
+        │       @ FloatNode (location: (0...3))
+        ├── @ RationalNode (location: (5...8))
+        │   └── numeric:
+        │       @ IntegerNode (location: (5...7))
+        ├── @ IntegerNode (location: (9...12))
+        ├── @ IntegerNode (location: (13...18))
+        ├── @ FloatNode (location: (19...23))
+        ├── @ FloatNode (location: (24...38))
+        ├── @ FloatNode (location: (39...54))
+        ├── @ StringNode (location: (55...57))
+        │   ├── opening_loc: (55...56) = "?"
+        │   ├── content_loc: (56...57) = "c"
+        │   ├── closing_loc: ∅
+        │   └── unescaped: "c"
+        ├── @ RegularExpressionNode (location: (58...63))
+        │   ├── opening_loc: (58...61) = "%r("
+        │   ├── content_loc: (61...62) = "/"
+        │   ├── closing_loc: (62...63) = ")"
+        │   ├── unescaped: "/"
+        │   └── flags: 
+        ├── @ RegularExpressionNode (location: (64...70))
+        │   ├── opening_loc: (64...67) = "%r("
+        │   ├── content_loc: (67...69) = "\\)"
+        │   ├── closing_loc: (69...70) = ")"
+        │   ├── unescaped: ")"
+        │   └── flags: 
+        ├── @ InterpolatedRegularExpressionNode (location: (71...85))
+        │   ├── opening_loc: (71...74) = "%r("
+        │   ├── parts: (length: 2)
+        │   │   ├── @ EmbeddedStatementsNode (location: (74...81))
+        │   │   │   ├── opening_loc: (74...76) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (76...80))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ InstanceVariableReadNode (location: (76...80))
+        │   │   │   │           └── name: :@bar
+        │   │   │   └── closing_loc: (80...81) = "}"
+        │   │   └── @ StringNode (location: (81...84))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (81...84) = "baz"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "baz"
+        │   ├── closing_loc: (84...85) = ")"
+        │   └── flags: 
+        ├── @ FloatNode (location: (86...102))
+        ├── @ FloatNode (location: (103...120))
+        └── @ CallNode (location: (121...131))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (121...122) = "w"
+            ├── opening_loc: (122...123) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (123...130))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (123...130))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (123...126) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (127...130))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ CallNode (location: (127...130))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (127...130) = "bar"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "bar"
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "foo"
+            ├── closing_loc: (130...131) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "w"
diff --git a/test/yarp/snapshots/unparser/corpus/semantic/send.txt b/test/yarp/snapshots/unparser/corpus/semantic/send.txt
index b584fa06cf..a15146b4e9 100644
--- a/test/yarp/snapshots/unparser/corpus/semantic/send.txt
+++ b/test/yarp/snapshots/unparser/corpus/semantic/send.txt
@@ -1,117 +1,156 @@
-ProgramNode(0...44)(
-  [],
-  StatementsNode(0...44)(
-    [CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-     CallNode(4...10)(
-       nil,
-       nil,
-       (4...7),
-       (7...8),
-       ArgumentsNode(8...9)([IntegerNode(8...9)()]),
-       (9...10),
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(12...27)(
-       CallNode(12...22)(
-         CallNode(12...20)(
-           CallNode(12...13)(nil, nil, (12...13), nil, nil, nil, nil, 2, "a"),
-           (13...14),
-           (14...17),
-           (17...18),
-           ArgumentsNode(18...19)(
-             [CallNode(18...19)(
-                nil,
-                nil,
-                (18...19),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "b"
-              )]
-           ),
-           (19...20),
-           nil,
-           0,
-           "==="
-         ),
-         (20...21),
-         (21...22),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "c"
-       ),
-       nil,
-       (23...25),
-       nil,
-       ArgumentsNode(26...27)(
-         [CallNode(26...27)(nil, nil, (26...27), nil, nil, nil, nil, 2, "d")]
-       ),
-       nil,
-       nil,
-       0,
-       "=="
-     ),
-     CallNode(29...44)(
-       CallNode(29...30)(nil, nil, (29...30), nil, nil, nil, nil, 2, "a"),
-       nil,
-       (31...33),
-       nil,
-       ArgumentsNode(34...44)(
-         [CallNode(34...44)(
-            CallNode(34...37)(
-              CallNode(34...35)(
-                nil,
-                nil,
-                (34...35),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "d"
-              ),
-              (35...36),
-              (36...37),
-              nil,
-              nil,
-              nil,
-              nil,
-              0,
-              "c"
-            ),
-            (37...38),
-            (38...41),
-            (41...42),
-            ArgumentsNode(42...43)(
-              [CallNode(42...43)(
-                 nil,
-                 nil,
-                 (42...43),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "c"
-               )]
-            ),
-            (43...44),
-            nil,
-            0,
-            "==="
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "=="
-     )]
-  )
-)
+@ ProgramNode (location: (0...44))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...44))
+    └── body: (length: 4)
+        ├── @ CallNode (location: (0...3))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "foo"
+        ├── @ CallNode (location: (4...10))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (4...7) = "foo"
+        │   ├── opening_loc: (7...8) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (8...9))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (8...9))
+        │   ├── closing_loc: (9...10) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (12...27))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (12...22))
+        │   │   ├── receiver:
+        │   │   │   @ CallNode (location: (12...20))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ CallNode (location: (12...13))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (12...13) = "a"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "a"
+        │   │   │   ├── call_operator_loc: (13...14) = "."
+        │   │   │   ├── message_loc: (14...17) = "==="
+        │   │   │   ├── opening_loc: (17...18) = "("
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (18...19))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (18...19))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (18...19) = "b"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "b"
+        │   │   │   ├── closing_loc: (19...20) = ")"
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "==="
+        │   │   ├── call_operator_loc: (20...21) = "."
+        │   │   ├── message_loc: (21...22) = "c"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "c"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (23...25) = "=="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (26...27))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (26...27))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (26...27) = "d"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "d"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=="
+        └── @ CallNode (location: (29...44))
+            ├── receiver:
+            │   @ CallNode (location: (29...30))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (29...30) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (31...33) = "=="
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (34...44))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (34...44))
+            │           ├── receiver:
+            │           │   @ CallNode (location: (34...37))
+            │           │   ├── receiver:
+            │           │   │   @ CallNode (location: (34...35))
+            │           │   │   ├── receiver: ∅
+            │           │   │   ├── call_operator_loc: ∅
+            │           │   │   ├── message_loc: (34...35) = "d"
+            │           │   │   ├── opening_loc: ∅
+            │           │   │   ├── arguments: ∅
+            │           │   │   ├── closing_loc: ∅
+            │           │   │   ├── block: ∅
+            │           │   │   ├── flags: variable_call
+            │           │   │   └── name: "d"
+            │           │   ├── call_operator_loc: (35...36) = "."
+            │           │   ├── message_loc: (36...37) = "c"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: 
+            │           │   └── name: "c"
+            │           ├── call_operator_loc: (37...38) = "."
+            │           ├── message_loc: (38...41) = "==="
+            │           ├── opening_loc: (41...42) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (42...43))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ CallNode (location: (42...43))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (42...43) = "c"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "c"
+            │           ├── closing_loc: (43...44) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "==="
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "=="
diff --git a/test/yarp/snapshots/unparser/corpus/semantic/undef.txt b/test/yarp/snapshots/unparser/corpus/semantic/undef.txt
index 429e904481..a8939e9892 100644
--- a/test/yarp/snapshots/unparser/corpus/semantic/undef.txt
+++ b/test/yarp/snapshots/unparser/corpus/semantic/undef.txt
@@ -1,11 +1,26 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [UndefNode(0...9)([SymbolNode(6...9)(nil, (6...9), nil, "foo")], (0...5)),
-     UndefNode(10...24)(
-       [SymbolNode(16...19)(nil, (16...19), nil, "foo"),
-        SymbolNode(21...24)(nil, (21...24), nil, "bar")],
-       (10...15)
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 2)
+        ├── @ UndefNode (location: (0...9))
+        │   ├── names: (length: 1)
+        │   │   └── @ SymbolNode (location: (6...9))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (6...9) = "foo"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "foo"
+        │   └── keyword_loc: (0...5) = "undef"
+        └── @ UndefNode (location: (10...24))
+            ├── names: (length: 2)
+            │   ├── @ SymbolNode (location: (16...19))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (16...19) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   └── @ SymbolNode (location: (21...24))
+            │       ├── opening_loc: ∅
+            │       ├── value_loc: (21...24) = "bar"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "bar"
+            └── keyword_loc: (10...15) = "undef"
diff --git a/test/yarp/snapshots/unparser/corpus/semantic/while.txt b/test/yarp/snapshots/unparser/corpus/semantic/while.txt
index 6b29da7e48..323528a0e6 100644
--- a/test/yarp/snapshots/unparser/corpus/semantic/while.txt
+++ b/test/yarp/snapshots/unparser/corpus/semantic/while.txt
@@ -1,192 +1,274 @@
-ProgramNode(0...188)(
-  [:foo, :a],
-  StatementsNode(0...188)(
-    [UntilNode(0...13)(
-       (2...7),
-       nil,
-       CallNode(8...13)(
-         nil,
-         nil,
-         (8...10),
-         nil,
-         nil,
-         nil,
-         BlockNode(11...13)([], nil, nil, (11...12), (12...13)),
-         0,
-         "b?"
-       ),
-       StatementsNode(0...1)(
-         [CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a")]
-       ),
-       0
-     ),
-     UntilNode(15...34)(
-       (15...20),
-       (31...34),
-       CallNode(21...26)(
-         nil,
-         nil,
-         (21...23),
-         nil,
-         nil,
-         nil,
-         BlockNode(24...26)([], nil, nil, (24...25), (25...26)),
-         0,
-         "b?"
-       ),
-       StatementsNode(29...30)(
-         [CallNode(29...30)(nil, nil, (29...30), nil, nil, nil, nil, 2, "a")]
-       ),
-       0
-     ),
-     WhileNode(36...55)(
-       (46...51),
-       nil,
-       LocalVariableReadNode(52...55)(:foo, 0),
-       StatementsNode(36...45)(
-         [LocalVariableWriteNode(36...45)(
-            :foo,
-            0,
-            (36...39),
-            CallNode(42...45)(
-              nil,
-              nil,
-              (42...45),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            ),
-            (40...41)
-          )]
-       ),
-       0
-     ),
-     UntilNode(57...75)(
-       (59...64),
-       nil,
-       AndNode(65...75)(
-         CallNode(65...66)(nil, nil, (65...66), nil, nil, nil, nil, 2, "b"),
-         CallNode(70...75)(
-           nil,
-           nil,
-           (70...71),
-           nil,
-           nil,
-           nil,
-           BlockNode(72...75)([], nil, nil, (72...73), (74...75)),
-           0,
-           "a"
-         ),
-         (67...69)
-       ),
-       StatementsNode(57...58)(
-         [CallNode(57...58)(nil, nil, (57...58), nil, nil, nil, nil, 2, "a")]
-       ),
-       0
-     ),
-     WhileNode(77...96)(
-       (77...82),
-       (93...96),
-       LocalVariableWriteNode(83...88)(
-         :a,
-         0,
-         (83...84),
-         CallNode(87...88)(nil, nil, (87...88), nil, nil, nil, nil, 2, "b"),
-         (85...86)
-       ),
-       StatementsNode(91...92)([LocalVariableReadNode(91...92)(:a, 0)]),
-       0
-     ),
-     UntilNode(98...130)(
-       (100...105),
-       nil,
-       CallNode(106...130)(
-         nil,
-         nil,
-         (106...107),
-         (107...108),
-         ArgumentsNode(108...114)(
-           [InterpolatedStringNode(108...114)((108...114), [], (119...123))]
-         ),
-         (114...115),
-         BlockNode(116...130)(
-           [],
-           nil,
-           StatementsNode(125...126)(
-             [CallNode(125...126)(
-                nil,
-                nil,
-                (125...126),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "c"
-              )]
-           ),
-           (116...118),
-           (127...130)
-         ),
-         0,
-         "b"
-       ),
-       StatementsNode(98...99)([LocalVariableReadNode(98...99)(:a, 0)]),
-       0
-     ),
-     ModuleNode(132...188)(
-       [:foo],
-       (132...138),
-       ConstantReadNode(139...140)(:A),
-       StatementsNode(143...184)(
-         [LocalVariableWriteNode(143...152)(
-            :foo,
-            0,
-            (143...146),
-            CallNode(149...152)(
-              nil,
-              nil,
-              (149...152),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "exp"
-            ),
-            (147...148)
-          ),
-          WhileNode(155...184)(
-            (155...160),
-            (181...184),
-            LocalVariableReadNode(161...164)(:foo, 0),
-            StatementsNode(169...178)(
-              [LocalVariableWriteNode(169...178)(
-                 :foo,
-                 0,
-                 (169...172),
-                 CallNode(175...178)(
-                   nil,
-                   nil,
-                   (175...178),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "bar"
-                 ),
-                 (173...174)
-               )]
-            ),
-            0
-          )]
-       ),
-       (185...188),
-       :A
-     )]
-  )
-)
+@ ProgramNode (location: (0...188))
+├── locals: [:foo, :a]
+└── statements:
+    @ StatementsNode (location: (0...188))
+    └── body: (length: 7)
+        ├── @ UntilNode (location: (0...13))
+        │   ├── keyword_loc: (2...7) = "until"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (8...13))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (8...10) = "b?"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (11...13))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (11...12) = "{"
+        │   │   │   └── closing_loc: (12...13) = "}"
+        │   │   ├── flags: 
+        │   │   └── name: "b?"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (0...1))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (0...1))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (0...1) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   └── flags: 
+        ├── @ UntilNode (location: (15...34))
+        │   ├── keyword_loc: (15...20) = "until"
+        │   ├── closing_loc: (31...34) = "end"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (21...26))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (21...23) = "b?"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (24...26))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (24...25) = "{"
+        │   │   │   └── closing_loc: (25...26) = "}"
+        │   │   ├── flags: 
+        │   │   └── name: "b?"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (29...30))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (29...30))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (29...30) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   └── flags: 
+        ├── @ WhileNode (location: (36...55))
+        │   ├── keyword_loc: (46...51) = "while"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ LocalVariableReadNode (location: (52...55))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (36...45))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableWriteNode (location: (36...45))
+        │   │           ├── name: :foo
+        │   │           ├── depth: 0
+        │   │           ├── name_loc: (36...39) = "foo"
+        │   │           ├── value:
+        │   │           │   @ CallNode (location: (42...45))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (42...45) = "bar"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "bar"
+        │   │           └── operator_loc: (40...41) = "="
+        │   └── flags: 
+        ├── @ UntilNode (location: (57...75))
+        │   ├── keyword_loc: (59...64) = "until"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ AndNode (location: (65...75))
+        │   │   ├── left:
+        │   │   │   @ CallNode (location: (65...66))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (65...66) = "b"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "b"
+        │   │   ├── right:
+        │   │   │   @ CallNode (location: (70...75))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (70...71) = "a"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block:
+        │   │   │   │   @ BlockNode (location: (72...75))
+        │   │   │   │   ├── locals: []
+        │   │   │   │   ├── parameters: ∅
+        │   │   │   │   ├── body: ∅
+        │   │   │   │   ├── opening_loc: (72...73) = "{"
+        │   │   │   │   └── closing_loc: (74...75) = "}"
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "a"
+        │   │   └── operator_loc: (67...69) = "&&"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (57...58))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (57...58))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (57...58) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "a"
+        │   └── flags: 
+        ├── @ WhileNode (location: (77...96))
+        │   ├── keyword_loc: (77...82) = "while"
+        │   ├── closing_loc: (93...96) = "end"
+        │   ├── predicate:
+        │   │   @ LocalVariableWriteNode (location: (83...88))
+        │   │   ├── name: :a
+        │   │   ├── depth: 0
+        │   │   ├── name_loc: (83...84) = "a"
+        │   │   ├── value:
+        │   │   │   @ CallNode (location: (87...88))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (87...88) = "b"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "b"
+        │   │   └── operator_loc: (85...86) = "="
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (91...92))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (91...92))
+        │   │           ├── name: :a
+        │   │           └── depth: 0
+        │   └── flags: 
+        ├── @ UntilNode (location: (98...130))
+        │   ├── keyword_loc: (100...105) = "until"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (106...130))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (106...107) = "b"
+        │   │   ├── opening_loc: (107...108) = "("
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (108...114))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ InterpolatedStringNode (location: (108...114))
+        │   │   │           ├── opening_loc: (108...114) = "<<-FOO"
+        │   │   │           ├── parts: (length: 0)
+        │   │   │           └── closing_loc: (119...123) = "FOO\n"
+        │   │   ├── closing_loc: (114...115) = ")"
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (116...130))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body:
+        │   │   │   │   @ StatementsNode (location: (125...126))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (125...126))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (125...126) = "c"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "c"
+        │   │   │   ├── opening_loc: (116...118) = "do"
+        │   │   │   └── closing_loc: (127...130) = "end"
+        │   │   ├── flags: 
+        │   │   └── name: "b"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (98...99))
+        │   │   └── body: (length: 1)
+        │   │       └── @ LocalVariableReadNode (location: (98...99))
+        │   │           ├── name: :a
+        │   │           └── depth: 0
+        │   └── flags: 
+        └── @ ModuleNode (location: (132...188))
+            ├── locals: [:foo]
+            ├── module_keyword_loc: (132...138) = "module"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (139...140))
+            │   └── name: :A
+            ├── body:
+            │   @ StatementsNode (location: (143...184))
+            │   └── body: (length: 2)
+            │       ├── @ LocalVariableWriteNode (location: (143...152))
+            │       │   ├── name: :foo
+            │       │   ├── depth: 0
+            │       │   ├── name_loc: (143...146) = "foo"
+            │       │   ├── value:
+            │       │   │   @ CallNode (location: (149...152))
+            │       │   │   ├── receiver: ∅
+            │       │   │   ├── call_operator_loc: ∅
+            │       │   │   ├── message_loc: (149...152) = "exp"
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── arguments: ∅
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   ├── block: ∅
+            │       │   │   ├── flags: variable_call
+            │       │   │   └── name: "exp"
+            │       │   └── operator_loc: (147...148) = "="
+            │       └── @ WhileNode (location: (155...184))
+            │           ├── keyword_loc: (155...160) = "while"
+            │           ├── closing_loc: (181...184) = "end"
+            │           ├── predicate:
+            │           │   @ LocalVariableReadNode (location: (161...164))
+            │           │   ├── name: :foo
+            │           │   └── depth: 0
+            │           ├── statements:
+            │           │   @ StatementsNode (location: (169...178))
+            │           │   └── body: (length: 1)
+            │           │       └── @ LocalVariableWriteNode (location: (169...178))
+            │           │           ├── name: :foo
+            │           │           ├── depth: 0
+            │           │           ├── name_loc: (169...172) = "foo"
+            │           │           ├── value:
+            │           │           │   @ CallNode (location: (175...178))
+            │           │           │   ├── receiver: ∅
+            │           │           │   ├── call_operator_loc: ∅
+            │           │           │   ├── message_loc: (175...178) = "bar"
+            │           │           │   ├── opening_loc: ∅
+            │           │           │   ├── arguments: ∅
+            │           │           │   ├── closing_loc: ∅
+            │           │           │   ├── block: ∅
+            │           │           │   ├── flags: variable_call
+            │           │           │   └── name: "bar"
+            │           │           └── operator_loc: (173...174) = "="
+            │           └── flags: 
+            ├── end_keyword_loc: (185...188) = "end"
+            └── name: :A
diff --git a/test/yarp/snapshots/until.txt b/test/yarp/snapshots/until.txt
index 6a93708e5b..c932be0ff8 100644
--- a/test/yarp/snapshots/until.txt
+++ b/test/yarp/snapshots/until.txt
@@ -1,72 +1,101 @@
-ProgramNode(0...109)(
-  [],
-  StatementsNode(0...109)(
-    [UntilNode(0...18)(
-       (0...5),
-       (15...18),
-       TrueNode(6...10)(),
-       StatementsNode(12...13)([IntegerNode(12...13)()]),
-       0
-     ),
-     UntilNode(20...32)(
-       (22...27),
-       nil,
-       TrueNode(28...32)(),
-       StatementsNode(20...21)([IntegerNode(20...21)()]),
-       0
-     ),
-     UntilNode(34...50)(
-       (40...45),
-       nil,
-       TrueNode(46...50)(),
-       StatementsNode(34...39)([BreakNode(34...39)(nil, (34...39))]),
-       0
-     ),
-     UntilNode(52...67)(
-       (57...62),
-       nil,
-       TrueNode(63...67)(),
-       StatementsNode(52...56)([NextNode(52...56)(nil, (52...56))]),
-       0
-     ),
-     UntilNode(69...86)(
-       (76...81),
-       nil,
-       TrueNode(82...86)(),
-       StatementsNode(69...75)([ReturnNode(69...75)((69...75), nil)]),
-       0
-     ),
-     UntilNode(88...109)(
-       (99...104),
-       nil,
-       CallNode(105...109)(
-         nil,
-         nil,
-         (105...109),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "bar?"
-       ),
-       StatementsNode(88...98)(
-         [CallNode(88...98)(
-            nil,
-            nil,
-            (88...91),
-            nil,
-            ArgumentsNode(92...98)(
-              [SymbolNode(92...94)((92...93), (93...94), nil, "a"),
-               SymbolNode(96...98)((96...97), (97...98), nil, "b")]
-            ),
-            nil,
-            nil,
-            0,
-            "foo"
-          )]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...109))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...109))
+    └── body: (length: 6)
+        ├── @ UntilNode (location: (0...18))
+        │   ├── keyword_loc: (0...5) = "until"
+        │   ├── closing_loc: (15...18) = "end"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (6...10))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (12...13))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (12...13))
+        │   └── flags: 
+        ├── @ UntilNode (location: (20...32))
+        │   ├── keyword_loc: (22...27) = "until"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (28...32))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (20...21))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (20...21))
+        │   └── flags: 
+        ├── @ UntilNode (location: (34...50))
+        │   ├── keyword_loc: (40...45) = "until"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (46...50))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (34...39))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (34...39))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (34...39) = "break"
+        │   └── flags: 
+        ├── @ UntilNode (location: (52...67))
+        │   ├── keyword_loc: (57...62) = "until"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (63...67))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (52...56))
+        │   │   └── body: (length: 1)
+        │   │       └── @ NextNode (location: (52...56))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (52...56) = "next"
+        │   └── flags: 
+        ├── @ UntilNode (location: (69...86))
+        │   ├── keyword_loc: (76...81) = "until"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (82...86))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (69...75))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ReturnNode (location: (69...75))
+        │   │           ├── keyword_loc: (69...75) = "return"
+        │   │           └── arguments: ∅
+        │   └── flags: 
+        └── @ UntilNode (location: (88...109))
+            ├── keyword_loc: (99...104) = "until"
+            ├── closing_loc: ∅
+            ├── predicate:
+            │   @ CallNode (location: (105...109))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (105...109) = "bar?"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "bar?"
+            ├── statements:
+            │   @ StatementsNode (location: (88...98))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (88...98))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (88...91) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (92...98))
+            │           │   └── arguments: (length: 2)
+            │           │       ├── @ SymbolNode (location: (92...94))
+            │           │       │   ├── opening_loc: (92...93) = ":"
+            │           │       │   ├── value_loc: (93...94) = "a"
+            │           │       │   ├── closing_loc: ∅
+            │           │       │   └── unescaped: "a"
+            │           │       └── @ SymbolNode (location: (96...98))
+            │           │           ├── opening_loc: (96...97) = ":"
+            │           │           ├── value_loc: (97...98) = "b"
+            │           │           ├── closing_loc: ∅
+            │           │           └── unescaped: "b"
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "foo"
+            └── flags: 
diff --git a/test/yarp/snapshots/variables.txt b/test/yarp/snapshots/variables.txt
index 29f5e44817..4e05266727 100644
--- a/test/yarp/snapshots/variables.txt
+++ b/test/yarp/snapshots/variables.txt
@@ -1,241 +1,293 @@
-ProgramNode(0...293)(
-  [:abc, :foo, :bar, :baz],
-  StatementsNode(0...293)(
-    [ClassVariableReadNode(0...5)(:@@abc),
-     ClassVariableWriteNode(7...16)(
-       :@@abc,
-       (7...12),
-       IntegerNode(15...16)(),
-       (13...14)
-     ),
-     MultiWriteNode(18...34)(
-       [ClassVariableTargetNode(18...23)(:@@foo),
-        ClassVariableTargetNode(25...30)(:@@bar)],
-       nil,
-       nil,
-       (31...32),
-       IntegerNode(33...34)()
-     ),
-     ClassVariableWriteNode(36...48)(
-       :@@foo,
-       (36...41),
-       ArrayNode(44...48)(
-         [IntegerNode(44...45)(), IntegerNode(47...48)()],
-         nil,
-         nil
-       ),
-       (42...43)
-     ),
-     GlobalVariableWriteNode(50...58)(
-       :$abc,
-       (50...54),
-       IntegerNode(57...58)(),
-       (55...56)
-     ),
-     GlobalVariableReadNode(60...64)(:$abc),
-     InstanceVariableReadNode(66...70)(:@abc),
-     InstanceVariableWriteNode(72...80)(
-       :@abc,
-       (72...76),
-       IntegerNode(79...80)(),
-       (77...78)
-     ),
-     CallNode(82...83)(nil, nil, (82...83), nil, nil, nil, nil, 2, "a"),
-     LocalVariableWriteNode(85...92)(
-       :abc,
-       0,
-       (85...88),
-       IntegerNode(91...92)(),
-       (89...90)
-     ),
-     MultiWriteNode(94...108)(
-       [GlobalVariableTargetNode(94...98)(:$foo),
-        GlobalVariableTargetNode(100...104)(:$bar)],
-       nil,
-       nil,
-       (105...106),
-       IntegerNode(107...108)()
-     ),
-     GlobalVariableWriteNode(110...121)(
-       :$foo,
-       (110...114),
-       ArrayNode(117...121)(
-         [IntegerNode(117...118)(), IntegerNode(120...121)()],
-         nil,
-         nil
-       ),
-       (115...116)
-     ),
-     MultiWriteNode(123...137)(
-       [InstanceVariableTargetNode(123...127)(:@foo),
-        InstanceVariableTargetNode(129...133)(:@bar)],
-       nil,
-       nil,
-       (134...135),
-       IntegerNode(136...137)()
-     ),
-     InstanceVariableWriteNode(139...150)(
-       :@foo,
-       (139...143),
-       ArrayNode(146...150)(
-         [IntegerNode(146...147)(), IntegerNode(149...150)()],
-         nil,
-         nil
-       ),
-       (144...145)
-     ),
-     LocalVariableWriteNode(152...159)(
-       :foo,
-       0,
-       (152...155),
-       IntegerNode(158...159)(),
-       (156...157)
-     ),
-     LocalVariableWriteNode(161...171)(
-       :foo,
-       0,
-       (161...164),
-       ArrayNode(167...171)(
-         [IntegerNode(167...168)(), IntegerNode(170...171)()],
-         nil,
-         nil
-       ),
-       (165...166)
-     ),
-     LocalVariableWriteNode(173...183)(
-       :foo,
-       0,
-       (173...176),
-       ArrayNode(179...183)(
-         [IntegerNode(179...180)(), IntegerNode(182...183)()],
-         nil,
-         nil
-       ),
-       (177...178)
-     ),
-     MultiWriteNode(185...198)(
-       [LocalVariableTargetNode(185...188)(:foo, 0),
-        SplatNode(190...191)((190...191), nil)],
-       nil,
-       nil,
-       (192...193),
-       ArrayNode(194...198)(
-         [IntegerNode(194...195)(), IntegerNode(197...198)()],
-         nil,
-         nil
-       )
-     ),
-     MultiWriteNode(200...211)(
-       [LocalVariableTargetNode(200...203)(:foo, 0),
-        SplatNode(203...204)((203...204), nil)],
-       nil,
-       nil,
-       (205...206),
-       ArrayNode(207...211)(
-         [IntegerNode(207...208)(), IntegerNode(210...211)()],
-         nil,
-         nil
-       )
-     ),
-     MultiWriteNode(213...229)(
-       [LocalVariableTargetNode(213...216)(:foo, 0),
-        SplatNode(218...222)(
-          (218...219),
-          LocalVariableTargetNode(219...222)(:bar, 0)
-        )],
-       nil,
-       nil,
-       (223...224),
-       ArrayNode(225...229)(
-         [IntegerNode(225...226)(), IntegerNode(228...229)()],
-         nil,
-         nil
-       )
-     ),
-     MultiWriteNode(231...258)(
-       [LocalVariableTargetNode(231...234)(:foo, 0),
-        MultiTargetNode(236...246)(
-          [LocalVariableTargetNode(237...240)(:bar, 0),
-           LocalVariableTargetNode(242...245)(:baz, 0)],
-          (236...237),
-          (245...246)
-        )],
-       nil,
-       nil,
-       (247...248),
-       ArrayNode(249...258)(
-         [IntegerNode(249...250)(),
-          ArrayNode(252...258)(
-            [IntegerNode(253...254)(), IntegerNode(256...257)()],
-            (252...253),
-            (257...258)
-          )],
-         nil,
-         nil
-       )
-     ),
-     LocalVariableWriteNode(260...270)(
-       :foo,
-       0,
-       (260...263),
-       ArrayNode(266...270)(
-         [SplatNode(266...270)(
-            (266...267),
-            LocalVariableReadNode(267...270)(:bar, 0)
-          )],
-         nil,
-         nil
-       ),
-       (264...265)
-     ),
-     ConstantWriteNode(272...282)(
-       :Foo,
-       (272...275),
-       ArrayNode(278...282)(
-         [IntegerNode(278...279)(), IntegerNode(281...282)()],
-         nil,
-         nil
-       ),
-       (276...277)
-     ),
-     ParenthesesNode(284...293)(
-       StatementsNode(285...292)(
-         [CallNode(285...286)(
-            nil,
-            nil,
-            (285...286),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "a"
-          ),
-          CallNode(288...289)(
-            nil,
-            nil,
-            (288...289),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "b"
-          ),
-          CallNode(291...292)(
-            nil,
-            nil,
-            (291...292),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "c"
-          )]
-       ),
-       (284...285),
-       (292...293)
-     )]
-  )
-)
+@ ProgramNode (location: (0...293))
+├── locals: [:abc, :foo, :bar, :baz]
+└── statements:
+    @ StatementsNode (location: (0...293))
+    └── body: (length: 24)
+        ├── @ ClassVariableReadNode (location: (0...5))
+        │   └── name: :@@abc
+        ├── @ ClassVariableWriteNode (location: (7...16))
+        │   ├── name: :@@abc
+        │   ├── name_loc: (7...12) = "@@abc"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (15...16))
+        │   └── operator_loc: (13...14) = "="
+        ├── @ MultiWriteNode (location: (18...34))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ ClassVariableTargetNode (location: (18...23))
+        │   │   │   └── name: :@@foo
+        │   │   └── @ ClassVariableTargetNode (location: (25...30))
+        │   │       └── name: :@@bar
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (31...32) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (33...34))
+        ├── @ ClassVariableWriteNode (location: (36...48))
+        │   ├── name: :@@foo
+        │   ├── name_loc: (36...41) = "@@foo"
+        │   ├── value:
+        │   │   @ ArrayNode (location: (44...48))
+        │   │   ├── elements: (length: 2)
+        │   │   │   ├── @ IntegerNode (location: (44...45))
+        │   │   │   └── @ IntegerNode (location: (47...48))
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (42...43) = "="
+        ├── @ GlobalVariableWriteNode (location: (50...58))
+        │   ├── name: :$abc
+        │   ├── name_loc: (50...54) = "$abc"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (57...58))
+        │   └── operator_loc: (55...56) = "="
+        ├── @ GlobalVariableReadNode (location: (60...64))
+        │   └── name: :$abc
+        ├── @ InstanceVariableReadNode (location: (66...70))
+        │   └── name: :@abc
+        ├── @ InstanceVariableWriteNode (location: (72...80))
+        │   ├── name: :@abc
+        │   ├── name_loc: (72...76) = "@abc"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (79...80))
+        │   └── operator_loc: (77...78) = "="
+        ├── @ CallNode (location: (82...83))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (82...83) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "a"
+        ├── @ LocalVariableWriteNode (location: (85...92))
+        │   ├── name: :abc
+        │   ├── depth: 0
+        │   ├── name_loc: (85...88) = "abc"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (91...92))
+        │   └── operator_loc: (89...90) = "="
+        ├── @ MultiWriteNode (location: (94...108))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ GlobalVariableTargetNode (location: (94...98))
+        │   │   │   └── name: :$foo
+        │   │   └── @ GlobalVariableTargetNode (location: (100...104))
+        │   │       └── name: :$bar
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (105...106) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (107...108))
+        ├── @ GlobalVariableWriteNode (location: (110...121))
+        │   ├── name: :$foo
+        │   ├── name_loc: (110...114) = "$foo"
+        │   ├── value:
+        │   │   @ ArrayNode (location: (117...121))
+        │   │   ├── elements: (length: 2)
+        │   │   │   ├── @ IntegerNode (location: (117...118))
+        │   │   │   └── @ IntegerNode (location: (120...121))
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (115...116) = "="
+        ├── @ MultiWriteNode (location: (123...137))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ InstanceVariableTargetNode (location: (123...127))
+        │   │   │   └── name: :@foo
+        │   │   └── @ InstanceVariableTargetNode (location: (129...133))
+        │   │       └── name: :@bar
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (134...135) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (136...137))
+        ├── @ InstanceVariableWriteNode (location: (139...150))
+        │   ├── name: :@foo
+        │   ├── name_loc: (139...143) = "@foo"
+        │   ├── value:
+        │   │   @ ArrayNode (location: (146...150))
+        │   │   ├── elements: (length: 2)
+        │   │   │   ├── @ IntegerNode (location: (146...147))
+        │   │   │   └── @ IntegerNode (location: (149...150))
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (144...145) = "="
+        ├── @ LocalVariableWriteNode (location: (152...159))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (152...155) = "foo"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (158...159))
+        │   └── operator_loc: (156...157) = "="
+        ├── @ LocalVariableWriteNode (location: (161...171))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (161...164) = "foo"
+        │   ├── value:
+        │   │   @ ArrayNode (location: (167...171))
+        │   │   ├── elements: (length: 2)
+        │   │   │   ├── @ IntegerNode (location: (167...168))
+        │   │   │   └── @ IntegerNode (location: (170...171))
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (165...166) = "="
+        ├── @ LocalVariableWriteNode (location: (173...183))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (173...176) = "foo"
+        │   ├── value:
+        │   │   @ ArrayNode (location: (179...183))
+        │   │   ├── elements: (length: 2)
+        │   │   │   ├── @ IntegerNode (location: (179...180))
+        │   │   │   └── @ IntegerNode (location: (182...183))
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (177...178) = "="
+        ├── @ MultiWriteNode (location: (185...198))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (185...188))
+        │   │   │   ├── name: :foo
+        │   │   │   └── depth: 0
+        │   │   └── @ SplatNode (location: (190...191))
+        │   │       ├── operator_loc: (190...191) = "*"
+        │   │       └── expression: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (192...193) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (194...198))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (194...195))
+        │       │   └── @ IntegerNode (location: (197...198))
+        │       ├── opening_loc: ∅
+        │       └── closing_loc: ∅
+        ├── @ MultiWriteNode (location: (200...211))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (200...203))
+        │   │   │   ├── name: :foo
+        │   │   │   └── depth: 0
+        │   │   └── @ SplatNode (location: (203...204))
+        │   │       ├── operator_loc: (203...204) = ","
+        │   │       └── expression: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (205...206) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (207...211))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (207...208))
+        │       │   └── @ IntegerNode (location: (210...211))
+        │       ├── opening_loc: ∅
+        │       └── closing_loc: ∅
+        ├── @ MultiWriteNode (location: (213...229))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (213...216))
+        │   │   │   ├── name: :foo
+        │   │   │   └── depth: 0
+        │   │   └── @ SplatNode (location: (218...222))
+        │   │       ├── operator_loc: (218...219) = "*"
+        │   │       └── expression:
+        │   │           @ LocalVariableTargetNode (location: (219...222))
+        │   │           ├── name: :bar
+        │   │           └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (223...224) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (225...229))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (225...226))
+        │       │   └── @ IntegerNode (location: (228...229))
+        │       ├── opening_loc: ∅
+        │       └── closing_loc: ∅
+        ├── @ MultiWriteNode (location: (231...258))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (231...234))
+        │   │   │   ├── name: :foo
+        │   │   │   └── depth: 0
+        │   │   └── @ MultiTargetNode (location: (236...246))
+        │   │       ├── targets: (length: 2)
+        │   │       │   ├── @ LocalVariableTargetNode (location: (237...240))
+        │   │       │   │   ├── name: :bar
+        │   │       │   │   └── depth: 0
+        │   │       │   └── @ LocalVariableTargetNode (location: (242...245))
+        │   │       │       ├── name: :baz
+        │   │       │       └── depth: 0
+        │   │       ├── lparen_loc: (236...237) = "("
+        │   │       └── rparen_loc: (245...246) = ")"
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (247...248) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (249...258))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (249...250))
+        │       │   └── @ ArrayNode (location: (252...258))
+        │       │       ├── elements: (length: 2)
+        │       │       │   ├── @ IntegerNode (location: (253...254))
+        │       │       │   └── @ IntegerNode (location: (256...257))
+        │       │       ├── opening_loc: (252...253) = "["
+        │       │       └── closing_loc: (257...258) = "]"
+        │       ├── opening_loc: ∅
+        │       └── closing_loc: ∅
+        ├── @ LocalVariableWriteNode (location: (260...270))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (260...263) = "foo"
+        │   ├── value:
+        │   │   @ ArrayNode (location: (266...270))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ SplatNode (location: (266...270))
+        │   │   │       ├── operator_loc: (266...267) = "*"
+        │   │   │       └── expression:
+        │   │   │           @ LocalVariableReadNode (location: (267...270))
+        │   │   │           ├── name: :bar
+        │   │   │           └── depth: 0
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (264...265) = "="
+        ├── @ ConstantWriteNode (location: (272...282))
+        │   ├── name: :Foo
+        │   ├── name_loc: (272...275) = "Foo"
+        │   ├── value:
+        │   │   @ ArrayNode (location: (278...282))
+        │   │   ├── elements: (length: 2)
+        │   │   │   ├── @ IntegerNode (location: (278...279))
+        │   │   │   └── @ IntegerNode (location: (281...282))
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (276...277) = "="
+        └── @ ParenthesesNode (location: (284...293))
+            ├── body:
+            │   @ StatementsNode (location: (285...292))
+            │   └── body: (length: 3)
+            │       ├── @ CallNode (location: (285...286))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (285...286) = "a"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "a"
+            │       ├── @ CallNode (location: (288...289))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (288...289) = "b"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "b"
+            │       └── @ CallNode (location: (291...292))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (291...292) = "c"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "c"
+            ├── opening_loc: (284...285) = "("
+            └── closing_loc: (292...293) = ")"
diff --git a/test/yarp/snapshots/while.txt b/test/yarp/snapshots/while.txt
index 078df5066c..3556c716ef 100644
--- a/test/yarp/snapshots/while.txt
+++ b/test/yarp/snapshots/while.txt
@@ -1,207 +1,281 @@
-ProgramNode(0...314)(
-  [],
-  StatementsNode(0...314)(
-    [WhileNode(0...18)(
-       (0...5),
-       (15...18),
-       TrueNode(6...10)(),
-       StatementsNode(12...13)([IntegerNode(12...13)()]),
-       0
-     ),
-     WhileNode(20...32)(
-       (22...27),
-       nil,
-       TrueNode(28...32)(),
-       StatementsNode(20...21)([IntegerNode(20...21)()]),
-       0
-     ),
-     WhileNode(34...50)(
-       (40...45),
-       nil,
-       TrueNode(46...50)(),
-       StatementsNode(34...39)([BreakNode(34...39)(nil, (34...39))]),
-       0
-     ),
-     WhileNode(52...67)(
-       (57...62),
-       nil,
-       TrueNode(63...67)(),
-       StatementsNode(52...56)([NextNode(52...56)(nil, (52...56))]),
-       0
-     ),
-     WhileNode(69...86)(
-       (76...81),
-       nil,
-       TrueNode(82...86)(),
-       StatementsNode(69...75)([ReturnNode(69...75)((69...75), nil)]),
-       0
-     ),
-     WhileNode(88...109)(
-       (99...104),
-       nil,
-       CallNode(105...109)(
-         nil,
-         nil,
-         (105...109),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "bar?"
-       ),
-       StatementsNode(88...98)(
-         [CallNode(88...98)(
-            nil,
-            nil,
-            (88...91),
-            nil,
-            ArgumentsNode(92...98)(
-              [SymbolNode(92...94)((92...93), (93...94), nil, "a"),
-               SymbolNode(96...98)((96...97), (97...98), nil, "b")]
-            ),
-            nil,
-            nil,
-            0,
-            "foo"
-          )]
-       ),
-       0
-     ),
-     WhileNode(111...161)(
-       (111...116),
-       (158...161),
-       DefNode(117...149)(
-         :foo,
-         (126...129),
-         SelfNode(121...125)(),
-         ParametersNode(130...144)(
-           [],
-           [OptionalParameterNode(130...144)(
-              :a,
-              (130...131),
-              (132...133),
-              CallNode(134...144)(
-                nil,
-                nil,
-                (134...137),
-                nil,
-                nil,
-                nil,
-                BlockNode(138...144)([], nil, nil, (138...140), (141...144)),
-                0,
-                "tap"
-              )
-            )],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         nil,
-         [:a],
-         (117...120),
-         (125...126),
-         nil,
-         nil,
-         nil,
-         (146...149)
-       ),
-       StatementsNode(151...156)([BreakNode(151...156)(nil, (151...156))]),
-       0
-     ),
-     WhileNode(163...210)(
-       (163...168),
-       (207...210),
-       ClassNode(169...198)(
-         [:a],
-         (169...174),
-         ConstantReadNode(175...178)(:Foo),
-         nil,
-         nil,
-         StatementsNode(179...193)(
-           [LocalVariableWriteNode(179...193)(
-              :a,
-              0,
-              (179...180),
-              CallNode(183...193)(
-                nil,
-                nil,
-                (183...186),
-                nil,
-                nil,
-                nil,
-                BlockNode(187...193)([], nil, nil, (187...189), (190...193)),
-                0,
-                "tap"
-              ),
-              (181...182)
-            )]
-         ),
-         (195...198),
-         :Foo
-       ),
-       StatementsNode(200...205)([BreakNode(200...205)(nil, (200...205))]),
-       0
-     ),
-     WhileNode(212...260)(
-       (212...217),
-       (257...260),
-       SingletonClassNode(218...248)(
-         [],
-         (218...223),
-         (224...226),
-         SelfNode(227...231)(),
-         StatementsNode(233...243)(
-           [CallNode(233...243)(
-              nil,
-              nil,
-              (233...236),
-              nil,
-              nil,
-              nil,
-              BlockNode(237...243)([], nil, nil, (237...239), (240...243)),
-              0,
-              "tap"
-            )]
-         ),
-         (245...248)
-       ),
-       StatementsNode(250...255)([BreakNode(250...255)(nil, (250...255))]),
-       0
-     ),
-     WhileNode(262...314)(
-       (262...267),
-       (311...314),
-       SingletonClassNode(268...302)(
-         [:a],
-         (268...273),
-         (274...276),
-         SelfNode(277...281)(),
-         StatementsNode(283...297)(
-           [LocalVariableWriteNode(283...297)(
-              :a,
-              0,
-              (283...284),
-              CallNode(287...297)(
-                nil,
-                nil,
-                (287...290),
-                nil,
-                nil,
-                nil,
-                BlockNode(291...297)([], nil, nil, (291...293), (294...297)),
-                0,
-                "tap"
-              ),
-              (285...286)
-            )]
-         ),
-         (299...302)
-       ),
-       StatementsNode(304...309)([BreakNode(304...309)(nil, (304...309))]),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...314))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...314))
+    └── body: (length: 10)
+        ├── @ WhileNode (location: (0...18))
+        │   ├── keyword_loc: (0...5) = "while"
+        │   ├── closing_loc: (15...18) = "end"
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (6...10))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (12...13))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (12...13))
+        │   └── flags: 
+        ├── @ WhileNode (location: (20...32))
+        │   ├── keyword_loc: (22...27) = "while"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (28...32))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (20...21))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (20...21))
+        │   └── flags: 
+        ├── @ WhileNode (location: (34...50))
+        │   ├── keyword_loc: (40...45) = "while"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (46...50))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (34...39))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (34...39))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (34...39) = "break"
+        │   └── flags: 
+        ├── @ WhileNode (location: (52...67))
+        │   ├── keyword_loc: (57...62) = "while"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (63...67))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (52...56))
+        │   │   └── body: (length: 1)
+        │   │       └── @ NextNode (location: (52...56))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (52...56) = "next"
+        │   └── flags: 
+        ├── @ WhileNode (location: (69...86))
+        │   ├── keyword_loc: (76...81) = "while"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ TrueNode (location: (82...86))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (69...75))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ReturnNode (location: (69...75))
+        │   │           ├── keyword_loc: (69...75) = "return"
+        │   │           └── arguments: ∅
+        │   └── flags: 
+        ├── @ WhileNode (location: (88...109))
+        │   ├── keyword_loc: (99...104) = "while"
+        │   ├── closing_loc: ∅
+        │   ├── predicate:
+        │   │   @ CallNode (location: (105...109))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (105...109) = "bar?"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "bar?"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (88...98))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (88...98))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (88...91) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (92...98))
+        │   │           │   └── arguments: (length: 2)
+        │   │           │       ├── @ SymbolNode (location: (92...94))
+        │   │           │       │   ├── opening_loc: (92...93) = ":"
+        │   │           │       │   ├── value_loc: (93...94) = "a"
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   └── unescaped: "a"
+        │   │           │       └── @ SymbolNode (location: (96...98))
+        │   │           │           ├── opening_loc: (96...97) = ":"
+        │   │           │           ├── value_loc: (97...98) = "b"
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           └── unescaped: "b"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "foo"
+        │   └── flags: 
+        ├── @ WhileNode (location: (111...161))
+        │   ├── keyword_loc: (111...116) = "while"
+        │   ├── closing_loc: (158...161) = "end"
+        │   ├── predicate:
+        │   │   @ DefNode (location: (117...149))
+        │   │   ├── name: :foo
+        │   │   ├── name_loc: (126...129) = "foo"
+        │   │   ├── receiver:
+        │   │   │   @ SelfNode (location: (121...125))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (130...144))
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   └── @ OptionalParameterNode (location: (130...144))
+        │   │   │   │       ├── name: :a
+        │   │   │   │       ├── name_loc: (130...131) = "a"
+        │   │   │   │       ├── operator_loc: (132...133) = "="
+        │   │   │   │       └── value:
+        │   │   │   │           @ CallNode (location: (134...144))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (134...137) = "tap"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block:
+        │   │   │   │           │   @ BlockNode (location: (138...144))
+        │   │   │   │           │   ├── locals: []
+        │   │   │   │           │   ├── parameters: ∅
+        │   │   │   │           │   ├── body: ∅
+        │   │   │   │           │   ├── opening_loc: (138...140) = "do"
+        │   │   │   │           │   └── closing_loc: (141...144) = "end"
+        │   │   │   │           ├── flags: 
+        │   │   │   │           └── name: "tap"
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── body: ∅
+        │   │   ├── locals: [:a]
+        │   │   ├── def_keyword_loc: (117...120) = "def"
+        │   │   ├── operator_loc: (125...126) = "."
+        │   │   ├── lparen_loc: ∅
+        │   │   ├── rparen_loc: ∅
+        │   │   ├── equal_loc: ∅
+        │   │   └── end_keyword_loc: (146...149) = "end"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (151...156))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (151...156))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (151...156) = "break"
+        │   └── flags: 
+        ├── @ WhileNode (location: (163...210))
+        │   ├── keyword_loc: (163...168) = "while"
+        │   ├── closing_loc: (207...210) = "end"
+        │   ├── predicate:
+        │   │   @ ClassNode (location: (169...198))
+        │   │   ├── locals: [:a]
+        │   │   ├── class_keyword_loc: (169...174) = "class"
+        │   │   ├── constant_path:
+        │   │   │   @ ConstantReadNode (location: (175...178))
+        │   │   │   └── name: :Foo
+        │   │   ├── inheritance_operator_loc: ∅
+        │   │   ├── superclass: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (179...193))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableWriteNode (location: (179...193))
+        │   │   │           ├── name: :a
+        │   │   │           ├── depth: 0
+        │   │   │           ├── name_loc: (179...180) = "a"
+        │   │   │           ├── value:
+        │   │   │           │   @ CallNode (location: (183...193))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (183...186) = "tap"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block:
+        │   │   │           │   │   @ BlockNode (location: (187...193))
+        │   │   │           │   │   ├── locals: []
+        │   │   │           │   │   ├── parameters: ∅
+        │   │   │           │   │   ├── body: ∅
+        │   │   │           │   │   ├── opening_loc: (187...189) = "do"
+        │   │   │           │   │   └── closing_loc: (190...193) = "end"
+        │   │   │           │   ├── flags: 
+        │   │   │           │   └── name: "tap"
+        │   │   │           └── operator_loc: (181...182) = "="
+        │   │   ├── end_keyword_loc: (195...198) = "end"
+        │   │   └── name: :Foo
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (200...205))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (200...205))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (200...205) = "break"
+        │   └── flags: 
+        ├── @ WhileNode (location: (212...260))
+        │   ├── keyword_loc: (212...217) = "while"
+        │   ├── closing_loc: (257...260) = "end"
+        │   ├── predicate:
+        │   │   @ SingletonClassNode (location: (218...248))
+        │   │   ├── locals: []
+        │   │   ├── class_keyword_loc: (218...223) = "class"
+        │   │   ├── operator_loc: (224...226) = "<<"
+        │   │   ├── expression:
+        │   │   │   @ SelfNode (location: (227...231))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (233...243))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (233...243))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (233...236) = "tap"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block:
+        │   │   │           │   @ BlockNode (location: (237...243))
+        │   │   │           │   ├── locals: []
+        │   │   │           │   ├── parameters: ∅
+        │   │   │           │   ├── body: ∅
+        │   │   │           │   ├── opening_loc: (237...239) = "do"
+        │   │   │           │   └── closing_loc: (240...243) = "end"
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "tap"
+        │   │   └── end_keyword_loc: (245...248) = "end"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (250...255))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (250...255))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (250...255) = "break"
+        │   └── flags: 
+        └── @ WhileNode (location: (262...314))
+            ├── keyword_loc: (262...267) = "while"
+            ├── closing_loc: (311...314) = "end"
+            ├── predicate:
+            │   @ SingletonClassNode (location: (268...302))
+            │   ├── locals: [:a]
+            │   ├── class_keyword_loc: (268...273) = "class"
+            │   ├── operator_loc: (274...276) = "<<"
+            │   ├── expression:
+            │   │   @ SelfNode (location: (277...281))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (283...297))
+            │   │   └── body: (length: 1)
+            │   │       └── @ LocalVariableWriteNode (location: (283...297))
+            │   │           ├── name: :a
+            │   │           ├── depth: 0
+            │   │           ├── name_loc: (283...284) = "a"
+            │   │           ├── value:
+            │   │           │   @ CallNode (location: (287...297))
+            │   │           │   ├── receiver: ∅
+            │   │           │   ├── call_operator_loc: ∅
+            │   │           │   ├── message_loc: (287...290) = "tap"
+            │   │           │   ├── opening_loc: ∅
+            │   │           │   ├── arguments: ∅
+            │   │           │   ├── closing_loc: ∅
+            │   │           │   ├── block:
+            │   │           │   │   @ BlockNode (location: (291...297))
+            │   │           │   │   ├── locals: []
+            │   │           │   │   ├── parameters: ∅
+            │   │           │   │   ├── body: ∅
+            │   │           │   │   ├── opening_loc: (291...293) = "do"
+            │   │           │   │   └── closing_loc: (294...297) = "end"
+            │   │           │   ├── flags: 
+            │   │           │   └── name: "tap"
+            │   │           └── operator_loc: (285...286) = "="
+            │   └── end_keyword_loc: (299...302) = "end"
+            ├── statements:
+            │   @ StatementsNode (location: (304...309))
+            │   └── body: (length: 1)
+            │       └── @ BreakNode (location: (304...309))
+            │           ├── arguments: ∅
+            │           └── keyword_loc: (304...309) = "break"
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/__ENCODING__.txt b/test/yarp/snapshots/whitequark/__ENCODING__.txt
index 2f5aaa5dfc..aa300aa827 100644
--- a/test/yarp/snapshots/whitequark/__ENCODING__.txt
+++ b/test/yarp/snapshots/whitequark/__ENCODING__.txt
@@ -1 +1,6 @@
-ProgramNode(0...12)([], StatementsNode(0...12)([SourceEncodingNode(0...12)()]))
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ SourceEncodingNode (location: (0...12))
diff --git a/test/yarp/snapshots/whitequark/__ENCODING___legacy_.txt b/test/yarp/snapshots/whitequark/__ENCODING___legacy_.txt
index 2f5aaa5dfc..aa300aa827 100644
--- a/test/yarp/snapshots/whitequark/__ENCODING___legacy_.txt
+++ b/test/yarp/snapshots/whitequark/__ENCODING___legacy_.txt
@@ -1 +1,6 @@
-ProgramNode(0...12)([], StatementsNode(0...12)([SourceEncodingNode(0...12)()]))
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ SourceEncodingNode (location: (0...12))
diff --git a/test/yarp/snapshots/whitequark/alias.txt b/test/yarp/snapshots/whitequark/alias.txt
index 3960bea48a..fce4c912f5 100644
--- a/test/yarp/snapshots/whitequark/alias.txt
+++ b/test/yarp/snapshots/whitequark/alias.txt
@@ -1,10 +1,19 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [AliasNode(0...14)(
-       SymbolNode(6...10)((6...7), (7...10), nil, "foo"),
-       SymbolNode(11...14)(nil, (11...14), nil, "bar"),
-       (0...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ AliasNode (location: (0...14))
+            ├── new_name:
+            │   @ SymbolNode (location: (6...10))
+            │   ├── opening_loc: (6...7) = ":"
+            │   ├── value_loc: (7...10) = "foo"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "foo"
+            ├── old_name:
+            │   @ SymbolNode (location: (11...14))
+            │   ├── opening_loc: ∅
+            │   ├── value_loc: (11...14) = "bar"
+            │   ├── closing_loc: ∅
+            │   └── unescaped: "bar"
+            └── keyword_loc: (0...5) = "alias"
diff --git a/test/yarp/snapshots/whitequark/alias_gvar.txt b/test/yarp/snapshots/whitequark/alias_gvar.txt
index 06482181f4..0d5616e10f 100644
--- a/test/yarp/snapshots/whitequark/alias_gvar.txt
+++ b/test/yarp/snapshots/whitequark/alias_gvar.txt
@@ -1,15 +1,20 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [AliasNode(0...11)(
-       GlobalVariableReadNode(6...8)(:$a),
-       BackReferenceReadNode(9...11)(),
-       (0...5)
-     ),
-     AliasNode(13...24)(
-       GlobalVariableReadNode(19...21)(:$a),
-       GlobalVariableReadNode(22...24)(:$b),
-       (13...18)
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 2)
+        ├── @ AliasNode (location: (0...11))
+        │   ├── new_name:
+        │   │   @ GlobalVariableReadNode (location: (6...8))
+        │   │   └── name: :$a
+        │   ├── old_name:
+        │   │   @ BackReferenceReadNode (location: (9...11))
+        │   └── keyword_loc: (0...5) = "alias"
+        └── @ AliasNode (location: (13...24))
+            ├── new_name:
+            │   @ GlobalVariableReadNode (location: (19...21))
+            │   └── name: :$a
+            ├── old_name:
+            │   @ GlobalVariableReadNode (location: (22...24))
+            │   └── name: :$b
+            └── keyword_loc: (13...18) = "alias"
diff --git a/test/yarp/snapshots/whitequark/ambiuous_quoted_label_in_ternary_operator.txt b/test/yarp/snapshots/whitequark/ambiuous_quoted_label_in_ternary_operator.txt
index 5fc3ec49db..3f0e5a9711 100644
--- a/test/yarp/snapshots/whitequark/ambiuous_quoted_label_in_ternary_operator.txt
+++ b/test/yarp/snapshots/whitequark/ambiuous_quoted_label_in_ternary_operator.txt
@@ -1,30 +1,57 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [IfNode(0...15)(
-       nil,
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       StatementsNode(4...10)(
-         [CallNode(4...10)(
-            CallNode(4...5)(nil, nil, (4...5), nil, nil, nil, nil, 2, "b"),
-            nil,
-            (6...7),
-            nil,
-            ArgumentsNode(8...10)(
-              [StringNode(8...10)((8...9), (9...9), (9...10), "")]
-            ),
-            nil,
-            nil,
-            0,
-            "&"
-          )]
-       ),
-       ElseNode(10...15)(
-         (10...11),
-         StatementsNode(12...15)([NilNode(12...15)()]),
-         nil
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...15))
+            ├── if_keyword_loc: ∅
+            ├── predicate:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── statements:
+            │   @ StatementsNode (location: (4...10))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (4...10))
+            │           ├── receiver:
+            │           │   @ CallNode (location: (4...5))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (4...5) = "b"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "b"
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (6...7) = "&"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (8...10))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ StringNode (location: (8...10))
+            │           │           ├── opening_loc: (8...9) = "'"
+            │           │           ├── content_loc: (9...9) = ""
+            │           │           ├── closing_loc: (9...10) = "'"
+            │           │           └── unescaped: ""
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "&"
+            ├── consequent:
+            │   @ ElseNode (location: (10...15))
+            │   ├── else_keyword_loc: (10...11) = ":"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (12...15))
+            │   │   └── body: (length: 1)
+            │   │       └── @ NilNode (location: (12...15))
+            │   └── end_keyword_loc: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/and.txt b/test/yarp/snapshots/whitequark/and.txt
index c6641a692b..dacaf095d5 100644
--- a/test/yarp/snapshots/whitequark/and.txt
+++ b/test/yarp/snapshots/whitequark/and.txt
@@ -1,15 +1,53 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [AndNode(0...10)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       CallNode(7...10)(nil, nil, (7...10), nil, nil, nil, nil, 2, "bar"),
-       (4...6)
-     ),
-     AndNode(12...23)(
-       CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "foo"),
-       CallNode(20...23)(nil, nil, (20...23), nil, nil, nil, nil, 2, "bar"),
-       (16...19)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 2)
+        ├── @ AndNode (location: (0...10))
+        │   ├── left:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── right:
+        │   │   @ CallNode (location: (7...10))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (7...10) = "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "bar"
+        │   └── operator_loc: (4...6) = "&&"
+        └── @ AndNode (location: (12...23))
+            ├── left:
+            │   @ CallNode (location: (12...15))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (12...15) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── right:
+            │   @ CallNode (location: (20...23))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (20...23) = "bar"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "bar"
+            └── operator_loc: (16...19) = "and"
diff --git a/test/yarp/snapshots/whitequark/and_asgn.txt b/test/yarp/snapshots/whitequark/and_asgn.txt
index fab12349c2..ddd6afef3b 100644
--- a/test/yarp/snapshots/whitequark/and_asgn.txt
+++ b/test/yarp/snapshots/whitequark/and_asgn.txt
@@ -1,33 +1,55 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CallAndWriteNode(0...11)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       (4...5),
-       nil,
-       nil,
-       nil,
-       0,
-       "a",
-       "a=",
-       (6...9),
-       IntegerNode(10...11)()
-     ),
-     CallAndWriteNode(13...28)(
-       CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (16...22),
-       (16...17),
-       ArgumentsNode(17...21)(
-         [IntegerNode(17...18)(), IntegerNode(20...21)()]
-       ),
-       (21...22),
-       0,
-       "[]",
-       "[]=",
-       (23...26),
-       IntegerNode(27...28)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 2)
+        ├── @ CallAndWriteNode (location: (0...11))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: (4...5) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "a"
+        │   ├── write_name: "a="
+        │   ├── operator_loc: (6...9) = "&&="
+        │   └── value:
+        │       @ IntegerNode (location: (10...11))
+        └── @ CallAndWriteNode (location: (13...28))
+            ├── receiver:
+            │   @ CallNode (location: (13...16))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (13...16) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (16...22) = "[0, 1]"
+            ├── opening_loc: (16...17) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (17...21))
+            │   └── arguments: (length: 2)
+            │       ├── @ IntegerNode (location: (17...18))
+            │       └── @ IntegerNode (location: (20...21))
+            ├── closing_loc: (21...22) = "]"
+            ├── flags: 
+            ├── read_name: "[]"
+            ├── write_name: "[]="
+            ├── operator_loc: (23...26) = "&&="
+            └── value:
+                @ IntegerNode (location: (27...28))
diff --git a/test/yarp/snapshots/whitequark/and_or_masgn.txt b/test/yarp/snapshots/whitequark/and_or_masgn.txt
index e34c3e19ee..d390298e65 100644
--- a/test/yarp/snapshots/whitequark/and_or_masgn.txt
+++ b/test/yarp/snapshots/whitequark/and_or_masgn.txt
@@ -1,61 +1,89 @@
-ProgramNode(0...40)(
-  [:a, :b],
-  StatementsNode(0...40)(
-    [AndNode(0...19)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       ParenthesesNode(7...19)(
-         StatementsNode(8...18)(
-           [MultiWriteNode(8...18)(
-              [LocalVariableTargetNode(8...9)(:a, 0),
-               LocalVariableTargetNode(11...12)(:b, 0)],
-              nil,
-              nil,
-              (13...14),
-              CallNode(15...18)(
-                nil,
-                nil,
-                (15...18),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )
-            )]
-         ),
-         (7...8),
-         (18...19)
-       ),
-       (4...6)
-     ),
-     OrNode(21...40)(
-       CallNode(21...24)(nil, nil, (21...24), nil, nil, nil, nil, 2, "foo"),
-       ParenthesesNode(28...40)(
-         StatementsNode(29...39)(
-           [MultiWriteNode(29...39)(
-              [LocalVariableTargetNode(29...30)(:a, 0),
-               LocalVariableTargetNode(32...33)(:b, 0)],
-              nil,
-              nil,
-              (34...35),
-              CallNode(36...39)(
-                nil,
-                nil,
-                (36...39),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )
-            )]
-         ),
-         (28...29),
-         (39...40)
-       ),
-       (25...27)
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 2)
+        ├── @ AndNode (location: (0...19))
+        │   ├── left:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── right:
+        │   │   @ ParenthesesNode (location: (7...19))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (8...18))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ MultiWriteNode (location: (8...18))
+        │   │   │           ├── targets: (length: 2)
+        │   │   │           │   ├── @ LocalVariableTargetNode (location: (8...9))
+        │   │   │           │   │   ├── name: :a
+        │   │   │           │   │   └── depth: 0
+        │   │   │           │   └── @ LocalVariableTargetNode (location: (11...12))
+        │   │   │           │       ├── name: :b
+        │   │   │           │       └── depth: 0
+        │   │   │           ├── lparen_loc: ∅
+        │   │   │           ├── rparen_loc: ∅
+        │   │   │           ├── operator_loc: (13...14) = "="
+        │   │   │           └── value:
+        │   │   │               @ CallNode (location: (15...18))
+        │   │   │               ├── receiver: ∅
+        │   │   │               ├── call_operator_loc: ∅
+        │   │   │               ├── message_loc: (15...18) = "bar"
+        │   │   │               ├── opening_loc: ∅
+        │   │   │               ├── arguments: ∅
+        │   │   │               ├── closing_loc: ∅
+        │   │   │               ├── block: ∅
+        │   │   │               ├── flags: variable_call
+        │   │   │               └── name: "bar"
+        │   │   ├── opening_loc: (7...8) = "("
+        │   │   └── closing_loc: (18...19) = ")"
+        │   └── operator_loc: (4...6) = "&&"
+        └── @ OrNode (location: (21...40))
+            ├── left:
+            │   @ CallNode (location: (21...24))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (21...24) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── right:
+            │   @ ParenthesesNode (location: (28...40))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (29...39))
+            │   │   └── body: (length: 1)
+            │   │       └── @ MultiWriteNode (location: (29...39))
+            │   │           ├── targets: (length: 2)
+            │   │           │   ├── @ LocalVariableTargetNode (location: (29...30))
+            │   │           │   │   ├── name: :a
+            │   │           │   │   └── depth: 0
+            │   │           │   └── @ LocalVariableTargetNode (location: (32...33))
+            │   │           │       ├── name: :b
+            │   │           │       └── depth: 0
+            │   │           ├── lparen_loc: ∅
+            │   │           ├── rparen_loc: ∅
+            │   │           ├── operator_loc: (34...35) = "="
+            │   │           └── value:
+            │   │               @ CallNode (location: (36...39))
+            │   │               ├── receiver: ∅
+            │   │               ├── call_operator_loc: ∅
+            │   │               ├── message_loc: (36...39) = "bar"
+            │   │               ├── opening_loc: ∅
+            │   │               ├── arguments: ∅
+            │   │               ├── closing_loc: ∅
+            │   │               ├── block: ∅
+            │   │               ├── flags: variable_call
+            │   │               └── name: "bar"
+            │   ├── opening_loc: (28...29) = "("
+            │   └── closing_loc: (39...40) = ")"
+            └── operator_loc: (25...27) = "||"
diff --git a/test/yarp/snapshots/whitequark/anonymous_blockarg.txt b/test/yarp/snapshots/whitequark/anonymous_blockarg.txt
index af34a92864..5a32c81517 100644
--- a/test/yarp/snapshots/whitequark/anonymous_blockarg.txt
+++ b/test/yarp/snapshots/whitequark/anonymous_blockarg.txt
@@ -1,41 +1,47 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [DefNode(0...23)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...9)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(8...9)(nil, nil, (8...9))
-       ),
-       StatementsNode(12...18)(
-         [CallNode(12...18)(
-            nil,
-            nil,
-            (12...15),
-            (15...16),
-            ArgumentsNode(16...17)(
-              [BlockArgumentNode(16...17)(nil, (16...17))]
-            ),
-            (17...18),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:&],
-       (0...3),
-       nil,
-       (7...8),
-       (9...10),
-       nil,
-       (20...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...23))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...9))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block:
+            │       @ BlockParameterNode (location: (8...9))
+            │       ├── name: nil
+            │       ├── name_loc: ∅
+            │       └── operator_loc: (8...9) = "&"
+            ├── body:
+            │   @ StatementsNode (location: (12...18))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (12...18))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (12...15) = "bar"
+            │           ├── opening_loc: (15...16) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (16...17))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ BlockArgumentNode (location: (16...17))
+            │           │           ├── expression: ∅
+            │           │           └── operator_loc: (16...17) = "&"
+            │           ├── closing_loc: (17...18) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:&]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (9...10) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (20...23) = "end"
diff --git a/test/yarp/snapshots/whitequark/arg.txt b/test/yarp/snapshots/whitequark/arg.txt
index 037d3eb070..b448be0cfc 100644
--- a/test/yarp/snapshots/whitequark/arg.txt
+++ b/test/yarp/snapshots/whitequark/arg.txt
@@ -1,50 +1,53 @@
-ProgramNode(0...37)(
-  [],
-  StatementsNode(0...37)(
-    [DefNode(0...15)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...9)(
-         [RequiredParameterNode(6...9)(:foo)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:foo],
-       (0...3),
-       nil,
-       (5...6),
-       (9...10),
-       nil,
-       (12...15)
-     ),
-     DefNode(17...37)(
-       :f,
-       (21...22),
-       nil,
-       ParametersNode(23...31)(
-         [RequiredParameterNode(23...26)(:foo),
-          RequiredParameterNode(28...31)(:bar)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:foo, :bar],
-       (17...20),
-       nil,
-       (22...23),
-       (31...32),
-       nil,
-       (34...37)
-     )]
-  )
-)
+@ ProgramNode (location: (0...37))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...37))
+    └── body: (length: 2)
+        ├── @ DefNode (location: (0...15))
+        │   ├── name: :f
+        │   ├── name_loc: (4...5) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (6...9))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (6...9))
+        │   │   │       └── name: :foo
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:foo]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (5...6) = "("
+        │   ├── rparen_loc: (9...10) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (12...15) = "end"
+        └── @ DefNode (location: (17...37))
+            ├── name: :f
+            ├── name_loc: (21...22) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (23...31))
+            │   ├── requireds: (length: 2)
+            │   │   ├── @ RequiredParameterNode (location: (23...26))
+            │   │   │   └── name: :foo
+            │   │   └── @ RequiredParameterNode (location: (28...31))
+            │   │       └── name: :bar
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:foo, :bar]
+            ├── def_keyword_loc: (17...20) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (22...23) = "("
+            ├── rparen_loc: (31...32) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (34...37) = "end"
diff --git a/test/yarp/snapshots/whitequark/arg_duplicate_ignored.txt b/test/yarp/snapshots/whitequark/arg_duplicate_ignored.txt
index 304ca36eba..dad9c0adfb 100644
--- a/test/yarp/snapshots/whitequark/arg_duplicate_ignored.txt
+++ b/test/yarp/snapshots/whitequark/arg_duplicate_ignored.txt
@@ -1,51 +1,55 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [DefNode(0...18)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...12)(
-         [RequiredParameterNode(8...9)(:_),
-          RequiredParameterNode(11...12)(:_)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:_],
-       (0...3),
-       nil,
-       (7...8),
-       (12...13),
-       nil,
-       (15...18)
-     ),
-     DefNode(20...40)(
-       :foo,
-       (24...27),
-       nil,
-       ParametersNode(28...34)(
-         [RequiredParameterNode(28...30)(:_a),
-          RequiredParameterNode(32...34)(:_a)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:_a],
-       (20...23),
-       nil,
-       (27...28),
-       (34...35),
-       nil,
-       (37...40)
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 2)
+        ├── @ DefNode (location: (0...18))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (8...12))
+        │   │   ├── requireds: (length: 2)
+        │   │   │   ├── @ RequiredParameterNode (location: (8...9))
+        │   │   │   │   └── name: :_
+        │   │   │   └── @ RequiredParameterNode (location: (11...12))
+        │   │   │       └── name: :_
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:_]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (7...8) = "("
+        │   ├── rparen_loc: (12...13) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (15...18) = "end"
+        └── @ DefNode (location: (20...40))
+            ├── name: :foo
+            ├── name_loc: (24...27) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (28...34))
+            │   ├── requireds: (length: 2)
+            │   │   ├── @ RequiredParameterNode (location: (28...30))
+            │   │   │   └── name: :_a
+            │   │   └── @ RequiredParameterNode (location: (32...34))
+            │   │       └── name: :_a
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:_a]
+            ├── def_keyword_loc: (20...23) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (27...28) = "("
+            ├── rparen_loc: (34...35) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (37...40) = "end"
diff --git a/test/yarp/snapshots/whitequark/arg_label.txt b/test/yarp/snapshots/whitequark/arg_label.txt
index 40014d7289..de3ad36588 100644
--- a/test/yarp/snapshots/whitequark/arg_label.txt
+++ b/test/yarp/snapshots/whitequark/arg_label.txt
@@ -1,92 +1,109 @@
-ProgramNode(0...49)(
-  [],
-  StatementsNode(0...49)(
-    [DefNode(0...16)(
-       :foo,
-       (4...7),
-       nil,
-       nil,
-       StatementsNode(9...12)(
-         [CallNode(9...12)(
-            nil,
-            nil,
-            (9...10),
-            nil,
-            ArgumentsNode(10...12)(
-              [SymbolNode(10...12)((10...11), (11...12), nil, "b")]
-            ),
-            nil,
-            nil,
-            0,
-            "a"
-          )]
-       ),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (13...16)
-     ),
-     DefNode(18...35)(
-       :foo,
-       (22...25),
-       nil,
-       nil,
-       StatementsNode(28...31)(
-         [CallNode(28...31)(
-            nil,
-            nil,
-            (28...29),
-            nil,
-            ArgumentsNode(29...31)(
-              [SymbolNode(29...31)((29...30), (30...31), nil, "b")]
-            ),
-            nil,
-            nil,
-            0,
-            "a"
-          )]
-       ),
-       [],
-       (18...21),
-       nil,
-       (25...26),
-       (26...27),
-       nil,
-       (32...35)
-     ),
-     CallNode(37...49)(
-       nil,
-       nil,
-       (37...38),
-       nil,
-       nil,
-       nil,
-       BlockNode(39...49)(
-         [],
-         BlockParametersNode(41...43)(nil, [], (41...42), (42...43)),
-         StatementsNode(44...47)(
-           [CallNode(44...47)(
-              nil,
-              nil,
-              (44...45),
-              nil,
-              ArgumentsNode(45...47)(
-                [SymbolNode(45...47)((45...46), (46...47), nil, "b")]
-              ),
-              nil,
-              nil,
-              0,
-              "a"
-            )]
-         ),
-         (39...40),
-         (48...49)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...49))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...49))
+    └── body: (length: 3)
+        ├── @ DefNode (location: (0...16))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (9...12))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (9...12))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (9...10) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (10...12))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ SymbolNode (location: (10...12))
+        │   │           │           ├── opening_loc: (10...11) = ":"
+        │   │           │           ├── value_loc: (11...12) = "b"
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           └── unescaped: "b"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "a"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (13...16) = "end"
+        ├── @ DefNode (location: (18...35))
+        │   ├── name: :foo
+        │   ├── name_loc: (22...25) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (28...31))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (28...31))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (28...29) = "a"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (29...31))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ SymbolNode (location: (29...31))
+        │   │           │           ├── opening_loc: (29...30) = ":"
+        │   │           │           ├── value_loc: (30...31) = "b"
+        │   │           │           ├── closing_loc: ∅
+        │   │           │           └── unescaped: "b"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "a"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (18...21) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (25...26) = "("
+        │   ├── rparen_loc: (26...27) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (32...35) = "end"
+        └── @ CallNode (location: (37...49))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (37...38) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (39...49))
+            │   ├── locals: []
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (41...43))
+            │   │   ├── parameters: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (41...42) = "|"
+            │   │   └── closing_loc: (42...43) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (44...47))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (44...47))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (44...45) = "a"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments:
+            │   │           │   @ ArgumentsNode (location: (45...47))
+            │   │           │   └── arguments: (length: 1)
+            │   │           │       └── @ SymbolNode (location: (45...47))
+            │   │           │           ├── opening_loc: (45...46) = ":"
+            │   │           │           ├── value_loc: (46...47) = "b"
+            │   │           │           ├── closing_loc: ∅
+            │   │           │           └── unescaped: "b"
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "a"
+            │   ├── opening_loc: (39...40) = "{"
+            │   └── closing_loc: (48...49) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/whitequark/arg_scope.txt b/test/yarp/snapshots/whitequark/arg_scope.txt
index baa33596be..352bb403b2 100644
--- a/test/yarp/snapshots/whitequark/arg_scope.txt
+++ b/test/yarp/snapshots/whitequark/arg_scope.txt
@@ -1,27 +1,33 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       nil,
-       nil,
-       (0...6),
-       nil,
-       nil,
-       nil,
-       BlockNode(6...13)(
-         [:a],
-         BlockParametersNode(7...11)(
-           nil,
-           [BlockLocalVariableNode(9...10)(:a)],
-           (7...8),
-           (10...11)
-         ),
-         StatementsNode(11...12)([LocalVariableReadNode(11...12)(:a, 0)]),
-         (6...7),
-         (12...13)
-       ),
-       0,
-       "lambda"
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...6) = "lambda"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (6...13))
+            │   ├── locals: [:a]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (7...11))
+            │   │   ├── parameters: ∅
+            │   │   ├── locals: (length: 1)
+            │   │   │   └── @ BlockLocalVariableNode (location: (9...10))
+            │   │   │       └── name: :a
+            │   │   ├── opening_loc: (7...8) = "|"
+            │   │   └── closing_loc: (10...11) = "|"
+            │   ├── body:
+            │   │   @ StatementsNode (location: (11...12))
+            │   │   └── body: (length: 1)
+            │   │       └── @ LocalVariableReadNode (location: (11...12))
+            │   │           ├── name: :a
+            │   │           └── depth: 0
+            │   ├── opening_loc: (6...7) = "{"
+            │   └── closing_loc: (12...13) = "}"
+            ├── flags: 
+            └── name: "lambda"
diff --git a/test/yarp/snapshots/whitequark/args.txt b/test/yarp/snapshots/whitequark/args.txt
index 7ee971121e..8831aa1aa4 100644
--- a/test/yarp/snapshots/whitequark/args.txt
+++ b/test/yarp/snapshots/whitequark/args.txt
@@ -1,801 +1,960 @@
-ProgramNode(0...690)(
-  [],
-  StatementsNode(0...690)(
-    [DefNode(0...13)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...8)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(6...8)(:b, (7...8), (6...7))
-       ),
-       nil,
-       [:b],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (10...13)
-     ),
-     DefNode(15...33)(
-       :f,
-       (19...20),
-       nil,
-       ParametersNode(22...27)(
-         [RequiredDestructuredParameterNode(22...27)(
-            [RequiredDestructuredParameterNode(23...26)(
-               [RequiredParameterNode(24...25)(:a)],
-               (23...24),
-               (25...26)
-             )],
-            (22...23),
-            (26...27)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (15...18),
-       nil,
-       (21...22),
-       (27...28),
-       nil,
-       (30...33)
-     ),
-     DefNode(35...51)(
-       :f,
-       (39...40),
-       nil,
-       ParametersNode(42...45)(
-         [RequiredDestructuredParameterNode(42...45)(
-            [SplatNode(43...44)((43...44), nil)],
-            (42...43),
-            (44...45)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [],
-       (35...38),
-       nil,
-       (41...42),
-       (45...46),
-       nil,
-       (48...51)
-     ),
-     DefNode(53...72)(
-       :f,
-       (57...58),
-       nil,
-       ParametersNode(60...66)(
-         [RequiredDestructuredParameterNode(60...66)(
-            [SplatNode(61...62)((61...62), nil),
-             RequiredParameterNode(64...65)(:p)],
-            (60...61),
-            (65...66)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:p],
-       (53...56),
-       nil,
-       (59...60),
-       (66...67),
-       nil,
-       (69...72)
-     ),
-     DefNode(74...91)(
-       :f,
-       (78...79),
-       nil,
-       ParametersNode(81...85)(
-         [RequiredDestructuredParameterNode(81...85)(
-            [SplatNode(82...84)(
-               (82...83),
-               RequiredParameterNode(83...84)(:r)
-             )],
-            (81...82),
-            (84...85)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:r],
-       (74...77),
-       nil,
-       (80...81),
-       (85...86),
-       nil,
-       (88...91)
-     ),
-     DefNode(93...113)(
-       :f,
-       (97...98),
-       nil,
-       ParametersNode(100...107)(
-         [RequiredDestructuredParameterNode(100...107)(
-            [SplatNode(101...103)(
-               (101...102),
-               RequiredParameterNode(102...103)(:r)
-             ),
-             RequiredParameterNode(105...106)(:p)],
-            (100...101),
-            (106...107)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:r, :p],
-       (93...96),
-       nil,
-       (99...100),
-       (107...108),
-       nil,
-       (110...113)
-     ),
-     DefNode(115...134)(
-       :f,
-       (119...120),
-       nil,
-       ParametersNode(122...128)(
-         [RequiredDestructuredParameterNode(122...128)(
-            [RequiredParameterNode(123...124)(:a),
-             SplatNode(126...127)((126...127), nil)],
-            (122...123),
-            (127...128)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a],
-       (115...118),
-       nil,
-       (121...122),
-       (128...129),
-       nil,
-       (131...134)
-     ),
-     DefNode(136...158)(
-       :f,
-       (140...141),
-       nil,
-       ParametersNode(143...152)(
-         [RequiredDestructuredParameterNode(143...152)(
-            [RequiredParameterNode(144...145)(:a),
-             SplatNode(147...148)((147...148), nil),
-             RequiredParameterNode(150...151)(:p)],
-            (143...144),
-            (151...152)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :p],
-       (136...139),
-       nil,
-       (142...143),
-       (152...153),
-       nil,
-       (155...158)
-     ),
-     DefNode(160...180)(
-       :f,
-       (164...165),
-       nil,
-       ParametersNode(167...174)(
-         [RequiredDestructuredParameterNode(167...174)(
-            [RequiredParameterNode(168...169)(:a),
-             SplatNode(171...173)(
-               (171...172),
-               RequiredParameterNode(172...173)(:r)
-             )],
-            (167...168),
-            (173...174)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :r],
-       (160...163),
-       nil,
-       (166...167),
-       (174...175),
-       nil,
-       (177...180)
-     ),
-     DefNode(182...205)(
-       :f,
-       (186...187),
-       nil,
-       ParametersNode(189...199)(
-         [RequiredDestructuredParameterNode(189...199)(
-            [RequiredParameterNode(190...191)(:a),
-             SplatNode(193...195)(
-               (193...194),
-               RequiredParameterNode(194...195)(:r)
-             ),
-             RequiredParameterNode(197...198)(:p)],
-            (189...190),
-            (198...199)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :r, :p],
-       (182...185),
-       nil,
-       (188...189),
-       (199...200),
-       nil,
-       (202...205)
-     ),
-     DefNode(207...227)(
-       :f,
-       (211...212),
-       nil,
-       ParametersNode(214...221)(
-         [RequiredDestructuredParameterNode(214...221)(
-            [RequiredParameterNode(215...216)(:a),
-             RequiredParameterNode(218...220)(:a1)],
-            (214...215),
-            (220...221)
-          )],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:a, :a1],
-       (207...210),
-       nil,
-       (213...214),
-       (221...222),
-       nil,
-       (224...227)
-     ),
-     DefNode(229...252)(
-       :f,
-       (233...234),
-       nil,
-       ParametersNode(236...246)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(236...242)(
-            :foo,
-            (236...240),
-            IntegerNode(241...242)()
-          )],
-         nil,
-         BlockParameterNode(244...246)(:b, (245...246), (244...245))
-       ),
-       nil,
-       [:foo, :b],
-       (229...232),
-       nil,
-       (235...236),
-       (246...247),
-       nil,
-       (249...252)
-     ),
-     DefNode(254...292)(
-       :f,
-       (258...259),
-       nil,
-       ParametersNode(261...286)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(261...267)(
-            :foo,
-            (261...265),
-            IntegerNode(266...267)()
-          ),
-          KeywordParameterNode(269...275)(
-            :bar,
-            (269...273),
-            IntegerNode(274...275)()
-          )],
-         KeywordRestParameterNode(277...282)(:baz, (279...282), (277...279)),
-         BlockParameterNode(284...286)(:b, (285...286), (284...285))
-       ),
-       nil,
-       [:foo, :bar, :baz, :b],
-       (254...257),
-       nil,
-       (260...261),
-       (286...287),
-       nil,
-       (289...292)
-     ),
-     DefNode(294...314)(
-       :f,
-       (298...299),
-       nil,
-       ParametersNode(300...309)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(300...305)(:baz, (302...305), (300...302)),
-         BlockParameterNode(307...309)(:b, (308...309), (307...308))
-       ),
-       nil,
-       [:baz, :b],
-       (294...297),
-       nil,
-       nil,
-       nil,
-       nil,
-       (311...314)
-     ),
-     DefNode(316...332)(
-       :f,
-       (320...321),
-       nil,
-       ParametersNode(322...327)(
-         [],
-         [],
-         [],
-         RestParameterNode(322...323)(nil, nil, (322...323)),
-         [],
-         KeywordRestParameterNode(325...327)(nil, nil, (325...327)),
-         nil
-       ),
-       nil,
-       [:*, :**],
-       (316...319),
-       nil,
-       nil,
-       nil,
-       nil,
-       (329...332)
-     ),
-     DefNode(334...351)(
-       :f,
-       (338...339),
-       nil,
-       ParametersNode(340...346)(
-         [],
-         [],
-         [],
-         RestParameterNode(340...342)(:r, (341...342), (340...341)),
-         [],
-         nil,
-         BlockParameterNode(344...346)(:b, (345...346), (344...345))
-       ),
-       nil,
-       [:r, :b],
-       (334...337),
-       nil,
-       nil,
-       nil,
-       nil,
-       (348...351)
-     ),
-     DefNode(353...373)(
-       :f,
-       (357...358),
-       nil,
-       ParametersNode(359...368)(
-         [],
-         [],
-         [RequiredParameterNode(363...364)(:p)],
-         RestParameterNode(359...361)(:r, (360...361), (359...360)),
-         [],
-         nil,
-         BlockParameterNode(366...368)(:b, (367...368), (366...367))
-       ),
-       nil,
-       [:r, :p, :b],
-       (353...356),
-       nil,
-       nil,
-       nil,
-       nil,
-       (370...373)
-     ),
-     DefNode(375...386)(
-       :f,
-       (379...380),
-       nil,
-       nil,
-       nil,
-       [],
-       (375...378),
-       nil,
-       nil,
-       nil,
-       nil,
-       (383...386)
-     ),
-     DefNode(388...404)(
-       :f,
-       (392...393),
-       nil,
-       ParametersNode(394...399)(
-         [RequiredParameterNode(394...395)(:a)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(397...399)(:b, (398...399), (397...398))
-       ),
-       nil,
-       [:a, :b],
-       (388...391),
-       nil,
-       nil,
-       nil,
-       nil,
-       (401...404)
-     ),
-     DefNode(406...426)(
-       :f,
-       (410...411),
-       nil,
-       ParametersNode(412...421)(
-         [RequiredParameterNode(412...413)(:a)],
-         [],
-         [],
-         RestParameterNode(415...417)(:r, (416...417), (415...416)),
-         [],
-         nil,
-         BlockParameterNode(419...421)(:b, (420...421), (419...420))
-       ),
-       nil,
-       [:a, :r, :b],
-       (406...409),
-       nil,
-       nil,
-       nil,
-       nil,
-       (423...426)
-     ),
-     DefNode(428...451)(
-       :f,
-       (432...433),
-       nil,
-       ParametersNode(434...446)(
-         [RequiredParameterNode(434...435)(:a)],
-         [],
-         [RequiredParameterNode(441...442)(:p)],
-         RestParameterNode(437...439)(:r, (438...439), (437...438)),
-         [],
-         nil,
-         BlockParameterNode(444...446)(:b, (445...446), (444...445))
-       ),
-       nil,
-       [:a, :r, :p, :b],
-       (428...431),
-       nil,
-       nil,
-       nil,
-       nil,
-       (448...451)
-     ),
-     DefNode(453...474)(
-       :f,
-       (457...458),
-       nil,
-       ParametersNode(459...469)(
-         [RequiredParameterNode(459...460)(:a)],
-         [OptionalParameterNode(462...465)(
-            :o,
-            (462...463),
-            (463...464),
-            IntegerNode(464...465)()
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(467...469)(:b, (468...469), (467...468))
-       ),
-       nil,
-       [:a, :o, :b],
-       (453...456),
-       nil,
-       nil,
-       nil,
-       nil,
-       (471...474)
-     ),
-     DefNode(476...501)(
-       :f,
-       (480...481),
-       nil,
-       ParametersNode(482...496)(
-         [RequiredParameterNode(482...483)(:a)],
-         [OptionalParameterNode(485...488)(
-            :o,
-            (485...486),
-            (486...487),
-            IntegerNode(487...488)()
-          )],
-         [],
-         RestParameterNode(490...492)(:r, (491...492), (490...491)),
-         [],
-         nil,
-         BlockParameterNode(494...496)(:b, (495...496), (494...495))
-       ),
-       nil,
-       [:a, :o, :r, :b],
-       (476...479),
-       nil,
-       nil,
-       nil,
-       nil,
-       (498...501)
-     ),
-     DefNode(503...531)(
-       :f,
-       (507...508),
-       nil,
-       ParametersNode(509...526)(
-         [RequiredParameterNode(509...510)(:a)],
-         [OptionalParameterNode(512...515)(
-            :o,
-            (512...513),
-            (513...514),
-            IntegerNode(514...515)()
-          )],
-         [RequiredParameterNode(521...522)(:p)],
-         RestParameterNode(517...519)(:r, (518...519), (517...518)),
-         [],
-         nil,
-         BlockParameterNode(524...526)(:b, (525...526), (524...525))
-       ),
-       nil,
-       [:a, :o, :r, :p, :b],
-       (503...506),
-       nil,
-       nil,
-       nil,
-       nil,
-       (528...531)
-     ),
-     DefNode(533...557)(
-       :f,
-       (537...538),
-       nil,
-       ParametersNode(539...552)(
-         [RequiredParameterNode(539...540)(:a)],
-         [OptionalParameterNode(542...545)(
-            :o,
-            (542...543),
-            (543...544),
-            IntegerNode(544...545)()
-          )],
-         [RequiredParameterNode(547...548)(:p)],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(550...552)(:b, (551...552), (550...551))
-       ),
-       nil,
-       [:a, :o, :p, :b],
-       (533...536),
-       nil,
-       nil,
-       nil,
-       nil,
-       (554...557)
-     ),
-     DefNode(559...575)(
-       :f,
-       (563...564),
-       nil,
-       ParametersNode(565...569)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(565...569)(:foo, (565...569), nil)],
-         nil,
-         nil
-       ),
-       nil,
-       [:foo],
-       (559...562),
-       nil,
-       nil,
-       nil,
-       nil,
-       (572...575)
-     ),
-     DefNode(577...596)(
-       :f,
-       (581...582),
-       nil,
-       ParametersNode(583...590)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(583...590)(
-            :foo,
-            (583...587),
-            IntegerNode(588...590)()
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:foo],
-       (577...580),
-       nil,
-       nil,
-       nil,
-       nil,
-       (593...596)
-     ),
-     DefNode(598...616)(
-       :f,
-       (602...603),
-       nil,
-       ParametersNode(604...611)(
-         [],
-         [OptionalParameterNode(604...607)(
-            :o,
-            (604...605),
-            (605...606),
-            IntegerNode(606...607)()
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(609...611)(:b, (610...611), (609...610))
-       ),
-       nil,
-       [:o, :b],
-       (598...601),
-       nil,
-       nil,
-       nil,
-       nil,
-       (613...616)
-     ),
-     DefNode(618...640)(
-       :f,
-       (622...623),
-       nil,
-       ParametersNode(624...635)(
-         [],
-         [OptionalParameterNode(624...627)(
-            :o,
-            (624...625),
-            (625...626),
-            IntegerNode(626...627)()
-          )],
-         [],
-         RestParameterNode(629...631)(:r, (630...631), (629...630)),
-         [],
-         nil,
-         BlockParameterNode(633...635)(:b, (634...635), (633...634))
-       ),
-       nil,
-       [:o, :r, :b],
-       (618...621),
-       nil,
-       nil,
-       nil,
-       nil,
-       (637...640)
-     ),
-     DefNode(642...667)(
-       :f,
-       (646...647),
-       nil,
-       ParametersNode(648...662)(
-         [],
-         [OptionalParameterNode(648...651)(
-            :o,
-            (648...649),
-            (649...650),
-            IntegerNode(650...651)()
-          )],
-         [RequiredParameterNode(657...658)(:p)],
-         RestParameterNode(653...655)(:r, (654...655), (653...654)),
-         [],
-         nil,
-         BlockParameterNode(660...662)(:b, (661...662), (660...661))
-       ),
-       nil,
-       [:o, :r, :p, :b],
-       (642...645),
-       nil,
-       nil,
-       nil,
-       nil,
-       (664...667)
-     ),
-     DefNode(669...690)(
-       :f,
-       (673...674),
-       nil,
-       ParametersNode(675...685)(
-         [],
-         [OptionalParameterNode(675...678)(
-            :o,
-            (675...676),
-            (676...677),
-            IntegerNode(677...678)()
-          )],
-         [RequiredParameterNode(680...681)(:p)],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(683...685)(:b, (684...685), (683...684))
-       ),
-       nil,
-       [:o, :p, :b],
-       (669...672),
-       nil,
-       nil,
-       nil,
-       nil,
-       (687...690)
-     )]
-  )
-)
+@ ProgramNode (location: (0...690))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...690))
+    └── body: (length: 31)
+        ├── @ DefNode (location: (0...13))
+        │   ├── name: :f
+        │   ├── name_loc: (4...5) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (6...8))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (6...8))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (7...8) = "b"
+        │   │       └── operator_loc: (6...7) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (10...13) = "end"
+        ├── @ DefNode (location: (15...33))
+        │   ├── name: :f
+        │   ├── name_loc: (19...20) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (22...27))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (22...27))
+        │   │   │       ├── parameters: (length: 1)
+        │   │   │       │   └── @ RequiredDestructuredParameterNode (location: (23...26))
+        │   │   │       │       ├── parameters: (length: 1)
+        │   │   │       │       │   └── @ RequiredParameterNode (location: (24...25))
+        │   │   │       │       │       └── name: :a
+        │   │   │       │       ├── opening_loc: (23...24) = "("
+        │   │   │       │       └── closing_loc: (25...26) = ")"
+        │   │   │       ├── opening_loc: (22...23) = "("
+        │   │   │       └── closing_loc: (26...27) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (15...18) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (21...22) = "("
+        │   ├── rparen_loc: (27...28) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (30...33) = "end"
+        ├── @ DefNode (location: (35...51))
+        │   ├── name: :f
+        │   ├── name_loc: (39...40) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (42...45))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (42...45))
+        │   │   │       ├── parameters: (length: 1)
+        │   │   │       │   └── @ SplatNode (location: (43...44))
+        │   │   │       │       ├── operator_loc: (43...44) = "*"
+        │   │   │       │       └── expression: ∅
+        │   │   │       ├── opening_loc: (42...43) = "("
+        │   │   │       └── closing_loc: (44...45) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (35...38) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (41...42) = "("
+        │   ├── rparen_loc: (45...46) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (48...51) = "end"
+        ├── @ DefNode (location: (53...72))
+        │   ├── name: :f
+        │   ├── name_loc: (57...58) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (60...66))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (60...66))
+        │   │   │       ├── parameters: (length: 2)
+        │   │   │       │   ├── @ SplatNode (location: (61...62))
+        │   │   │       │   │   ├── operator_loc: (61...62) = "*"
+        │   │   │       │   │   └── expression: ∅
+        │   │   │       │   └── @ RequiredParameterNode (location: (64...65))
+        │   │   │       │       └── name: :p
+        │   │   │       ├── opening_loc: (60...61) = "("
+        │   │   │       └── closing_loc: (65...66) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:p]
+        │   ├── def_keyword_loc: (53...56) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (59...60) = "("
+        │   ├── rparen_loc: (66...67) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (69...72) = "end"
+        ├── @ DefNode (location: (74...91))
+        │   ├── name: :f
+        │   ├── name_loc: (78...79) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (81...85))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (81...85))
+        │   │   │       ├── parameters: (length: 1)
+        │   │   │       │   └── @ SplatNode (location: (82...84))
+        │   │   │       │       ├── operator_loc: (82...83) = "*"
+        │   │   │       │       └── expression:
+        │   │   │       │           @ RequiredParameterNode (location: (83...84))
+        │   │   │       │           └── name: :r
+        │   │   │       ├── opening_loc: (81...82) = "("
+        │   │   │       └── closing_loc: (84...85) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:r]
+        │   ├── def_keyword_loc: (74...77) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (80...81) = "("
+        │   ├── rparen_loc: (85...86) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (88...91) = "end"
+        ├── @ DefNode (location: (93...113))
+        │   ├── name: :f
+        │   ├── name_loc: (97...98) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (100...107))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (100...107))
+        │   │   │       ├── parameters: (length: 2)
+        │   │   │       │   ├── @ SplatNode (location: (101...103))
+        │   │   │       │   │   ├── operator_loc: (101...102) = "*"
+        │   │   │       │   │   └── expression:
+        │   │   │       │   │       @ RequiredParameterNode (location: (102...103))
+        │   │   │       │   │       └── name: :r
+        │   │   │       │   └── @ RequiredParameterNode (location: (105...106))
+        │   │   │       │       └── name: :p
+        │   │   │       ├── opening_loc: (100...101) = "("
+        │   │   │       └── closing_loc: (106...107) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:r, :p]
+        │   ├── def_keyword_loc: (93...96) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (99...100) = "("
+        │   ├── rparen_loc: (107...108) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (110...113) = "end"
+        ├── @ DefNode (location: (115...134))
+        │   ├── name: :f
+        │   ├── name_loc: (119...120) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (122...128))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (122...128))
+        │   │   │       ├── parameters: (length: 2)
+        │   │   │       │   ├── @ RequiredParameterNode (location: (123...124))
+        │   │   │       │   │   └── name: :a
+        │   │   │       │   └── @ SplatNode (location: (126...127))
+        │   │   │       │       ├── operator_loc: (126...127) = "*"
+        │   │   │       │       └── expression: ∅
+        │   │   │       ├── opening_loc: (122...123) = "("
+        │   │   │       └── closing_loc: (127...128) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a]
+        │   ├── def_keyword_loc: (115...118) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (121...122) = "("
+        │   ├── rparen_loc: (128...129) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (131...134) = "end"
+        ├── @ DefNode (location: (136...158))
+        │   ├── name: :f
+        │   ├── name_loc: (140...141) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (143...152))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (143...152))
+        │   │   │       ├── parameters: (length: 3)
+        │   │   │       │   ├── @ RequiredParameterNode (location: (144...145))
+        │   │   │       │   │   └── name: :a
+        │   │   │       │   ├── @ SplatNode (location: (147...148))
+        │   │   │       │   │   ├── operator_loc: (147...148) = "*"
+        │   │   │       │   │   └── expression: ∅
+        │   │   │       │   └── @ RequiredParameterNode (location: (150...151))
+        │   │   │       │       └── name: :p
+        │   │   │       ├── opening_loc: (143...144) = "("
+        │   │   │       └── closing_loc: (151...152) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :p]
+        │   ├── def_keyword_loc: (136...139) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (142...143) = "("
+        │   ├── rparen_loc: (152...153) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (155...158) = "end"
+        ├── @ DefNode (location: (160...180))
+        │   ├── name: :f
+        │   ├── name_loc: (164...165) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (167...174))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (167...174))
+        │   │   │       ├── parameters: (length: 2)
+        │   │   │       │   ├── @ RequiredParameterNode (location: (168...169))
+        │   │   │       │   │   └── name: :a
+        │   │   │       │   └── @ SplatNode (location: (171...173))
+        │   │   │       │       ├── operator_loc: (171...172) = "*"
+        │   │   │       │       └── expression:
+        │   │   │       │           @ RequiredParameterNode (location: (172...173))
+        │   │   │       │           └── name: :r
+        │   │   │       ├── opening_loc: (167...168) = "("
+        │   │   │       └── closing_loc: (173...174) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :r]
+        │   ├── def_keyword_loc: (160...163) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (166...167) = "("
+        │   ├── rparen_loc: (174...175) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (177...180) = "end"
+        ├── @ DefNode (location: (182...205))
+        │   ├── name: :f
+        │   ├── name_loc: (186...187) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (189...199))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (189...199))
+        │   │   │       ├── parameters: (length: 3)
+        │   │   │       │   ├── @ RequiredParameterNode (location: (190...191))
+        │   │   │       │   │   └── name: :a
+        │   │   │       │   ├── @ SplatNode (location: (193...195))
+        │   │   │       │   │   ├── operator_loc: (193...194) = "*"
+        │   │   │       │   │   └── expression:
+        │   │   │       │   │       @ RequiredParameterNode (location: (194...195))
+        │   │   │       │   │       └── name: :r
+        │   │   │       │   └── @ RequiredParameterNode (location: (197...198))
+        │   │   │       │       └── name: :p
+        │   │   │       ├── opening_loc: (189...190) = "("
+        │   │   │       └── closing_loc: (198...199) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :r, :p]
+        │   ├── def_keyword_loc: (182...185) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (188...189) = "("
+        │   ├── rparen_loc: (199...200) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (202...205) = "end"
+        ├── @ DefNode (location: (207...227))
+        │   ├── name: :f
+        │   ├── name_loc: (211...212) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (214...221))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredDestructuredParameterNode (location: (214...221))
+        │   │   │       ├── parameters: (length: 2)
+        │   │   │       │   ├── @ RequiredParameterNode (location: (215...216))
+        │   │   │       │   │   └── name: :a
+        │   │   │       │   └── @ RequiredParameterNode (location: (218...220))
+        │   │   │       │       └── name: :a1
+        │   │   │       ├── opening_loc: (214...215) = "("
+        │   │   │       └── closing_loc: (220...221) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :a1]
+        │   ├── def_keyword_loc: (207...210) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (213...214) = "("
+        │   ├── rparen_loc: (221...222) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (224...227) = "end"
+        ├── @ DefNode (location: (229...252))
+        │   ├── name: :f
+        │   ├── name_loc: (233...234) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (236...246))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (236...242))
+        │   │   │       ├── name: :foo
+        │   │   │       ├── name_loc: (236...240) = "foo:"
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (241...242))
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (244...246))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (245...246) = "b"
+        │   │       └── operator_loc: (244...245) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:foo, :b]
+        │   ├── def_keyword_loc: (229...232) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (235...236) = "("
+        │   ├── rparen_loc: (246...247) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (249...252) = "end"
+        ├── @ DefNode (location: (254...292))
+        │   ├── name: :f
+        │   ├── name_loc: (258...259) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (261...286))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 2)
+        │   │   │   ├── @ KeywordParameterNode (location: (261...267))
+        │   │   │   │   ├── name: :foo
+        │   │   │   │   ├── name_loc: (261...265) = "foo:"
+        │   │   │   │   └── value:
+        │   │   │   │       @ IntegerNode (location: (266...267))
+        │   │   │   └── @ KeywordParameterNode (location: (269...275))
+        │   │   │       ├── name: :bar
+        │   │   │       ├── name_loc: (269...273) = "bar:"
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (274...275))
+        │   │   ├── keyword_rest:
+        │   │   │   @ KeywordRestParameterNode (location: (277...282))
+        │   │   │   ├── name: :baz
+        │   │   │   ├── name_loc: (279...282) = "baz"
+        │   │   │   └── operator_loc: (277...279) = "**"
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (284...286))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (285...286) = "b"
+        │   │       └── operator_loc: (284...285) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:foo, :bar, :baz, :b]
+        │   ├── def_keyword_loc: (254...257) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (260...261) = "("
+        │   ├── rparen_loc: (286...287) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (289...292) = "end"
+        ├── @ DefNode (location: (294...314))
+        │   ├── name: :f
+        │   ├── name_loc: (298...299) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (300...309))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ KeywordRestParameterNode (location: (300...305))
+        │   │   │   ├── name: :baz
+        │   │   │   ├── name_loc: (302...305) = "baz"
+        │   │   │   └── operator_loc: (300...302) = "**"
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (307...309))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (308...309) = "b"
+        │   │       └── operator_loc: (307...308) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:baz, :b]
+        │   ├── def_keyword_loc: (294...297) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (311...314) = "end"
+        ├── @ DefNode (location: (316...332))
+        │   ├── name: :f
+        │   ├── name_loc: (320...321) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (322...327))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (322...323))
+        │   │   │   ├── name: nil
+        │   │   │   ├── name_loc: ∅
+        │   │   │   └── operator_loc: (322...323) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ KeywordRestParameterNode (location: (325...327))
+        │   │   │   ├── name: nil
+        │   │   │   ├── name_loc: ∅
+        │   │   │   └── operator_loc: (325...327) = "**"
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:*, :**]
+        │   ├── def_keyword_loc: (316...319) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (329...332) = "end"
+        ├── @ DefNode (location: (334...351))
+        │   ├── name: :f
+        │   ├── name_loc: (338...339) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (340...346))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (340...342))
+        │   │   │   ├── name: :r
+        │   │   │   ├── name_loc: (341...342) = "r"
+        │   │   │   └── operator_loc: (340...341) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (344...346))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (345...346) = "b"
+        │   │       └── operator_loc: (344...345) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:r, :b]
+        │   ├── def_keyword_loc: (334...337) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (348...351) = "end"
+        ├── @ DefNode (location: (353...373))
+        │   ├── name: :f
+        │   ├── name_loc: (357...358) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (359...368))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (363...364))
+        │   │   │       └── name: :p
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (359...361))
+        │   │   │   ├── name: :r
+        │   │   │   ├── name_loc: (360...361) = "r"
+        │   │   │   └── operator_loc: (359...360) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (366...368))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (367...368) = "b"
+        │   │       └── operator_loc: (366...367) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:r, :p, :b]
+        │   ├── def_keyword_loc: (353...356) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (370...373) = "end"
+        ├── @ DefNode (location: (375...386))
+        │   ├── name: :f
+        │   ├── name_loc: (379...380) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (375...378) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (383...386) = "end"
+        ├── @ DefNode (location: (388...404))
+        │   ├── name: :f
+        │   ├── name_loc: (392...393) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (394...399))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (394...395))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (397...399))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (398...399) = "b"
+        │   │       └── operator_loc: (397...398) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:a, :b]
+        │   ├── def_keyword_loc: (388...391) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (401...404) = "end"
+        ├── @ DefNode (location: (406...426))
+        │   ├── name: :f
+        │   ├── name_loc: (410...411) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (412...421))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (412...413))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (415...417))
+        │   │   │   ├── name: :r
+        │   │   │   ├── name_loc: (416...417) = "r"
+        │   │   │   └── operator_loc: (415...416) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (419...421))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (420...421) = "b"
+        │   │       └── operator_loc: (419...420) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:a, :r, :b]
+        │   ├── def_keyword_loc: (406...409) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (423...426) = "end"
+        ├── @ DefNode (location: (428...451))
+        │   ├── name: :f
+        │   ├── name_loc: (432...433) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (434...446))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (434...435))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (441...442))
+        │   │   │       └── name: :p
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (437...439))
+        │   │   │   ├── name: :r
+        │   │   │   ├── name_loc: (438...439) = "r"
+        │   │   │   └── operator_loc: (437...438) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (444...446))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (445...446) = "b"
+        │   │       └── operator_loc: (444...445) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:a, :r, :p, :b]
+        │   ├── def_keyword_loc: (428...431) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (448...451) = "end"
+        ├── @ DefNode (location: (453...474))
+        │   ├── name: :f
+        │   ├── name_loc: (457...458) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (459...469))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (459...460))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (462...465))
+        │   │   │       ├── name: :o
+        │   │   │       ├── name_loc: (462...463) = "o"
+        │   │   │       ├── operator_loc: (463...464) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (464...465))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (467...469))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (468...469) = "b"
+        │   │       └── operator_loc: (467...468) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:a, :o, :b]
+        │   ├── def_keyword_loc: (453...456) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (471...474) = "end"
+        ├── @ DefNode (location: (476...501))
+        │   ├── name: :f
+        │   ├── name_loc: (480...481) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (482...496))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (482...483))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (485...488))
+        │   │   │       ├── name: :o
+        │   │   │       ├── name_loc: (485...486) = "o"
+        │   │   │       ├── operator_loc: (486...487) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (487...488))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (490...492))
+        │   │   │   ├── name: :r
+        │   │   │   ├── name_loc: (491...492) = "r"
+        │   │   │   └── operator_loc: (490...491) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (494...496))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (495...496) = "b"
+        │   │       └── operator_loc: (494...495) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:a, :o, :r, :b]
+        │   ├── def_keyword_loc: (476...479) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (498...501) = "end"
+        ├── @ DefNode (location: (503...531))
+        │   ├── name: :f
+        │   ├── name_loc: (507...508) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (509...526))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (509...510))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (512...515))
+        │   │   │       ├── name: :o
+        │   │   │       ├── name_loc: (512...513) = "o"
+        │   │   │       ├── operator_loc: (513...514) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (514...515))
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (521...522))
+        │   │   │       └── name: :p
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (517...519))
+        │   │   │   ├── name: :r
+        │   │   │   ├── name_loc: (518...519) = "r"
+        │   │   │   └── operator_loc: (517...518) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (524...526))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (525...526) = "b"
+        │   │       └── operator_loc: (524...525) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:a, :o, :r, :p, :b]
+        │   ├── def_keyword_loc: (503...506) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (528...531) = "end"
+        ├── @ DefNode (location: (533...557))
+        │   ├── name: :f
+        │   ├── name_loc: (537...538) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (539...552))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (539...540))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (542...545))
+        │   │   │       ├── name: :o
+        │   │   │       ├── name_loc: (542...543) = "o"
+        │   │   │       ├── operator_loc: (543...544) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (544...545))
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (547...548))
+        │   │   │       └── name: :p
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (550...552))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (551...552) = "b"
+        │   │       └── operator_loc: (550...551) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:a, :o, :p, :b]
+        │   ├── def_keyword_loc: (533...536) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (554...557) = "end"
+        ├── @ DefNode (location: (559...575))
+        │   ├── name: :f
+        │   ├── name_loc: (563...564) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (565...569))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (565...569))
+        │   │   │       ├── name: :foo
+        │   │   │       ├── name_loc: (565...569) = "foo:"
+        │   │   │       └── value: ∅
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:foo]
+        │   ├── def_keyword_loc: (559...562) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (572...575) = "end"
+        ├── @ DefNode (location: (577...596))
+        │   ├── name: :f
+        │   ├── name_loc: (581...582) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (583...590))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (583...590))
+        │   │   │       ├── name: :foo
+        │   │   │       ├── name_loc: (583...587) = "foo:"
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (588...590))
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:foo]
+        │   ├── def_keyword_loc: (577...580) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (593...596) = "end"
+        ├── @ DefNode (location: (598...616))
+        │   ├── name: :f
+        │   ├── name_loc: (602...603) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (604...611))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (604...607))
+        │   │   │       ├── name: :o
+        │   │   │       ├── name_loc: (604...605) = "o"
+        │   │   │       ├── operator_loc: (605...606) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (606...607))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (609...611))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (610...611) = "b"
+        │   │       └── operator_loc: (609...610) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:o, :b]
+        │   ├── def_keyword_loc: (598...601) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (613...616) = "end"
+        ├── @ DefNode (location: (618...640))
+        │   ├── name: :f
+        │   ├── name_loc: (622...623) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (624...635))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (624...627))
+        │   │   │       ├── name: :o
+        │   │   │       ├── name_loc: (624...625) = "o"
+        │   │   │       ├── operator_loc: (625...626) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (626...627))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (629...631))
+        │   │   │   ├── name: :r
+        │   │   │   ├── name_loc: (630...631) = "r"
+        │   │   │   └── operator_loc: (629...630) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (633...635))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (634...635) = "b"
+        │   │       └── operator_loc: (633...634) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:o, :r, :b]
+        │   ├── def_keyword_loc: (618...621) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (637...640) = "end"
+        ├── @ DefNode (location: (642...667))
+        │   ├── name: :f
+        │   ├── name_loc: (646...647) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (648...662))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (648...651))
+        │   │   │       ├── name: :o
+        │   │   │       ├── name_loc: (648...649) = "o"
+        │   │   │       ├── operator_loc: (649...650) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (650...651))
+        │   │   ├── posts: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (657...658))
+        │   │   │       └── name: :p
+        │   │   ├── rest:
+        │   │   │   @ RestParameterNode (location: (653...655))
+        │   │   │   ├── name: :r
+        │   │   │   ├── name_loc: (654...655) = "r"
+        │   │   │   └── operator_loc: (653...654) = "*"
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (660...662))
+        │   │       ├── name: :b
+        │   │       ├── name_loc: (661...662) = "b"
+        │   │       └── operator_loc: (660...661) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:o, :r, :p, :b]
+        │   ├── def_keyword_loc: (642...645) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (664...667) = "end"
+        └── @ DefNode (location: (669...690))
+            ├── name: :f
+            ├── name_loc: (673...674) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (675...685))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 1)
+            │   │   └── @ OptionalParameterNode (location: (675...678))
+            │   │       ├── name: :o
+            │   │       ├── name_loc: (675...676) = "o"
+            │   │       ├── operator_loc: (676...677) = "="
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (677...678))
+            │   ├── posts: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (680...681))
+            │   │       └── name: :p
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block:
+            │       @ BlockParameterNode (location: (683...685))
+            │       ├── name: :b
+            │       ├── name_loc: (684...685) = "b"
+            │       └── operator_loc: (683...684) = "&"
+            ├── body: ∅
+            ├── locals: [:o, :p, :b]
+            ├── def_keyword_loc: (669...672) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (687...690) = "end"
diff --git a/test/yarp/snapshots/whitequark/args_args_assocs.txt b/test/yarp/snapshots/whitequark/args_args_assocs.txt
index 5363d6780d..e427c74349 100644
--- a/test/yarp/snapshots/whitequark/args_args_assocs.txt
+++ b/test/yarp/snapshots/whitequark/args_args_assocs.txt
@@ -1,59 +1,86 @@
-ProgramNode(0...46)(
-  [],
-  StatementsNode(0...46)(
-    [CallNode(0...19)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...18)(
-         [CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "foo"),
-          KeywordHashNode(9...18)(
-            [AssocNode(9...18)(
-               SymbolNode(9...13)((9...10), (10...13), nil, "foo"),
-               IntegerNode(17...18)(),
-               (14...16)
-             )]
-          )]
-       ),
-       (18...19),
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(21...46)(
-       nil,
-       nil,
-       (21...24),
-       (24...25),
-       ArgumentsNode(25...45)(
-         [CallNode(25...28)(nil, nil, (25...28), nil, nil, nil, nil, 2, "foo"),
-          KeywordHashNode(30...39)(
-            [AssocNode(30...39)(
-               SymbolNode(30...34)((30...31), (31...34), nil, "foo"),
-               IntegerNode(38...39)(),
-               (35...37)
-             )]
-          ),
-          BlockArgumentNode(41...45)(
-            CallNode(42...45)(
-              nil,
-              nil,
-              (42...45),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            ),
-            (41...42)
-          )]
-       ),
-       (45...46),
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...46))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...46))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...19))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "fun"
+        │   ├── opening_loc: (3...4) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...18))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (4...7))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (4...7) = "foo"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "foo"
+        │   │       └── @ KeywordHashNode (location: (9...18))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (9...18))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (9...13))
+        │   │                   │   ├── opening_loc: (9...10) = ":"
+        │   │                   │   ├── value_loc: (10...13) = "foo"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "foo"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (17...18))
+        │   │                   └── operator_loc: (14...16) = "=>"
+        │   ├── closing_loc: (18...19) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        └── @ CallNode (location: (21...46))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (21...24) = "fun"
+            ├── opening_loc: (24...25) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (25...45))
+            │   └── arguments: (length: 3)
+            │       ├── @ CallNode (location: (25...28))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (25...28) = "foo"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "foo"
+            │       ├── @ KeywordHashNode (location: (30...39))
+            │       │   └── elements: (length: 1)
+            │       │       └── @ AssocNode (location: (30...39))
+            │       │           ├── key:
+            │       │           │   @ SymbolNode (location: (30...34))
+            │       │           │   ├── opening_loc: (30...31) = ":"
+            │       │           │   ├── value_loc: (31...34) = "foo"
+            │       │           │   ├── closing_loc: ∅
+            │       │           │   └── unescaped: "foo"
+            │       │           ├── value:
+            │       │           │   @ IntegerNode (location: (38...39))
+            │       │           └── operator_loc: (35...37) = "=>"
+            │       └── @ BlockArgumentNode (location: (41...45))
+            │           ├── expression:
+            │           │   @ CallNode (location: (42...45))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (42...45) = "baz"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "baz"
+            │           └── operator_loc: (41...42) = "&"
+            ├── closing_loc: (45...46) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/args_args_assocs_comma.txt b/test/yarp/snapshots/whitequark/args_args_assocs_comma.txt
index da9ea1bd81..d2b40b95a3 100644
--- a/test/yarp/snapshots/whitequark/args_args_assocs_comma.txt
+++ b/test/yarp/snapshots/whitequark/args_args_assocs_comma.txt
@@ -1,25 +1,49 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [CallNode(0...20)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...20),
-       (3...4),
-       ArgumentsNode(4...18)(
-         [CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "bar"),
-          KeywordHashNode(9...18)(
-            [AssocNode(9...18)(
-               SymbolNode(9...13)((9...10), (10...13), nil, "baz"),
-               IntegerNode(17...18)(),
-               (14...16)
-             )]
-          )]
-       ),
-       (19...20),
-       nil,
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...20))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...20) = "[bar, :baz => 1,]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...18))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (4...7))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (4...7) = "bar"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "bar"
+            │       └── @ KeywordHashNode (location: (9...18))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (9...18))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (9...13))
+            │                   │   ├── opening_loc: (9...10) = ":"
+            │                   │   ├── value_loc: (10...13) = "baz"
+            │                   │   ├── closing_loc: ∅
+            │                   │   └── unescaped: "baz"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (17...18))
+            │                   └── operator_loc: (14...16) = "=>"
+            ├── closing_loc: (19...20) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/whitequark/args_args_comma.txt b/test/yarp/snapshots/whitequark/args_args_comma.txt
index a6014eebc4..ab35f83c9f 100644
--- a/test/yarp/snapshots/whitequark/args_args_comma.txt
+++ b/test/yarp/snapshots/whitequark/args_args_comma.txt
@@ -1,18 +1,37 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...9),
-       (3...4),
-       ArgumentsNode(4...7)(
-         [CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "bar")]
-       ),
-       (8...9),
-       nil,
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...9) = "[bar,]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...7))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (4...7))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (4...7) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── closing_loc: (8...9) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/whitequark/args_args_star.txt b/test/yarp/snapshots/whitequark/args_args_star.txt
index ed007cfa5a..45abbfb674 100644
--- a/test/yarp/snapshots/whitequark/args_args_star.txt
+++ b/test/yarp/snapshots/whitequark/args_args_star.txt
@@ -1,73 +1,88 @@
-ProgramNode(0...36)(
-  [],
-  StatementsNode(0...36)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...13)(
-         [CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "foo"),
-          SplatNode(9...13)(
-            (9...10),
-            CallNode(10...13)(
-              nil,
-              nil,
-              (10...13),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )
-          )]
-       ),
-       (13...14),
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(16...36)(
-       nil,
-       nil,
-       (16...19),
-       (19...20),
-       ArgumentsNode(20...35)(
-         [CallNode(20...23)(nil, nil, (20...23), nil, nil, nil, nil, 2, "foo"),
-          SplatNode(25...29)(
-            (25...26),
-            CallNode(26...29)(
-              nil,
-              nil,
-              (26...29),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )
-          ),
-          BlockArgumentNode(31...35)(
-            CallNode(32...35)(
-              nil,
-              nil,
-              (32...35),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            ),
-            (31...32)
-          )]
-       ),
-       (35...36),
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...36))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...36))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...14))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "fun"
+        │   ├── opening_loc: (3...4) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...13))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (4...7))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (4...7) = "foo"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "foo"
+        │   │       └── @ SplatNode (location: (9...13))
+        │   │           ├── operator_loc: (9...10) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (10...13))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (10...13) = "bar"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "bar"
+        │   ├── closing_loc: (13...14) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        └── @ CallNode (location: (16...36))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (16...19) = "fun"
+            ├── opening_loc: (19...20) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (20...35))
+            │   └── arguments: (length: 3)
+            │       ├── @ CallNode (location: (20...23))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (20...23) = "foo"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "foo"
+            │       ├── @ SplatNode (location: (25...29))
+            │       │   ├── operator_loc: (25...26) = "*"
+            │       │   └── expression:
+            │       │       @ CallNode (location: (26...29))
+            │       │       ├── receiver: ∅
+            │       │       ├── call_operator_loc: ∅
+            │       │       ├── message_loc: (26...29) = "bar"
+            │       │       ├── opening_loc: ∅
+            │       │       ├── arguments: ∅
+            │       │       ├── closing_loc: ∅
+            │       │       ├── block: ∅
+            │       │       ├── flags: variable_call
+            │       │       └── name: "bar"
+            │       └── @ BlockArgumentNode (location: (31...35))
+            │           ├── expression:
+            │           │   @ CallNode (location: (32...35))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (32...35) = "baz"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "baz"
+            │           └── operator_loc: (31...32) = "&"
+            ├── closing_loc: (35...36) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/args_assocs.txt b/test/yarp/snapshots/whitequark/args_assocs.txt
index 8fa24ab479..17a7dfb89e 100644
--- a/test/yarp/snapshots/whitequark/args_assocs.txt
+++ b/test/yarp/snapshots/whitequark/args_assocs.txt
@@ -1,125 +1,165 @@
-ProgramNode(0...114)(
-  [],
-  StatementsNode(0...114)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...13)(
-         [KeywordHashNode(4...13)(
-            [AssocNode(4...13)(
-               SymbolNode(4...8)((4...5), (5...8), nil, "foo"),
-               IntegerNode(12...13)(),
-               (9...11)
-             )]
-          )]
-       ),
-       (13...14),
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(16...36)(
-       nil,
-       nil,
-       (16...19),
-       (19...20),
-       ArgumentsNode(20...35)(
-         [KeywordHashNode(20...29)(
-            [AssocNode(20...29)(
-               SymbolNode(20...24)((20...21), (21...24), nil, "foo"),
-               IntegerNode(28...29)(),
-               (25...27)
-             )]
-          ),
-          BlockArgumentNode(31...35)(
-            CallNode(32...35)(
-              nil,
-              nil,
-              (32...35),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            ),
-            (31...32)
-          )]
-       ),
-       (35...36),
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(38...59)(
-       SelfNode(38...42)(),
-       (42...43),
-       (43...46),
-       nil,
-       ArgumentsNode(47...59)(
-         [CallNode(47...50)(nil, nil, (47...50), nil, nil, nil, nil, 2, "foo"),
-          KeywordHashNode(52...59)(
-            [AssocNode(52...59)(
-               SymbolNode(52...54)((52...53), (53...54), nil, "a"),
-               IntegerNode(58...59)(),
-               (55...57)
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(61...76)(
-       SelfNode(61...65)(),
-       nil,
-       (65...76),
-       (65...66),
-       ArgumentsNode(66...75)(
-         [KeywordHashNode(66...75)(
-            [AssocNode(66...75)(
-               SymbolNode(66...70)((66...67), (67...70), nil, "bar"),
-               IntegerNode(74...75)(),
-               (71...73)
-             )]
-          )]
-       ),
-       (75...76),
-       nil,
-       0,
-       "[]"
-     ),
-     SuperNode(78...95)(
-       (78...83),
-       (83...84),
-       ArgumentsNode(84...94)(
-         [KeywordHashNode(84...94)(
-            [AssocNode(84...94)(
-               SymbolNode(84...88)((84...85), (85...88), nil, "foo"),
-               IntegerNode(92...94)(),
-               (89...91)
-             )]
-          )]
-       ),
-       (94...95),
-       nil
-     ),
-     YieldNode(97...114)(
-       (97...102),
-       (102...103),
-       ArgumentsNode(103...113)(
-         [KeywordHashNode(103...113)(
-            [AssocNode(103...113)(
-               SymbolNode(103...107)((103...104), (104...107), nil, "foo"),
-               IntegerNode(111...113)(),
-               (108...110)
-             )]
-          )]
-       ),
-       (113...114)
-     )]
-  )
-)
+@ ProgramNode (location: (0...114))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...114))
+    └── body: (length: 6)
+        ├── @ CallNode (location: (0...14))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "fun"
+        │   ├── opening_loc: (3...4) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...13))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (4...13))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (4...13))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (4...8))
+        │   │                   │   ├── opening_loc: (4...5) = ":"
+        │   │                   │   ├── value_loc: (5...8) = "foo"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "foo"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (12...13))
+        │   │                   └── operator_loc: (9...11) = "=>"
+        │   ├── closing_loc: (13...14) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (16...36))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (16...19) = "fun"
+        │   ├── opening_loc: (19...20) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (20...35))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ KeywordHashNode (location: (20...29))
+        │   │       │   └── elements: (length: 1)
+        │   │       │       └── @ AssocNode (location: (20...29))
+        │   │       │           ├── key:
+        │   │       │           │   @ SymbolNode (location: (20...24))
+        │   │       │           │   ├── opening_loc: (20...21) = ":"
+        │   │       │           │   ├── value_loc: (21...24) = "foo"
+        │   │       │           │   ├── closing_loc: ∅
+        │   │       │           │   └── unescaped: "foo"
+        │   │       │           ├── value:
+        │   │       │           │   @ IntegerNode (location: (28...29))
+        │   │       │           └── operator_loc: (25...27) = "=>"
+        │   │       └── @ BlockArgumentNode (location: (31...35))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (32...35))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (32...35) = "baz"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "baz"
+        │   │           └── operator_loc: (31...32) = "&"
+        │   ├── closing_loc: (35...36) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (38...59))
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (38...42))
+        │   ├── call_operator_loc: (42...43) = "."
+        │   ├── message_loc: (43...46) = "[]="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (47...59))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (47...50))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (47...50) = "foo"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "foo"
+        │   │       └── @ KeywordHashNode (location: (52...59))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (52...59))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (52...54))
+        │   │                   │   ├── opening_loc: (52...53) = ":"
+        │   │                   │   ├── value_loc: (53...54) = "a"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "a"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (58...59))
+        │   │                   └── operator_loc: (55...57) = "=>"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (61...76))
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (61...65))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (65...76) = "[:bar => 1]"
+        │   ├── opening_loc: (65...66) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (66...75))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (66...75))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (66...75))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (66...70))
+        │   │                   │   ├── opening_loc: (66...67) = ":"
+        │   │                   │   ├── value_loc: (67...70) = "bar"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "bar"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (74...75))
+        │   │                   └── operator_loc: (71...73) = "=>"
+        │   ├── closing_loc: (75...76) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ SuperNode (location: (78...95))
+        │   ├── keyword_loc: (78...83) = "super"
+        │   ├── lparen_loc: (83...84) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (84...94))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (84...94))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (84...94))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (84...88))
+        │   │                   │   ├── opening_loc: (84...85) = ":"
+        │   │                   │   ├── value_loc: (85...88) = "foo"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "foo"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (92...94))
+        │   │                   └── operator_loc: (89...91) = "=>"
+        │   ├── rparen_loc: (94...95) = ")"
+        │   └── block: ∅
+        └── @ YieldNode (location: (97...114))
+            ├── keyword_loc: (97...102) = "yield"
+            ├── lparen_loc: (102...103) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (103...113))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (103...113))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (103...113))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (103...107))
+            │                   │   ├── opening_loc: (103...104) = ":"
+            │                   │   ├── value_loc: (104...107) = "foo"
+            │                   │   ├── closing_loc: ∅
+            │                   │   └── unescaped: "foo"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (111...113))
+            │                   └── operator_loc: (108...110) = "=>"
+            └── rparen_loc: (113...114) = ")"
diff --git a/test/yarp/snapshots/whitequark/args_assocs_comma.txt b/test/yarp/snapshots/whitequark/args_assocs_comma.txt
index 97de8d44ef..e57cce8ed3 100644
--- a/test/yarp/snapshots/whitequark/args_assocs_comma.txt
+++ b/test/yarp/snapshots/whitequark/args_assocs_comma.txt
@@ -1,24 +1,39 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...15)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...15),
-       (3...4),
-       ArgumentsNode(4...13)(
-         [KeywordHashNode(4...13)(
-            [AssocNode(4...13)(
-               SymbolNode(4...8)((4...5), (5...8), nil, "baz"),
-               IntegerNode(12...13)(),
-               (9...11)
-             )]
-          )]
-       ),
-       (14...15),
-       nil,
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...15))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...15) = "[:baz => 1,]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...13))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (4...13))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (4...13))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (4...8))
+            │                   │   ├── opening_loc: (4...5) = ":"
+            │                   │   ├── value_loc: (5...8) = "baz"
+            │                   │   ├── closing_loc: ∅
+            │                   │   └── unescaped: "baz"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (12...13))
+            │                   └── operator_loc: (9...11) = "=>"
+            ├── closing_loc: (14...15) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/whitequark/args_assocs_legacy.txt b/test/yarp/snapshots/whitequark/args_assocs_legacy.txt
index 8fa24ab479..17a7dfb89e 100644
--- a/test/yarp/snapshots/whitequark/args_assocs_legacy.txt
+++ b/test/yarp/snapshots/whitequark/args_assocs_legacy.txt
@@ -1,125 +1,165 @@
-ProgramNode(0...114)(
-  [],
-  StatementsNode(0...114)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...13)(
-         [KeywordHashNode(4...13)(
-            [AssocNode(4...13)(
-               SymbolNode(4...8)((4...5), (5...8), nil, "foo"),
-               IntegerNode(12...13)(),
-               (9...11)
-             )]
-          )]
-       ),
-       (13...14),
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(16...36)(
-       nil,
-       nil,
-       (16...19),
-       (19...20),
-       ArgumentsNode(20...35)(
-         [KeywordHashNode(20...29)(
-            [AssocNode(20...29)(
-               SymbolNode(20...24)((20...21), (21...24), nil, "foo"),
-               IntegerNode(28...29)(),
-               (25...27)
-             )]
-          ),
-          BlockArgumentNode(31...35)(
-            CallNode(32...35)(
-              nil,
-              nil,
-              (32...35),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            ),
-            (31...32)
-          )]
-       ),
-       (35...36),
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(38...59)(
-       SelfNode(38...42)(),
-       (42...43),
-       (43...46),
-       nil,
-       ArgumentsNode(47...59)(
-         [CallNode(47...50)(nil, nil, (47...50), nil, nil, nil, nil, 2, "foo"),
-          KeywordHashNode(52...59)(
-            [AssocNode(52...59)(
-               SymbolNode(52...54)((52...53), (53...54), nil, "a"),
-               IntegerNode(58...59)(),
-               (55...57)
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "[]="
-     ),
-     CallNode(61...76)(
-       SelfNode(61...65)(),
-       nil,
-       (65...76),
-       (65...66),
-       ArgumentsNode(66...75)(
-         [KeywordHashNode(66...75)(
-            [AssocNode(66...75)(
-               SymbolNode(66...70)((66...67), (67...70), nil, "bar"),
-               IntegerNode(74...75)(),
-               (71...73)
-             )]
-          )]
-       ),
-       (75...76),
-       nil,
-       0,
-       "[]"
-     ),
-     SuperNode(78...95)(
-       (78...83),
-       (83...84),
-       ArgumentsNode(84...94)(
-         [KeywordHashNode(84...94)(
-            [AssocNode(84...94)(
-               SymbolNode(84...88)((84...85), (85...88), nil, "foo"),
-               IntegerNode(92...94)(),
-               (89...91)
-             )]
-          )]
-       ),
-       (94...95),
-       nil
-     ),
-     YieldNode(97...114)(
-       (97...102),
-       (102...103),
-       ArgumentsNode(103...113)(
-         [KeywordHashNode(103...113)(
-            [AssocNode(103...113)(
-               SymbolNode(103...107)((103...104), (104...107), nil, "foo"),
-               IntegerNode(111...113)(),
-               (108...110)
-             )]
-          )]
-       ),
-       (113...114)
-     )]
-  )
-)
+@ ProgramNode (location: (0...114))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...114))
+    └── body: (length: 6)
+        ├── @ CallNode (location: (0...14))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "fun"
+        │   ├── opening_loc: (3...4) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...13))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (4...13))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (4...13))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (4...8))
+        │   │                   │   ├── opening_loc: (4...5) = ":"
+        │   │                   │   ├── value_loc: (5...8) = "foo"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "foo"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (12...13))
+        │   │                   └── operator_loc: (9...11) = "=>"
+        │   ├── closing_loc: (13...14) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (16...36))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (16...19) = "fun"
+        │   ├── opening_loc: (19...20) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (20...35))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ KeywordHashNode (location: (20...29))
+        │   │       │   └── elements: (length: 1)
+        │   │       │       └── @ AssocNode (location: (20...29))
+        │   │       │           ├── key:
+        │   │       │           │   @ SymbolNode (location: (20...24))
+        │   │       │           │   ├── opening_loc: (20...21) = ":"
+        │   │       │           │   ├── value_loc: (21...24) = "foo"
+        │   │       │           │   ├── closing_loc: ∅
+        │   │       │           │   └── unescaped: "foo"
+        │   │       │           ├── value:
+        │   │       │           │   @ IntegerNode (location: (28...29))
+        │   │       │           └── operator_loc: (25...27) = "=>"
+        │   │       └── @ BlockArgumentNode (location: (31...35))
+        │   │           ├── expression:
+        │   │           │   @ CallNode (location: (32...35))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (32...35) = "baz"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "baz"
+        │   │           └── operator_loc: (31...32) = "&"
+        │   ├── closing_loc: (35...36) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (38...59))
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (38...42))
+        │   ├── call_operator_loc: (42...43) = "."
+        │   ├── message_loc: (43...46) = "[]="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (47...59))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (47...50))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (47...50) = "foo"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: variable_call
+        │   │       │   └── name: "foo"
+        │   │       └── @ KeywordHashNode (location: (52...59))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (52...59))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (52...54))
+        │   │                   │   ├── opening_loc: (52...53) = ":"
+        │   │                   │   ├── value_loc: (53...54) = "a"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "a"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (58...59))
+        │   │                   └── operator_loc: (55...57) = "=>"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]="
+        ├── @ CallNode (location: (61...76))
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (61...65))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (65...76) = "[:bar => 1]"
+        │   ├── opening_loc: (65...66) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (66...75))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (66...75))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (66...75))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (66...70))
+        │   │                   │   ├── opening_loc: (66...67) = ":"
+        │   │                   │   ├── value_loc: (67...70) = "bar"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "bar"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (74...75))
+        │   │                   └── operator_loc: (71...73) = "=>"
+        │   ├── closing_loc: (75...76) = "]"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "[]"
+        ├── @ SuperNode (location: (78...95))
+        │   ├── keyword_loc: (78...83) = "super"
+        │   ├── lparen_loc: (83...84) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (84...94))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (84...94))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (84...94))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (84...88))
+        │   │                   │   ├── opening_loc: (84...85) = ":"
+        │   │                   │   ├── value_loc: (85...88) = "foo"
+        │   │                   │   ├── closing_loc: ∅
+        │   │                   │   └── unescaped: "foo"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (92...94))
+        │   │                   └── operator_loc: (89...91) = "=>"
+        │   ├── rparen_loc: (94...95) = ")"
+        │   └── block: ∅
+        └── @ YieldNode (location: (97...114))
+            ├── keyword_loc: (97...102) = "yield"
+            ├── lparen_loc: (102...103) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (103...113))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (103...113))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (103...113))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (103...107))
+            │                   │   ├── opening_loc: (103...104) = ":"
+            │                   │   ├── value_loc: (104...107) = "foo"
+            │                   │   ├── closing_loc: ∅
+            │                   │   └── unescaped: "foo"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (111...113))
+            │                   └── operator_loc: (108...110) = "=>"
+            └── rparen_loc: (113...114) = ")"
diff --git a/test/yarp/snapshots/whitequark/args_block_pass.txt b/test/yarp/snapshots/whitequark/args_block_pass.txt
index 50c51ba7b3..9cb1337a92 100644
--- a/test/yarp/snapshots/whitequark/args_block_pass.txt
+++ b/test/yarp/snapshots/whitequark/args_block_pass.txt
@@ -1,21 +1,30 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...8)(
-         [BlockArgumentNode(4...8)(
-            CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "bar"),
-            (4...5)
-          )]
-       ),
-       (8...9),
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "fun"
+            ├── opening_loc: (3...4) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...8))
+            │   └── arguments: (length: 1)
+            │       └── @ BlockArgumentNode (location: (4...8))
+            │           ├── expression:
+            │           │   @ CallNode (location: (5...8))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (5...8) = "bar"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "bar"
+            │           └── operator_loc: (4...5) = "&"
+            ├── closing_loc: (8...9) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/args_cmd.txt b/test/yarp/snapshots/whitequark/args_cmd.txt
index 9b0cfedb00..8a020d5b59 100644
--- a/test/yarp/snapshots/whitequark/args_cmd.txt
+++ b/test/yarp/snapshots/whitequark/args_cmd.txt
@@ -1,40 +1,39 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [CallNode(0...10)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...9)(
-         [CallNode(4...9)(
-            nil,
-            nil,
-            (4...5),
-            nil,
-            ArgumentsNode(6...9)(
-              [CallNode(6...9)(
-                 nil,
-                 nil,
-                 (6...9),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "bar"
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "f"
-          )]
-       ),
-       (9...10),
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...10))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "fun"
+            ├── opening_loc: (3...4) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...9))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (4...9))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (4...5) = "f"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (6...9))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ CallNode (location: (6...9))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (6...9) = "bar"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "bar"
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "f"
+            ├── closing_loc: (9...10) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/args_star.txt b/test/yarp/snapshots/whitequark/args_star.txt
index eaffafdd3d..c788c453af 100644
--- a/test/yarp/snapshots/whitequark/args_star.txt
+++ b/test/yarp/snapshots/whitequark/args_star.txt
@@ -1,61 +1,68 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [CallNode(0...9)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...8)(
-         [SplatNode(4...8)(
-            (4...5),
-            CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "bar")
-          )]
-       ),
-       (8...9),
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(11...26)(
-       nil,
-       nil,
-       (11...14),
-       (14...15),
-       ArgumentsNode(15...25)(
-         [SplatNode(15...19)(
-            (15...16),
-            CallNode(16...19)(
-              nil,
-              nil,
-              (16...19),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )
-          ),
-          BlockArgumentNode(21...25)(
-            CallNode(22...25)(
-              nil,
-              nil,
-              (22...25),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            ),
-            (21...22)
-          )]
-       ),
-       (25...26),
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...9))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "fun"
+        │   ├── opening_loc: (3...4) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...8))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ SplatNode (location: (4...8))
+        │   │           ├── operator_loc: (4...5) = "*"
+        │   │           └── expression:
+        │   │               @ CallNode (location: (5...8))
+        │   │               ├── receiver: ∅
+        │   │               ├── call_operator_loc: ∅
+        │   │               ├── message_loc: (5...8) = "bar"
+        │   │               ├── opening_loc: ∅
+        │   │               ├── arguments: ∅
+        │   │               ├── closing_loc: ∅
+        │   │               ├── block: ∅
+        │   │               ├── flags: variable_call
+        │   │               └── name: "bar"
+        │   ├── closing_loc: (8...9) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        └── @ CallNode (location: (11...26))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (11...14) = "fun"
+            ├── opening_loc: (14...15) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (15...25))
+            │   └── arguments: (length: 2)
+            │       ├── @ SplatNode (location: (15...19))
+            │       │   ├── operator_loc: (15...16) = "*"
+            │       │   └── expression:
+            │       │       @ CallNode (location: (16...19))
+            │       │       ├── receiver: ∅
+            │       │       ├── call_operator_loc: ∅
+            │       │       ├── message_loc: (16...19) = "bar"
+            │       │       ├── opening_loc: ∅
+            │       │       ├── arguments: ∅
+            │       │       ├── closing_loc: ∅
+            │       │       ├── block: ∅
+            │       │       ├── flags: variable_call
+            │       │       └── name: "bar"
+            │       └── @ BlockArgumentNode (location: (21...25))
+            │           ├── expression:
+            │           │   @ CallNode (location: (22...25))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (22...25) = "baz"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "baz"
+            │           └── operator_loc: (21...22) = "&"
+            ├── closing_loc: (25...26) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/array_assocs.txt b/test/yarp/snapshots/whitequark/array_assocs.txt
index 6dc20662ca..ae0d34f73a 100644
--- a/test/yarp/snapshots/whitequark/array_assocs.txt
+++ b/test/yarp/snapshots/whitequark/array_assocs.txt
@@ -1,28 +1,30 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [ArrayNode(0...10)(
-       [KeywordHashNode(2...8)(
-          [AssocNode(2...8)(
-             IntegerNode(2...3)(),
-             IntegerNode(7...8)(),
-             (4...6)
-           )]
-        )],
-       (0...1),
-       (9...10)
-     ),
-     ArrayNode(12...25)(
-       [IntegerNode(14...15)(),
-        KeywordHashNode(17...23)(
-          [AssocNode(17...23)(
-             IntegerNode(17...18)(),
-             IntegerNode(22...23)(),
-             (19...21)
-           )]
-        )],
-       (12...13),
-       (24...25)
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...10))
+        │   ├── elements: (length: 1)
+        │   │   └── @ KeywordHashNode (location: (2...8))
+        │   │       └── elements: (length: 1)
+        │   │           └── @ AssocNode (location: (2...8))
+        │   │               ├── key:
+        │   │               │   @ IntegerNode (location: (2...3))
+        │   │               ├── value:
+        │   │               │   @ IntegerNode (location: (7...8))
+        │   │               └── operator_loc: (4...6) = "=>"
+        │   ├── opening_loc: (0...1) = "["
+        │   └── closing_loc: (9...10) = "]"
+        └── @ ArrayNode (location: (12...25))
+            ├── elements: (length: 2)
+            │   ├── @ IntegerNode (location: (14...15))
+            │   └── @ KeywordHashNode (location: (17...23))
+            │       └── elements: (length: 1)
+            │           └── @ AssocNode (location: (17...23))
+            │               ├── key:
+            │               │   @ IntegerNode (location: (17...18))
+            │               ├── value:
+            │               │   @ IntegerNode (location: (22...23))
+            │               └── operator_loc: (19...21) = "=>"
+            ├── opening_loc: (12...13) = "["
+            └── closing_loc: (24...25) = "]"
diff --git a/test/yarp/snapshots/whitequark/array_plain.txt b/test/yarp/snapshots/whitequark/array_plain.txt
index d8c89ba8b9..e37b67bdda 100644
--- a/test/yarp/snapshots/whitequark/array_plain.txt
+++ b/test/yarp/snapshots/whitequark/array_plain.txt
@@ -1,10 +1,11 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [ArrayNode(0...6)(
-       [IntegerNode(1...2)(), IntegerNode(4...5)()],
-       (0...1),
-       (5...6)
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...6))
+            ├── elements: (length: 2)
+            │   ├── @ IntegerNode (location: (1...2))
+            │   └── @ IntegerNode (location: (4...5))
+            ├── opening_loc: (0...1) = "["
+            └── closing_loc: (5...6) = "]"
diff --git a/test/yarp/snapshots/whitequark/array_splat.txt b/test/yarp/snapshots/whitequark/array_splat.txt
index 770e42e814..d7d77cf0b5 100644
--- a/test/yarp/snapshots/whitequark/array_splat.txt
+++ b/test/yarp/snapshots/whitequark/array_splat.txt
@@ -1,32 +1,59 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)(
-    [ArrayNode(0...6)(
-       [SplatNode(1...5)(
-          (1...2),
-          CallNode(2...5)(nil, nil, (2...5), nil, nil, nil, nil, 2, "foo")
-        )],
-       (0...1),
-       (5...6)
-     ),
-     ArrayNode(8...20)(
-       [IntegerNode(9...10)(),
-        SplatNode(12...16)(
-          (12...13),
-          CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo")
-        ),
-        IntegerNode(18...19)()],
-       (8...9),
-       (19...20)
-     ),
-     ArrayNode(22...31)(
-       [IntegerNode(23...24)(),
-        SplatNode(26...30)(
-          (26...27),
-          CallNode(27...30)(nil, nil, (27...30), nil, nil, nil, nil, 2, "foo")
-        )],
-       (22...23),
-       (30...31)
-     )]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 3)
+        ├── @ ArrayNode (location: (0...6))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SplatNode (location: (1...5))
+        │   │       ├── operator_loc: (1...2) = "*"
+        │   │       └── expression:
+        │   │           @ CallNode (location: (2...5))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (2...5) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "foo"
+        │   ├── opening_loc: (0...1) = "["
+        │   └── closing_loc: (5...6) = "]"
+        ├── @ ArrayNode (location: (8...20))
+        │   ├── elements: (length: 3)
+        │   │   ├── @ IntegerNode (location: (9...10))
+        │   │   ├── @ SplatNode (location: (12...16))
+        │   │   │   ├── operator_loc: (12...13) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ CallNode (location: (13...16))
+        │   │   │       ├── receiver: ∅
+        │   │   │       ├── call_operator_loc: ∅
+        │   │   │       ├── message_loc: (13...16) = "foo"
+        │   │   │       ├── opening_loc: ∅
+        │   │   │       ├── arguments: ∅
+        │   │   │       ├── closing_loc: ∅
+        │   │   │       ├── block: ∅
+        │   │   │       ├── flags: variable_call
+        │   │   │       └── name: "foo"
+        │   │   └── @ IntegerNode (location: (18...19))
+        │   ├── opening_loc: (8...9) = "["
+        │   └── closing_loc: (19...20) = "]"
+        └── @ ArrayNode (location: (22...31))
+            ├── elements: (length: 2)
+            │   ├── @ IntegerNode (location: (23...24))
+            │   └── @ SplatNode (location: (26...30))
+            │       ├── operator_loc: (26...27) = "*"
+            │       └── expression:
+            │           @ CallNode (location: (27...30))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (27...30) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "foo"
+            ├── opening_loc: (22...23) = "["
+            └── closing_loc: (30...31) = "]"
diff --git a/test/yarp/snapshots/whitequark/array_symbols.txt b/test/yarp/snapshots/whitequark/array_symbols.txt
index 9d036af7cf..29ab12d427 100644
--- a/test/yarp/snapshots/whitequark/array_symbols.txt
+++ b/test/yarp/snapshots/whitequark/array_symbols.txt
@@ -1,11 +1,19 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [ArrayNode(0...11)(
-       [SymbolNode(3...6)(nil, (3...6), nil, "foo"),
-        SymbolNode(7...10)(nil, (7...10), nil, "bar")],
-       (0...3),
-       (10...11)
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...11))
+            ├── elements: (length: 2)
+            │   ├── @ SymbolNode (location: (3...6))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (3...6) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   └── @ SymbolNode (location: (7...10))
+            │       ├── opening_loc: ∅
+            │       ├── value_loc: (7...10) = "bar"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "bar"
+            ├── opening_loc: (0...3) = "%i["
+            └── closing_loc: (10...11) = "]"
diff --git a/test/yarp/snapshots/whitequark/array_symbols_empty.txt b/test/yarp/snapshots/whitequark/array_symbols_empty.txt
index ce2b82c914..15495e3f24 100644
--- a/test/yarp/snapshots/whitequark/array_symbols_empty.txt
+++ b/test/yarp/snapshots/whitequark/array_symbols_empty.txt
@@ -1,7 +1,13 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [ArrayNode(0...4)([], (0...3), (3...4)),
-     ArrayNode(6...10)([], (6...9), (9...10))]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...4))
+        │   ├── elements: (length: 0)
+        │   ├── opening_loc: (0...3) = "%I("
+        │   └── closing_loc: (3...4) = ")"
+        └── @ ArrayNode (location: (6...10))
+            ├── elements: (length: 0)
+            ├── opening_loc: (6...9) = "%i["
+            └── closing_loc: (9...10) = "]"
diff --git a/test/yarp/snapshots/whitequark/array_symbols_interp.txt b/test/yarp/snapshots/whitequark/array_symbols_interp.txt
index 8488e7e9c2..6c9a48a551 100644
--- a/test/yarp/snapshots/whitequark/array_symbols_interp.txt
+++ b/test/yarp/snapshots/whitequark/array_symbols_interp.txt
@@ -1,57 +1,63 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [ArrayNode(0...14)(
-       [SymbolNode(3...6)(nil, (3...6), nil, "foo"),
-        InterpolatedSymbolNode(7...13)(
-          nil,
-          [EmbeddedStatementsNode(7...13)(
-             (7...9),
-             StatementsNode(9...12)(
-               [CallNode(9...12)(
-                  nil,
-                  nil,
-                  (9...12),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )]
-             ),
-             (12...13)
-           )],
-          nil
-        )],
-       (0...3),
-       (13...14)
-     ),
-     ArrayNode(16...29)(
-       [InterpolatedSymbolNode(19...28)(
-          nil,
-          [StringNode(19...22)(nil, (19...22), nil, "foo"),
-           EmbeddedStatementsNode(22...28)(
-             (22...24),
-             StatementsNode(24...27)(
-               [CallNode(24...27)(
-                  nil,
-                  nil,
-                  (24...27),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )]
-             ),
-             (27...28)
-           )],
-          nil
-        )],
-       (16...19),
-       (28...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...14))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ SymbolNode (location: (3...6))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── value_loc: (3...6) = "foo"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo"
+        │   │   └── @ InterpolatedSymbolNode (location: (7...13))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── parts: (length: 1)
+        │   │       │   └── @ EmbeddedStatementsNode (location: (7...13))
+        │   │       │       ├── opening_loc: (7...9) = "\#{"
+        │   │       │       ├── statements:
+        │   │       │       │   @ StatementsNode (location: (9...12))
+        │   │       │       │   └── body: (length: 1)
+        │   │       │       │       └── @ CallNode (location: (9...12))
+        │   │       │       │           ├── receiver: ∅
+        │   │       │       │           ├── call_operator_loc: ∅
+        │   │       │       │           ├── message_loc: (9...12) = "bar"
+        │   │       │       │           ├── opening_loc: ∅
+        │   │       │       │           ├── arguments: ∅
+        │   │       │       │           ├── closing_loc: ∅
+        │   │       │       │           ├── block: ∅
+        │   │       │       │           ├── flags: variable_call
+        │   │       │       │           └── name: "bar"
+        │   │       │       └── closing_loc: (12...13) = "}"
+        │   │       └── closing_loc: ∅
+        │   ├── opening_loc: (0...3) = "%I["
+        │   └── closing_loc: (13...14) = "]"
+        └── @ ArrayNode (location: (16...29))
+            ├── elements: (length: 1)
+            │   └── @ InterpolatedSymbolNode (location: (19...28))
+            │       ├── opening_loc: ∅
+            │       ├── parts: (length: 2)
+            │       │   ├── @ StringNode (location: (19...22))
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── content_loc: (19...22) = "foo"
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   └── unescaped: "foo"
+            │       │   └── @ EmbeddedStatementsNode (location: (22...28))
+            │       │       ├── opening_loc: (22...24) = "\#{"
+            │       │       ├── statements:
+            │       │       │   @ StatementsNode (location: (24...27))
+            │       │       │   └── body: (length: 1)
+            │       │       │       └── @ CallNode (location: (24...27))
+            │       │       │           ├── receiver: ∅
+            │       │       │           ├── call_operator_loc: ∅
+            │       │       │           ├── message_loc: (24...27) = "bar"
+            │       │       │           ├── opening_loc: ∅
+            │       │       │           ├── arguments: ∅
+            │       │       │           ├── closing_loc: ∅
+            │       │       │           ├── block: ∅
+            │       │       │           ├── flags: variable_call
+            │       │       │           └── name: "bar"
+            │       │       └── closing_loc: (27...28) = "}"
+            │       └── closing_loc: ∅
+            ├── opening_loc: (16...19) = "%I["
+            └── closing_loc: (28...29) = "]"
diff --git a/test/yarp/snapshots/whitequark/array_words.txt b/test/yarp/snapshots/whitequark/array_words.txt
index 3308b6b7f2..39cf04afa4 100644
--- a/test/yarp/snapshots/whitequark/array_words.txt
+++ b/test/yarp/snapshots/whitequark/array_words.txt
@@ -1,11 +1,19 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [ArrayNode(0...11)(
-       [StringNode(3...6)(nil, (3...6), nil, "foo"),
-        StringNode(7...10)(nil, (7...10), nil, "bar")],
-       (0...3),
-       (10...11)
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ ArrayNode (location: (0...11))
+            ├── elements: (length: 2)
+            │   ├── @ StringNode (location: (3...6))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (3...6) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   └── @ StringNode (location: (7...10))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (7...10) = "bar"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "bar"
+            ├── opening_loc: (0...3) = "%w["
+            └── closing_loc: (10...11) = "]"
diff --git a/test/yarp/snapshots/whitequark/array_words_empty.txt b/test/yarp/snapshots/whitequark/array_words_empty.txt
index ce2b82c914..fc103a67af 100644
--- a/test/yarp/snapshots/whitequark/array_words_empty.txt
+++ b/test/yarp/snapshots/whitequark/array_words_empty.txt
@@ -1,7 +1,13 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [ArrayNode(0...4)([], (0...3), (3...4)),
-     ArrayNode(6...10)([], (6...9), (9...10))]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...4))
+        │   ├── elements: (length: 0)
+        │   ├── opening_loc: (0...3) = "%W("
+        │   └── closing_loc: (3...4) = ")"
+        └── @ ArrayNode (location: (6...10))
+            ├── elements: (length: 0)
+            ├── opening_loc: (6...9) = "%w["
+            └── closing_loc: (9...10) = "]"
diff --git a/test/yarp/snapshots/whitequark/array_words_interp.txt b/test/yarp/snapshots/whitequark/array_words_interp.txt
index d4bc9292e6..1ca2ebe1d2 100644
--- a/test/yarp/snapshots/whitequark/array_words_interp.txt
+++ b/test/yarp/snapshots/whitequark/array_words_interp.txt
@@ -1,62 +1,73 @@
-ProgramNode(0...38)(
-  [],
-  StatementsNode(0...38)(
-    [ArrayNode(0...14)(
-       [StringNode(3...6)(nil, (3...6), nil, "foo"),
-        InterpolatedStringNode(7...13)(
-          nil,
-          [EmbeddedStatementsNode(7...13)(
-             (7...9),
-             StatementsNode(9...12)(
-               [CallNode(9...12)(
-                  nil,
-                  nil,
-                  (9...12),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )]
-             ),
-             (12...13)
-           )],
-          nil
-        )],
-       (0...3),
-       (13...14)
-     ),
-     ArrayNode(16...38)(
-       [StringNode(19...22)(nil, (19...22), nil, "foo"),
-        InterpolatedStringNode(23...37)(
-          nil,
-          [EmbeddedStatementsNode(23...29)(
-             (23...25),
-             StatementsNode(25...28)(
-               [CallNode(25...28)(
-                  nil,
-                  nil,
-                  (25...28),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )]
-             ),
-             (28...29)
-           ),
-           StringNode(29...32)(nil, (29...32), nil, "foo"),
-           EmbeddedVariableNode(32...37)(
-             (32...33),
-             InstanceVariableReadNode(33...37)(:@baz)
-           )],
-          nil
-        )],
-       (16...19),
-       (37...38)
-     )]
-  )
-)
+@ ProgramNode (location: (0...38))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...38))
+    └── body: (length: 2)
+        ├── @ ArrayNode (location: (0...14))
+        │   ├── elements: (length: 2)
+        │   │   ├── @ StringNode (location: (3...6))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (3...6) = "foo"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo"
+        │   │   └── @ InterpolatedStringNode (location: (7...13))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── parts: (length: 1)
+        │   │       │   └── @ EmbeddedStatementsNode (location: (7...13))
+        │   │       │       ├── opening_loc: (7...9) = "\#{"
+        │   │       │       ├── statements:
+        │   │       │       │   @ StatementsNode (location: (9...12))
+        │   │       │       │   └── body: (length: 1)
+        │   │       │       │       └── @ CallNode (location: (9...12))
+        │   │       │       │           ├── receiver: ∅
+        │   │       │       │           ├── call_operator_loc: ∅
+        │   │       │       │           ├── message_loc: (9...12) = "bar"
+        │   │       │       │           ├── opening_loc: ∅
+        │   │       │       │           ├── arguments: ∅
+        │   │       │       │           ├── closing_loc: ∅
+        │   │       │       │           ├── block: ∅
+        │   │       │       │           ├── flags: variable_call
+        │   │       │       │           └── name: "bar"
+        │   │       │       └── closing_loc: (12...13) = "}"
+        │   │       └── closing_loc: ∅
+        │   ├── opening_loc: (0...3) = "%W["
+        │   └── closing_loc: (13...14) = "]"
+        └── @ ArrayNode (location: (16...38))
+            ├── elements: (length: 2)
+            │   ├── @ StringNode (location: (19...22))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (19...22) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   └── @ InterpolatedStringNode (location: (23...37))
+            │       ├── opening_loc: ∅
+            │       ├── parts: (length: 3)
+            │       │   ├── @ EmbeddedStatementsNode (location: (23...29))
+            │       │   │   ├── opening_loc: (23...25) = "\#{"
+            │       │   │   ├── statements:
+            │       │   │   │   @ StatementsNode (location: (25...28))
+            │       │   │   │   └── body: (length: 1)
+            │       │   │   │       └── @ CallNode (location: (25...28))
+            │       │   │   │           ├── receiver: ∅
+            │       │   │   │           ├── call_operator_loc: ∅
+            │       │   │   │           ├── message_loc: (25...28) = "bar"
+            │       │   │   │           ├── opening_loc: ∅
+            │       │   │   │           ├── arguments: ∅
+            │       │   │   │           ├── closing_loc: ∅
+            │       │   │   │           ├── block: ∅
+            │       │   │   │           ├── flags: variable_call
+            │       │   │   │           └── name: "bar"
+            │       │   │   └── closing_loc: (28...29) = "}"
+            │       │   ├── @ StringNode (location: (29...32))
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── content_loc: (29...32) = "foo"
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   └── unescaped: "foo"
+            │       │   └── @ EmbeddedVariableNode (location: (32...37))
+            │       │       ├── operator_loc: (32...33) = "#"
+            │       │       └── variable:
+            │       │           @ InstanceVariableReadNode (location: (33...37))
+            │       │           └── name: :@baz
+            │       └── closing_loc: ∅
+            ├── opening_loc: (16...19) = "%W["
+            └── closing_loc: (37...38) = "]"
diff --git a/test/yarp/snapshots/whitequark/asgn_cmd.txt b/test/yarp/snapshots/whitequark/asgn_cmd.txt
index ef24cc0477..8b27981f84 100644
--- a/test/yarp/snapshots/whitequark/asgn_cmd.txt
+++ b/test/yarp/snapshots/whitequark/asgn_cmd.txt
@@ -1,45 +1,53 @@
-ProgramNode(0...30)(
-  [:foo, :bar],
-  StatementsNode(0...30)(
-    [LocalVariableWriteNode(0...17)(
-       :foo,
-       0,
-       (0...3),
-       LocalVariableWriteNode(6...17)(
-         :bar,
-         0,
-         (6...9),
-         CallNode(12...17)(
-           nil,
-           nil,
-           (12...13),
-           nil,
-           ArgumentsNode(14...17)([LocalVariableReadNode(14...17)(:foo, 0)]),
-           nil,
-           nil,
-           0,
-           "m"
-         ),
-         (10...11)
-       ),
-       (4...5)
-     ),
-     LocalVariableWriteNode(19...30)(
-       :foo,
-       0,
-       (19...22),
-       CallNode(25...30)(
-         nil,
-         nil,
-         (25...26),
-         nil,
-         ArgumentsNode(27...30)([LocalVariableReadNode(27...30)(:foo, 0)]),
-         nil,
-         nil,
-         0,
-         "m"
-       ),
-       (23...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: [:foo, :bar]
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 2)
+        ├── @ LocalVariableWriteNode (location: (0...17))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (0...3) = "foo"
+        │   ├── value:
+        │   │   @ LocalVariableWriteNode (location: (6...17))
+        │   │   ├── name: :bar
+        │   │   ├── depth: 0
+        │   │   ├── name_loc: (6...9) = "bar"
+        │   │   ├── value:
+        │   │   │   @ CallNode (location: (12...17))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (12...13) = "m"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (14...17))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ LocalVariableReadNode (location: (14...17))
+        │   │   │   │           ├── name: :foo
+        │   │   │   │           └── depth: 0
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "m"
+        │   │   └── operator_loc: (10...11) = "="
+        │   └── operator_loc: (4...5) = "="
+        └── @ LocalVariableWriteNode (location: (19...30))
+            ├── name: :foo
+            ├── depth: 0
+            ├── name_loc: (19...22) = "foo"
+            ├── value:
+            │   @ CallNode (location: (25...30))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (25...26) = "m"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (27...30))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ LocalVariableReadNode (location: (27...30))
+            │   │           ├── name: :foo
+            │   │           └── depth: 0
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "m"
+            └── operator_loc: (23...24) = "="
diff --git a/test/yarp/snapshots/whitequark/asgn_mrhs.txt b/test/yarp/snapshots/whitequark/asgn_mrhs.txt
index aaf2bedb6f..5ceac10414 100644
--- a/test/yarp/snapshots/whitequark/asgn_mrhs.txt
+++ b/test/yarp/snapshots/whitequark/asgn_mrhs.txt
@@ -1,56 +1,82 @@
-ProgramNode(0...41)(
-  [:foo],
-  StatementsNode(0...41)(
-    [LocalVariableWriteNode(0...10)(
-       :foo,
-       0,
-       (0...3),
-       ArrayNode(6...10)(
-         [SplatNode(6...10)(
-            (6...7),
-            CallNode(7...10)(nil, nil, (7...10), nil, nil, nil, nil, 2, "bar")
-          )],
-         nil,
-         nil
-       ),
-       (4...5)
-     ),
-     LocalVariableWriteNode(12...24)(
-       :foo,
-       0,
-       (12...15),
-       ArrayNode(18...24)(
-         [CallNode(18...21)(nil, nil, (18...21), nil, nil, nil, nil, 2, "bar"),
-          IntegerNode(23...24)()],
-         nil,
-         nil
-       ),
-       (16...17)
-     ),
-     LocalVariableWriteNode(26...41)(
-       :foo,
-       0,
-       (26...29),
-       ArrayNode(32...41)(
-         [CallNode(32...35)(nil, nil, (32...35), nil, nil, nil, nil, 2, "baz"),
-          SplatNode(37...41)(
-            (37...38),
-            CallNode(38...41)(
-              nil,
-              nil,
-              (38...41),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )
-          )],
-         nil,
-         nil
-       ),
-       (30...31)
-     )]
-  )
-)
+@ ProgramNode (location: (0...41))
+├── locals: [:foo]
+└── statements:
+    @ StatementsNode (location: (0...41))
+    └── body: (length: 3)
+        ├── @ LocalVariableWriteNode (location: (0...10))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (0...3) = "foo"
+        │   ├── value:
+        │   │   @ ArrayNode (location: (6...10))
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ SplatNode (location: (6...10))
+        │   │   │       ├── operator_loc: (6...7) = "*"
+        │   │   │       └── expression:
+        │   │   │           @ CallNode (location: (7...10))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (7...10) = "bar"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (4...5) = "="
+        ├── @ LocalVariableWriteNode (location: (12...24))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (12...15) = "foo"
+        │   ├── value:
+        │   │   @ ArrayNode (location: (18...24))
+        │   │   ├── elements: (length: 2)
+        │   │   │   ├── @ CallNode (location: (18...21))
+        │   │   │   │   ├── receiver: ∅
+        │   │   │   │   ├── call_operator_loc: ∅
+        │   │   │   │   ├── message_loc: (18...21) = "bar"
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── arguments: ∅
+        │   │   │   │   ├── closing_loc: ∅
+        │   │   │   │   ├── block: ∅
+        │   │   │   │   ├── flags: variable_call
+        │   │   │   │   └── name: "bar"
+        │   │   │   └── @ IntegerNode (location: (23...24))
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (16...17) = "="
+        └── @ LocalVariableWriteNode (location: (26...41))
+            ├── name: :foo
+            ├── depth: 0
+            ├── name_loc: (26...29) = "foo"
+            ├── value:
+            │   @ ArrayNode (location: (32...41))
+            │   ├── elements: (length: 2)
+            │   │   ├── @ CallNode (location: (32...35))
+            │   │   │   ├── receiver: ∅
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (32...35) = "baz"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments: ∅
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: variable_call
+            │   │   │   └── name: "baz"
+            │   │   └── @ SplatNode (location: (37...41))
+            │   │       ├── operator_loc: (37...38) = "*"
+            │   │       └── expression:
+            │   │           @ CallNode (location: (38...41))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (38...41) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   ├── opening_loc: ∅
+            │   └── closing_loc: ∅
+            └── operator_loc: (30...31) = "="
diff --git a/test/yarp/snapshots/whitequark/back_ref.txt b/test/yarp/snapshots/whitequark/back_ref.txt
index d072409376..325e09c39b 100644
--- a/test/yarp/snapshots/whitequark/back_ref.txt
+++ b/test/yarp/snapshots/whitequark/back_ref.txt
@@ -1 +1,6 @@
-ProgramNode(0...2)([], StatementsNode(0...2)([BackReferenceReadNode(0...2)()]))
+@ ProgramNode (location: (0...2))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...2))
+    └── body: (length: 1)
+        └── @ BackReferenceReadNode (location: (0...2))
diff --git a/test/yarp/snapshots/whitequark/bang.txt b/test/yarp/snapshots/whitequark/bang.txt
index 65ea29dfd3..aa518956d9 100644
--- a/test/yarp/snapshots/whitequark/bang.txt
+++ b/test/yarp/snapshots/whitequark/bang.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [CallNode(0...4)(
-       CallNode(1...4)(nil, nil, (1...4), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...4))
+            ├── receiver:
+            │   @ CallNode (location: (1...4))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (1...4) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "!"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/whitequark/bang_cmd.txt b/test/yarp/snapshots/whitequark/bang_cmd.txt
index 23921cc1b3..7473581844 100644
--- a/test/yarp/snapshots/whitequark/bang_cmd.txt
+++ b/test/yarp/snapshots/whitequark/bang_cmd.txt
@@ -1,28 +1,37 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [CallNode(0...6)(
-       CallNode(1...6)(
-         nil,
-         nil,
-         (1...2),
-         nil,
-         ArgumentsNode(3...6)(
-           [CallNode(3...6)(nil, nil, (3...6), nil, nil, nil, nil, 2, "foo")]
-         ),
-         nil,
-         nil,
-         0,
-         "m"
-       ),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...6))
+            ├── receiver:
+            │   @ CallNode (location: (1...6))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (1...2) = "m"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (3...6))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (3...6))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (3...6) = "foo"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "foo"
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "m"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "!"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/whitequark/begin_cmdarg.txt b/test/yarp/snapshots/whitequark/begin_cmdarg.txt
index 2d1d4e53e5..c0227f2eaa 100644
--- a/test/yarp/snapshots/whitequark/begin_cmdarg.txt
+++ b/test/yarp/snapshots/whitequark/begin_cmdarg.txt
@@ -1,43 +1,46 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CallNode(0...28)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...28)(
-         [BeginNode(2...28)(
-            (2...7),
-            StatementsNode(8...24)(
-              [CallNode(8...24)(
-                 IntegerNode(8...9)(),
-                 (9...10),
-                 (10...15),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(16...24)(
-                   [],
-                   nil,
-                   StatementsNode(19...20)([IntegerNode(19...20)()]),
-                   (16...18),
-                   (21...24)
-                 ),
-                 0,
-                 "times"
-               )]
-            ),
-            nil,
-            nil,
-            nil,
-            (25...28)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...28))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...28))
+            │   └── arguments: (length: 1)
+            │       └── @ BeginNode (location: (2...28))
+            │           ├── begin_keyword_loc: (2...7) = "begin"
+            │           ├── statements:
+            │           │   @ StatementsNode (location: (8...24))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (8...24))
+            │           │           ├── receiver:
+            │           │           │   @ IntegerNode (location: (8...9))
+            │           │           ├── call_operator_loc: (9...10) = "."
+            │           │           ├── message_loc: (10...15) = "times"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block:
+            │           │           │   @ BlockNode (location: (16...24))
+            │           │           │   ├── locals: []
+            │           │           │   ├── parameters: ∅
+            │           │           │   ├── body:
+            │           │           │   │   @ StatementsNode (location: (19...20))
+            │           │           │   │   └── body: (length: 1)
+            │           │           │   │       └── @ IntegerNode (location: (19...20))
+            │           │           │   ├── opening_loc: (16...18) = "do"
+            │           │           │   └── closing_loc: (21...24) = "end"
+            │           │           ├── flags: 
+            │           │           └── name: "times"
+            │           ├── rescue_clause: ∅
+            │           ├── else_clause: ∅
+            │           ├── ensure_clause: ∅
+            │           └── end_keyword_loc: (25...28) = "end"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/whitequark/beginless_erange_after_newline.txt b/test/yarp/snapshots/whitequark/beginless_erange_after_newline.txt
index dbe6e585a2..f4c5ac017f 100644
--- a/test/yarp/snapshots/whitequark/beginless_erange_after_newline.txt
+++ b/test/yarp/snapshots/whitequark/beginless_erange_after_newline.txt
@@ -1,7 +1,21 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-     RangeNode(4...10)(nil, IntegerNode(7...10)(), (4...7), 1)]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...3))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "foo"
+        └── @ RangeNode (location: (4...10))
+            ├── left: ∅
+            ├── right:
+            │   @ IntegerNode (location: (7...10))
+            ├── operator_loc: (4...7) = "..."
+            └── flags: exclude_end
diff --git a/test/yarp/snapshots/whitequark/beginless_irange_after_newline.txt b/test/yarp/snapshots/whitequark/beginless_irange_after_newline.txt
index f784561012..42aa05944b 100644
--- a/test/yarp/snapshots/whitequark/beginless_irange_after_newline.txt
+++ b/test/yarp/snapshots/whitequark/beginless_irange_after_newline.txt
@@ -1,7 +1,21 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-     RangeNode(4...9)(nil, IntegerNode(6...9)(), (4...6), 0)]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...3))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "foo"
+        └── @ RangeNode (location: (4...9))
+            ├── left: ∅
+            ├── right:
+            │   @ IntegerNode (location: (6...9))
+            ├── operator_loc: (4...6) = ".."
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/beginless_range.txt b/test/yarp/snapshots/whitequark/beginless_range.txt
index 3750508629..6a18f51733 100644
--- a/test/yarp/snapshots/whitequark/beginless_range.txt
+++ b/test/yarp/snapshots/whitequark/beginless_range.txt
@@ -1,7 +1,17 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [RangeNode(0...6)(nil, IntegerNode(3...6)(), (0...3), 1),
-     RangeNode(8...13)(nil, IntegerNode(10...13)(), (8...10), 0)]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 2)
+        ├── @ RangeNode (location: (0...6))
+        │   ├── left: ∅
+        │   ├── right:
+        │   │   @ IntegerNode (location: (3...6))
+        │   ├── operator_loc: (0...3) = "..."
+        │   └── flags: exclude_end
+        └── @ RangeNode (location: (8...13))
+            ├── left: ∅
+            ├── right:
+            │   @ IntegerNode (location: (10...13))
+            ├── operator_loc: (8...10) = ".."
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/blockarg.txt b/test/yarp/snapshots/whitequark/blockarg.txt
index 67e1db44df..a8e036f611 100644
--- a/test/yarp/snapshots/whitequark/blockarg.txt
+++ b/test/yarp/snapshots/whitequark/blockarg.txt
@@ -1,27 +1,30 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [DefNode(0...18)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...12)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         BlockParameterNode(6...12)(:block, (7...12), (6...7))
-       ),
-       nil,
-       [:block],
-       (0...3),
-       nil,
-       (5...6),
-       (12...13),
-       nil,
-       (15...18)
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...18))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...12))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block:
+            │       @ BlockParameterNode (location: (6...12))
+            │       ├── name: :block
+            │       ├── name_loc: (7...12) = "block"
+            │       └── operator_loc: (6...7) = "&"
+            ├── body: ∅
+            ├── locals: [:block]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (12...13) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (15...18) = "end"
diff --git a/test/yarp/snapshots/whitequark/blockargs.txt b/test/yarp/snapshots/whitequark/blockargs.txt
index dd0b942a29..1f32656143 100644
--- a/test/yarp/snapshots/whitequark/blockargs.txt
+++ b/test/yarp/snapshots/whitequark/blockargs.txt
@@ -1,1059 +1,1248 @@
-ProgramNode(0...550)(
-  [],
-  StatementsNode(0...550)(
-    [CallNode(0...5)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(1...5)([], nil, nil, (1...2), (4...5)),
-       0,
-       "f"
-     ),
-     CallNode(7...15)(
-       nil,
-       nil,
-       (7...8),
-       nil,
-       nil,
-       nil,
-       BlockNode(8...15)(
-         [],
-         BlockParametersNode(10...13)(nil, [], (10...11), (12...13)),
-         nil,
-         (8...9),
-         (14...15)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(17...26)(
-       nil,
-       nil,
-       (17...18),
-       nil,
-       nil,
-       nil,
-       BlockNode(18...26)(
-         [:b],
-         BlockParametersNode(20...24)(
-           ParametersNode(21...23)(
-             [],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(21...23)(:b, (22...23), (21...22))
-           ),
-           [],
-           (20...21),
-           (23...24)
-         ),
-         nil,
-         (18...19),
-         (25...26)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(28...44)(
-       nil,
-       nil,
-       (28...29),
-       nil,
-       nil,
-       nil,
-       BlockNode(29...44)(
-         [:baz, :b],
-         BlockParametersNode(31...42)(
-           ParametersNode(32...41)(
-             [],
-             [],
-             [],
-             nil,
-             [],
-             KeywordRestParameterNode(32...37)(:baz, (34...37), (32...34)),
-             BlockParameterNode(39...41)(:b, (40...41), (39...40))
-           ),
-           [],
-           (31...32),
-           (41...42)
-         ),
-         nil,
-         (29...30),
-         (43...44)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(46...58)(
-       nil,
-       nil,
-       (46...47),
-       nil,
-       nil,
-       nil,
-       BlockNode(47...58)(
-         [:*, :b],
-         BlockParametersNode(49...56)(
-           ParametersNode(50...55)(
-             [],
-             [],
-             [],
-             RestParameterNode(50...51)(nil, nil, (50...51)),
-             [],
-             nil,
-             BlockParameterNode(53...55)(:b, (54...55), (53...54))
-           ),
-           [],
-           (49...50),
-           (55...56)
-         ),
-         nil,
-         (47...48),
-         (57...58)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(60...76)(
-       nil,
-       nil,
-       (60...61),
-       nil,
-       nil,
-       nil,
-       BlockNode(61...76)(
-         [:r, :p, :b],
-         BlockParametersNode(63...74)(
-           ParametersNode(64...73)(
-             [],
-             [],
-             [RequiredParameterNode(68...69)(:p)],
-             RestParameterNode(64...66)(:r, (65...66), (64...65)),
-             [],
-             nil,
-             BlockParameterNode(71...73)(:b, (72...73), (71...72))
-           ),
-           [],
-           (63...64),
-           (73...74)
-         ),
-         nil,
-         (61...62),
-         (75...76)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(78...91)(
-       nil,
-       nil,
-       (78...79),
-       nil,
-       nil,
-       nil,
-       BlockNode(79...91)(
-         [:s, :b],
-         BlockParametersNode(81...89)(
-           ParametersNode(82...88)(
-             [],
-             [],
-             [],
-             RestParameterNode(82...84)(:s, (83...84), (82...83)),
-             [],
-             nil,
-             BlockParameterNode(86...88)(:b, (87...88), (86...87))
-           ),
-           [],
-           (81...82),
-           (88...89)
-         ),
-         nil,
-         (79...80),
-         (90...91)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(93...102)(
-       nil,
-       nil,
-       (93...94),
-       nil,
-       nil,
-       nil,
-       BlockNode(94...102)(
-         [:s],
-         BlockParametersNode(96...100)(
-           ParametersNode(97...99)(
-             [],
-             [],
-             [],
-             RestParameterNode(97...99)(:s, (98...99), (97...98)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (96...97),
-           (99...100)
-         ),
-         nil,
-         (94...95),
-         (101...102)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(104...112)(
-       nil,
-       nil,
-       (104...105),
-       nil,
-       nil,
-       nil,
-       BlockNode(105...112)(
-         [:*],
-         BlockParametersNode(107...110)(
-           ParametersNode(108...109)(
-             [],
-             [],
-             [],
-             RestParameterNode(108...109)(nil, nil, (108...109)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (107...108),
-           (109...110)
-         ),
-         nil,
-         (105...106),
-         (111...112)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(114...125)(
-       nil,
-       nil,
-       (114...115),
-       nil,
-       nil,
-       nil,
-       BlockNode(115...125)(
-         [:a],
-         BlockParametersNode(117...123)(
-           nil,
-           [BlockLocalVariableNode(120...121)(:a)],
-           (117...118),
-           (122...123)
-         ),
-         nil,
-         (115...116),
-         (124...125)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(127...136)(
-       nil,
-       nil,
-       (127...128),
-       nil,
-       nil,
-       nil,
-       BlockNode(128...136)(
-         [:a],
-         BlockParametersNode(130...134)(
-           nil,
-           [BlockLocalVariableNode(132...133)(:a)],
-           (130...131),
-           (133...134)
-         ),
-         nil,
-         (128...129),
-         (135...136)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(138...150)(
-       nil,
-       nil,
-       (138...139),
-       nil,
-       nil,
-       nil,
-       BlockNode(139...150)(
-         [:a, :b],
-         BlockParametersNode(141...148)(
-           ParametersNode(142...147)(
-             [RequiredParameterNode(142...143)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(145...147)(:b, (146...147), (145...146))
-           ),
-           [],
-           (141...142),
-           (147...148)
-         ),
-         nil,
-         (139...140),
-         (149...150)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(152...167)(
-       nil,
-       nil,
-       (152...153),
-       nil,
-       nil,
-       nil,
-       BlockNode(153...167)(
-         [:a, :*, :b],
-         BlockParametersNode(155...165)(
-           ParametersNode(156...164)(
-             [RequiredParameterNode(156...157)(:a)],
-             [],
-             [],
-             RestParameterNode(159...160)(nil, nil, (159...160)),
-             [],
-             nil,
-             BlockParameterNode(162...164)(:b, (163...164), (162...163))
-           ),
-           [],
-           (155...156),
-           (164...165)
-         ),
-         nil,
-         (153...154),
-         (166...167)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(169...188)(
-       nil,
-       nil,
-       (169...170),
-       nil,
-       nil,
-       nil,
-       BlockNode(170...188)(
-         [:a, :r, :p, :b],
-         BlockParametersNode(172...186)(
-           ParametersNode(173...185)(
-             [RequiredParameterNode(173...174)(:a)],
-             [],
-             [RequiredParameterNode(180...181)(:p)],
-             RestParameterNode(176...178)(:r, (177...178), (176...177)),
-             [],
-             nil,
-             BlockParameterNode(183...185)(:b, (184...185), (183...184))
-           ),
-           [],
-           (172...173),
-           (185...186)
-         ),
-         nil,
-         (170...171),
-         (187...188)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(190...206)(
-       nil,
-       nil,
-       (190...191),
-       nil,
-       nil,
-       nil,
-       BlockNode(191...206)(
-         [:a, :s, :b],
-         BlockParametersNode(193...204)(
-           ParametersNode(194...203)(
-             [RequiredParameterNode(194...195)(:a)],
-             [],
-             [],
-             RestParameterNode(197...199)(:s, (198...199), (197...198)),
-             [],
-             nil,
-             BlockParameterNode(201...203)(:b, (202...203), (201...202))
-           ),
-           [],
-           (193...194),
-           (203...204)
-         ),
-         nil,
-         (191...192),
-         (205...206)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(208...220)(
-       nil,
-       nil,
-       (208...209),
-       nil,
-       nil,
-       nil,
-       BlockNode(209...220)(
-         [:a, :s],
-         BlockParametersNode(211...218)(
-           ParametersNode(212...217)(
-             [RequiredParameterNode(212...213)(:a)],
-             [],
-             [],
-             RestParameterNode(215...217)(:s, (216...217), (215...216)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (211...212),
-           (217...218)
-         ),
-         nil,
-         (209...210),
-         (219...220)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(222...233)(
-       nil,
-       nil,
-       (222...223),
-       nil,
-       nil,
-       nil,
-       BlockNode(223...233)(
-         [:a, :*],
-         BlockParametersNode(225...231)(
-           ParametersNode(226...230)(
-             [RequiredParameterNode(226...227)(:a)],
-             [],
-             [],
-             RestParameterNode(229...230)(nil, nil, (229...230)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (225...226),
-           (230...231)
-         ),
-         nil,
-         (223...224),
-         (232...233)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(235...247)(
-       nil,
-       nil,
-       (235...236),
-       nil,
-       nil,
-       nil,
-       BlockNode(236...247)(
-         [:a, :b],
-         BlockParametersNode(238...245)(
-           ParametersNode(239...244)(
-             [RequiredParameterNode(239...240)(:a),
-              RequiredParameterNode(242...243)(:b)],
-             [],
-             [],
-             RestParameterNode(243...244)(nil, nil, (243...244)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (238...239),
-           (244...245)
-         ),
-         nil,
-         (236...237),
-         (246...247)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(249...260)(
-       nil,
-       nil,
-       (249...250),
-       nil,
-       nil,
-       nil,
-       BlockNode(250...260)(
-         [:a, :c],
-         BlockParametersNode(252...258)(
-           ParametersNode(253...257)(
-             [RequiredParameterNode(253...254)(:a),
-              RequiredParameterNode(256...257)(:c)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (252...253),
-           (257...258)
-         ),
-         nil,
-         (250...251),
-         (259...260)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(262...279)(
-       nil,
-       nil,
-       (262...263),
-       nil,
-       nil,
-       nil,
-       BlockNode(263...279)(
-         [:a, :o, :b],
-         BlockParametersNode(265...277)(
-           ParametersNode(266...276)(
-             [RequiredParameterNode(266...267)(:a)],
-             [OptionalParameterNode(269...272)(
-                :o,
-                (269...270),
-                (270...271),
-                IntegerNode(271...272)()
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(274...276)(:b, (275...276), (274...275))
-           ),
-           [],
-           (265...266),
-           (276...277)
-         ),
-         nil,
-         (263...264),
-         (278...279)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(281...305)(
-       nil,
-       nil,
-       (281...282),
-       nil,
-       nil,
-       nil,
-       BlockNode(282...305)(
-         [:a, :o, :r, :p, :b],
-         BlockParametersNode(284...303)(
-           ParametersNode(285...302)(
-             [RequiredParameterNode(285...286)(:a)],
-             [OptionalParameterNode(288...291)(
-                :o,
-                (288...289),
-                (289...290),
-                IntegerNode(290...291)()
-              )],
-             [RequiredParameterNode(297...298)(:p)],
-             RestParameterNode(293...295)(:r, (294...295), (293...294)),
-             [],
-             nil,
-             BlockParameterNode(300...302)(:b, (301...302), (300...301))
-           ),
-           [],
-           (284...285),
-           (302...303)
-         ),
-         nil,
-         (282...283),
-         (304...305)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(307...334)(
-       nil,
-       nil,
-       (307...308),
-       nil,
-       nil,
-       nil,
-       BlockNode(308...334)(
-         [:a, :o, :o1, :r, :b],
-         BlockParametersNode(310...332)(
-           ParametersNode(311...331)(
-             [RequiredParameterNode(311...312)(:a)],
-             [OptionalParameterNode(314...317)(
-                :o,
-                (314...315),
-                (315...316),
-                IntegerNode(316...317)()
-              ),
-              OptionalParameterNode(319...323)(
-                :o1,
-                (319...321),
-                (321...322),
-                IntegerNode(322...323)()
-              )],
-             [],
-             RestParameterNode(325...327)(:r, (326...327), (325...326)),
-             [],
-             nil,
-             BlockParameterNode(329...331)(:b, (330...331), (329...330))
-           ),
-           [],
-           (310...311),
-           (331...332)
-         ),
-         nil,
-         (308...309),
-         (333...334)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(336...356)(
-       nil,
-       nil,
-       (336...337),
-       nil,
-       nil,
-       nil,
-       BlockNode(337...356)(
-         [:a, :o, :p, :b],
-         BlockParametersNode(339...354)(
-           ParametersNode(340...353)(
-             [RequiredParameterNode(340...341)(:a)],
-             [OptionalParameterNode(343...346)(
-                :o,
-                (343...344),
-                (344...345),
-                IntegerNode(345...346)()
-              )],
-             [RequiredParameterNode(348...349)(:p)],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(351...353)(:b, (352...353), (351...352))
-           ),
-           [],
-           (339...340),
-           (353...354)
-         ),
-         nil,
-         (337...338),
-         (355...356)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(358...367)(
-       nil,
-       nil,
-       (358...359),
-       nil,
-       nil,
-       nil,
-       BlockNode(359...367)(
-         [:a],
-         BlockParametersNode(361...365)(
-           ParametersNode(362...364)(
-             [RequiredParameterNode(362...363)(:a)],
-             [],
-             [],
-             RestParameterNode(363...364)(nil, nil, (363...364)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (361...362),
-           (364...365)
-         ),
-         nil,
-         (359...360),
-         (366...367)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(369...377)(
-       nil,
-       nil,
-       (369...370),
-       nil,
-       nil,
-       nil,
-       BlockNode(370...377)(
-         [:a],
-         BlockParametersNode(372...375)(
-           ParametersNode(373...374)(
-             [RequiredParameterNode(373...374)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (372...373),
-           (374...375)
-         ),
-         nil,
-         (370...371),
-         (376...377)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(379...387)(
-       nil,
-       nil,
-       (379...380),
-       nil,
-       nil,
-       nil,
-       BlockNode(380...387)(
-         [:a],
-         BlockParametersNode(382...385)(
-           ParametersNode(383...384)(
-             [RequiredParameterNode(383...384)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (382...383),
-           (384...385)
-         ),
-         nil,
-         (380...381),
-         (386...387)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(389...397)(
-       nil,
-       nil,
-       (389...390),
-       nil,
-       nil,
-       nil,
-       BlockNode(390...397)(
-         [:a],
-         BlockParametersNode(392...395)(
-           ParametersNode(393...394)(
-             [RequiredParameterNode(393...394)(:a)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (392...393),
-           (394...395)
-         ),
-         nil,
-         (390...391),
-         (396...397)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(399...416)(
-       nil,
-       nil,
-       (399...400),
-       nil,
-       nil,
-       nil,
-       BlockNode(400...416)(
-         [:foo, :b],
-         BlockParametersNode(402...414)(
-           ParametersNode(403...413)(
-             [],
-             [],
-             [],
-             nil,
-             [KeywordParameterNode(403...409)(
-                :foo,
-                (403...407),
-                IntegerNode(408...409)()
-              )],
-             nil,
-             BlockParameterNode(411...413)(:b, (412...413), (411...412))
-           ),
-           [],
-           (402...403),
-           (413...414)
-         ),
-         nil,
-         (400...401),
-         (415...416)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(418...450)(
-       nil,
-       nil,
-       (418...419),
-       nil,
-       nil,
-       nil,
-       BlockNode(419...450)(
-         [:foo, :bar, :baz, :b],
-         BlockParametersNode(421...448)(
-           ParametersNode(422...447)(
-             [],
-             [],
-             [],
-             nil,
-             [KeywordParameterNode(422...428)(
-                :foo,
-                (422...426),
-                IntegerNode(427...428)()
-              ),
-              KeywordParameterNode(430...436)(
-                :bar,
-                (430...434),
-                IntegerNode(435...436)()
-              )],
-             KeywordRestParameterNode(438...443)(
-               :baz,
-               (440...443),
-               (438...440)
-             ),
-             BlockParameterNode(445...447)(:b, (446...447), (445...446))
-           ),
-           [],
-           (421...422),
-           (447...448)
-         ),
-         nil,
-         (419...420),
-         (449...450)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(452...463)(
-       nil,
-       nil,
-       (452...453),
-       nil,
-       nil,
-       nil,
-       BlockNode(453...463)(
-         [:foo],
-         BlockParametersNode(455...461)(
-           ParametersNode(456...460)(
-             [],
-             [],
-             [],
-             nil,
-             [KeywordParameterNode(456...460)(:foo, (456...460), nil)],
-             nil,
-             nil
-           ),
-           [],
-           (455...456),
-           (460...461)
-         ),
-         nil,
-         (453...454),
-         (462...463)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(465...479)(
-       nil,
-       nil,
-       (465...466),
-       nil,
-       nil,
-       nil,
-       BlockNode(466...479)(
-         [:o, :b],
-         BlockParametersNode(468...477)(
-           ParametersNode(469...476)(
-             [],
-             [OptionalParameterNode(469...472)(
-                :o,
-                (469...470),
-                (470...471),
-                IntegerNode(471...472)()
-              )],
-             [],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(474...476)(:b, (475...476), (474...475))
-           ),
-           [],
-           (468...469),
-           (476...477)
-         ),
-         nil,
-         (466...467),
-         (478...479)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(481...499)(
-       nil,
-       nil,
-       (481...482),
-       nil,
-       nil,
-       nil,
-       BlockNode(482...499)(
-         [:o, :r, :b],
-         BlockParametersNode(484...497)(
-           ParametersNode(485...496)(
-             [],
-             [OptionalParameterNode(485...488)(
-                :o,
-                (485...486),
-                (486...487),
-                IntegerNode(487...488)()
-              )],
-             [],
-             RestParameterNode(490...492)(:r, (491...492), (490...491)),
-             [],
-             nil,
-             BlockParameterNode(494...496)(:b, (495...496), (494...495))
-           ),
-           [],
-           (484...485),
-           (496...497)
-         ),
-         nil,
-         (482...483),
-         (498...499)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(501...522)(
-       nil,
-       nil,
-       (501...502),
-       nil,
-       nil,
-       nil,
-       BlockNode(502...522)(
-         [:o, :r, :p, :b],
-         BlockParametersNode(504...520)(
-           ParametersNode(505...519)(
-             [],
-             [OptionalParameterNode(505...508)(
-                :o,
-                (505...506),
-                (506...507),
-                IntegerNode(507...508)()
-              )],
-             [RequiredParameterNode(514...515)(:p)],
-             RestParameterNode(510...512)(:r, (511...512), (510...511)),
-             [],
-             nil,
-             BlockParameterNode(517...519)(:b, (518...519), (517...518))
-           ),
-           [],
-           (504...505),
-           (519...520)
-         ),
-         nil,
-         (502...503),
-         (521...522)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(524...541)(
-       nil,
-       nil,
-       (524...525),
-       nil,
-       nil,
-       nil,
-       BlockNode(525...541)(
-         [:o, :p, :b],
-         BlockParametersNode(527...539)(
-           ParametersNode(528...538)(
-             [],
-             [OptionalParameterNode(528...531)(
-                :o,
-                (528...529),
-                (529...530),
-                IntegerNode(530...531)()
-              )],
-             [RequiredParameterNode(533...534)(:p)],
-             nil,
-             [],
-             nil,
-             BlockParameterNode(536...538)(:b, (537...538), (536...537))
-           ),
-           [],
-           (527...528),
-           (538...539)
-         ),
-         nil,
-         (525...526),
-         (540...541)
-       ),
-       0,
-       "f"
-     ),
-     CallNode(543...550)(
-       nil,
-       nil,
-       (543...544),
-       nil,
-       nil,
-       nil,
-       BlockNode(544...550)(
-         [],
-         BlockParametersNode(546...548)(nil, [], (546...547), (547...548)),
-         nil,
-         (544...545),
-         (549...550)
-       ),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...550))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...550))
+    └── body: (length: 35)
+        ├── @ CallNode (location: (0...5))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (1...5))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (1...2) = "{"
+        │   │   └── closing_loc: (4...5) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (7...15))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (7...8) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (8...15))
+        │   │   ├── locals: []
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (10...13))
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (10...11) = "|"
+        │   │   │   └── closing_loc: (12...13) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (8...9) = "{"
+        │   │   └── closing_loc: (14...15) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (17...26))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (17...18) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (18...26))
+        │   │   ├── locals: [:b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (20...24))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (21...23))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (21...23))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (22...23) = "b"
+        │   │   │   │       └── operator_loc: (21...22) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (20...21) = "|"
+        │   │   │   └── closing_loc: (23...24) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (18...19) = "{"
+        │   │   └── closing_loc: (25...26) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (28...44))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (28...29) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (29...44))
+        │   │   ├── locals: [:baz, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (31...42))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (32...41))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest:
+        │   │   │   │   │   @ KeywordRestParameterNode (location: (32...37))
+        │   │   │   │   │   ├── name: :baz
+        │   │   │   │   │   ├── name_loc: (34...37) = "baz"
+        │   │   │   │   │   └── operator_loc: (32...34) = "**"
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (39...41))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (40...41) = "b"
+        │   │   │   │       └── operator_loc: (39...40) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (31...32) = "|"
+        │   │   │   └── closing_loc: (41...42) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (29...30) = "{"
+        │   │   └── closing_loc: (43...44) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (46...58))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (46...47) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (47...58))
+        │   │   ├── locals: [:*, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (49...56))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (50...55))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (50...51))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (50...51) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (53...55))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (54...55) = "b"
+        │   │   │   │       └── operator_loc: (53...54) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (49...50) = "|"
+        │   │   │   └── closing_loc: (55...56) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (47...48) = "{"
+        │   │   └── closing_loc: (57...58) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (60...76))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (60...61) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (61...76))
+        │   │   ├── locals: [:r, :p, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (63...74))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (64...73))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (68...69))
+        │   │   │   │   │       └── name: :p
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (64...66))
+        │   │   │   │   │   ├── name: :r
+        │   │   │   │   │   ├── name_loc: (65...66) = "r"
+        │   │   │   │   │   └── operator_loc: (64...65) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (71...73))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (72...73) = "b"
+        │   │   │   │       └── operator_loc: (71...72) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (63...64) = "|"
+        │   │   │   └── closing_loc: (73...74) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (61...62) = "{"
+        │   │   └── closing_loc: (75...76) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (78...91))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (78...79) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (79...91))
+        │   │   ├── locals: [:s, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (81...89))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (82...88))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (82...84))
+        │   │   │   │   │   ├── name: :s
+        │   │   │   │   │   ├── name_loc: (83...84) = "s"
+        │   │   │   │   │   └── operator_loc: (82...83) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (86...88))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (87...88) = "b"
+        │   │   │   │       └── operator_loc: (86...87) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (81...82) = "|"
+        │   │   │   └── closing_loc: (88...89) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (79...80) = "{"
+        │   │   └── closing_loc: (90...91) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (93...102))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (93...94) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (94...102))
+        │   │   ├── locals: [:s]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (96...100))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (97...99))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (97...99))
+        │   │   │   │   │   ├── name: :s
+        │   │   │   │   │   ├── name_loc: (98...99) = "s"
+        │   │   │   │   │   └── operator_loc: (97...98) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (96...97) = "|"
+        │   │   │   └── closing_loc: (99...100) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (94...95) = "{"
+        │   │   └── closing_loc: (101...102) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (104...112))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (104...105) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (105...112))
+        │   │   ├── locals: [:*]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (107...110))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (108...109))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (108...109))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (108...109) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (107...108) = "|"
+        │   │   │   └── closing_loc: (109...110) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (105...106) = "{"
+        │   │   └── closing_loc: (111...112) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (114...125))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (114...115) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (115...125))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (117...123))
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── locals: (length: 1)
+        │   │   │   │   └── @ BlockLocalVariableNode (location: (120...121))
+        │   │   │   │       └── name: :a
+        │   │   │   ├── opening_loc: (117...118) = "|"
+        │   │   │   └── closing_loc: (122...123) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (115...116) = "{"
+        │   │   └── closing_loc: (124...125) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (127...136))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (127...128) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (128...136))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (130...134))
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── locals: (length: 1)
+        │   │   │   │   └── @ BlockLocalVariableNode (location: (132...133))
+        │   │   │   │       └── name: :a
+        │   │   │   ├── opening_loc: (130...131) = "|"
+        │   │   │   └── closing_loc: (133...134) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (128...129) = "{"
+        │   │   └── closing_loc: (135...136) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (138...150))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (138...139) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (139...150))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (141...148))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (142...147))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (142...143))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (145...147))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (146...147) = "b"
+        │   │   │   │       └── operator_loc: (145...146) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (141...142) = "|"
+        │   │   │   └── closing_loc: (147...148) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (139...140) = "{"
+        │   │   └── closing_loc: (149...150) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (152...167))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (152...153) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (153...167))
+        │   │   ├── locals: [:a, :*, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (155...165))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (156...164))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (156...157))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (159...160))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (159...160) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (162...164))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (163...164) = "b"
+        │   │   │   │       └── operator_loc: (162...163) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (155...156) = "|"
+        │   │   │   └── closing_loc: (164...165) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (153...154) = "{"
+        │   │   └── closing_loc: (166...167) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (169...188))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (169...170) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (170...188))
+        │   │   ├── locals: [:a, :r, :p, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (172...186))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (173...185))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (173...174))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (180...181))
+        │   │   │   │   │       └── name: :p
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (176...178))
+        │   │   │   │   │   ├── name: :r
+        │   │   │   │   │   ├── name_loc: (177...178) = "r"
+        │   │   │   │   │   └── operator_loc: (176...177) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (183...185))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (184...185) = "b"
+        │   │   │   │       └── operator_loc: (183...184) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (172...173) = "|"
+        │   │   │   └── closing_loc: (185...186) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (170...171) = "{"
+        │   │   └── closing_loc: (187...188) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (190...206))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (190...191) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (191...206))
+        │   │   ├── locals: [:a, :s, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (193...204))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (194...203))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (194...195))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (197...199))
+        │   │   │   │   │   ├── name: :s
+        │   │   │   │   │   ├── name_loc: (198...199) = "s"
+        │   │   │   │   │   └── operator_loc: (197...198) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (201...203))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (202...203) = "b"
+        │   │   │   │       └── operator_loc: (201...202) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (193...194) = "|"
+        │   │   │   └── closing_loc: (203...204) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (191...192) = "{"
+        │   │   └── closing_loc: (205...206) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (208...220))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (208...209) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (209...220))
+        │   │   ├── locals: [:a, :s]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (211...218))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (212...217))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (212...213))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (215...217))
+        │   │   │   │   │   ├── name: :s
+        │   │   │   │   │   ├── name_loc: (216...217) = "s"
+        │   │   │   │   │   └── operator_loc: (215...216) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (211...212) = "|"
+        │   │   │   └── closing_loc: (217...218) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (209...210) = "{"
+        │   │   └── closing_loc: (219...220) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (222...233))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (222...223) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (223...233))
+        │   │   ├── locals: [:a, :*]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (225...231))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (226...230))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (226...227))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (229...230))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (229...230) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (225...226) = "|"
+        │   │   │   └── closing_loc: (230...231) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (223...224) = "{"
+        │   │   └── closing_loc: (232...233) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (235...247))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (235...236) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (236...247))
+        │   │   ├── locals: [:a, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (238...245))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (239...244))
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ RequiredParameterNode (location: (239...240))
+        │   │   │   │   │   │   └── name: :a
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (242...243))
+        │   │   │   │   │       └── name: :b
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (243...244))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (243...244) = ","
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (238...239) = "|"
+        │   │   │   └── closing_loc: (244...245) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (236...237) = "{"
+        │   │   └── closing_loc: (246...247) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (249...260))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (249...250) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (250...260))
+        │   │   ├── locals: [:a, :c]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (252...258))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (253...257))
+        │   │   │   │   ├── requireds: (length: 2)
+        │   │   │   │   │   ├── @ RequiredParameterNode (location: (253...254))
+        │   │   │   │   │   │   └── name: :a
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (256...257))
+        │   │   │   │   │       └── name: :c
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (252...253) = "|"
+        │   │   │   └── closing_loc: (257...258) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (250...251) = "{"
+        │   │   └── closing_loc: (259...260) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (262...279))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (262...263) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (263...279))
+        │   │   ├── locals: [:a, :o, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (265...277))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (266...276))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (266...267))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (269...272))
+        │   │   │   │   │       ├── name: :o
+        │   │   │   │   │       ├── name_loc: (269...270) = "o"
+        │   │   │   │   │       ├── operator_loc: (270...271) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (271...272))
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (274...276))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (275...276) = "b"
+        │   │   │   │       └── operator_loc: (274...275) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (265...266) = "|"
+        │   │   │   └── closing_loc: (276...277) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (263...264) = "{"
+        │   │   └── closing_loc: (278...279) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (281...305))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (281...282) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (282...305))
+        │   │   ├── locals: [:a, :o, :r, :p, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (284...303))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (285...302))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (285...286))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (288...291))
+        │   │   │   │   │       ├── name: :o
+        │   │   │   │   │       ├── name_loc: (288...289) = "o"
+        │   │   │   │   │       ├── operator_loc: (289...290) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (290...291))
+        │   │   │   │   ├── posts: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (297...298))
+        │   │   │   │   │       └── name: :p
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (293...295))
+        │   │   │   │   │   ├── name: :r
+        │   │   │   │   │   ├── name_loc: (294...295) = "r"
+        │   │   │   │   │   └── operator_loc: (293...294) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (300...302))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (301...302) = "b"
+        │   │   │   │       └── operator_loc: (300...301) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (284...285) = "|"
+        │   │   │   └── closing_loc: (302...303) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (282...283) = "{"
+        │   │   └── closing_loc: (304...305) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (307...334))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (307...308) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (308...334))
+        │   │   ├── locals: [:a, :o, :o1, :r, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (310...332))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (311...331))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (311...312))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 2)
+        │   │   │   │   │   ├── @ OptionalParameterNode (location: (314...317))
+        │   │   │   │   │   │   ├── name: :o
+        │   │   │   │   │   │   ├── name_loc: (314...315) = "o"
+        │   │   │   │   │   │   ├── operator_loc: (315...316) = "="
+        │   │   │   │   │   │   └── value:
+        │   │   │   │   │   │       @ IntegerNode (location: (316...317))
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (319...323))
+        │   │   │   │   │       ├── name: :o1
+        │   │   │   │   │       ├── name_loc: (319...321) = "o1"
+        │   │   │   │   │       ├── operator_loc: (321...322) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (322...323))
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (325...327))
+        │   │   │   │   │   ├── name: :r
+        │   │   │   │   │   ├── name_loc: (326...327) = "r"
+        │   │   │   │   │   └── operator_loc: (325...326) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (329...331))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (330...331) = "b"
+        │   │   │   │       └── operator_loc: (329...330) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (310...311) = "|"
+        │   │   │   └── closing_loc: (331...332) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (308...309) = "{"
+        │   │   └── closing_loc: (333...334) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (336...356))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (336...337) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (337...356))
+        │   │   ├── locals: [:a, :o, :p, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (339...354))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (340...353))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (340...341))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (343...346))
+        │   │   │   │   │       ├── name: :o
+        │   │   │   │   │       ├── name_loc: (343...344) = "o"
+        │   │   │   │   │       ├── operator_loc: (344...345) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (345...346))
+        │   │   │   │   ├── posts: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (348...349))
+        │   │   │   │   │       └── name: :p
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (351...353))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (352...353) = "b"
+        │   │   │   │       └── operator_loc: (351...352) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (339...340) = "|"
+        │   │   │   └── closing_loc: (353...354) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (337...338) = "{"
+        │   │   └── closing_loc: (355...356) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (358...367))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (358...359) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (359...367))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (361...365))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (362...364))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (362...363))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (363...364))
+        │   │   │   │   │   ├── name: nil
+        │   │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   │   └── operator_loc: (363...364) = ","
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (361...362) = "|"
+        │   │   │   └── closing_loc: (364...365) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (359...360) = "{"
+        │   │   └── closing_loc: (366...367) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (369...377))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (369...370) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (370...377))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (372...375))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (373...374))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (373...374))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (372...373) = "|"
+        │   │   │   └── closing_loc: (374...375) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (370...371) = "{"
+        │   │   └── closing_loc: (376...377) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (379...387))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (379...380) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (380...387))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (382...385))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (383...384))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (383...384))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (382...383) = "|"
+        │   │   │   └── closing_loc: (384...385) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (380...381) = "{"
+        │   │   └── closing_loc: (386...387) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (389...397))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (389...390) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (390...397))
+        │   │   ├── locals: [:a]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (392...395))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (393...394))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (393...394))
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (392...393) = "|"
+        │   │   │   └── closing_loc: (394...395) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (390...391) = "{"
+        │   │   └── closing_loc: (396...397) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (399...416))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (399...400) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (400...416))
+        │   │   ├── locals: [:foo, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (402...414))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (403...413))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 1)
+        │   │   │   │   │   └── @ KeywordParameterNode (location: (403...409))
+        │   │   │   │   │       ├── name: :foo
+        │   │   │   │   │       ├── name_loc: (403...407) = "foo:"
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (408...409))
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (411...413))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (412...413) = "b"
+        │   │   │   │       └── operator_loc: (411...412) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (402...403) = "|"
+        │   │   │   └── closing_loc: (413...414) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (400...401) = "{"
+        │   │   └── closing_loc: (415...416) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (418...450))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (418...419) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (419...450))
+        │   │   ├── locals: [:foo, :bar, :baz, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (421...448))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (422...447))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 2)
+        │   │   │   │   │   ├── @ KeywordParameterNode (location: (422...428))
+        │   │   │   │   │   │   ├── name: :foo
+        │   │   │   │   │   │   ├── name_loc: (422...426) = "foo:"
+        │   │   │   │   │   │   └── value:
+        │   │   │   │   │   │       @ IntegerNode (location: (427...428))
+        │   │   │   │   │   └── @ KeywordParameterNode (location: (430...436))
+        │   │   │   │   │       ├── name: :bar
+        │   │   │   │   │       ├── name_loc: (430...434) = "bar:"
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (435...436))
+        │   │   │   │   ├── keyword_rest:
+        │   │   │   │   │   @ KeywordRestParameterNode (location: (438...443))
+        │   │   │   │   │   ├── name: :baz
+        │   │   │   │   │   ├── name_loc: (440...443) = "baz"
+        │   │   │   │   │   └── operator_loc: (438...440) = "**"
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (445...447))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (446...447) = "b"
+        │   │   │   │       └── operator_loc: (445...446) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (421...422) = "|"
+        │   │   │   └── closing_loc: (447...448) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (419...420) = "{"
+        │   │   └── closing_loc: (449...450) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (452...463))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (452...453) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (453...463))
+        │   │   ├── locals: [:foo]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (455...461))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (456...460))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 1)
+        │   │   │   │   │   └── @ KeywordParameterNode (location: (456...460))
+        │   │   │   │   │       ├── name: :foo
+        │   │   │   │   │       ├── name_loc: (456...460) = "foo:"
+        │   │   │   │   │       └── value: ∅
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (455...456) = "|"
+        │   │   │   └── closing_loc: (460...461) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (453...454) = "{"
+        │   │   └── closing_loc: (462...463) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (465...479))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (465...466) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (466...479))
+        │   │   ├── locals: [:o, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (468...477))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (469...476))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (469...472))
+        │   │   │   │   │       ├── name: :o
+        │   │   │   │   │       ├── name_loc: (469...470) = "o"
+        │   │   │   │   │       ├── operator_loc: (470...471) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (471...472))
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (474...476))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (475...476) = "b"
+        │   │   │   │       └── operator_loc: (474...475) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (468...469) = "|"
+        │   │   │   └── closing_loc: (476...477) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (466...467) = "{"
+        │   │   └── closing_loc: (478...479) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (481...499))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (481...482) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (482...499))
+        │   │   ├── locals: [:o, :r, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (484...497))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (485...496))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (485...488))
+        │   │   │   │   │       ├── name: :o
+        │   │   │   │   │       ├── name_loc: (485...486) = "o"
+        │   │   │   │   │       ├── operator_loc: (486...487) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (487...488))
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (490...492))
+        │   │   │   │   │   ├── name: :r
+        │   │   │   │   │   ├── name_loc: (491...492) = "r"
+        │   │   │   │   │   └── operator_loc: (490...491) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (494...496))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (495...496) = "b"
+        │   │   │   │       └── operator_loc: (494...495) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (484...485) = "|"
+        │   │   │   └── closing_loc: (496...497) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (482...483) = "{"
+        │   │   └── closing_loc: (498...499) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (501...522))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (501...502) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (502...522))
+        │   │   ├── locals: [:o, :r, :p, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (504...520))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (505...519))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (505...508))
+        │   │   │   │   │       ├── name: :o
+        │   │   │   │   │       ├── name_loc: (505...506) = "o"
+        │   │   │   │   │       ├── operator_loc: (506...507) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (507...508))
+        │   │   │   │   ├── posts: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (514...515))
+        │   │   │   │   │       └── name: :p
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ RestParameterNode (location: (510...512))
+        │   │   │   │   │   ├── name: :r
+        │   │   │   │   │   ├── name_loc: (511...512) = "r"
+        │   │   │   │   │   └── operator_loc: (510...511) = "*"
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (517...519))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (518...519) = "b"
+        │   │   │   │       └── operator_loc: (517...518) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (504...505) = "|"
+        │   │   │   └── closing_loc: (519...520) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (502...503) = "{"
+        │   │   └── closing_loc: (521...522) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ CallNode (location: (524...541))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (524...525) = "f"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (525...541))
+        │   │   ├── locals: [:o, :p, :b]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (527...539))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (528...538))
+        │   │   │   │   ├── requireds: (length: 0)
+        │   │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   │   └── @ OptionalParameterNode (location: (528...531))
+        │   │   │   │   │       ├── name: :o
+        │   │   │   │   │       ├── name_loc: (528...529) = "o"
+        │   │   │   │   │       ├── operator_loc: (529...530) = "="
+        │   │   │   │   │       └── value:
+        │   │   │   │   │           @ IntegerNode (location: (530...531))
+        │   │   │   │   ├── posts: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (533...534))
+        │   │   │   │   │       └── name: :p
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block:
+        │   │   │   │       @ BlockParameterNode (location: (536...538))
+        │   │   │   │       ├── name: :b
+        │   │   │   │       ├── name_loc: (537...538) = "b"
+        │   │   │   │       └── operator_loc: (536...537) = "&"
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (527...528) = "|"
+        │   │   │   └── closing_loc: (538...539) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (525...526) = "{"
+        │   │   └── closing_loc: (540...541) = "}"
+        │   ├── flags: 
+        │   └── name: "f"
+        └── @ CallNode (location: (543...550))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (543...544) = "f"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (544...550))
+            │   ├── locals: []
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (546...548))
+            │   │   ├── parameters: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (546...547) = "|"
+            │   │   └── closing_loc: (547...548) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (544...545) = "{"
+            │   └── closing_loc: (549...550) = "}"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/whitequark/break.txt b/test/yarp/snapshots/whitequark/break.txt
index 46d3b6a570..f83a13166a 100644
--- a/test/yarp/snapshots/whitequark/break.txt
+++ b/test/yarp/snapshots/whitequark/break.txt
@@ -1,40 +1,53 @@
-ProgramNode(0...37)(
-  [],
-  StatementsNode(0...37)(
-    [BreakNode(0...5)(nil, (0...5)),
-     BreakNode(7...16)(
-       ArgumentsNode(13...16)(
-         [CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo")]
-       ),
-       (7...12)
-     ),
-     BreakNode(18...25)(
-       ArgumentsNode(23...25)(
-         [ParenthesesNode(23...25)(nil, (23...24), (24...25))]
-       ),
-       (18...23)
-     ),
-     BreakNode(27...37)(
-       ArgumentsNode(32...37)(
-         [ParenthesesNode(32...37)(
-            StatementsNode(33...36)(
-              [CallNode(33...36)(
-                 nil,
-                 nil,
-                 (33...36),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               )]
-            ),
-            (32...33),
-            (36...37)
-          )]
-       ),
-       (27...32)
-     )]
-  )
-)
+@ ProgramNode (location: (0...37))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...37))
+    └── body: (length: 4)
+        ├── @ BreakNode (location: (0...5))
+        │   ├── arguments: ∅
+        │   └── keyword_loc: (0...5) = "break"
+        ├── @ BreakNode (location: (7...16))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (13...16))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (13...16))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (13...16) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "foo"
+        │   └── keyword_loc: (7...12) = "break"
+        ├── @ BreakNode (location: (18...25))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (23...25))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (23...25))
+        │   │           ├── body: ∅
+        │   │           ├── opening_loc: (23...24) = "("
+        │   │           └── closing_loc: (24...25) = ")"
+        │   └── keyword_loc: (18...23) = "break"
+        └── @ BreakNode (location: (27...37))
+            ├── arguments:
+            │   @ ArgumentsNode (location: (32...37))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (32...37))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (33...36))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (33...36))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (33...36) = "foo"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "foo"
+            │           ├── opening_loc: (32...33) = "("
+            │           └── closing_loc: (36...37) = ")"
+            └── keyword_loc: (27...32) = "break"
diff --git a/test/yarp/snapshots/whitequark/break_block.txt b/test/yarp/snapshots/whitequark/break_block.txt
index ad81bcf163..04fc2bdcd6 100644
--- a/test/yarp/snapshots/whitequark/break_block.txt
+++ b/test/yarp/snapshots/whitequark/break_block.txt
@@ -1,33 +1,38 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [BreakNode(0...20)(
-       ArgumentsNode(6...20)(
-         [CallNode(6...20)(
-            nil,
-            nil,
-            (6...9),
-            nil,
-            ArgumentsNode(10...13)(
-              [CallNode(10...13)(
-                 nil,
-                 nil,
-                 (10...13),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               )]
-            ),
-            nil,
-            BlockNode(14...20)([], nil, nil, (14...16), (17...20)),
-            0,
-            "fun"
-          )]
-       ),
-       (0...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ BreakNode (location: (0...20))
+            ├── arguments:
+            │   @ ArgumentsNode (location: (6...20))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (6...20))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (6...9) = "fun"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (10...13))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ CallNode (location: (10...13))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (10...13) = "foo"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "foo"
+            │           ├── closing_loc: ∅
+            │           ├── block:
+            │           │   @ BlockNode (location: (14...20))
+            │           │   ├── locals: []
+            │           │   ├── parameters: ∅
+            │           │   ├── body: ∅
+            │           │   ├── opening_loc: (14...16) = "do"
+            │           │   └── closing_loc: (17...20) = "end"
+            │           ├── flags: 
+            │           └── name: "fun"
+            └── keyword_loc: (0...5) = "break"
diff --git a/test/yarp/snapshots/whitequark/bug_435.txt b/test/yarp/snapshots/whitequark/bug_435.txt
index 7d74c8c8a2..a287a0513f 100644
--- a/test/yarp/snapshots/whitequark/bug_435.txt
+++ b/test/yarp/snapshots/whitequark/bug_435.txt
@@ -1,36 +1,37 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [InterpolatedStringNode(0...14)(
-       (0...1),
-       [EmbeddedStatementsNode(1...13)(
-          (1...3),
-          StatementsNode(3...12)(
-            [LambdaNode(3...12)(
-               [:foo],
-               (3...5),
-               (10...11),
-               (11...12),
-               BlockParametersNode(6...9)(
-                 ParametersNode(6...9)(
-                   [RequiredParameterNode(6...9)(:foo)],
-                   [],
-                   [],
-                   nil,
-                   [],
-                   nil,
-                   nil
-                 ),
-                 [],
-                 nil,
-                 nil
-               ),
-               nil
-             )]
-          ),
-          (12...13)
-        )],
-       (13...14)
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...14))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 1)
+            │   └── @ EmbeddedStatementsNode (location: (1...13))
+            │       ├── opening_loc: (1...3) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (3...12))
+            │       │   └── body: (length: 1)
+            │       │       └── @ LambdaNode (location: (3...12))
+            │       │           ├── locals: [:foo]
+            │       │           ├── operator_loc: (3...5) = "->"
+            │       │           ├── opening_loc: (10...11) = "{"
+            │       │           ├── closing_loc: (11...12) = "}"
+            │       │           ├── parameters:
+            │       │           │   @ BlockParametersNode (location: (6...9))
+            │       │           │   ├── parameters:
+            │       │           │   │   @ ParametersNode (location: (6...9))
+            │       │           │   │   ├── requireds: (length: 1)
+            │       │           │   │   │   └── @ RequiredParameterNode (location: (6...9))
+            │       │           │   │   │       └── name: :foo
+            │       │           │   │   ├── optionals: (length: 0)
+            │       │           │   │   ├── posts: (length: 0)
+            │       │           │   │   ├── rest: ∅
+            │       │           │   │   ├── keywords: (length: 0)
+            │       │           │   │   ├── keyword_rest: ∅
+            │       │           │   │   └── block: ∅
+            │       │           │   ├── locals: (length: 0)
+            │       │           │   ├── opening_loc: ∅
+            │       │           │   └── closing_loc: ∅
+            │       │           └── body: ∅
+            │       └── closing_loc: (12...13) = "}"
+            └── closing_loc: (13...14) = "\""
diff --git a/test/yarp/snapshots/whitequark/bug_447.txt b/test/yarp/snapshots/whitequark/bug_447.txt
index 3903748cec..691848adf0 100644
--- a/test/yarp/snapshots/whitequark/bug_447.txt
+++ b/test/yarp/snapshots/whitequark/bug_447.txt
@@ -1,29 +1,50 @@
-ProgramNode(0...27)(
-  [],
-  StatementsNode(0...27)(
-    [CallNode(0...11)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...4)([ArrayNode(2...4)([], (2...3), (3...4))]),
-       nil,
-       BlockNode(5...11)([], nil, nil, (5...7), (8...11)),
-       0,
-       "m"
-     ),
-     CallNode(13...27)(
-       nil,
-       nil,
-       (13...14),
-       nil,
-       ArgumentsNode(15...20)(
-         [ArrayNode(15...17)([], (15...16), (16...17)), IntegerNode(19...20)()]
-       ),
-       nil,
-       BlockNode(21...27)([], nil, nil, (21...23), (24...27)),
-       0,
-       "m"
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...11))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...4))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ArrayNode (location: (2...4))
+        │   │           ├── elements: (length: 0)
+        │   │           ├── opening_loc: (2...3) = "["
+        │   │           └── closing_loc: (3...4) = "]"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (5...11))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (5...7) = "do"
+        │   │   └── closing_loc: (8...11) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        └── @ CallNode (location: (13...27))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (13...14) = "m"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (15...20))
+            │   └── arguments: (length: 2)
+            │       ├── @ ArrayNode (location: (15...17))
+            │       │   ├── elements: (length: 0)
+            │       │   ├── opening_loc: (15...16) = "["
+            │       │   └── closing_loc: (16...17) = "]"
+            │       └── @ IntegerNode (location: (19...20))
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (21...27))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (21...23) = "do"
+            │   └── closing_loc: (24...27) = "end"
+            ├── flags: 
+            └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/bug_452.txt b/test/yarp/snapshots/whitequark/bug_452.txt
index 31cf38cfc2..be37df34df 100644
--- a/test/yarp/snapshots/whitequark/bug_452.txt
+++ b/test/yarp/snapshots/whitequark/bug_452.txt
@@ -1,43 +1,60 @@
-ProgramNode(0...37)(
-  [],
-  StatementsNode(0...37)(
-    [CallNode(0...21)(
-       nil,
-       nil,
-       (0...2),
-       nil,
-       ArgumentsNode(3...21)(
-         [CallNode(3...21)(
-            ParenthesesNode(3...10)(
-              StatementsNode(4...9)([IntegerNode(4...9)()]),
-              (3...4),
-              (9...10)
-            ),
-            (10...11),
-            (11...19),
-            (19...20),
-            nil,
-            (20...21),
-            nil,
-            0,
-            "toString"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "td"
-     ),
-     CallNode(23...37)(
-       CallNode(23...25)(nil, nil, (23...25), nil, nil, nil, nil, 2, "td"),
-       (25...26),
-       (26...29),
-       nil,
-       nil,
-       nil,
-       BlockNode(30...37)([], nil, nil, (30...32), (34...37)),
-       0,
-       "num"
-     )]
-  )
-)
+@ ProgramNode (location: (0...37))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...37))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...21))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...2) = "td"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (3...21))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (3...21))
+        │   │           ├── receiver:
+        │   │           │   @ ParenthesesNode (location: (3...10))
+        │   │           │   ├── body:
+        │   │           │   │   @ StatementsNode (location: (4...9))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ IntegerNode (location: (4...9))
+        │   │           │   ├── opening_loc: (3...4) = "("
+        │   │           │   └── closing_loc: (9...10) = ")"
+        │   │           ├── call_operator_loc: (10...11) = "."
+        │   │           ├── message_loc: (11...19) = "toString"
+        │   │           ├── opening_loc: (19...20) = "("
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: (20...21) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "toString"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "td"
+        └── @ CallNode (location: (23...37))
+            ├── receiver:
+            │   @ CallNode (location: (23...25))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (23...25) = "td"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "td"
+            ├── call_operator_loc: (25...26) = "."
+            ├── message_loc: (26...29) = "num"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (30...37))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (30...32) = "do"
+            │   └── closing_loc: (34...37) = "end"
+            ├── flags: 
+            └── name: "num"
diff --git a/test/yarp/snapshots/whitequark/bug_466.txt b/test/yarp/snapshots/whitequark/bug_466.txt
index 3b153e4995..8813c7e644 100644
--- a/test/yarp/snapshots/whitequark/bug_466.txt
+++ b/test/yarp/snapshots/whitequark/bug_466.txt
@@ -1,54 +1,63 @@
-ProgramNode(0...27)(
-  [],
-  StatementsNode(0...27)(
-    [CallNode(0...27)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...19)(
-         [InterpolatedStringNode(4...19)(
-            (4...5),
-            [EmbeddedStatementsNode(5...18)(
-               (5...7),
-               StatementsNode(7...17)(
-                 [CallNode(7...17)(
-                    ParenthesesNode(7...12)(
-                      StatementsNode(8...11)(
-                        [CallNode(8...11)(
-                           IntegerNode(8...9)(),
-                           nil,
-                           (9...10),
-                           nil,
-                           ArgumentsNode(10...11)([IntegerNode(10...11)()]),
-                           nil,
-                           nil,
-                           0,
-                           "+"
-                         )]
-                      ),
-                      (7...8),
-                      (11...12)
-                    ),
-                    (12...13),
-                    (13...17),
-                    nil,
-                    nil,
-                    nil,
-                    nil,
-                    0,
-                    "to_i"
-                  )]
-               ),
-               (17...18)
-             )],
-            (18...19)
-          )]
-       ),
-       nil,
-       BlockNode(20...27)([], nil, nil, (20...22), (24...27)),
-       0,
-       "foo"
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...27))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "foo"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...19))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedStringNode (location: (4...19))
+            │           ├── opening_loc: (4...5) = "\""
+            │           ├── parts: (length: 1)
+            │           │   └── @ EmbeddedStatementsNode (location: (5...18))
+            │           │       ├── opening_loc: (5...7) = "\#{"
+            │           │       ├── statements:
+            │           │       │   @ StatementsNode (location: (7...17))
+            │           │       │   └── body: (length: 1)
+            │           │       │       └── @ CallNode (location: (7...17))
+            │           │       │           ├── receiver:
+            │           │       │           │   @ ParenthesesNode (location: (7...12))
+            │           │       │           │   ├── body:
+            │           │       │           │   │   @ StatementsNode (location: (8...11))
+            │           │       │           │   │   └── body: (length: 1)
+            │           │       │           │   │       └── @ CallNode (location: (8...11))
+            │           │       │           │   │           ├── receiver:
+            │           │       │           │   │           │   @ IntegerNode (location: (8...9))
+            │           │       │           │   │           ├── call_operator_loc: ∅
+            │           │       │           │   │           ├── message_loc: (9...10) = "+"
+            │           │       │           │   │           ├── opening_loc: ∅
+            │           │       │           │   │           ├── arguments:
+            │           │       │           │   │           │   @ ArgumentsNode (location: (10...11))
+            │           │       │           │   │           │   └── arguments: (length: 1)
+            │           │       │           │   │           │       └── @ IntegerNode (location: (10...11))
+            │           │       │           │   │           ├── closing_loc: ∅
+            │           │       │           │   │           ├── block: ∅
+            │           │       │           │   │           ├── flags: 
+            │           │       │           │   │           └── name: "+"
+            │           │       │           │   ├── opening_loc: (7...8) = "("
+            │           │       │           │   └── closing_loc: (11...12) = ")"
+            │           │       │           ├── call_operator_loc: (12...13) = "."
+            │           │       │           ├── message_loc: (13...17) = "to_i"
+            │           │       │           ├── opening_loc: ∅
+            │           │       │           ├── arguments: ∅
+            │           │       │           ├── closing_loc: ∅
+            │           │       │           ├── block: ∅
+            │           │       │           ├── flags: 
+            │           │       │           └── name: "to_i"
+            │           │       └── closing_loc: (17...18) = "}"
+            │           └── closing_loc: (18...19) = "\""
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (20...27))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (20...22) = "do"
+            │   └── closing_loc: (24...27) = "end"
+            ├── flags: 
+            └── name: "foo"
diff --git a/test/yarp/snapshots/whitequark/bug_473.txt b/test/yarp/snapshots/whitequark/bug_473.txt
index a9978db50d..12228231e0 100644
--- a/test/yarp/snapshots/whitequark/bug_473.txt
+++ b/test/yarp/snapshots/whitequark/bug_473.txt
@@ -1,26 +1,31 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...9)(
-         [InterpolatedStringNode(2...9)(
-            (2...3),
-            [EmbeddedStatementsNode(3...8)(
-               (3...5),
-               StatementsNode(5...7)([ArrayNode(5...7)([], (5...6), (6...7))]),
-               (7...8)
-             )],
-            (8...9)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "m"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "m"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...9))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedStringNode (location: (2...9))
+            │           ├── opening_loc: (2...3) = "\""
+            │           ├── parts: (length: 1)
+            │           │   └── @ EmbeddedStatementsNode (location: (3...8))
+            │           │       ├── opening_loc: (3...5) = "\#{"
+            │           │       ├── statements:
+            │           │       │   @ StatementsNode (location: (5...7))
+            │           │       │   └── body: (length: 1)
+            │           │       │       └── @ ArrayNode (location: (5...7))
+            │           │       │           ├── elements: (length: 0)
+            │           │       │           ├── opening_loc: (5...6) = "["
+            │           │       │           └── closing_loc: (6...7) = "]"
+            │           │       └── closing_loc: (7...8) = "}"
+            │           └── closing_loc: (8...9) = "\""
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/bug_480.txt b/test/yarp/snapshots/whitequark/bug_480.txt
index 8457cefa86..242b25fe86 100644
--- a/test/yarp/snapshots/whitequark/bug_480.txt
+++ b/test/yarp/snapshots/whitequark/bug_480.txt
@@ -1,29 +1,35 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...12)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...12)(
-         [InterpolatedStringNode(2...12)(
-            (2...3),
-            [EmbeddedStatementsNode(3...6)((3...5), nil, (5...6)),
-             EmbeddedStatementsNode(6...11)(
-               (6...8),
-               StatementsNode(8...10)(
-                 [ParenthesesNode(8...10)(nil, (8...9), (9...10))]
-               ),
-               (10...11)
-             )],
-            (11...12)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "m"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...12))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "m"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...12))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedStringNode (location: (2...12))
+            │           ├── opening_loc: (2...3) = "\""
+            │           ├── parts: (length: 2)
+            │           │   ├── @ EmbeddedStatementsNode (location: (3...6))
+            │           │   │   ├── opening_loc: (3...5) = "\#{"
+            │           │   │   ├── statements: ∅
+            │           │   │   └── closing_loc: (5...6) = "}"
+            │           │   └── @ EmbeddedStatementsNode (location: (6...11))
+            │           │       ├── opening_loc: (6...8) = "\#{"
+            │           │       ├── statements:
+            │           │       │   @ StatementsNode (location: (8...10))
+            │           │       │   └── body: (length: 1)
+            │           │       │       └── @ ParenthesesNode (location: (8...10))
+            │           │       │           ├── body: ∅
+            │           │       │           ├── opening_loc: (8...9) = "("
+            │           │       │           └── closing_loc: (9...10) = ")"
+            │           │       └── closing_loc: (10...11) = "}"
+            │           └── closing_loc: (11...12) = "\""
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/bug_481.txt b/test/yarp/snapshots/whitequark/bug_481.txt
index 5bdeaf1d47..94eac2be77 100644
--- a/test/yarp/snapshots/whitequark/bug_481.txt
+++ b/test/yarp/snapshots/whitequark/bug_481.txt
@@ -1,42 +1,47 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...14)(
-         [DefNode(2...14)(
-            :x,
-            (6...7),
-            nil,
-            nil,
-            nil,
-            [],
-            (2...5),
-            nil,
-            (7...8),
-            (8...9),
-            nil,
-            (11...14)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "m"
-     ),
-     CallNode(16...28)(
-       IntegerNode(16...17)(),
-       (17...18),
-       (18...21),
-       nil,
-       nil,
-       nil,
-       BlockNode(22...28)([], nil, nil, (22...24), (25...28)),
-       0,
-       "tap"
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...14))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...14))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ DefNode (location: (2...14))
+        │   │           ├── name: :x
+        │   │           ├── name_loc: (6...7) = "x"
+        │   │           ├── receiver: ∅
+        │   │           ├── parameters: ∅
+        │   │           ├── body: ∅
+        │   │           ├── locals: []
+        │   │           ├── def_keyword_loc: (2...5) = "def"
+        │   │           ├── operator_loc: ∅
+        │   │           ├── lparen_loc: (7...8) = "("
+        │   │           ├── rparen_loc: (8...9) = ")"
+        │   │           ├── equal_loc: ∅
+        │   │           └── end_keyword_loc: (11...14) = "end"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "m"
+        └── @ CallNode (location: (16...28))
+            ├── receiver:
+            │   @ IntegerNode (location: (16...17))
+            ├── call_operator_loc: (17...18) = "."
+            ├── message_loc: (18...21) = "tap"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (22...28))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (22...24) = "do"
+            │   └── closing_loc: (25...28) = "end"
+            ├── flags: 
+            └── name: "tap"
diff --git a/test/yarp/snapshots/whitequark/bug_ascii_8bit_in_literal.txt b/test/yarp/snapshots/whitequark/bug_ascii_8bit_in_literal.txt
index 40251879fc..6fdd7daadf 100644
--- a/test/yarp/snapshots/whitequark/bug_ascii_8bit_in_literal.txt
+++ b/test/yarp/snapshots/whitequark/bug_ascii_8bit_in_literal.txt
@@ -1,6 +1,10 @@
-ProgramNode(24...90)(
-  [],
-  StatementsNode(24...90)(
-    [StringNode(24...90)((24...25), (25...89), (89...90), "проверка")]
-  )
-)
+@ ProgramNode (location: (24...90))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (24...90))
+    └── body: (length: 1)
+        └── @ StringNode (location: (24...90))
+            ├── opening_loc: (24...25) = "\""
+            ├── content_loc: (25...89) = "\\xD0\\xBF\\xD1\\x80\\xD0\\xBE\\xD0\\xB2\\xD0\\xB5\\xD1\\x80\\xD0\\xBA\\xD0\\xB0"
+            ├── closing_loc: (89...90) = "\""
+            └── unescaped: "проверка"
diff --git a/test/yarp/snapshots/whitequark/bug_cmd_string_lookahead.txt b/test/yarp/snapshots/whitequark/bug_cmd_string_lookahead.txt
index 0004e1a758..997f487cb9 100644
--- a/test/yarp/snapshots/whitequark/bug_cmd_string_lookahead.txt
+++ b/test/yarp/snapshots/whitequark/bug_cmd_string_lookahead.txt
@@ -1,18 +1,28 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...4),
-       nil,
-       ArgumentsNode(5...10)(
-         [StringNode(5...10)((5...6), (6...9), (9...10), "foo")]
-       ),
-       nil,
-       BlockNode(11...17)([], nil, nil, (11...13), (14...17)),
-       0,
-       "desc"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...4) = "desc"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...10))
+            │   └── arguments: (length: 1)
+            │       └── @ StringNode (location: (5...10))
+            │           ├── opening_loc: (5...6) = "\""
+            │           ├── content_loc: (6...9) = "foo"
+            │           ├── closing_loc: (9...10) = "\""
+            │           └── unescaped: "foo"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (11...17))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (11...13) = "do"
+            │   └── closing_loc: (14...17) = "end"
+            ├── flags: 
+            └── name: "desc"
diff --git a/test/yarp/snapshots/whitequark/bug_cmdarg.txt b/test/yarp/snapshots/whitequark/bug_cmdarg.txt
index b3f79aafd4..9d1a7d3f74 100644
--- a/test/yarp/snapshots/whitequark/bug_cmdarg.txt
+++ b/test/yarp/snapshots/whitequark/bug_cmdarg.txt
@@ -1,85 +1,99 @@
-ProgramNode(0...56)(
-  [],
-  StatementsNode(0...56)(
-    [CallNode(0...15)(
-       nil,
-       nil,
-       (0...6),
-       nil,
-       ArgumentsNode(7...15)(
-         [KeywordHashNode(7...15)(
-            [AssocNode(7...15)(
-               SymbolNode(7...10)(nil, (7...9), (9...10), "do"),
-               TrueNode(11...15)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "assert"
-     ),
-     CallNode(17...28)(
-       nil,
-       nil,
-       (17...23),
-       nil,
-       ArgumentsNode(24...28)(
-         [CallNode(24...28)(
-            nil,
-            nil,
-            (24...28),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "dogs"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "assert"
-     ),
-     CallNode(30...56)(
-       nil,
-       nil,
-       (30...31),
-       nil,
-       ArgumentsNode(32...56)(
-         [KeywordHashNode(32...56)(
-            [AssocNode(32...56)(
-               SymbolNode(32...34)(nil, (32...33), (33...34), "x"),
-               LambdaNode(35...56)(
-                 [],
-                 (35...37),
-                 (38...40),
-                 (53...56),
-                 nil,
-                 StatementsNode(41...52)(
-                   [CallNode(41...52)(
-                      nil,
-                      nil,
-                      (41...45),
-                      nil,
-                      nil,
-                      nil,
-                      BlockNode(46...52)([], nil, nil, (46...48), (49...52)),
-                      0,
-                      "meth"
-                    )]
-                 )
-               ),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...56))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...56))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...15))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...6) = "assert"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (7...15))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (7...15))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (7...15))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (7...10))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (7...9) = "do"
+        │   │                   │   ├── closing_loc: (9...10) = ":"
+        │   │                   │   └── unescaped: "do"
+        │   │                   ├── value:
+        │   │                   │   @ TrueNode (location: (11...15))
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "assert"
+        ├── @ CallNode (location: (17...28))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (17...23) = "assert"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (24...28))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (24...28))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (24...28) = "dogs"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "dogs"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "assert"
+        └── @ CallNode (location: (30...56))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (30...31) = "f"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (32...56))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (32...56))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (32...56))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (32...34))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (32...33) = "x"
+            │                   │   ├── closing_loc: (33...34) = ":"
+            │                   │   └── unescaped: "x"
+            │                   ├── value:
+            │                   │   @ LambdaNode (location: (35...56))
+            │                   │   ├── locals: []
+            │                   │   ├── operator_loc: (35...37) = "->"
+            │                   │   ├── opening_loc: (38...40) = "do"
+            │                   │   ├── closing_loc: (53...56) = "end"
+            │                   │   ├── parameters: ∅
+            │                   │   └── body:
+            │                   │       @ StatementsNode (location: (41...52))
+            │                   │       └── body: (length: 1)
+            │                   │           └── @ CallNode (location: (41...52))
+            │                   │               ├── receiver: ∅
+            │                   │               ├── call_operator_loc: ∅
+            │                   │               ├── message_loc: (41...45) = "meth"
+            │                   │               ├── opening_loc: ∅
+            │                   │               ├── arguments: ∅
+            │                   │               ├── closing_loc: ∅
+            │                   │               ├── block:
+            │                   │               │   @ BlockNode (location: (46...52))
+            │                   │               │   ├── locals: []
+            │                   │               │   ├── parameters: ∅
+            │                   │               │   ├── body: ∅
+            │                   │               │   ├── opening_loc: (46...48) = "do"
+            │                   │               │   └── closing_loc: (49...52) = "end"
+            │                   │               ├── flags: 
+            │                   │               └── name: "meth"
+            │                   └── operator_loc: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/whitequark/bug_def_no_paren_eql_begin.txt b/test/yarp/snapshots/whitequark/bug_def_no_paren_eql_begin.txt
index 24159031ce..7c40b5754d 100644
--- a/test/yarp/snapshots/whitequark/bug_def_no_paren_eql_begin.txt
+++ b/test/yarp/snapshots/whitequark/bug_def_no_paren_eql_begin.txt
@@ -1,19 +1,18 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [DefNode(0...23)(
-       :foo,
-       (4...7),
-       nil,
-       nil,
-       nil,
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (20...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...23))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (20...23) = "end"
diff --git a/test/yarp/snapshots/whitequark/bug_do_block_in_call_args.txt b/test/yarp/snapshots/whitequark/bug_do_block_in_call_args.txt
index 70ce5db09b..b109b3fafc 100644
--- a/test/yarp/snapshots/whitequark/bug_do_block_in_call_args.txt
+++ b/test/yarp/snapshots/whitequark/bug_do_block_in_call_args.txt
@@ -1,43 +1,49 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [CallNode(0...33)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...33)(
-         [DefNode(4...33)(
-            :foo,
-            (8...11),
-            nil,
-            nil,
-            StatementsNode(13...29)(
-              [CallNode(13...29)(
-                 SelfNode(13...17)(),
-                 (17...18),
-                 (18...22),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(23...29)([], nil, nil, (23...25), (26...29)),
-                 0,
-                 "each"
-               )]
-            ),
-            [],
-            (4...7),
-            nil,
-            nil,
-            nil,
-            nil,
-            (30...33)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "bar"
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...33))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "bar"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...33))
+            │   └── arguments: (length: 1)
+            │       └── @ DefNode (location: (4...33))
+            │           ├── name: :foo
+            │           ├── name_loc: (8...11) = "foo"
+            │           ├── receiver: ∅
+            │           ├── parameters: ∅
+            │           ├── body:
+            │           │   @ StatementsNode (location: (13...29))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (13...29))
+            │           │           ├── receiver:
+            │           │           │   @ SelfNode (location: (13...17))
+            │           │           ├── call_operator_loc: (17...18) = "."
+            │           │           ├── message_loc: (18...22) = "each"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block:
+            │           │           │   @ BlockNode (location: (23...29))
+            │           │           │   ├── locals: []
+            │           │           │   ├── parameters: ∅
+            │           │           │   ├── body: ∅
+            │           │           │   ├── opening_loc: (23...25) = "do"
+            │           │           │   └── closing_loc: (26...29) = "end"
+            │           │           ├── flags: 
+            │           │           └── name: "each"
+            │           ├── locals: []
+            │           ├── def_keyword_loc: (4...7) = "def"
+            │           ├── operator_loc: ∅
+            │           ├── lparen_loc: ∅
+            │           ├── rparen_loc: ∅
+            │           ├── equal_loc: ∅
+            │           └── end_keyword_loc: (30...33) = "end"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "bar"
diff --git a/test/yarp/snapshots/whitequark/bug_do_block_in_cmdarg.txt b/test/yarp/snapshots/whitequark/bug_do_block_in_cmdarg.txt
index 81fa1d3609..f4a5db8bc3 100644
--- a/test/yarp/snapshots/whitequark/bug_do_block_in_cmdarg.txt
+++ b/test/yarp/snapshots/whitequark/bug_do_block_in_cmdarg.txt
@@ -1,34 +1,39 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...17)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...17)(
-         [ParenthesesNode(4...17)(
-            StatementsNode(5...16)(
-              [CallNode(5...16)(
-                 nil,
-                 nil,
-                 (5...9),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(10...16)([], nil, nil, (10...12), (13...16)),
-                 0,
-                 "proc"
-               )]
-            ),
-            (4...5),
-            (16...17)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "tap"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "tap"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...17))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (4...17))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (5...16))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (5...16))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (5...9) = "proc"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block:
+            │           │           │   @ BlockNode (location: (10...16))
+            │           │           │   ├── locals: []
+            │           │           │   ├── parameters: ∅
+            │           │           │   ├── body: ∅
+            │           │           │   ├── opening_loc: (10...12) = "do"
+            │           │           │   └── closing_loc: (13...16) = "end"
+            │           │           ├── flags: 
+            │           │           └── name: "proc"
+            │           ├── opening_loc: (4...5) = "("
+            │           └── closing_loc: (16...17) = ")"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "tap"
diff --git a/test/yarp/snapshots/whitequark/bug_do_block_in_hash_brace.txt b/test/yarp/snapshots/whitequark/bug_do_block_in_hash_brace.txt
index bce92ea25b..62db6cd67b 100644
--- a/test/yarp/snapshots/whitequark/bug_do_block_in_hash_brace.txt
+++ b/test/yarp/snapshots/whitequark/bug_do_block_in_hash_brace.txt
@@ -1,249 +1,365 @@
-ProgramNode(0...225)(
-  [],
-  StatementsNode(0...225)(
-    [CallNode(0...42)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...42)(
-         [SymbolNode(2...6)((2...3), (3...6), nil, "foo"),
-          HashNode(8...42)(
-            (8...9),
-            [AssocNode(9...25)(
-               SymbolNode(9...13)((9...10), (10...11), (11...13), "a"),
-               CallNode(14...25)(
-                 nil,
-                 nil,
-                 (14...18),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(19...25)([], nil, nil, (19...21), (22...25)),
-                 0,
-                 "proc"
-               ),
-               nil
-             ),
-             AssocNode(27...41)(
-               SymbolNode(27...29)(nil, (27...28), (28...29), "b"),
-               CallNode(30...41)(
-                 nil,
-                 nil,
-                 (30...34),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(35...41)([], nil, nil, (35...37), (38...41)),
-                 0,
-                 "proc"
-               ),
-               nil
-             )],
-            (41...42)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(44...84)(
-       nil,
-       nil,
-       (44...45),
-       nil,
-       ArgumentsNode(46...84)(
-         [SymbolNode(46...50)((46...47), (47...50), nil, "foo"),
-          HashNode(52...84)(
-            (52...53),
-            [AssocSplatNode(53...67)(
-               CallNode(56...67)(
-                 nil,
-                 nil,
-                 (56...60),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(61...67)([], nil, nil, (61...63), (64...67)),
-                 0,
-                 "proc"
-               ),
-               (53...55)
-             ),
-             AssocNode(69...83)(
-               SymbolNode(69...71)(nil, (69...70), (70...71), "b"),
-               CallNode(72...83)(
-                 nil,
-                 nil,
-                 (72...76),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(77...83)([], nil, nil, (77...79), (80...83)),
-                 0,
-                 "proc"
-               ),
-               nil
-             )],
-            (83...84)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(86...129)(
-       nil,
-       nil,
-       (86...87),
-       nil,
-       ArgumentsNode(88...129)(
-         [SymbolNode(88...92)((88...89), (89...92), nil, "foo"),
-          HashNode(94...129)(
-            (94...95),
-            [AssocNode(95...112)(
-               SymbolNode(95...97)((95...96), (96...97), nil, "a"),
-               CallNode(101...112)(
-                 nil,
-                 nil,
-                 (101...105),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(106...112)([], nil, nil, (106...108), (109...112)),
-                 0,
-                 "proc"
-               ),
-               (98...100)
-             ),
-             AssocNode(114...128)(
-               SymbolNode(114...116)(nil, (114...115), (115...116), "b"),
-               CallNode(117...128)(
-                 nil,
-                 nil,
-                 (117...121),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(122...128)([], nil, nil, (122...124), (125...128)),
-                 0,
-                 "proc"
-               ),
-               nil
-             )],
-            (128...129)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(131...171)(
-       nil,
-       nil,
-       (131...132),
-       nil,
-       ArgumentsNode(133...171)(
-         [SymbolNode(133...137)((133...134), (134...137), nil, "foo"),
-          HashNode(139...171)(
-            (139...140),
-            [AssocNode(140...154)(
-               SymbolNode(140...142)(nil, (140...141), (141...142), "a"),
-               CallNode(143...154)(
-                 nil,
-                 nil,
-                 (143...147),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(148...154)([], nil, nil, (148...150), (151...154)),
-                 0,
-                 "proc"
-               ),
-               nil
-             ),
-             AssocNode(156...170)(
-               SymbolNode(156...158)(nil, (156...157), (157...158), "b"),
-               CallNode(159...170)(
-                 nil,
-                 nil,
-                 (159...163),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(164...170)([], nil, nil, (164...166), (167...170)),
-                 0,
-                 "proc"
-               ),
-               nil
-             )],
-            (170...171)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(173...225)(
-       nil,
-       nil,
-       (173...174),
-       nil,
-       ArgumentsNode(175...225)(
-         [SymbolNode(175...179)((175...176), (176...179), nil, "foo"),
-          HashNode(181...225)(
-            (181...182),
-            [AssocNode(182...208)(
-               CallNode(182...193)(
-                 nil,
-                 nil,
-                 (182...186),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(187...193)([], nil, nil, (187...189), (190...193)),
-                 0,
-                 "proc"
-               ),
-               CallNode(197...208)(
-                 nil,
-                 nil,
-                 (197...201),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(202...208)([], nil, nil, (202...204), (205...208)),
-                 0,
-                 "proc"
-               ),
-               (194...196)
-             ),
-             AssocNode(210...224)(
-               SymbolNode(210...212)(nil, (210...211), (211...212), "b"),
-               CallNode(213...224)(
-                 nil,
-                 nil,
-                 (213...217),
-                 nil,
-                 nil,
-                 nil,
-                 BlockNode(218...224)([], nil, nil, (218...220), (221...224)),
-                 0,
-                 "proc"
-               ),
-               nil
-             )],
-            (224...225)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...225))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...225))
+    └── body: (length: 5)
+        ├── @ CallNode (location: (0...42))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...42))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (2...6))
+        │   │       │   ├── opening_loc: (2...3) = ":"
+        │   │       │   ├── value_loc: (3...6) = "foo"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "foo"
+        │   │       └── @ HashNode (location: (8...42))
+        │   │           ├── opening_loc: (8...9) = "{"
+        │   │           ├── elements: (length: 2)
+        │   │           │   ├── @ AssocNode (location: (9...25))
+        │   │           │   │   ├── key:
+        │   │           │   │   │   @ SymbolNode (location: (9...13))
+        │   │           │   │   │   ├── opening_loc: (9...10) = "\""
+        │   │           │   │   │   ├── value_loc: (10...11) = "a"
+        │   │           │   │   │   ├── closing_loc: (11...13) = "\":"
+        │   │           │   │   │   └── unescaped: "a"
+        │   │           │   │   ├── value:
+        │   │           │   │   │   @ CallNode (location: (14...25))
+        │   │           │   │   │   ├── receiver: ∅
+        │   │           │   │   │   ├── call_operator_loc: ∅
+        │   │           │   │   │   ├── message_loc: (14...18) = "proc"
+        │   │           │   │   │   ├── opening_loc: ∅
+        │   │           │   │   │   ├── arguments: ∅
+        │   │           │   │   │   ├── closing_loc: ∅
+        │   │           │   │   │   ├── block:
+        │   │           │   │   │   │   @ BlockNode (location: (19...25))
+        │   │           │   │   │   │   ├── locals: []
+        │   │           │   │   │   │   ├── parameters: ∅
+        │   │           │   │   │   │   ├── body: ∅
+        │   │           │   │   │   │   ├── opening_loc: (19...21) = "do"
+        │   │           │   │   │   │   └── closing_loc: (22...25) = "end"
+        │   │           │   │   │   ├── flags: 
+        │   │           │   │   │   └── name: "proc"
+        │   │           │   │   └── operator_loc: ∅
+        │   │           │   └── @ AssocNode (location: (27...41))
+        │   │           │       ├── key:
+        │   │           │       │   @ SymbolNode (location: (27...29))
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── value_loc: (27...28) = "b"
+        │   │           │       │   ├── closing_loc: (28...29) = ":"
+        │   │           │       │   └── unescaped: "b"
+        │   │           │       ├── value:
+        │   │           │       │   @ CallNode (location: (30...41))
+        │   │           │       │   ├── receiver: ∅
+        │   │           │       │   ├── call_operator_loc: ∅
+        │   │           │       │   ├── message_loc: (30...34) = "proc"
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── arguments: ∅
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   ├── block:
+        │   │           │       │   │   @ BlockNode (location: (35...41))
+        │   │           │       │   │   ├── locals: []
+        │   │           │       │   │   ├── parameters: ∅
+        │   │           │       │   │   ├── body: ∅
+        │   │           │       │   │   ├── opening_loc: (35...37) = "do"
+        │   │           │       │   │   └── closing_loc: (38...41) = "end"
+        │   │           │       │   ├── flags: 
+        │   │           │       │   └── name: "proc"
+        │   │           │       └── operator_loc: ∅
+        │   │           └── closing_loc: (41...42) = "}"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (44...84))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (44...45) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (46...84))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (46...50))
+        │   │       │   ├── opening_loc: (46...47) = ":"
+        │   │       │   ├── value_loc: (47...50) = "foo"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "foo"
+        │   │       └── @ HashNode (location: (52...84))
+        │   │           ├── opening_loc: (52...53) = "{"
+        │   │           ├── elements: (length: 2)
+        │   │           │   ├── @ AssocSplatNode (location: (53...67))
+        │   │           │   │   ├── value:
+        │   │           │   │   │   @ CallNode (location: (56...67))
+        │   │           │   │   │   ├── receiver: ∅
+        │   │           │   │   │   ├── call_operator_loc: ∅
+        │   │           │   │   │   ├── message_loc: (56...60) = "proc"
+        │   │           │   │   │   ├── opening_loc: ∅
+        │   │           │   │   │   ├── arguments: ∅
+        │   │           │   │   │   ├── closing_loc: ∅
+        │   │           │   │   │   ├── block:
+        │   │           │   │   │   │   @ BlockNode (location: (61...67))
+        │   │           │   │   │   │   ├── locals: []
+        │   │           │   │   │   │   ├── parameters: ∅
+        │   │           │   │   │   │   ├── body: ∅
+        │   │           │   │   │   │   ├── opening_loc: (61...63) = "do"
+        │   │           │   │   │   │   └── closing_loc: (64...67) = "end"
+        │   │           │   │   │   ├── flags: 
+        │   │           │   │   │   └── name: "proc"
+        │   │           │   │   └── operator_loc: (53...55) = "**"
+        │   │           │   └── @ AssocNode (location: (69...83))
+        │   │           │       ├── key:
+        │   │           │       │   @ SymbolNode (location: (69...71))
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── value_loc: (69...70) = "b"
+        │   │           │       │   ├── closing_loc: (70...71) = ":"
+        │   │           │       │   └── unescaped: "b"
+        │   │           │       ├── value:
+        │   │           │       │   @ CallNode (location: (72...83))
+        │   │           │       │   ├── receiver: ∅
+        │   │           │       │   ├── call_operator_loc: ∅
+        │   │           │       │   ├── message_loc: (72...76) = "proc"
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── arguments: ∅
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   ├── block:
+        │   │           │       │   │   @ BlockNode (location: (77...83))
+        │   │           │       │   │   ├── locals: []
+        │   │           │       │   │   ├── parameters: ∅
+        │   │           │       │   │   ├── body: ∅
+        │   │           │       │   │   ├── opening_loc: (77...79) = "do"
+        │   │           │       │   │   └── closing_loc: (80...83) = "end"
+        │   │           │       │   ├── flags: 
+        │   │           │       │   └── name: "proc"
+        │   │           │       └── operator_loc: ∅
+        │   │           └── closing_loc: (83...84) = "}"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (86...129))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (86...87) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (88...129))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (88...92))
+        │   │       │   ├── opening_loc: (88...89) = ":"
+        │   │       │   ├── value_loc: (89...92) = "foo"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "foo"
+        │   │       └── @ HashNode (location: (94...129))
+        │   │           ├── opening_loc: (94...95) = "{"
+        │   │           ├── elements: (length: 2)
+        │   │           │   ├── @ AssocNode (location: (95...112))
+        │   │           │   │   ├── key:
+        │   │           │   │   │   @ SymbolNode (location: (95...97))
+        │   │           │   │   │   ├── opening_loc: (95...96) = ":"
+        │   │           │   │   │   ├── value_loc: (96...97) = "a"
+        │   │           │   │   │   ├── closing_loc: ∅
+        │   │           │   │   │   └── unescaped: "a"
+        │   │           │   │   ├── value:
+        │   │           │   │   │   @ CallNode (location: (101...112))
+        │   │           │   │   │   ├── receiver: ∅
+        │   │           │   │   │   ├── call_operator_loc: ∅
+        │   │           │   │   │   ├── message_loc: (101...105) = "proc"
+        │   │           │   │   │   ├── opening_loc: ∅
+        │   │           │   │   │   ├── arguments: ∅
+        │   │           │   │   │   ├── closing_loc: ∅
+        │   │           │   │   │   ├── block:
+        │   │           │   │   │   │   @ BlockNode (location: (106...112))
+        │   │           │   │   │   │   ├── locals: []
+        │   │           │   │   │   │   ├── parameters: ∅
+        │   │           │   │   │   │   ├── body: ∅
+        │   │           │   │   │   │   ├── opening_loc: (106...108) = "do"
+        │   │           │   │   │   │   └── closing_loc: (109...112) = "end"
+        │   │           │   │   │   ├── flags: 
+        │   │           │   │   │   └── name: "proc"
+        │   │           │   │   └── operator_loc: (98...100) = "=>"
+        │   │           │   └── @ AssocNode (location: (114...128))
+        │   │           │       ├── key:
+        │   │           │       │   @ SymbolNode (location: (114...116))
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── value_loc: (114...115) = "b"
+        │   │           │       │   ├── closing_loc: (115...116) = ":"
+        │   │           │       │   └── unescaped: "b"
+        │   │           │       ├── value:
+        │   │           │       │   @ CallNode (location: (117...128))
+        │   │           │       │   ├── receiver: ∅
+        │   │           │       │   ├── call_operator_loc: ∅
+        │   │           │       │   ├── message_loc: (117...121) = "proc"
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── arguments: ∅
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   ├── block:
+        │   │           │       │   │   @ BlockNode (location: (122...128))
+        │   │           │       │   │   ├── locals: []
+        │   │           │       │   │   ├── parameters: ∅
+        │   │           │       │   │   ├── body: ∅
+        │   │           │       │   │   ├── opening_loc: (122...124) = "do"
+        │   │           │       │   │   └── closing_loc: (125...128) = "end"
+        │   │           │       │   ├── flags: 
+        │   │           │       │   └── name: "proc"
+        │   │           │       └── operator_loc: ∅
+        │   │           └── closing_loc: (128...129) = "}"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (131...171))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (131...132) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (133...171))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ SymbolNode (location: (133...137))
+        │   │       │   ├── opening_loc: (133...134) = ":"
+        │   │       │   ├── value_loc: (134...137) = "foo"
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   └── unescaped: "foo"
+        │   │       └── @ HashNode (location: (139...171))
+        │   │           ├── opening_loc: (139...140) = "{"
+        │   │           ├── elements: (length: 2)
+        │   │           │   ├── @ AssocNode (location: (140...154))
+        │   │           │   │   ├── key:
+        │   │           │   │   │   @ SymbolNode (location: (140...142))
+        │   │           │   │   │   ├── opening_loc: ∅
+        │   │           │   │   │   ├── value_loc: (140...141) = "a"
+        │   │           │   │   │   ├── closing_loc: (141...142) = ":"
+        │   │           │   │   │   └── unescaped: "a"
+        │   │           │   │   ├── value:
+        │   │           │   │   │   @ CallNode (location: (143...154))
+        │   │           │   │   │   ├── receiver: ∅
+        │   │           │   │   │   ├── call_operator_loc: ∅
+        │   │           │   │   │   ├── message_loc: (143...147) = "proc"
+        │   │           │   │   │   ├── opening_loc: ∅
+        │   │           │   │   │   ├── arguments: ∅
+        │   │           │   │   │   ├── closing_loc: ∅
+        │   │           │   │   │   ├── block:
+        │   │           │   │   │   │   @ BlockNode (location: (148...154))
+        │   │           │   │   │   │   ├── locals: []
+        │   │           │   │   │   │   ├── parameters: ∅
+        │   │           │   │   │   │   ├── body: ∅
+        │   │           │   │   │   │   ├── opening_loc: (148...150) = "do"
+        │   │           │   │   │   │   └── closing_loc: (151...154) = "end"
+        │   │           │   │   │   ├── flags: 
+        │   │           │   │   │   └── name: "proc"
+        │   │           │   │   └── operator_loc: ∅
+        │   │           │   └── @ AssocNode (location: (156...170))
+        │   │           │       ├── key:
+        │   │           │       │   @ SymbolNode (location: (156...158))
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── value_loc: (156...157) = "b"
+        │   │           │       │   ├── closing_loc: (157...158) = ":"
+        │   │           │       │   └── unescaped: "b"
+        │   │           │       ├── value:
+        │   │           │       │   @ CallNode (location: (159...170))
+        │   │           │       │   ├── receiver: ∅
+        │   │           │       │   ├── call_operator_loc: ∅
+        │   │           │       │   ├── message_loc: (159...163) = "proc"
+        │   │           │       │   ├── opening_loc: ∅
+        │   │           │       │   ├── arguments: ∅
+        │   │           │       │   ├── closing_loc: ∅
+        │   │           │       │   ├── block:
+        │   │           │       │   │   @ BlockNode (location: (164...170))
+        │   │           │       │   │   ├── locals: []
+        │   │           │       │   │   ├── parameters: ∅
+        │   │           │       │   │   ├── body: ∅
+        │   │           │       │   │   ├── opening_loc: (164...166) = "do"
+        │   │           │       │   │   └── closing_loc: (167...170) = "end"
+        │   │           │       │   ├── flags: 
+        │   │           │       │   └── name: "proc"
+        │   │           │       └── operator_loc: ∅
+        │   │           └── closing_loc: (170...171) = "}"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        └── @ CallNode (location: (173...225))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (173...174) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (175...225))
+            │   └── arguments: (length: 2)
+            │       ├── @ SymbolNode (location: (175...179))
+            │       │   ├── opening_loc: (175...176) = ":"
+            │       │   ├── value_loc: (176...179) = "foo"
+            │       │   ├── closing_loc: ∅
+            │       │   └── unescaped: "foo"
+            │       └── @ HashNode (location: (181...225))
+            │           ├── opening_loc: (181...182) = "{"
+            │           ├── elements: (length: 2)
+            │           │   ├── @ AssocNode (location: (182...208))
+            │           │   │   ├── key:
+            │           │   │   │   @ CallNode (location: (182...193))
+            │           │   │   │   ├── receiver: ∅
+            │           │   │   │   ├── call_operator_loc: ∅
+            │           │   │   │   ├── message_loc: (182...186) = "proc"
+            │           │   │   │   ├── opening_loc: ∅
+            │           │   │   │   ├── arguments: ∅
+            │           │   │   │   ├── closing_loc: ∅
+            │           │   │   │   ├── block:
+            │           │   │   │   │   @ BlockNode (location: (187...193))
+            │           │   │   │   │   ├── locals: []
+            │           │   │   │   │   ├── parameters: ∅
+            │           │   │   │   │   ├── body: ∅
+            │           │   │   │   │   ├── opening_loc: (187...189) = "do"
+            │           │   │   │   │   └── closing_loc: (190...193) = "end"
+            │           │   │   │   ├── flags: 
+            │           │   │   │   └── name: "proc"
+            │           │   │   ├── value:
+            │           │   │   │   @ CallNode (location: (197...208))
+            │           │   │   │   ├── receiver: ∅
+            │           │   │   │   ├── call_operator_loc: ∅
+            │           │   │   │   ├── message_loc: (197...201) = "proc"
+            │           │   │   │   ├── opening_loc: ∅
+            │           │   │   │   ├── arguments: ∅
+            │           │   │   │   ├── closing_loc: ∅
+            │           │   │   │   ├── block:
+            │           │   │   │   │   @ BlockNode (location: (202...208))
+            │           │   │   │   │   ├── locals: []
+            │           │   │   │   │   ├── parameters: ∅
+            │           │   │   │   │   ├── body: ∅
+            │           │   │   │   │   ├── opening_loc: (202...204) = "do"
+            │           │   │   │   │   └── closing_loc: (205...208) = "end"
+            │           │   │   │   ├── flags: 
+            │           │   │   │   └── name: "proc"
+            │           │   │   └── operator_loc: (194...196) = "=>"
+            │           │   └── @ AssocNode (location: (210...224))
+            │           │       ├── key:
+            │           │       │   @ SymbolNode (location: (210...212))
+            │           │       │   ├── opening_loc: ∅
+            │           │       │   ├── value_loc: (210...211) = "b"
+            │           │       │   ├── closing_loc: (211...212) = ":"
+            │           │       │   └── unescaped: "b"
+            │           │       ├── value:
+            │           │       │   @ CallNode (location: (213...224))
+            │           │       │   ├── receiver: ∅
+            │           │       │   ├── call_operator_loc: ∅
+            │           │       │   ├── message_loc: (213...217) = "proc"
+            │           │       │   ├── opening_loc: ∅
+            │           │       │   ├── arguments: ∅
+            │           │       │   ├── closing_loc: ∅
+            │           │       │   ├── block:
+            │           │       │   │   @ BlockNode (location: (218...224))
+            │           │       │   │   ├── locals: []
+            │           │       │   │   ├── parameters: ∅
+            │           │       │   │   ├── body: ∅
+            │           │       │   │   ├── opening_loc: (218...220) = "do"
+            │           │       │   │   └── closing_loc: (221...224) = "end"
+            │           │       │   ├── flags: 
+            │           │       │   └── name: "proc"
+            │           │       └── operator_loc: ∅
+            │           └── closing_loc: (224...225) = "}"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/whitequark/bug_heredoc_do.txt b/test/yarp/snapshots/whitequark/bug_heredoc_do.txt
index 947af0ece7..6707aa214c 100644
--- a/test/yarp/snapshots/whitequark/bug_heredoc_do.txt
+++ b/test/yarp/snapshots/whitequark/bug_heredoc_do.txt
@@ -1,18 +1,27 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [CallNode(0...23)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...10)(
-         [InterpolatedStringNode(2...10)((2...10), [], (14...20))]
-       ),
-       nil,
-       BlockNode(11...23)([], nil, nil, (11...13), (20...23)),
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...23))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...10))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedStringNode (location: (2...10))
+            │           ├── opening_loc: (2...10) = "<<-TABLE"
+            │           ├── parts: (length: 0)
+            │           └── closing_loc: (14...20) = "TABLE\n"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (11...23))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (11...13) = "do"
+            │   └── closing_loc: (20...23) = "end"
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/whitequark/bug_interp_single.txt b/test/yarp/snapshots/whitequark/bug_interp_single.txt
index bd56c9998a..40ed696284 100644
--- a/test/yarp/snapshots/whitequark/bug_interp_single.txt
+++ b/test/yarp/snapshots/whitequark/bug_interp_single.txt
@@ -1,27 +1,31 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [InterpolatedStringNode(0...6)(
-       (0...1),
-       [EmbeddedStatementsNode(1...5)(
-          (1...3),
-          StatementsNode(3...4)([IntegerNode(3...4)()]),
-          (4...5)
-        )],
-       (5...6)
-     ),
-     ArrayNode(8...16)(
-       [InterpolatedStringNode(11...15)(
-          nil,
-          [EmbeddedStatementsNode(11...15)(
-             (11...13),
-             StatementsNode(13...14)([IntegerNode(13...14)()]),
-             (14...15)
-           )],
-          nil
-        )],
-       (8...11),
-       (15...16)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 2)
+        ├── @ InterpolatedStringNode (location: (0...6))
+        │   ├── opening_loc: (0...1) = "\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedStatementsNode (location: (1...5))
+        │   │       ├── opening_loc: (1...3) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (3...4))
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ IntegerNode (location: (3...4))
+        │   │       └── closing_loc: (4...5) = "}"
+        │   └── closing_loc: (5...6) = "\""
+        └── @ ArrayNode (location: (8...16))
+            ├── elements: (length: 1)
+            │   └── @ InterpolatedStringNode (location: (11...15))
+            │       ├── opening_loc: ∅
+            │       ├── parts: (length: 1)
+            │       │   └── @ EmbeddedStatementsNode (location: (11...15))
+            │       │       ├── opening_loc: (11...13) = "\#{"
+            │       │       ├── statements:
+            │       │       │   @ StatementsNode (location: (13...14))
+            │       │       │   └── body: (length: 1)
+            │       │       │       └── @ IntegerNode (location: (13...14))
+            │       │       └── closing_loc: (14...15) = "}"
+            │       └── closing_loc: ∅
+            ├── opening_loc: (8...11) = "%W\""
+            └── closing_loc: (15...16) = "\""
diff --git a/test/yarp/snapshots/whitequark/bug_lambda_leakage.txt b/test/yarp/snapshots/whitequark/bug_lambda_leakage.txt
index 7792fa495a..b5a4b46f45 100644
--- a/test/yarp/snapshots/whitequark/bug_lambda_leakage.txt
+++ b/test/yarp/snapshots/whitequark/bug_lambda_leakage.txt
@@ -1,27 +1,37 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [LambdaNode(0...12)(
-       [:scope],
-       (0...2),
-       (10...11),
-       (11...12),
-       BlockParametersNode(2...9)(
-         ParametersNode(3...8)(
-           [RequiredParameterNode(3...8)(:scope)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (2...3),
-         (8...9)
-       ),
-       nil
-     ),
-     CallNode(14...19)(nil, nil, (14...19), nil, nil, nil, nil, 2, "scope")]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 2)
+        ├── @ LambdaNode (location: (0...12))
+        │   ├── locals: [:scope]
+        │   ├── operator_loc: (0...2) = "->"
+        │   ├── opening_loc: (10...11) = "{"
+        │   ├── closing_loc: (11...12) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (2...9))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (3...8))
+        │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   └── @ RequiredParameterNode (location: (3...8))
+        │   │   │   │       └── name: :scope
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (2...3) = "("
+        │   │   └── closing_loc: (8...9) = ")"
+        │   └── body: ∅
+        └── @ CallNode (location: (14...19))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (14...19) = "scope"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "scope"
diff --git a/test/yarp/snapshots/whitequark/bug_regex_verification.txt b/test/yarp/snapshots/whitequark/bug_regex_verification.txt
index 0c78794fa2..66467bcbec 100644
--- a/test/yarp/snapshots/whitequark/bug_regex_verification.txt
+++ b/test/yarp/snapshots/whitequark/bug_regex_verification.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [RegularExpressionNode(0...5)((0...1), (1...3), (3...5), "#)", 2)]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ RegularExpressionNode (location: (0...5))
+            ├── opening_loc: (0...1) = "/"
+            ├── content_loc: (1...3) = "#)"
+            ├── closing_loc: (3...5) = "/x"
+            ├── unescaped: "#)"
+            └── flags: extended
diff --git a/test/yarp/snapshots/whitequark/bug_rescue_empty_else.txt b/test/yarp/snapshots/whitequark/bug_rescue_empty_else.txt
index 02c4736f8c..4e0c0735d9 100644
--- a/test/yarp/snapshots/whitequark/bug_rescue_empty_else.txt
+++ b/test/yarp/snapshots/whitequark/bug_rescue_empty_else.txt
@@ -1,20 +1,25 @@
-ProgramNode(0...34)(
-  [],
-  StatementsNode(0...34)(
-    [BeginNode(0...34)(
-       (0...5),
-       nil,
-       RescueNode(7...23)(
-         (7...13),
-         [ConstantReadNode(14...23)(:LoadError)],
-         nil,
-         nil,
-         nil,
-         nil
-       ),
-       ElseNode(25...34)((25...29), nil, (31...34)),
-       nil,
-       (31...34)
-     )]
-  )
-)
+@ ProgramNode (location: (0...34))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...34))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...34))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements: ∅
+            ├── rescue_clause:
+            │   @ RescueNode (location: (7...23))
+            │   ├── keyword_loc: (7...13) = "rescue"
+            │   ├── exceptions: (length: 1)
+            │   │   └── @ ConstantReadNode (location: (14...23))
+            │   │       └── name: :LoadError
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements: ∅
+            │   └── consequent: ∅
+            ├── else_clause:
+            │   @ ElseNode (location: (25...34))
+            │   ├── else_keyword_loc: (25...29) = "else"
+            │   ├── statements: ∅
+            │   └── end_keyword_loc: (31...34) = "end"
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (31...34) = "end"
diff --git a/test/yarp/snapshots/whitequark/bug_while_not_parens_do.txt b/test/yarp/snapshots/whitequark/bug_while_not_parens_do.txt
index f5e086059a..e83bf79d72 100644
--- a/test/yarp/snapshots/whitequark/bug_while_not_parens_do.txt
+++ b/test/yarp/snapshots/whitequark/bug_while_not_parens_do.txt
@@ -1,26 +1,28 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [WhileNode(0...23)(
-       (0...5),
-       (20...23),
-       CallNode(6...16)(
-         ParenthesesNode(10...16)(
-           StatementsNode(11...15)([TrueNode(11...15)()]),
-           (10...11),
-           (15...16)
-         ),
-         nil,
-         (6...9),
-         nil,
-         nil,
-         nil,
-         nil,
-         0,
-         "!"
-       ),
-       nil,
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ WhileNode (location: (0...23))
+            ├── keyword_loc: (0...5) = "while"
+            ├── closing_loc: (20...23) = "end"
+            ├── predicate:
+            │   @ CallNode (location: (6...16))
+            │   ├── receiver:
+            │   │   @ ParenthesesNode (location: (10...16))
+            │   │   ├── body:
+            │   │   │   @ StatementsNode (location: (11...15))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ TrueNode (location: (11...15))
+            │   │   ├── opening_loc: (10...11) = "("
+            │   │   └── closing_loc: (15...16) = ")"
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (6...9) = "not"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "!"
+            ├── statements: ∅
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/case_cond.txt b/test/yarp/snapshots/whitequark/case_cond.txt
index 207fbe9a48..e80fa6c78a 100644
--- a/test/yarp/snapshots/whitequark/case_cond.txt
+++ b/test/yarp/snapshots/whitequark/case_cond.txt
@@ -1,28 +1,32 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [CaseNode(0...26)(
-       nil,
-       [WhenNode(6...21)(
-          (6...10),
-          [CallNode(11...14)(
-             nil,
-             nil,
-             (11...14),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "foo"
-           )],
-          StatementsNode(16...21)(
-            [StringNode(16...21)((16...17), (17...20), (20...21), "foo")]
-          )
-        )],
-       nil,
-       (0...4),
-       (23...26)
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...26))
+            ├── predicate: ∅
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (6...21))
+            │       ├── keyword_loc: (6...10) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ CallNode (location: (11...14))
+            │       │       ├── receiver: ∅
+            │       │       ├── call_operator_loc: ∅
+            │       │       ├── message_loc: (11...14) = "foo"
+            │       │       ├── opening_loc: ∅
+            │       │       ├── arguments: ∅
+            │       │       ├── closing_loc: ∅
+            │       │       ├── block: ∅
+            │       │       ├── flags: variable_call
+            │       │       └── name: "foo"
+            │       └── statements:
+            │           @ StatementsNode (location: (16...21))
+            │           └── body: (length: 1)
+            │               └── @ StringNode (location: (16...21))
+            │                   ├── opening_loc: (16...17) = "'"
+            │                   ├── content_loc: (17...20) = "foo"
+            │                   ├── closing_loc: (20...21) = "'"
+            │                   └── unescaped: "foo"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (23...26) = "end"
diff --git a/test/yarp/snapshots/whitequark/case_cond_else.txt b/test/yarp/snapshots/whitequark/case_cond_else.txt
index 263c4d3a08..af62c1a34b 100644
--- a/test/yarp/snapshots/whitequark/case_cond_else.txt
+++ b/test/yarp/snapshots/whitequark/case_cond_else.txt
@@ -1,34 +1,43 @@
-ProgramNode(0...38)(
-  [],
-  StatementsNode(0...38)(
-    [CaseNode(0...38)(
-       nil,
-       [WhenNode(6...21)(
-          (6...10),
-          [CallNode(11...14)(
-             nil,
-             nil,
-             (11...14),
-             nil,
-             nil,
-             nil,
-             nil,
-             2,
-             "foo"
-           )],
-          StatementsNode(16...21)(
-            [StringNode(16...21)((16...17), (17...20), (20...21), "foo")]
-          )
-        )],
-       ElseNode(23...38)(
-         (23...27),
-         StatementsNode(28...33)(
-           [StringNode(28...33)((28...29), (29...32), (32...33), "bar")]
-         ),
-         (35...38)
-       ),
-       (0...4),
-       (35...38)
-     )]
-  )
-)
+@ ProgramNode (location: (0...38))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...38))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...38))
+            ├── predicate: ∅
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (6...21))
+            │       ├── keyword_loc: (6...10) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ CallNode (location: (11...14))
+            │       │       ├── receiver: ∅
+            │       │       ├── call_operator_loc: ∅
+            │       │       ├── message_loc: (11...14) = "foo"
+            │       │       ├── opening_loc: ∅
+            │       │       ├── arguments: ∅
+            │       │       ├── closing_loc: ∅
+            │       │       ├── block: ∅
+            │       │       ├── flags: variable_call
+            │       │       └── name: "foo"
+            │       └── statements:
+            │           @ StatementsNode (location: (16...21))
+            │           └── body: (length: 1)
+            │               └── @ StringNode (location: (16...21))
+            │                   ├── opening_loc: (16...17) = "'"
+            │                   ├── content_loc: (17...20) = "foo"
+            │                   ├── closing_loc: (20...21) = "'"
+            │                   └── unescaped: "foo"
+            ├── consequent:
+            │   @ ElseNode (location: (23...38))
+            │   ├── else_keyword_loc: (23...27) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (28...33))
+            │   │   └── body: (length: 1)
+            │   │       └── @ StringNode (location: (28...33))
+            │   │           ├── opening_loc: (28...29) = "'"
+            │   │           ├── content_loc: (29...32) = "bar"
+            │   │           ├── closing_loc: (32...33) = "'"
+            │   │           └── unescaped: "bar"
+            │   └── end_keyword_loc: (35...38) = "end"
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (35...38) = "end"
diff --git a/test/yarp/snapshots/whitequark/case_expr.txt b/test/yarp/snapshots/whitequark/case_expr.txt
index 8b01d8f81a..49b6c41410 100644
--- a/test/yarp/snapshots/whitequark/case_expr.txt
+++ b/test/yarp/snapshots/whitequark/case_expr.txt
@@ -1,28 +1,42 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [CaseNode(0...30)(
-       CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "foo"),
-       [WhenNode(10...25)(
-          (10...14),
-          [StringNode(15...20)((15...16), (16...19), (19...20), "bar")],
-          StatementsNode(22...25)(
-            [CallNode(22...25)(
-               nil,
-               nil,
-               (22...25),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          )
-        )],
-       nil,
-       (0...4),
-       (27...30)
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...30))
+            ├── predicate:
+            │   @ CallNode (location: (5...8))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (5...8) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (10...25))
+            │       ├── keyword_loc: (10...14) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ StringNode (location: (15...20))
+            │       │       ├── opening_loc: (15...16) = "'"
+            │       │       ├── content_loc: (16...19) = "bar"
+            │       │       ├── closing_loc: (19...20) = "'"
+            │       │       └── unescaped: "bar"
+            │       └── statements:
+            │           @ StatementsNode (location: (22...25))
+            │           └── body: (length: 1)
+            │               └── @ CallNode (location: (22...25))
+            │                   ├── receiver: ∅
+            │                   ├── call_operator_loc: ∅
+            │                   ├── message_loc: (22...25) = "bar"
+            │                   ├── opening_loc: ∅
+            │                   ├── arguments: ∅
+            │                   ├── closing_loc: ∅
+            │                   ├── block: ∅
+            │                   ├── flags: variable_call
+            │                   └── name: "bar"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (27...30) = "end"
diff --git a/test/yarp/snapshots/whitequark/case_expr_else.txt b/test/yarp/snapshots/whitequark/case_expr_else.txt
index 79356e6cf3..2d40dc59ef 100644
--- a/test/yarp/snapshots/whitequark/case_expr_else.txt
+++ b/test/yarp/snapshots/whitequark/case_expr_else.txt
@@ -1,44 +1,58 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [CaseNode(0...40)(
-       CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "foo"),
-       [WhenNode(10...25)(
-          (10...14),
-          [StringNode(15...20)((15...16), (16...19), (19...20), "bar")],
-          StatementsNode(22...25)(
-            [CallNode(22...25)(
-               nil,
-               nil,
-               (22...25),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          )
-        )],
-       ElseNode(27...40)(
-         (27...31),
-         StatementsNode(32...35)(
-           [CallNode(32...35)(
-              nil,
-              nil,
-              (32...35),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         (37...40)
-       ),
-       (0...4),
-       (37...40)
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...40))
+            ├── predicate:
+            │   @ CallNode (location: (5...8))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (5...8) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (10...25))
+            │       ├── keyword_loc: (10...14) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ StringNode (location: (15...20))
+            │       │       ├── opening_loc: (15...16) = "'"
+            │       │       ├── content_loc: (16...19) = "bar"
+            │       │       ├── closing_loc: (19...20) = "'"
+            │       │       └── unescaped: "bar"
+            │       └── statements:
+            │           @ StatementsNode (location: (22...25))
+            │           └── body: (length: 1)
+            │               └── @ CallNode (location: (22...25))
+            │                   ├── receiver: ∅
+            │                   ├── call_operator_loc: ∅
+            │                   ├── message_loc: (22...25) = "bar"
+            │                   ├── opening_loc: ∅
+            │                   ├── arguments: ∅
+            │                   ├── closing_loc: ∅
+            │                   ├── block: ∅
+            │                   ├── flags: variable_call
+            │                   └── name: "bar"
+            ├── consequent:
+            │   @ ElseNode (location: (27...40))
+            │   ├── else_keyword_loc: (27...31) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (32...35))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (32...35))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (32...35) = "baz"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "baz"
+            │   └── end_keyword_loc: (37...40) = "end"
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (37...40) = "end"
diff --git a/test/yarp/snapshots/whitequark/casgn_scoped.txt b/test/yarp/snapshots/whitequark/casgn_scoped.txt
index b5e719abfc..6899a07912 100644
--- a/test/yarp/snapshots/whitequark/casgn_scoped.txt
+++ b/test/yarp/snapshots/whitequark/casgn_scoped.txt
@@ -1,14 +1,18 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [ConstantPathWriteNode(0...13)(
-       ConstantPathNode(0...8)(
-         ConstantReadNode(0...3)(:Bar),
-         ConstantReadNode(5...8)(:Foo),
-         (3...5)
-       ),
-       (9...10),
-       IntegerNode(11...13)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ ConstantPathWriteNode (location: (0...13))
+            ├── target:
+            │   @ ConstantPathNode (location: (0...8))
+            │   ├── parent:
+            │   │   @ ConstantReadNode (location: (0...3))
+            │   │   └── name: :Bar
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (5...8))
+            │   │   └── name: :Foo
+            │   └── delimiter_loc: (3...5) = "::"
+            ├── operator_loc: (9...10) = "="
+            └── value:
+                @ IntegerNode (location: (11...13))
diff --git a/test/yarp/snapshots/whitequark/casgn_toplevel.txt b/test/yarp/snapshots/whitequark/casgn_toplevel.txt
index 7fff870f8a..045dd5fd5f 100644
--- a/test/yarp/snapshots/whitequark/casgn_toplevel.txt
+++ b/test/yarp/snapshots/whitequark/casgn_toplevel.txt
@@ -1,10 +1,16 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [ConstantPathWriteNode(0...10)(
-       ConstantPathNode(0...5)(nil, ConstantReadNode(2...5)(:Foo), (0...2)),
-       (6...7),
-       IntegerNode(8...10)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ ConstantPathWriteNode (location: (0...10))
+            ├── target:
+            │   @ ConstantPathNode (location: (0...5))
+            │   ├── parent: ∅
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (2...5))
+            │   │   └── name: :Foo
+            │   └── delimiter_loc: (0...2) = "::"
+            ├── operator_loc: (6...7) = "="
+            └── value:
+                @ IntegerNode (location: (8...10))
diff --git a/test/yarp/snapshots/whitequark/casgn_unscoped.txt b/test/yarp/snapshots/whitequark/casgn_unscoped.txt
index 7e778015b1..79d659b107 100644
--- a/test/yarp/snapshots/whitequark/casgn_unscoped.txt
+++ b/test/yarp/snapshots/whitequark/casgn_unscoped.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [ConstantWriteNode(0...8)(:Foo, (0...3), IntegerNode(6...8)(), (4...5))]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ ConstantWriteNode (location: (0...8))
+            ├── name: :Foo
+            ├── name_loc: (0...3) = "Foo"
+            ├── value:
+            │   @ IntegerNode (location: (6...8))
+            └── operator_loc: (4...5) = "="
diff --git a/test/yarp/snapshots/whitequark/character.txt b/test/yarp/snapshots/whitequark/character.txt
index 7865df42fa..d0ff0ea792 100644
--- a/test/yarp/snapshots/whitequark/character.txt
+++ b/test/yarp/snapshots/whitequark/character.txt
@@ -1,4 +1,10 @@
-ProgramNode(0...2)(
-  [],
-  StatementsNode(0...2)([StringNode(0...2)((0...1), (1...2), nil, "a")])
-)
+@ ProgramNode (location: (0...2))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...2))
+    └── body: (length: 1)
+        └── @ StringNode (location: (0...2))
+            ├── opening_loc: (0...1) = "?"
+            ├── content_loc: (1...2) = "a"
+            ├── closing_loc: ∅
+            └── unescaped: "a"
diff --git a/test/yarp/snapshots/whitequark/class.txt b/test/yarp/snapshots/whitequark/class.txt
index 692e70859d..60fb7b32e9 100644
--- a/test/yarp/snapshots/whitequark/class.txt
+++ b/test/yarp/snapshots/whitequark/class.txt
@@ -1,25 +1,27 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [ClassNode(0...13)(
-       [],
-       (0...5),
-       ConstantReadNode(6...9)(:Foo),
-       nil,
-       nil,
-       nil,
-       (10...13),
-       :Foo
-     ),
-     ClassNode(15...29)(
-       [],
-       (15...20),
-       ConstantReadNode(21...24)(:Foo),
-       nil,
-       nil,
-       nil,
-       (26...29),
-       :Foo
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 2)
+        ├── @ ClassNode (location: (0...13))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (0...5) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (6...9))
+        │   │   └── name: :Foo
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (10...13) = "end"
+        │   └── name: :Foo
+        └── @ ClassNode (location: (15...29))
+            ├── locals: []
+            ├── class_keyword_loc: (15...20) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (21...24))
+            │   └── name: :Foo
+            ├── inheritance_operator_loc: ∅
+            ├── superclass: ∅
+            ├── body: ∅
+            ├── end_keyword_loc: (26...29) = "end"
+            └── name: :Foo
diff --git a/test/yarp/snapshots/whitequark/class_definition_in_while_cond.txt b/test/yarp/snapshots/whitequark/class_definition_in_while_cond.txt
index 8fbb656c2c..0afe8336b4 100644
--- a/test/yarp/snapshots/whitequark/class_definition_in_while_cond.txt
+++ b/test/yarp/snapshots/whitequark/class_definition_in_while_cond.txt
@@ -1,125 +1,171 @@
-ProgramNode(0...197)(
-  [],
-  StatementsNode(0...197)(
-    [WhileNode(0...52)(
-       (0...5),
-       (49...52),
-       SingletonClassNode(6...40)(
-         [:a],
-         (6...11),
-         (12...14),
-         SelfNode(15...19)(),
-         StatementsNode(21...35)(
-           [LocalVariableWriteNode(21...35)(
-              :a,
-              0,
-              (21...22),
-              CallNode(25...35)(
-                nil,
-                nil,
-                (25...28),
-                nil,
-                nil,
-                nil,
-                BlockNode(29...35)([], nil, nil, (29...31), (32...35)),
-                0,
-                "tap"
-              ),
-              (23...24)
-            )]
-         ),
-         (37...40)
-       ),
-       StatementsNode(42...47)([BreakNode(42...47)(nil, (42...47))]),
-       0
-     ),
-     WhileNode(54...102)(
-       (54...59),
-       (99...102),
-       SingletonClassNode(60...90)(
-         [],
-         (60...65),
-         (66...68),
-         SelfNode(69...73)(),
-         StatementsNode(75...85)(
-           [CallNode(75...85)(
-              nil,
-              nil,
-              (75...78),
-              nil,
-              nil,
-              nil,
-              BlockNode(79...85)([], nil, nil, (79...81), (82...85)),
-              0,
-              "tap"
-            )]
-         ),
-         (87...90)
-       ),
-       StatementsNode(92...97)([BreakNode(92...97)(nil, (92...97))]),
-       0
-     ),
-     WhileNode(104...151)(
-       (104...109),
-       (148...151),
-       ClassNode(110...139)(
-         [:a],
-         (110...115),
-         ConstantReadNode(116...119)(:Foo),
-         nil,
-         nil,
-         StatementsNode(120...134)(
-           [LocalVariableWriteNode(120...134)(
-              :a,
-              0,
-              (120...121),
-              CallNode(124...134)(
-                nil,
-                nil,
-                (124...127),
-                nil,
-                nil,
-                nil,
-                BlockNode(128...134)([], nil, nil, (128...130), (131...134)),
-                0,
-                "tap"
-              ),
-              (122...123)
-            )]
-         ),
-         (136...139),
-         :Foo
-       ),
-       StatementsNode(141...146)([BreakNode(141...146)(nil, (141...146))]),
-       0
-     ),
-     WhileNode(153...197)(
-       (153...158),
-       (194...197),
-       ClassNode(159...185)(
-         [],
-         (159...164),
-         ConstantReadNode(165...168)(:Foo),
-         nil,
-         nil,
-         StatementsNode(170...180)(
-           [CallNode(170...180)(
-              nil,
-              nil,
-              (170...173),
-              nil,
-              nil,
-              nil,
-              BlockNode(174...180)([], nil, nil, (174...176), (177...180)),
-              0,
-              "tap"
-            )]
-         ),
-         (182...185),
-         :Foo
-       ),
-       StatementsNode(187...192)([BreakNode(187...192)(nil, (187...192))]),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...197))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...197))
+    └── body: (length: 4)
+        ├── @ WhileNode (location: (0...52))
+        │   ├── keyword_loc: (0...5) = "while"
+        │   ├── closing_loc: (49...52) = "end"
+        │   ├── predicate:
+        │   │   @ SingletonClassNode (location: (6...40))
+        │   │   ├── locals: [:a]
+        │   │   ├── class_keyword_loc: (6...11) = "class"
+        │   │   ├── operator_loc: (12...14) = "<<"
+        │   │   ├── expression:
+        │   │   │   @ SelfNode (location: (15...19))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (21...35))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableWriteNode (location: (21...35))
+        │   │   │           ├── name: :a
+        │   │   │           ├── depth: 0
+        │   │   │           ├── name_loc: (21...22) = "a"
+        │   │   │           ├── value:
+        │   │   │           │   @ CallNode (location: (25...35))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (25...28) = "tap"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block:
+        │   │   │           │   │   @ BlockNode (location: (29...35))
+        │   │   │           │   │   ├── locals: []
+        │   │   │           │   │   ├── parameters: ∅
+        │   │   │           │   │   ├── body: ∅
+        │   │   │           │   │   ├── opening_loc: (29...31) = "do"
+        │   │   │           │   │   └── closing_loc: (32...35) = "end"
+        │   │   │           │   ├── flags: 
+        │   │   │           │   └── name: "tap"
+        │   │   │           └── operator_loc: (23...24) = "="
+        │   │   └── end_keyword_loc: (37...40) = "end"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (42...47))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (42...47))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (42...47) = "break"
+        │   └── flags: 
+        ├── @ WhileNode (location: (54...102))
+        │   ├── keyword_loc: (54...59) = "while"
+        │   ├── closing_loc: (99...102) = "end"
+        │   ├── predicate:
+        │   │   @ SingletonClassNode (location: (60...90))
+        │   │   ├── locals: []
+        │   │   ├── class_keyword_loc: (60...65) = "class"
+        │   │   ├── operator_loc: (66...68) = "<<"
+        │   │   ├── expression:
+        │   │   │   @ SelfNode (location: (69...73))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (75...85))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (75...85))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (75...78) = "tap"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block:
+        │   │   │           │   @ BlockNode (location: (79...85))
+        │   │   │           │   ├── locals: []
+        │   │   │           │   ├── parameters: ∅
+        │   │   │           │   ├── body: ∅
+        │   │   │           │   ├── opening_loc: (79...81) = "do"
+        │   │   │           │   └── closing_loc: (82...85) = "end"
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "tap"
+        │   │   └── end_keyword_loc: (87...90) = "end"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (92...97))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (92...97))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (92...97) = "break"
+        │   └── flags: 
+        ├── @ WhileNode (location: (104...151))
+        │   ├── keyword_loc: (104...109) = "while"
+        │   ├── closing_loc: (148...151) = "end"
+        │   ├── predicate:
+        │   │   @ ClassNode (location: (110...139))
+        │   │   ├── locals: [:a]
+        │   │   ├── class_keyword_loc: (110...115) = "class"
+        │   │   ├── constant_path:
+        │   │   │   @ ConstantReadNode (location: (116...119))
+        │   │   │   └── name: :Foo
+        │   │   ├── inheritance_operator_loc: ∅
+        │   │   ├── superclass: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (120...134))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ LocalVariableWriteNode (location: (120...134))
+        │   │   │           ├── name: :a
+        │   │   │           ├── depth: 0
+        │   │   │           ├── name_loc: (120...121) = "a"
+        │   │   │           ├── value:
+        │   │   │           │   @ CallNode (location: (124...134))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (124...127) = "tap"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block:
+        │   │   │           │   │   @ BlockNode (location: (128...134))
+        │   │   │           │   │   ├── locals: []
+        │   │   │           │   │   ├── parameters: ∅
+        │   │   │           │   │   ├── body: ∅
+        │   │   │           │   │   ├── opening_loc: (128...130) = "do"
+        │   │   │           │   │   └── closing_loc: (131...134) = "end"
+        │   │   │           │   ├── flags: 
+        │   │   │           │   └── name: "tap"
+        │   │   │           └── operator_loc: (122...123) = "="
+        │   │   ├── end_keyword_loc: (136...139) = "end"
+        │   │   └── name: :Foo
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (141...146))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (141...146))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (141...146) = "break"
+        │   └── flags: 
+        └── @ WhileNode (location: (153...197))
+            ├── keyword_loc: (153...158) = "while"
+            ├── closing_loc: (194...197) = "end"
+            ├── predicate:
+            │   @ ClassNode (location: (159...185))
+            │   ├── locals: []
+            │   ├── class_keyword_loc: (159...164) = "class"
+            │   ├── constant_path:
+            │   │   @ ConstantReadNode (location: (165...168))
+            │   │   └── name: :Foo
+            │   ├── inheritance_operator_loc: ∅
+            │   ├── superclass: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (170...180))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (170...180))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (170...173) = "tap"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block:
+            │   │           │   @ BlockNode (location: (174...180))
+            │   │           │   ├── locals: []
+            │   │           │   ├── parameters: ∅
+            │   │           │   ├── body: ∅
+            │   │           │   ├── opening_loc: (174...176) = "do"
+            │   │           │   └── closing_loc: (177...180) = "end"
+            │   │           ├── flags: 
+            │   │           └── name: "tap"
+            │   ├── end_keyword_loc: (182...185) = "end"
+            │   └── name: :Foo
+            ├── statements:
+            │   @ StatementsNode (location: (187...192))
+            │   └── body: (length: 1)
+            │       └── @ BreakNode (location: (187...192))
+            │           ├── arguments: ∅
+            │           └── keyword_loc: (187...192) = "break"
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/class_super.txt b/test/yarp/snapshots/whitequark/class_super.txt
index a2458fe128..f4be49a683 100644
--- a/test/yarp/snapshots/whitequark/class_super.txt
+++ b/test/yarp/snapshots/whitequark/class_super.txt
@@ -1,15 +1,18 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [ClassNode(0...20)(
-       [],
-       (0...5),
-       ConstantReadNode(6...9)(:Foo),
-       (10...11),
-       ConstantReadNode(12...15)(:Bar),
-       nil,
-       (17...20),
-       :Foo
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ ClassNode (location: (0...20))
+            ├── locals: []
+            ├── class_keyword_loc: (0...5) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (6...9))
+            │   └── name: :Foo
+            ├── inheritance_operator_loc: (10...11) = "<"
+            ├── superclass:
+            │   @ ConstantReadNode (location: (12...15))
+            │   └── name: :Bar
+            ├── body: ∅
+            ├── end_keyword_loc: (17...20) = "end"
+            └── name: :Foo
diff --git a/test/yarp/snapshots/whitequark/class_super_label.txt b/test/yarp/snapshots/whitequark/class_super_label.txt
index ab6bf568d8..d462018f7b 100644
--- a/test/yarp/snapshots/whitequark/class_super_label.txt
+++ b/test/yarp/snapshots/whitequark/class_super_label.txt
@@ -1,27 +1,33 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [ClassNode(0...20)(
-       [],
-       (0...5),
-       ConstantReadNode(6...9)(:Foo),
-       (10...11),
-       CallNode(12...15)(
-         nil,
-         nil,
-         (12...13),
-         nil,
-         ArgumentsNode(13...15)(
-           [SymbolNode(13...15)((13...14), (14...15), nil, "b")]
-         ),
-         nil,
-         nil,
-         0,
-         "a"
-       ),
-       nil,
-       (17...20),
-       :Foo
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ ClassNode (location: (0...20))
+            ├── locals: []
+            ├── class_keyword_loc: (0...5) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (6...9))
+            │   └── name: :Foo
+            ├── inheritance_operator_loc: (10...11) = "<"
+            ├── superclass:
+            │   @ CallNode (location: (12...15))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (12...13) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (13...15))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ SymbolNode (location: (13...15))
+            │   │           ├── opening_loc: (13...14) = ":"
+            │   │           ├── value_loc: (14...15) = "b"
+            │   │           ├── closing_loc: ∅
+            │   │           └── unescaped: "b"
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "a"
+            ├── body: ∅
+            ├── end_keyword_loc: (17...20) = "end"
+            └── name: :Foo
diff --git a/test/yarp/snapshots/whitequark/comments_before_leading_dot__27.txt b/test/yarp/snapshots/whitequark/comments_before_leading_dot__27.txt
index b01a481eca..95d91b2835 100644
--- a/test/yarp/snapshots/whitequark/comments_before_leading_dot__27.txt
+++ b/test/yarp/snapshots/whitequark/comments_before_leading_dot__27.txt
@@ -1,49 +1,85 @@
-ProgramNode(0...55)(
-  [],
-  StatementsNode(0...55)(
-    [CallNode(0...13)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (8...10),
-       (10...13),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "foo"
-     ),
-     CallNode(16...28)(
-       CallNode(16...17)(nil, nil, (16...17), nil, nil, nil, nil, 2, "a"),
-       (24...25),
-       (25...28),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(31...42)(
-       CallNode(31...32)(nil, nil, (31...32), nil, nil, nil, nil, 2, "a"),
-       (37...39),
-       (39...42),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "foo"
-     ),
-     CallNode(45...55)(
-       CallNode(45...46)(nil, nil, (45...46), nil, nil, nil, nil, 2, "a"),
-       (51...52),
-       (52...55),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "foo"
-     )]
-  )
-)
+@ ProgramNode (location: (0...55))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...55))
+    └── body: (length: 4)
+        ├── @ CallNode (location: (0...13))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...1))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...1) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (8...10) = "&."
+        │   ├── message_loc: (10...13) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: safe_navigation
+        │   └── name: "foo"
+        ├── @ CallNode (location: (16...28))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (16...17))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (16...17) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (24...25) = "."
+        │   ├── message_loc: (25...28) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        ├── @ CallNode (location: (31...42))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (31...32))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (31...32) = "a"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "a"
+        │   ├── call_operator_loc: (37...39) = "&."
+        │   ├── message_loc: (39...42) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: safe_navigation
+        │   └── name: "foo"
+        └── @ CallNode (location: (45...55))
+            ├── receiver:
+            │   @ CallNode (location: (45...46))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (45...46) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (51...52) = "."
+            ├── message_loc: (52...55) = "foo"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "foo"
diff --git a/test/yarp/snapshots/whitequark/complex.txt b/test/yarp/snapshots/whitequark/complex.txt
index f8273f3806..04944b936c 100644
--- a/test/yarp/snapshots/whitequark/complex.txt
+++ b/test/yarp/snapshots/whitequark/complex.txt
@@ -1,9 +1,21 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [ImaginaryNode(0...5)(FloatNode(0...4)()),
-     ImaginaryNode(7...13)(RationalNode(7...12)(FloatNode(7...11)())),
-     ImaginaryNode(15...18)(IntegerNode(15...17)()),
-     ImaginaryNode(20...24)(RationalNode(20...23)(IntegerNode(20...22)()))]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 4)
+        ├── @ ImaginaryNode (location: (0...5))
+        │   └── numeric:
+        │       @ FloatNode (location: (0...4))
+        ├── @ ImaginaryNode (location: (7...13))
+        │   └── numeric:
+        │       @ RationalNode (location: (7...12))
+        │       └── numeric:
+        │           @ FloatNode (location: (7...11))
+        ├── @ ImaginaryNode (location: (15...18))
+        │   └── numeric:
+        │       @ IntegerNode (location: (15...17))
+        └── @ ImaginaryNode (location: (20...24))
+            └── numeric:
+                @ RationalNode (location: (20...23))
+                └── numeric:
+                    @ IntegerNode (location: (20...22))
diff --git a/test/yarp/snapshots/whitequark/cond_begin.txt b/test/yarp/snapshots/whitequark/cond_begin.txt
index e3e3650e48..cb74d8f442 100644
--- a/test/yarp/snapshots/whitequark/cond_begin.txt
+++ b/test/yarp/snapshots/whitequark/cond_begin.txt
@@ -1,20 +1,39 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [IfNode(0...18)(
-       (0...2),
-       ParenthesesNode(3...8)(
-         StatementsNode(4...7)(
-           [CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "bar")]
-         ),
-         (3...4),
-         (7...8)
-       ),
-       StatementsNode(10...13)(
-         [CallNode(10...13)(nil, nil, (10...13), nil, nil, nil, nil, 2, "foo")]
-       ),
-       nil,
-       (15...18)
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...18))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ ParenthesesNode (location: (3...8))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (4...7))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (4...7))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (4...7) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   ├── opening_loc: (3...4) = "("
+            │   └── closing_loc: (7...8) = ")"
+            ├── statements:
+            │   @ StatementsNode (location: (10...13))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (10...13))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (10...13) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "foo"
+            ├── consequent: ∅
+            └── end_keyword_loc: (15...18) = "end"
diff --git a/test/yarp/snapshots/whitequark/cond_begin_masgn.txt b/test/yarp/snapshots/whitequark/cond_begin_masgn.txt
index 9a5e51bd10..6ab943ef36 100644
--- a/test/yarp/snapshots/whitequark/cond_begin_masgn.txt
+++ b/test/yarp/snapshots/whitequark/cond_begin_masgn.txt
@@ -1,36 +1,49 @@
-ProgramNode(0...25)(
-  [:a, :b],
-  StatementsNode(0...25)(
-    [IfNode(0...25)(
-       (0...2),
-       ParenthesesNode(3...20)(
-         StatementsNode(4...19)(
-           [CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "bar"),
-            MultiWriteNode(9...19)(
-              [LocalVariableTargetNode(9...10)(:a, 0),
-               LocalVariableTargetNode(12...13)(:b, 0)],
-              nil,
-              nil,
-              (14...15),
-              CallNode(16...19)(
-                nil,
-                nil,
-                (16...19),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "foo"
-              )
-            )]
-         ),
-         (3...4),
-         (19...20)
-       ),
-       nil,
-       nil,
-       (22...25)
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...25))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ ParenthesesNode (location: (3...20))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (4...19))
+            │   │   └── body: (length: 2)
+            │   │       ├── @ CallNode (location: (4...7))
+            │   │       │   ├── receiver: ∅
+            │   │       │   ├── call_operator_loc: ∅
+            │   │       │   ├── message_loc: (4...7) = "bar"
+            │   │       │   ├── opening_loc: ∅
+            │   │       │   ├── arguments: ∅
+            │   │       │   ├── closing_loc: ∅
+            │   │       │   ├── block: ∅
+            │   │       │   ├── flags: variable_call
+            │   │       │   └── name: "bar"
+            │   │       └── @ MultiWriteNode (location: (9...19))
+            │   │           ├── targets: (length: 2)
+            │   │           │   ├── @ LocalVariableTargetNode (location: (9...10))
+            │   │           │   │   ├── name: :a
+            │   │           │   │   └── depth: 0
+            │   │           │   └── @ LocalVariableTargetNode (location: (12...13))
+            │   │           │       ├── name: :b
+            │   │           │       └── depth: 0
+            │   │           ├── lparen_loc: ∅
+            │   │           ├── rparen_loc: ∅
+            │   │           ├── operator_loc: (14...15) = "="
+            │   │           └── value:
+            │   │               @ CallNode (location: (16...19))
+            │   │               ├── receiver: ∅
+            │   │               ├── call_operator_loc: ∅
+            │   │               ├── message_loc: (16...19) = "foo"
+            │   │               ├── opening_loc: ∅
+            │   │               ├── arguments: ∅
+            │   │               ├── closing_loc: ∅
+            │   │               ├── block: ∅
+            │   │               ├── flags: variable_call
+            │   │               └── name: "foo"
+            │   ├── opening_loc: (3...4) = "("
+            │   └── closing_loc: (19...20) = ")"
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (22...25) = "end"
diff --git a/test/yarp/snapshots/whitequark/cond_eflipflop.txt b/test/yarp/snapshots/whitequark/cond_eflipflop.txt
index 31ef52f1e9..c525850a52 100644
--- a/test/yarp/snapshots/whitequark/cond_eflipflop.txt
+++ b/test/yarp/snapshots/whitequark/cond_eflipflop.txt
@@ -1,49 +1,77 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)(
-    [CallNode(0...12)(
-       ParenthesesNode(1...12)(
-         StatementsNode(2...11)(
-           [FlipFlopNode(2...11)(
-              CallNode(2...5)(nil, nil, (2...5), nil, nil, nil, nil, 2, "foo"),
-              CallNode(8...11)(
-                nil,
-                nil,
-                (8...11),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (5...8),
-              1
-            )]
-         ),
-         (1...2),
-         (11...12)
-       ),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     IfNode(14...31)(
-       (14...16),
-       FlipFlopNode(17...26)(
-         CallNode(17...20)(nil, nil, (17...20), nil, nil, nil, nil, 2, "foo"),
-         CallNode(23...26)(nil, nil, (23...26), nil, nil, nil, nil, 2, "bar"),
-         (20...23),
-         1
-       ),
-       nil,
-       nil,
-       (28...31)
-     )]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...12))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (1...12))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (2...11))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ FlipFlopNode (location: (2...11))
+        │   │   │           ├── left:
+        │   │   │           │   @ CallNode (location: (2...5))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (2...5) = "foo"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "foo"
+        │   │   │           ├── right:
+        │   │   │           │   @ CallNode (location: (8...11))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (8...11) = "bar"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "bar"
+        │   │   │           ├── operator_loc: (5...8) = "..."
+        │   │   │           └── flags: exclude_end
+        │   │   ├── opening_loc: (1...2) = "("
+        │   │   └── closing_loc: (11...12) = ")"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        └── @ IfNode (location: (14...31))
+            ├── if_keyword_loc: (14...16) = "if"
+            ├── predicate:
+            │   @ FlipFlopNode (location: (17...26))
+            │   ├── left:
+            │   │   @ CallNode (location: (17...20))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (17...20) = "foo"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "foo"
+            │   ├── right:
+            │   │   @ CallNode (location: (23...26))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (23...26) = "bar"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "bar"
+            │   ├── operator_loc: (20...23) = "..."
+            │   └── flags: exclude_end
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (28...31) = "end"
diff --git a/test/yarp/snapshots/whitequark/cond_iflipflop.txt b/test/yarp/snapshots/whitequark/cond_iflipflop.txt
index 4d1d42ed82..42d728bc57 100644
--- a/test/yarp/snapshots/whitequark/cond_iflipflop.txt
+++ b/test/yarp/snapshots/whitequark/cond_iflipflop.txt
@@ -1,49 +1,77 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [CallNode(0...11)(
-       ParenthesesNode(1...11)(
-         StatementsNode(2...10)(
-           [FlipFlopNode(2...10)(
-              CallNode(2...5)(nil, nil, (2...5), nil, nil, nil, nil, 2, "foo"),
-              CallNode(7...10)(
-                nil,
-                nil,
-                (7...10),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (5...7),
-              0
-            )]
-         ),
-         (1...2),
-         (10...11)
-       ),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     IfNode(13...29)(
-       (13...15),
-       FlipFlopNode(16...24)(
-         CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "foo"),
-         CallNode(21...24)(nil, nil, (21...24), nil, nil, nil, nil, 2, "bar"),
-         (19...21),
-         0
-       ),
-       nil,
-       nil,
-       (26...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...11))
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (1...11))
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (2...10))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ FlipFlopNode (location: (2...10))
+        │   │   │           ├── left:
+        │   │   │           │   @ CallNode (location: (2...5))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (2...5) = "foo"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "foo"
+        │   │   │           ├── right:
+        │   │   │           │   @ CallNode (location: (7...10))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (7...10) = "bar"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "bar"
+        │   │   │           ├── operator_loc: (5...7) = ".."
+        │   │   │           └── flags: 
+        │   │   ├── opening_loc: (1...2) = "("
+        │   │   └── closing_loc: (10...11) = ")"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        └── @ IfNode (location: (13...29))
+            ├── if_keyword_loc: (13...15) = "if"
+            ├── predicate:
+            │   @ FlipFlopNode (location: (16...24))
+            │   ├── left:
+            │   │   @ CallNode (location: (16...19))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (16...19) = "foo"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "foo"
+            │   ├── right:
+            │   │   @ CallNode (location: (21...24))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (21...24) = "bar"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "bar"
+            │   ├── operator_loc: (19...21) = ".."
+            │   └── flags: 
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (26...29) = "end"
diff --git a/test/yarp/snapshots/whitequark/cond_match_current_line.txt b/test/yarp/snapshots/whitequark/cond_match_current_line.txt
index 02bceef3d7..e5902bce8f 100644
--- a/test/yarp/snapshots/whitequark/cond_match_current_line.txt
+++ b/test/yarp/snapshots/whitequark/cond_match_current_line.txt
@@ -1,29 +1,33 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [CallNode(0...6)(
-       RegularExpressionNode(1...6)((1...2), (2...5), (5...6), "wat", 0),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     IfNode(8...21)(
-       (8...10),
-       RegularExpressionNode(11...16)(
-         (11...12),
-         (12...15),
-         (15...16),
-         "wat",
-         0
-       ),
-       nil,
-       nil,
-       (18...21)
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...6))
+        │   ├── receiver:
+        │   │   @ RegularExpressionNode (location: (1...6))
+        │   │   ├── opening_loc: (1...2) = "/"
+        │   │   ├── content_loc: (2...5) = "wat"
+        │   │   ├── closing_loc: (5...6) = "/"
+        │   │   ├── unescaped: "wat"
+        │   │   └── flags: 
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        └── @ IfNode (location: (8...21))
+            ├── if_keyword_loc: (8...10) = "if"
+            ├── predicate:
+            │   @ RegularExpressionNode (location: (11...16))
+            │   ├── opening_loc: (11...12) = "/"
+            │   ├── content_loc: (12...15) = "wat"
+            │   ├── closing_loc: (15...16) = "/"
+            │   ├── unescaped: "wat"
+            │   └── flags: 
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (18...21) = "end"
diff --git a/test/yarp/snapshots/whitequark/const_op_asgn.txt b/test/yarp/snapshots/whitequark/const_op_asgn.txt
index 1b17733415..b2df902b92 100644
--- a/test/yarp/snapshots/whitequark/const_op_asgn.txt
+++ b/test/yarp/snapshots/whitequark/const_op_asgn.txt
@@ -1,76 +1,91 @@
-ProgramNode(0...77)(
-  [],
-  StatementsNode(0...77)(
-    [ConstantPathOperatorWriteNode(0...8)(
-       ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(:A), (0...2)),
-       (4...6),
-       IntegerNode(7...8)(),
-       :+
-     ),
-     ConstantOperatorWriteNode(10...16)(
-       :A,
-       (10...11),
-       (12...14),
-       IntegerNode(15...16)(),
-       :+
-     ),
-     ConstantPathOperatorWriteNode(18...27)(
-       ConstantPathNode(18...22)(
-         ConstantReadNode(18...19)(:B),
-         ConstantReadNode(21...22)(:A),
-         (19...21)
-       ),
-       (23...25),
-       IntegerNode(26...27)(),
-       :+
-     ),
-     DefNode(29...50)(
-       :x,
-       (33...34),
-       nil,
-       nil,
-       StatementsNode(36...45)(
-         [ConstantPathOrWriteNode(36...45)(
-            ConstantPathNode(36...39)(
-              nil,
-              ConstantReadNode(38...39)(:A),
-              (36...38)
-            ),
-            (40...43),
-            IntegerNode(44...45)()
-          )]
-       ),
-       [],
-       (29...32),
-       nil,
-       nil,
-       nil,
-       nil,
-       (47...50)
-     ),
-     DefNode(52...77)(
-       :x,
-       (56...57),
-       nil,
-       nil,
-       StatementsNode(59...72)(
-         [ConstantPathOrWriteNode(59...72)(
-            ConstantPathNode(59...66)(
-              SelfNode(59...63)(),
-              ConstantReadNode(65...66)(:A),
-              (63...65)
-            ),
-            (67...70),
-            IntegerNode(71...72)()
-          )]
-       ),
-       [],
-       (52...55),
-       nil,
-       nil,
-       nil,
-       nil,
-       (74...77)
-     )]
-  )
-)
+@ ProgramNode (location: (0...77))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...77))
+    └── body: (length: 5)
+        ├── @ ConstantPathOperatorWriteNode (location: (0...8))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (0...3))
+        │   │   ├── parent: ∅
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (2...3))
+        │   │   │   └── name: :A
+        │   │   └── delimiter_loc: (0...2) = "::"
+        │   ├── operator_loc: (4...6) = "+="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (7...8))
+        │   └── operator: :+
+        ├── @ ConstantOperatorWriteNode (location: (10...16))
+        │   ├── name: :A
+        │   ├── name_loc: (10...11) = "A"
+        │   ├── operator_loc: (12...14) = "+="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (15...16))
+        │   └── operator: :+
+        ├── @ ConstantPathOperatorWriteNode (location: (18...27))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (18...22))
+        │   │   ├── parent:
+        │   │   │   @ ConstantReadNode (location: (18...19))
+        │   │   │   └── name: :B
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (21...22))
+        │   │   │   └── name: :A
+        │   │   └── delimiter_loc: (19...21) = "::"
+        │   ├── operator_loc: (23...25) = "+="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (26...27))
+        │   └── operator: :+
+        ├── @ DefNode (location: (29...50))
+        │   ├── name: :x
+        │   ├── name_loc: (33...34) = "x"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (36...45))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ConstantPathOrWriteNode (location: (36...45))
+        │   │           ├── target:
+        │   │           │   @ ConstantPathNode (location: (36...39))
+        │   │           │   ├── parent: ∅
+        │   │           │   ├── child:
+        │   │           │   │   @ ConstantReadNode (location: (38...39))
+        │   │           │   │   └── name: :A
+        │   │           │   └── delimiter_loc: (36...38) = "::"
+        │   │           ├── operator_loc: (40...43) = "||="
+        │   │           └── value:
+        │   │               @ IntegerNode (location: (44...45))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (29...32) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (47...50) = "end"
+        └── @ DefNode (location: (52...77))
+            ├── name: :x
+            ├── name_loc: (56...57) = "x"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (59...72))
+            │   └── body: (length: 1)
+            │       └── @ ConstantPathOrWriteNode (location: (59...72))
+            │           ├── target:
+            │           │   @ ConstantPathNode (location: (59...66))
+            │           │   ├── parent:
+            │           │   │   @ SelfNode (location: (59...63))
+            │           │   ├── child:
+            │           │   │   @ ConstantReadNode (location: (65...66))
+            │           │   │   └── name: :A
+            │           │   └── delimiter_loc: (63...65) = "::"
+            │           ├── operator_loc: (67...70) = "||="
+            │           └── value:
+            │               @ IntegerNode (location: (71...72))
+            ├── locals: []
+            ├── def_keyword_loc: (52...55) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (74...77) = "end"
diff --git a/test/yarp/snapshots/whitequark/const_scoped.txt b/test/yarp/snapshots/whitequark/const_scoped.txt
index 2404bd0529..716f9b4c5c 100644
--- a/test/yarp/snapshots/whitequark/const_scoped.txt
+++ b/test/yarp/snapshots/whitequark/const_scoped.txt
@@ -1,10 +1,13 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [ConstantPathNode(0...8)(
-       ConstantReadNode(0...3)(:Bar),
-       ConstantReadNode(5...8)(:Foo),
-       (3...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ ConstantPathNode (location: (0...8))
+            ├── parent:
+            │   @ ConstantReadNode (location: (0...3))
+            │   └── name: :Bar
+            ├── child:
+            │   @ ConstantReadNode (location: (5...8))
+            │   └── name: :Foo
+            └── delimiter_loc: (3...5) = "::"
diff --git a/test/yarp/snapshots/whitequark/const_toplevel.txt b/test/yarp/snapshots/whitequark/const_toplevel.txt
index 14647d31be..423b23a359 100644
--- a/test/yarp/snapshots/whitequark/const_toplevel.txt
+++ b/test/yarp/snapshots/whitequark/const_toplevel.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [ConstantPathNode(0...5)(nil, ConstantReadNode(2...5)(:Foo), (0...2))]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ ConstantPathNode (location: (0...5))
+            ├── parent: ∅
+            ├── child:
+            │   @ ConstantReadNode (location: (2...5))
+            │   └── name: :Foo
+            └── delimiter_loc: (0...2) = "::"
diff --git a/test/yarp/snapshots/whitequark/const_unscoped.txt b/test/yarp/snapshots/whitequark/const_unscoped.txt
index 716cbf5249..ba87db9a59 100644
--- a/test/yarp/snapshots/whitequark/const_unscoped.txt
+++ b/test/yarp/snapshots/whitequark/const_unscoped.txt
@@ -1 +1,7 @@
-ProgramNode(0...3)([], StatementsNode(0...3)([ConstantReadNode(0...3)(:Foo)]))
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ ConstantReadNode (location: (0...3))
+            └── name: :Foo
diff --git a/test/yarp/snapshots/whitequark/cpath.txt b/test/yarp/snapshots/whitequark/cpath.txt
index 7e3f62ee17..ce24198772 100644
--- a/test/yarp/snapshots/whitequark/cpath.txt
+++ b/test/yarp/snapshots/whitequark/cpath.txt
@@ -1,25 +1,33 @@
-ProgramNode(0...39)(
-  [],
-  StatementsNode(0...39)(
-    [ModuleNode(0...17)(
-       [],
-       (0...6),
-       ConstantPathNode(7...12)(nil, ConstantReadNode(9...12)(:Foo), (7...9)),
-       nil,
-       (14...17),
-       :Foo
-     ),
-     ModuleNode(19...39)(
-       [],
-       (19...25),
-       ConstantPathNode(26...34)(
-         ConstantReadNode(26...29)(:Bar),
-         ConstantReadNode(31...34)(:Foo),
-         (29...31)
-       ),
-       nil,
-       (36...39),
-       :Foo
-     )]
-  )
-)
+@ ProgramNode (location: (0...39))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...39))
+    └── body: (length: 2)
+        ├── @ ModuleNode (location: (0...17))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (0...6) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (7...12))
+        │   │   ├── parent: ∅
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (9...12))
+        │   │   │   └── name: :Foo
+        │   │   └── delimiter_loc: (7...9) = "::"
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (14...17) = "end"
+        │   └── name: :Foo
+        └── @ ModuleNode (location: (19...39))
+            ├── locals: []
+            ├── module_keyword_loc: (19...25) = "module"
+            ├── constant_path:
+            │   @ ConstantPathNode (location: (26...34))
+            │   ├── parent:
+            │   │   @ ConstantReadNode (location: (26...29))
+            │   │   └── name: :Bar
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (31...34))
+            │   │   └── name: :Foo
+            │   └── delimiter_loc: (29...31) = "::"
+            ├── body: ∅
+            ├── end_keyword_loc: (36...39) = "end"
+            └── name: :Foo
diff --git a/test/yarp/snapshots/whitequark/cvar.txt b/test/yarp/snapshots/whitequark/cvar.txt
index 6a1f2e50f4..40017f5129 100644
--- a/test/yarp/snapshots/whitequark/cvar.txt
+++ b/test/yarp/snapshots/whitequark/cvar.txt
@@ -1,4 +1,7 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)([ClassVariableReadNode(0...5)(:@@foo)])
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ ClassVariableReadNode (location: (0...5))
+            └── name: :@@foo
diff --git a/test/yarp/snapshots/whitequark/cvasgn.txt b/test/yarp/snapshots/whitequark/cvasgn.txt
index 7e07810eb6..6d1c287d2c 100644
--- a/test/yarp/snapshots/whitequark/cvasgn.txt
+++ b/test/yarp/snapshots/whitequark/cvasgn.txt
@@ -1,11 +1,11 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [ClassVariableWriteNode(0...10)(
-       :@@var,
-       (0...5),
-       IntegerNode(8...10)(),
-       (6...7)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ ClassVariableWriteNode (location: (0...10))
+            ├── name: :@@var
+            ├── name_loc: (0...5) = "@@var"
+            ├── value:
+            │   @ IntegerNode (location: (8...10))
+            └── operator_loc: (6...7) = "="
diff --git a/test/yarp/snapshots/whitequark/dedenting_heredoc.txt b/test/yarp/snapshots/whitequark/dedenting_heredoc.txt
index d74deb09b0..a0a900f693 100644
--- a/test/yarp/snapshots/whitequark/dedenting_heredoc.txt
+++ b/test/yarp/snapshots/whitequark/dedenting_heredoc.txt
@@ -1,323 +1,389 @@
-ProgramNode(0...313)(
-  [],
-  StatementsNode(0...313)(
-    [CallNode(0...8)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...8)(
-         [InterpolatedStringNode(2...8)(
-            (2...8),
-            [StringNode(9...17)(nil, (9...17), nil, "  x\n"),
-             EmbeddedStatementsNode(17...25)(
-               (17...19),
-               StatementsNode(19...24)(
-                 [StringNode(19...24)((19...20), (20...23), (23...24), "  y")]
-               ),
-               (24...25)
-             ),
-             StringNode(25...26)(nil, (25...26), nil, "\n")],
-            (26...28)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(29...37)(
-       nil,
-       nil,
-       (29...30),
-       nil,
-       ArgumentsNode(31...37)(
-         [InterpolatedStringNode(31...37)(
-            (31...37),
-            [StringNode(38...46)(nil, (38...46), nil, "  x\n"),
-             EmbeddedStatementsNode(46...52)(
-               (46...48),
-               StatementsNode(48...51)(
-                 [CallNode(48...51)(
-                    nil,
-                    nil,
-                    (48...51),
-                    nil,
-                    nil,
-                    nil,
-                    nil,
-                    2,
-                    "foo"
-                  )]
-               ),
-               (51...52)
-             ),
-             StringNode(52...53)(nil, (52...53), nil, "\n")],
-            (53...55)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(56...62)(
-       nil,
-       nil,
-       (56...57),
-       nil,
-       ArgumentsNode(58...62)(
-         [InterpolatedStringNode(58...62)(
-            (58...62),
-            [StringNode(63...76)(nil, (63...76), nil, "x\n" + "y\n")],
-            (76...78)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(79...85)(
-       nil,
-       nil,
-       (79...80),
-       nil,
-       ArgumentsNode(81...85)(
-         [InterpolatedStringNode(81...85)(
-            (81...85),
-            [StringNode(86...95)(nil, (86...95), nil, "\tx\n" + "y\n")],
-            (95...97)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(98...104)(
-       nil,
-       nil,
-       (98...99),
-       nil,
-       ArgumentsNode(100...104)(
-         [InterpolatedStringNode(100...104)(
-            (100...104),
-            [StringNode(105...122)(nil, (105...122), nil, "x\n" + "y\n")],
-            (122...124)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(125...131)(
-       nil,
-       nil,
-       (125...126),
-       nil,
-       ArgumentsNode(127...131)(
-         [InterpolatedStringNode(127...131)(
-            (127...131),
-            [StringNode(132...146)(nil, (132...146), nil, "\tx\n" + "y\n")],
-            (146...148)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(149...155)(
-       nil,
-       nil,
-       (149...150),
-       nil,
-       ArgumentsNode(151...155)(
-         [InterpolatedStringNode(151...155)(
-            (151...155),
-            [StringNode(156...168)(nil, (156...168), nil, "  x\n" + "\ty\n")],
-            (168...170)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(171...177)(
-       nil,
-       nil,
-       (171...172),
-       nil,
-       ArgumentsNode(173...177)(
-         [InterpolatedStringNode(173...177)(
-            (173...177),
-            [StringNode(178...191)(nil, (178...191), nil, "  x\n" + "  y\n")],
-            (191...193)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(194...200)(
-       nil,
-       nil,
-       (194...195),
-       nil,
-       ArgumentsNode(196...200)(
-         [InterpolatedStringNode(196...200)((196...200), [], (201...205))]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(206...212)(
-       nil,
-       nil,
-       (206...207),
-       nil,
-       ArgumentsNode(208...212)(
-         [InterpolatedStringNode(208...212)(
-            (208...212),
-            [StringNode(213...220)(
-               nil,
-               (213...220),
-               nil,
-               "  x\n" + "\n" + "y\n"
-             )],
-            (220...222)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(223...229)(
-       nil,
-       nil,
-       (223...224),
-       nil,
-       ArgumentsNode(225...229)(
-         [InterpolatedStringNode(225...229)(
-            (225...229),
-            [StringNode(230...243)(
-               nil,
-               (230...243),
-               nil,
-               "x\n" + "  \n" + "y\n"
-             )],
-            (243...245)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(246...252)(
-       nil,
-       nil,
-       (246...247),
-       nil,
-       ArgumentsNode(248...252)(
-         [InterpolatedStringNode(248...252)(
-            (248...252),
-            [StringNode(253...263)(nil, (253...263), nil, "x\n" + "  y\n")],
-            (263...265)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(266...272)(
-       nil,
-       nil,
-       (266...267),
-       nil,
-       ArgumentsNode(268...272)(
-         [InterpolatedStringNode(268...272)(
-            (268...272),
-            [StringNode(273...277)(nil, (273...277), nil, "x\n")],
-            (277...279)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(280...286)(
-       nil,
-       nil,
-       (280...281),
-       nil,
-       ArgumentsNode(282...286)(
-         [InterpolatedStringNode(282...286)(
-            (282...286),
-            [StringNode(287...292)(nil, (287...292), nil, "ð\n")],
-            (292...294)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(295...301)(
-       nil,
-       nil,
-       (295...296),
-       nil,
-       ArgumentsNode(297...301)(
-         [InterpolatedStringNode(297...301)((297...301), [], (302...304))]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     ),
-     CallNode(305...313)(
-       nil,
-       nil,
-       (305...306),
-       nil,
-       ArgumentsNode(307...313)(
-         [InterpolatedXStringNode(307...313)(
-            (307...313),
-            [StringNode(314...322)(nil, (314...322), nil, "  x\n"),
-             EmbeddedStatementsNode(322...328)(
-               (322...324),
-               StatementsNode(324...327)(
-                 [CallNode(324...327)(
-                    nil,
-                    nil,
-                    (324...327),
-                    nil,
-                    nil,
-                    nil,
-                    nil,
-                    2,
-                    "foo"
-                  )]
-               ),
-               (327...328)
-             ),
-             StringNode(328...329)(nil, (328...329), nil, "\n")],
-            (329...331)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...313))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...313))
+    └── body: (length: 16)
+        ├── @ CallNode (location: (0...8))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...8))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (2...8))
+        │   │           ├── opening_loc: (2...8) = "<<~\"E\""
+        │   │           ├── parts: (length: 3)
+        │   │           │   ├── @ StringNode (location: (9...17))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (9...17) = "    x\n  "
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "  x\n"
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (17...25))
+        │   │           │   │   ├── opening_loc: (17...19) = "\#{"
+        │   │           │   │   ├── statements:
+        │   │           │   │   │   @ StatementsNode (location: (19...24))
+        │   │           │   │   │   └── body: (length: 1)
+        │   │           │   │   │       └── @ StringNode (location: (19...24))
+        │   │           │   │   │           ├── opening_loc: (19...20) = "\""
+        │   │           │   │   │           ├── content_loc: (20...23) = "  y"
+        │   │           │   │   │           ├── closing_loc: (23...24) = "\""
+        │   │           │   │   │           └── unescaped: "  y"
+        │   │           │   │   └── closing_loc: (24...25) = "}"
+        │   │           │   └── @ StringNode (location: (25...26))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (25...26) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (26...28) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (29...37))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (29...30) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (31...37))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (31...37))
+        │   │           ├── opening_loc: (31...37) = "<<~\"E\""
+        │   │           ├── parts: (length: 3)
+        │   │           │   ├── @ StringNode (location: (38...46))
+        │   │           │   │   ├── opening_loc: ∅
+        │   │           │   │   ├── content_loc: (38...46) = "    x\n  "
+        │   │           │   │   ├── closing_loc: ∅
+        │   │           │   │   └── unescaped: "  x\n"
+        │   │           │   ├── @ EmbeddedStatementsNode (location: (46...52))
+        │   │           │   │   ├── opening_loc: (46...48) = "\#{"
+        │   │           │   │   ├── statements:
+        │   │           │   │   │   @ StatementsNode (location: (48...51))
+        │   │           │   │   │   └── body: (length: 1)
+        │   │           │   │   │       └── @ CallNode (location: (48...51))
+        │   │           │   │   │           ├── receiver: ∅
+        │   │           │   │   │           ├── call_operator_loc: ∅
+        │   │           │   │   │           ├── message_loc: (48...51) = "foo"
+        │   │           │   │   │           ├── opening_loc: ∅
+        │   │           │   │   │           ├── arguments: ∅
+        │   │           │   │   │           ├── closing_loc: ∅
+        │   │           │   │   │           ├── block: ∅
+        │   │           │   │   │           ├── flags: variable_call
+        │   │           │   │   │           └── name: "foo"
+        │   │           │   │   └── closing_loc: (51...52) = "}"
+        │   │           │   └── @ StringNode (location: (52...53))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (52...53) = "\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\n"
+        │   │           └── closing_loc: (53...55) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (56...62))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (56...57) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (58...62))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (58...62))
+        │   │           ├── opening_loc: (58...62) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (63...76))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (63...76) = "\tx\n        y\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "x\ny\n"
+        │   │           └── closing_loc: (76...78) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (79...85))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (79...80) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (81...85))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (81...85))
+        │   │           ├── opening_loc: (81...85) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (86...95))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (86...95) = "\tx\n    y\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\tx\ny\n"
+        │   │           └── closing_loc: (95...97) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (98...104))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (98...99) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (100...104))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (100...104))
+        │   │           ├── opening_loc: (100...104) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (105...122))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (105...122) = "    \tx\n        y\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "x\ny\n"
+        │   │           └── closing_loc: (122...124) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (125...131))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (125...126) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (127...131))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (127...131))
+        │   │           ├── opening_loc: (127...131) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (132...146))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (132...146) = "        \tx\n\ty\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "\tx\ny\n"
+        │   │           └── closing_loc: (146...148) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (149...155))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (149...150) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (151...155))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (151...155))
+        │   │           ├── opening_loc: (151...155) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (156...168))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (156...168) = "    x\n  \\\ty\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "  x\n\ty\n"
+        │   │           └── closing_loc: (168...170) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (171...177))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (171...172) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (173...177))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (173...177))
+        │   │           ├── opening_loc: (173...177) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (178...191))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (178...191) = "    x\n  \\  y\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "  x\n  y\n"
+        │   │           └── closing_loc: (191...193) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (194...200))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (194...195) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (196...200))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (196...200))
+        │   │           ├── opening_loc: (196...200) = "<<~E"
+        │   │           ├── parts: (length: 0)
+        │   │           └── closing_loc: (201...205) = "  E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (206...212))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (206...207) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (208...212))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (208...212))
+        │   │           ├── opening_loc: (208...212) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (213...220))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (213...220) = "  x\n\ny\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "  x\n\ny\n"
+        │   │           └── closing_loc: (220...222) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (223...229))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (223...224) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (225...229))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (225...229))
+        │   │           ├── opening_loc: (225...229) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (230...243))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (230...243) = "  x\n    \n  y\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "x\n  \ny\n"
+        │   │           └── closing_loc: (243...245) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (246...252))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (246...247) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (248...252))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (248...252))
+        │   │           ├── opening_loc: (248...252) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (253...263))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (253...263) = "  x\n    y\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "x\n  y\n"
+        │   │           └── closing_loc: (263...265) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (266...272))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (266...267) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (268...272))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (268...272))
+        │   │           ├── opening_loc: (268...272) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (273...277))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (273...277) = "  x\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "x\n"
+        │   │           └── closing_loc: (277...279) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (280...286))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (280...281) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (282...286))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (282...286))
+        │   │           ├── opening_loc: (282...286) = "<<~E"
+        │   │           ├── parts: (length: 1)
+        │   │           │   └── @ StringNode (location: (287...292))
+        │   │           │       ├── opening_loc: ∅
+        │   │           │       ├── content_loc: (287...292) = "  ð\n"
+        │   │           │       ├── closing_loc: ∅
+        │   │           │       └── unescaped: "ð\n"
+        │   │           └── closing_loc: (292...294) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        ├── @ CallNode (location: (295...301))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (295...296) = "p"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (297...301))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ InterpolatedStringNode (location: (297...301))
+        │   │           ├── opening_loc: (297...301) = "<<~E"
+        │   │           ├── parts: (length: 0)
+        │   │           └── closing_loc: (302...304) = "E\n"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "p"
+        └── @ CallNode (location: (305...313))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (305...306) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (307...313))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedXStringNode (location: (307...313))
+            │           ├── opening_loc: (307...313) = "<<~`E`"
+            │           ├── parts: (length: 3)
+            │           │   ├── @ StringNode (location: (314...322))
+            │           │   │   ├── opening_loc: ∅
+            │           │   │   ├── content_loc: (314...322) = "    x\n  "
+            │           │   │   ├── closing_loc: ∅
+            │           │   │   └── unescaped: "  x\n"
+            │           │   ├── @ EmbeddedStatementsNode (location: (322...328))
+            │           │   │   ├── opening_loc: (322...324) = "\#{"
+            │           │   │   ├── statements:
+            │           │   │   │   @ StatementsNode (location: (324...327))
+            │           │   │   │   └── body: (length: 1)
+            │           │   │   │       └── @ CallNode (location: (324...327))
+            │           │   │   │           ├── receiver: ∅
+            │           │   │   │           ├── call_operator_loc: ∅
+            │           │   │   │           ├── message_loc: (324...327) = "foo"
+            │           │   │   │           ├── opening_loc: ∅
+            │           │   │   │           ├── arguments: ∅
+            │           │   │   │           ├── closing_loc: ∅
+            │           │   │   │           ├── block: ∅
+            │           │   │   │           ├── flags: variable_call
+            │           │   │   │           └── name: "foo"
+            │           │   │   └── closing_loc: (327...328) = "}"
+            │           │   └── @ StringNode (location: (328...329))
+            │           │       ├── opening_loc: ∅
+            │           │       ├── content_loc: (328...329) = "\n"
+            │           │       ├── closing_loc: ∅
+            │           │       └── unescaped: "\n"
+            │           └── closing_loc: (329...331) = "E\n"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/whitequark/dedenting_interpolating_heredoc_fake_line_continuation.txt b/test/yarp/snapshots/whitequark/dedenting_interpolating_heredoc_fake_line_continuation.txt
index f076eed1fe..fb23aed909 100644
--- a/test/yarp/snapshots/whitequark/dedenting_interpolating_heredoc_fake_line_continuation.txt
+++ b/test/yarp/snapshots/whitequark/dedenting_interpolating_heredoc_fake_line_continuation.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [InterpolatedStringNode(0...8)(
-       (0...8),
-       [StringNode(9...23)(nil, (9...23), nil, "baz\\\n" + "qux\n")],
-       (23...27)
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...8))
+            ├── opening_loc: (0...8) = "<<~'FOO'"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (9...23))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (9...23) = "  baz\\\\\n  qux\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "baz\\\nqux\n"
+            └── closing_loc: (23...27) = "FOO\n"
diff --git a/test/yarp/snapshots/whitequark/dedenting_non_interpolating_heredoc_line_continuation.txt b/test/yarp/snapshots/whitequark/dedenting_non_interpolating_heredoc_line_continuation.txt
index ce1617b1ad..4f349a265d 100644
--- a/test/yarp/snapshots/whitequark/dedenting_non_interpolating_heredoc_line_continuation.txt
+++ b/test/yarp/snapshots/whitequark/dedenting_non_interpolating_heredoc_line_continuation.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [InterpolatedStringNode(0...8)(
-       (0...8),
-       [StringNode(9...22)(nil, (9...22), nil, "baz\\\n" + "qux\n")],
-       (22...26)
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...8))
+            ├── opening_loc: (0...8) = "<<~'FOO'"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (9...22))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (9...22) = "  baz\\\n  qux\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "baz\\\nqux\n"
+            └── closing_loc: (22...26) = "FOO\n"
diff --git a/test/yarp/snapshots/whitequark/def.txt b/test/yarp/snapshots/whitequark/def.txt
index 383b2a666c..c67a8b3a1a 100644
--- a/test/yarp/snapshots/whitequark/def.txt
+++ b/test/yarp/snapshots/whitequark/def.txt
@@ -1,89 +1,83 @@
-ProgramNode(0...93)(
-  [],
-  StatementsNode(0...93)(
-    [DefNode(0...14)(
-       :BEGIN,
-       (4...9),
-       nil,
-       nil,
-       nil,
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (11...14)
-     ),
-     DefNode(16...28)(
-       :END,
-       (20...23),
-       nil,
-       nil,
-       nil,
-       [],
-       (16...19),
-       nil,
-       nil,
-       nil,
-       nil,
-       (25...28)
-     ),
-     DefNode(30...45)(
-       :String,
-       (34...40),
-       nil,
-       nil,
-       nil,
-       [],
-       (30...33),
-       nil,
-       nil,
-       nil,
-       nil,
-       (42...45)
-     ),
-     DefNode(47...63)(
-       :String=,
-       (51...58),
-       nil,
-       nil,
-       nil,
-       [],
-       (47...50),
-       nil,
-       nil,
-       nil,
-       nil,
-       (60...63)
-     ),
-     DefNode(65...77)(
-       :foo,
-       (69...72),
-       nil,
-       nil,
-       nil,
-       [],
-       (65...68),
-       nil,
-       nil,
-       nil,
-       nil,
-       (74...77)
-     ),
-     DefNode(79...93)(
-       :until,
-       (83...88),
-       nil,
-       nil,
-       nil,
-       [],
-       (79...82),
-       nil,
-       nil,
-       nil,
-       nil,
-       (90...93)
-     )]
-  )
-)
+@ ProgramNode (location: (0...93))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...93))
+    └── body: (length: 6)
+        ├── @ DefNode (location: (0...14))
+        │   ├── name: :BEGIN
+        │   ├── name_loc: (4...9) = "BEGIN"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (11...14) = "end"
+        ├── @ DefNode (location: (16...28))
+        │   ├── name: :END
+        │   ├── name_loc: (20...23) = "END"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (16...19) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (25...28) = "end"
+        ├── @ DefNode (location: (30...45))
+        │   ├── name: :String
+        │   ├── name_loc: (34...40) = "String"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (30...33) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (42...45) = "end"
+        ├── @ DefNode (location: (47...63))
+        │   ├── name: :String=
+        │   ├── name_loc: (51...58) = "String="
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (47...50) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (60...63) = "end"
+        ├── @ DefNode (location: (65...77))
+        │   ├── name: :foo
+        │   ├── name_loc: (69...72) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (65...68) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (74...77) = "end"
+        └── @ DefNode (location: (79...93))
+            ├── name: :until
+            ├── name_loc: (83...88) = "until"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (79...82) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (90...93) = "end"
diff --git a/test/yarp/snapshots/whitequark/defined.txt b/test/yarp/snapshots/whitequark/defined.txt
index 3ddfdd84bb..511967f049 100644
--- a/test/yarp/snapshots/whitequark/defined.txt
+++ b/test/yarp/snapshots/whitequark/defined.txt
@@ -1,23 +1,42 @@
-ProgramNode(0...42)(
-  [],
-  StatementsNode(0...42)(
-    [DefinedNode(0...13)(
-       nil,
-       InstanceVariableReadNode(9...13)(:@foo),
-       nil,
-       (0...8)
-     ),
-     DefinedNode(15...27)(
-       nil,
-       CallNode(24...27)(nil, nil, (24...27), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (15...23)
-     ),
-     DefinedNode(29...42)(
-       (37...38),
-       CallNode(38...41)(nil, nil, (38...41), nil, nil, nil, nil, 2, "foo"),
-       (41...42),
-       (29...37)
-     )]
-  )
-)
+@ ProgramNode (location: (0...42))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...42))
+    └── body: (length: 3)
+        ├── @ DefinedNode (location: (0...13))
+        │   ├── lparen_loc: ∅
+        │   ├── value:
+        │   │   @ InstanceVariableReadNode (location: (9...13))
+        │   │   └── name: :@foo
+        │   ├── rparen_loc: ∅
+        │   └── keyword_loc: (0...8) = "defined?"
+        ├── @ DefinedNode (location: (15...27))
+        │   ├── lparen_loc: ∅
+        │   ├── value:
+        │   │   @ CallNode (location: (24...27))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (24...27) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── rparen_loc: ∅
+        │   └── keyword_loc: (15...23) = "defined?"
+        └── @ DefinedNode (location: (29...42))
+            ├── lparen_loc: (37...38) = "("
+            ├── value:
+            │   @ CallNode (location: (38...41))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (38...41) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── rparen_loc: (41...42) = ")"
+            └── keyword_loc: (29...37) = "defined?"
diff --git a/test/yarp/snapshots/whitequark/defs.txt b/test/yarp/snapshots/whitequark/defs.txt
index 6072d21645..9432471f3b 100644
--- a/test/yarp/snapshots/whitequark/defs.txt
+++ b/test/yarp/snapshots/whitequark/defs.txt
@@ -1,79 +1,90 @@
-ProgramNode(0...100)(
-  [],
-  StatementsNode(0...100)(
-    [DefNode(0...18)(
-       :foo,
-       (10...13),
-       ParenthesesNode(4...9)(
-         CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "foo"),
-         (4...5),
-         (8...9)
-       ),
-       nil,
-       nil,
-       [],
-       (0...3),
-       (9...10),
-       nil,
-       nil,
-       nil,
-       (15...18)
-     ),
-     DefNode(20...39)(
-       :foo,
-       (31...34),
-       ConstantReadNode(24...30)(:String),
-       nil,
-       nil,
-       [],
-       (20...23),
-       (30...31),
-       nil,
-       nil,
-       nil,
-       (36...39)
-     ),
-     DefNode(41...61)(
-       :foo,
-       (53...56),
-       ConstantReadNode(45...51)(:String),
-       nil,
-       nil,
-       [],
-       (41...44),
-       (51...53),
-       nil,
-       nil,
-       nil,
-       (58...61)
-     ),
-     DefNode(63...80)(
-       :foo,
-       (72...75),
-       SelfNode(67...71)(),
-       nil,
-       nil,
-       [],
-       (63...66),
-       (71...72),
-       nil,
-       nil,
-       nil,
-       (77...80)
-     ),
-     DefNode(82...100)(
-       :foo,
-       (92...95),
-       SelfNode(86...90)(),
-       nil,
-       nil,
-       [],
-       (82...85),
-       (90...92),
-       nil,
-       nil,
-       nil,
-       (97...100)
-     )]
-  )
-)
+@ ProgramNode (location: (0...100))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...100))
+    └── body: (length: 5)
+        ├── @ DefNode (location: (0...18))
+        │   ├── name: :foo
+        │   ├── name_loc: (10...13) = "foo"
+        │   ├── receiver:
+        │   │   @ ParenthesesNode (location: (4...9))
+        │   │   ├── body:
+        │   │   │   @ CallNode (location: (5...8))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (5...8) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── opening_loc: (4...5) = "("
+        │   │   └── closing_loc: (8...9) = ")"
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: (9...10) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (15...18) = "end"
+        ├── @ DefNode (location: (20...39))
+        │   ├── name: :foo
+        │   ├── name_loc: (31...34) = "foo"
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (24...30))
+        │   │   └── name: :String
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (20...23) = "def"
+        │   ├── operator_loc: (30...31) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (36...39) = "end"
+        ├── @ DefNode (location: (41...61))
+        │   ├── name: :foo
+        │   ├── name_loc: (53...56) = "foo"
+        │   ├── receiver:
+        │   │   @ ConstantReadNode (location: (45...51))
+        │   │   └── name: :String
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (41...44) = "def"
+        │   ├── operator_loc: (51...53) = "::"
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (58...61) = "end"
+        ├── @ DefNode (location: (63...80))
+        │   ├── name: :foo
+        │   ├── name_loc: (72...75) = "foo"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (67...71))
+        │   ├── parameters: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (63...66) = "def"
+        │   ├── operator_loc: (71...72) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (77...80) = "end"
+        └── @ DefNode (location: (82...100))
+            ├── name: :foo
+            ├── name_loc: (92...95) = "foo"
+            ├── receiver:
+            │   @ SelfNode (location: (86...90))
+            ├── parameters: ∅
+            ├── body: ∅
+            ├── locals: []
+            ├── def_keyword_loc: (82...85) = "def"
+            ├── operator_loc: (90...92) = "::"
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (97...100) = "end"
diff --git a/test/yarp/snapshots/whitequark/empty_stmt.txt b/test/yarp/snapshots/whitequark/empty_stmt.txt
index bd3eaf5ff4..81b8a103ea 100644
--- a/test/yarp/snapshots/whitequark/empty_stmt.txt
+++ b/test/yarp/snapshots/whitequark/empty_stmt.txt
@@ -1 +1,5 @@
-ProgramNode(0...0)([], StatementsNode(0...0)([]))
+@ ProgramNode (location: (0...0))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...0))
+    └── body: (length: 0)
diff --git a/test/yarp/snapshots/whitequark/endless_comparison_method.txt b/test/yarp/snapshots/whitequark/endless_comparison_method.txt
index b0d3b33aca..e1b10ac4b2 100644
--- a/test/yarp/snapshots/whitequark/endless_comparison_method.txt
+++ b/test/yarp/snapshots/whitequark/endless_comparison_method.txt
@@ -1,209 +1,215 @@
-ProgramNode(0...179)(
-  [],
-  StatementsNode(0...179)(
-    [DefNode(0...28)(
-       :!=,
-       (4...6),
-       nil,
-       ParametersNode(7...12)(
-         [RequiredParameterNode(7...12)(:other)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(16...28)(
-         [CallNode(16...28)(
-            nil,
-            nil,
-            (16...28),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "do_something"
-          )]
-       ),
-       [:other],
-       (0...3),
-       nil,
-       (6...7),
-       (12...13),
-       (14...15),
-       nil
-     ),
-     DefNode(30...58)(
-       :!=,
-       (34...36),
-       nil,
-       ParametersNode(37...42)(
-         [RequiredParameterNode(37...42)(:other)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(46...58)(
-         [CallNode(46...58)(
-            nil,
-            nil,
-            (46...58),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "do_something"
-          )]
-       ),
-       [:other],
-       (30...33),
-       nil,
-       (36...37),
-       (42...43),
-       (44...45),
-       nil
-     ),
-     DefNode(60...88)(
-       :<=,
-       (64...66),
-       nil,
-       ParametersNode(67...72)(
-         [RequiredParameterNode(67...72)(:other)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(76...88)(
-         [CallNode(76...88)(
-            nil,
-            nil,
-            (76...88),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "do_something"
-          )]
-       ),
-       [:other],
-       (60...63),
-       nil,
-       (66...67),
-       (72...73),
-       (74...75),
-       nil
-     ),
-     DefNode(90...118)(
-       :==,
-       (94...96),
-       nil,
-       ParametersNode(97...102)(
-         [RequiredParameterNode(97...102)(:other)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(106...118)(
-         [CallNode(106...118)(
-            nil,
-            nil,
-            (106...118),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "do_something"
-          )]
-       ),
-       [:other],
-       (90...93),
-       nil,
-       (96...97),
-       (102...103),
-       (104...105),
-       nil
-     ),
-     DefNode(120...149)(
-       :===,
-       (124...127),
-       nil,
-       ParametersNode(128...133)(
-         [RequiredParameterNode(128...133)(:other)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(137...149)(
-         [CallNode(137...149)(
-            nil,
-            nil,
-            (137...149),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "do_something"
-          )]
-       ),
-       [:other],
-       (120...123),
-       nil,
-       (127...128),
-       (133...134),
-       (135...136),
-       nil
-     ),
-     DefNode(151...179)(
-       :>=,
-       (155...157),
-       nil,
-       ParametersNode(158...163)(
-         [RequiredParameterNode(158...163)(:other)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(167...179)(
-         [CallNode(167...179)(
-            nil,
-            nil,
-            (167...179),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "do_something"
-          )]
-       ),
-       [:other],
-       (151...154),
-       nil,
-       (157...158),
-       (163...164),
-       (165...166),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...179))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...179))
+    └── body: (length: 6)
+        ├── @ DefNode (location: (0...28))
+        │   ├── name: :!=
+        │   ├── name_loc: (4...6) = "!="
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (7...12))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (7...12))
+        │   │   │       └── name: :other
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (16...28))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (16...28))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (16...28) = "do_something"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "do_something"
+        │   ├── locals: [:other]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (6...7) = "("
+        │   ├── rparen_loc: (12...13) = ")"
+        │   ├── equal_loc: (14...15) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (30...58))
+        │   ├── name: :!=
+        │   ├── name_loc: (34...36) = "!="
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (37...42))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (37...42))
+        │   │   │       └── name: :other
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (46...58))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (46...58))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (46...58) = "do_something"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "do_something"
+        │   ├── locals: [:other]
+        │   ├── def_keyword_loc: (30...33) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (36...37) = "("
+        │   ├── rparen_loc: (42...43) = ")"
+        │   ├── equal_loc: (44...45) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (60...88))
+        │   ├── name: :<=
+        │   ├── name_loc: (64...66) = "<="
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (67...72))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (67...72))
+        │   │   │       └── name: :other
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (76...88))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (76...88))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (76...88) = "do_something"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "do_something"
+        │   ├── locals: [:other]
+        │   ├── def_keyword_loc: (60...63) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (66...67) = "("
+        │   ├── rparen_loc: (72...73) = ")"
+        │   ├── equal_loc: (74...75) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (90...118))
+        │   ├── name: :==
+        │   ├── name_loc: (94...96) = "=="
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (97...102))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (97...102))
+        │   │   │       └── name: :other
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (106...118))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (106...118))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (106...118) = "do_something"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "do_something"
+        │   ├── locals: [:other]
+        │   ├── def_keyword_loc: (90...93) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (96...97) = "("
+        │   ├── rparen_loc: (102...103) = ")"
+        │   ├── equal_loc: (104...105) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (120...149))
+        │   ├── name: :===
+        │   ├── name_loc: (124...127) = "==="
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (128...133))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (128...133))
+        │   │   │       └── name: :other
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (137...149))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (137...149))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (137...149) = "do_something"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "do_something"
+        │   ├── locals: [:other]
+        │   ├── def_keyword_loc: (120...123) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (127...128) = "("
+        │   ├── rparen_loc: (133...134) = ")"
+        │   ├── equal_loc: (135...136) = "="
+        │   └── end_keyword_loc: ∅
+        └── @ DefNode (location: (151...179))
+            ├── name: :>=
+            ├── name_loc: (155...157) = ">="
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (158...163))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (158...163))
+            │   │       └── name: :other
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (167...179))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (167...179))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (167...179) = "do_something"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "do_something"
+            ├── locals: [:other]
+            ├── def_keyword_loc: (151...154) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (157...158) = "("
+            ├── rparen_loc: (163...164) = ")"
+            ├── equal_loc: (165...166) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/endless_method.txt b/test/yarp/snapshots/whitequark/endless_method.txt
index c81dd69456..f6ebbd9061 100644
--- a/test/yarp/snapshots/whitequark/endless_method.txt
+++ b/test/yarp/snapshots/whitequark/endless_method.txt
@@ -1,101 +1,139 @@
-ProgramNode(0...78)(
-  [],
-  StatementsNode(0...78)(
-    [DefNode(0...14)(
-       :foo,
-       (4...7),
-       nil,
-       nil,
-       StatementsNode(12...14)([IntegerNode(12...14)()]),
-       [],
-       (0...3),
-       nil,
-       (7...8),
-       (8...9),
-       (10...11),
-       nil
-     ),
-     DefNode(16...34)(
-       :inc,
-       (20...23),
-       nil,
-       ParametersNode(24...25)(
-         [RequiredParameterNode(24...25)(:x)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(29...34)(
-         [CallNode(29...34)(
-            LocalVariableReadNode(29...30)(:x, 0),
-            nil,
-            (31...32),
-            nil,
-            ArgumentsNode(33...34)([IntegerNode(33...34)()]),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       ),
-       [:x],
-       (16...19),
-       nil,
-       (23...24),
-       (25...26),
-       (27...28),
-       nil
-     ),
-     DefNode(36...54)(
-       :foo,
-       (44...47),
-       CallNode(40...43)(nil, nil, (40...43), nil, nil, nil, nil, 2, "obj"),
-       nil,
-       StatementsNode(52...54)([IntegerNode(52...54)()]),
-       [],
-       (36...39),
-       (43...44),
-       (47...48),
-       (48...49),
-       (50...51),
-       nil
-     ),
-     DefNode(56...78)(
-       :inc,
-       (64...67),
-       CallNode(60...63)(nil, nil, (60...63), nil, nil, nil, nil, 2, "obj"),
-       ParametersNode(68...69)(
-         [RequiredParameterNode(68...69)(:x)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(73...78)(
-         [CallNode(73...78)(
-            LocalVariableReadNode(73...74)(:x, 0),
-            nil,
-            (75...76),
-            nil,
-            ArgumentsNode(77...78)([IntegerNode(77...78)()]),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       ),
-       [:x],
-       (56...59),
-       (63...64),
-       (67...68),
-       (69...70),
-       (71...72),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...78))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...78))
+    └── body: (length: 4)
+        ├── @ DefNode (location: (0...14))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (12...14))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (12...14))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (7...8) = "("
+        │   ├── rparen_loc: (8...9) = ")"
+        │   ├── equal_loc: (10...11) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (16...34))
+        │   ├── name: :inc
+        │   ├── name_loc: (20...23) = "inc"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (24...25))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (24...25))
+        │   │   │       └── name: :x
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (29...34))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (29...34))
+        │   │           ├── receiver:
+        │   │           │   @ LocalVariableReadNode (location: (29...30))
+        │   │           │   ├── name: :x
+        │   │           │   └── depth: 0
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (31...32) = "+"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (33...34))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (33...34))
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "+"
+        │   ├── locals: [:x]
+        │   ├── def_keyword_loc: (16...19) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (23...24) = "("
+        │   ├── rparen_loc: (25...26) = ")"
+        │   ├── equal_loc: (27...28) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (36...54))
+        │   ├── name: :foo
+        │   ├── name_loc: (44...47) = "foo"
+        │   ├── receiver:
+        │   │   @ CallNode (location: (40...43))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (40...43) = "obj"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "obj"
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (52...54))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (52...54))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (36...39) = "def"
+        │   ├── operator_loc: (43...44) = "."
+        │   ├── lparen_loc: (47...48) = "("
+        │   ├── rparen_loc: (48...49) = ")"
+        │   ├── equal_loc: (50...51) = "="
+        │   └── end_keyword_loc: ∅
+        └── @ DefNode (location: (56...78))
+            ├── name: :inc
+            ├── name_loc: (64...67) = "inc"
+            ├── receiver:
+            │   @ CallNode (location: (60...63))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (60...63) = "obj"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "obj"
+            ├── parameters:
+            │   @ ParametersNode (location: (68...69))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (68...69))
+            │   │       └── name: :x
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (73...78))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (73...78))
+            │           ├── receiver:
+            │           │   @ LocalVariableReadNode (location: (73...74))
+            │           │   ├── name: :x
+            │           │   └── depth: 0
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (75...76) = "+"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (77...78))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ IntegerNode (location: (77...78))
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "+"
+            ├── locals: [:x]
+            ├── def_keyword_loc: (56...59) = "def"
+            ├── operator_loc: (63...64) = "."
+            ├── lparen_loc: (67...68) = "("
+            ├── rparen_loc: (69...70) = ")"
+            ├── equal_loc: (71...72) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/endless_method_command_syntax.txt b/test/yarp/snapshots/whitequark/endless_method_command_syntax.txt
index 3015996dde..5634c12f1b 100644
--- a/test/yarp/snapshots/whitequark/endless_method_command_syntax.txt
+++ b/test/yarp/snapshots/whitequark/endless_method_command_syntax.txt
@@ -1,324 +1,372 @@
-ProgramNode(0...278)(
-  [],
-  StatementsNode(0...278)(
-    [DefNode(0...22)(
-       :foo,
-       (4...7),
-       nil,
-       nil,
-       StatementsNode(10...22)(
-         [CallNode(10...22)(
-            nil,
-            nil,
-            (10...14),
-            nil,
-            ArgumentsNode(15...22)(
-              [StringNode(15...22)((15...16), (16...21), (21...22), "Hello")]
-            ),
-            nil,
-            nil,
-            0,
-            "puts"
-          )]
-       ),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       (8...9),
-       nil
-     ),
-     DefNode(24...48)(
-       :foo,
-       (28...31),
-       nil,
-       nil,
-       StatementsNode(36...48)(
-         [CallNode(36...48)(
-            nil,
-            nil,
-            (36...40),
-            nil,
-            ArgumentsNode(41...48)(
-              [StringNode(41...48)((41...42), (42...47), (47...48), "Hello")]
-            ),
-            nil,
-            nil,
-            0,
-            "puts"
-          )]
-       ),
-       [],
-       (24...27),
-       nil,
-       (31...32),
-       (32...33),
-       (34...35),
-       nil
-     ),
-     DefNode(50...69)(
-       :foo,
-       (54...57),
-       nil,
-       ParametersNode(58...59)(
-         [RequiredParameterNode(58...59)(:x)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(63...69)(
-         [CallNode(63...69)(
-            nil,
-            nil,
-            (63...67),
-            nil,
-            ArgumentsNode(68...69)([LocalVariableReadNode(68...69)(:x, 0)]),
-            nil,
-            nil,
-            0,
-            "puts"
-          )]
-       ),
-       [:x],
-       (50...53),
-       nil,
-       (57...58),
-       (59...60),
-       (61...62),
-       nil
-     ),
-     DefNode(71...97)(
-       :foo,
-       (79...82),
-       CallNode(75...78)(nil, nil, (75...78), nil, nil, nil, nil, 2, "obj"),
-       nil,
-       StatementsNode(85...97)(
-         [CallNode(85...97)(
-            nil,
-            nil,
-            (85...89),
-            nil,
-            ArgumentsNode(90...97)(
-              [StringNode(90...97)((90...91), (91...96), (96...97), "Hello")]
-            ),
-            nil,
-            nil,
-            0,
-            "puts"
-          )]
-       ),
-       [],
-       (71...74),
-       (78...79),
-       nil,
-       nil,
-       (83...84),
-       nil
-     ),
-     DefNode(99...127)(
-       :foo,
-       (107...110),
-       CallNode(103...106)(
-         nil,
-         nil,
-         (103...106),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "obj"
-       ),
-       nil,
-       StatementsNode(115...127)(
-         [CallNode(115...127)(
-            nil,
-            nil,
-            (115...119),
-            nil,
-            ArgumentsNode(120...127)(
-              [StringNode(120...127)(
-                 (120...121),
-                 (121...126),
-                 (126...127),
-                 "Hello"
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "puts"
-          )]
-       ),
-       [],
-       (99...102),
-       (106...107),
-       (110...111),
-       (111...112),
-       (113...114),
-       nil
-     ),
-     DefNode(129...152)(
-       :foo,
-       (137...140),
-       CallNode(133...136)(
-         nil,
-         nil,
-         (133...136),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "obj"
-       ),
-       ParametersNode(141...142)(
-         [RequiredParameterNode(141...142)(:x)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(146...152)(
-         [CallNode(146...152)(
-            nil,
-            nil,
-            (146...150),
-            nil,
-            ArgumentsNode(151...152)(
-              [LocalVariableReadNode(151...152)(:x, 0)]
-            ),
-            nil,
-            nil,
-            0,
-            "puts"
-          )]
-       ),
-       [:x],
-       (129...132),
-       (136...137),
-       (140...141),
-       (142...143),
-       (144...145),
-       nil
-     ),
-     DefNode(154...214)(
-       :rescued,
-       (158...165),
-       nil,
-       ParametersNode(166...167)(
-         [RequiredParameterNode(166...167)(:x)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(171...214)(
-         [CallNode(171...214)(
-            nil,
-            nil,
-            (171...176),
-            nil,
-            ArgumentsNode(177...214)(
-              [RescueModifierNode(177...214)(
-                 StringNode(177...191)(
-                   (177...178),
-                   (178...190),
-                   (190...191),
-                   "to be caught"
-                 ),
-                 (192...198),
-                 InterpolatedStringNode(199...214)(
-                   (199...200),
-                   [StringNode(200...209)(nil, (200...209), nil, "instance "),
-                    EmbeddedStatementsNode(209...213)(
-                      (209...211),
-                      StatementsNode(211...212)(
-                        [LocalVariableReadNode(211...212)(:x, 0)]
-                      ),
-                      (212...213)
-                    )],
-                   (213...214)
-                 )
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "raise"
-          )]
-       ),
-       [:x],
-       (154...157),
-       nil,
-       (165...166),
-       (167...168),
-       (169...170),
-       nil
-     ),
-     DefNode(216...278)(
-       :rescued,
-       (225...232),
-       SelfNode(220...224)(),
-       ParametersNode(233...234)(
-         [RequiredParameterNode(233...234)(:x)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(238...278)(
-         [CallNode(238...278)(
-            nil,
-            nil,
-            (238...243),
-            nil,
-            ArgumentsNode(244...278)(
-              [RescueModifierNode(244...278)(
-                 StringNode(244...258)(
-                   (244...245),
-                   (245...257),
-                   (257...258),
-                   "to be caught"
-                 ),
-                 (259...265),
-                 InterpolatedStringNode(266...278)(
-                   (266...267),
-                   [StringNode(267...273)(nil, (267...273), nil, "class "),
-                    EmbeddedStatementsNode(273...277)(
-                      (273...275),
-                      StatementsNode(275...276)(
-                        [LocalVariableReadNode(275...276)(:x, 0)]
-                      ),
-                      (276...277)
-                    )],
-                   (277...278)
-                 )
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "raise"
-          )]
-       ),
-       [:x],
-       (216...219),
-       (224...225),
-       (232...233),
-       (234...235),
-       (236...237),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...278))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...278))
+    └── body: (length: 8)
+        ├── @ DefNode (location: (0...22))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (10...22))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (10...22))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (10...14) = "puts"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (15...22))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ StringNode (location: (15...22))
+        │   │           │           ├── opening_loc: (15...16) = "\""
+        │   │           │           ├── content_loc: (16...21) = "Hello"
+        │   │           │           ├── closing_loc: (21...22) = "\""
+        │   │           │           └── unescaped: "Hello"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "puts"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (8...9) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (24...48))
+        │   ├── name: :foo
+        │   ├── name_loc: (28...31) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (36...48))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (36...48))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (36...40) = "puts"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (41...48))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ StringNode (location: (41...48))
+        │   │           │           ├── opening_loc: (41...42) = "\""
+        │   │           │           ├── content_loc: (42...47) = "Hello"
+        │   │           │           ├── closing_loc: (47...48) = "\""
+        │   │           │           └── unescaped: "Hello"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "puts"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (24...27) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (31...32) = "("
+        │   ├── rparen_loc: (32...33) = ")"
+        │   ├── equal_loc: (34...35) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (50...69))
+        │   ├── name: :foo
+        │   ├── name_loc: (54...57) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (58...59))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (58...59))
+        │   │   │       └── name: :x
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (63...69))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (63...69))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (63...67) = "puts"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (68...69))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ LocalVariableReadNode (location: (68...69))
+        │   │           │           ├── name: :x
+        │   │           │           └── depth: 0
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "puts"
+        │   ├── locals: [:x]
+        │   ├── def_keyword_loc: (50...53) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (57...58) = "("
+        │   ├── rparen_loc: (59...60) = ")"
+        │   ├── equal_loc: (61...62) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (71...97))
+        │   ├── name: :foo
+        │   ├── name_loc: (79...82) = "foo"
+        │   ├── receiver:
+        │   │   @ CallNode (location: (75...78))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (75...78) = "obj"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "obj"
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (85...97))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (85...97))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (85...89) = "puts"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (90...97))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ StringNode (location: (90...97))
+        │   │           │           ├── opening_loc: (90...91) = "\""
+        │   │           │           ├── content_loc: (91...96) = "Hello"
+        │   │           │           ├── closing_loc: (96...97) = "\""
+        │   │           │           └── unescaped: "Hello"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "puts"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (71...74) = "def"
+        │   ├── operator_loc: (78...79) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (83...84) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (99...127))
+        │   ├── name: :foo
+        │   ├── name_loc: (107...110) = "foo"
+        │   ├── receiver:
+        │   │   @ CallNode (location: (103...106))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (103...106) = "obj"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "obj"
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (115...127))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (115...127))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (115...119) = "puts"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (120...127))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ StringNode (location: (120...127))
+        │   │           │           ├── opening_loc: (120...121) = "\""
+        │   │           │           ├── content_loc: (121...126) = "Hello"
+        │   │           │           ├── closing_loc: (126...127) = "\""
+        │   │           │           └── unescaped: "Hello"
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "puts"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (99...102) = "def"
+        │   ├── operator_loc: (106...107) = "."
+        │   ├── lparen_loc: (110...111) = "("
+        │   ├── rparen_loc: (111...112) = ")"
+        │   ├── equal_loc: (113...114) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (129...152))
+        │   ├── name: :foo
+        │   ├── name_loc: (137...140) = "foo"
+        │   ├── receiver:
+        │   │   @ CallNode (location: (133...136))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (133...136) = "obj"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "obj"
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (141...142))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (141...142))
+        │   │   │       └── name: :x
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (146...152))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (146...152))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (146...150) = "puts"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (151...152))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ LocalVariableReadNode (location: (151...152))
+        │   │           │           ├── name: :x
+        │   │           │           └── depth: 0
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "puts"
+        │   ├── locals: [:x]
+        │   ├── def_keyword_loc: (129...132) = "def"
+        │   ├── operator_loc: (136...137) = "."
+        │   ├── lparen_loc: (140...141) = "("
+        │   ├── rparen_loc: (142...143) = ")"
+        │   ├── equal_loc: (144...145) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (154...214))
+        │   ├── name: :rescued
+        │   ├── name_loc: (158...165) = "rescued"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (166...167))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (166...167))
+        │   │   │       └── name: :x
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (171...214))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (171...214))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (171...176) = "raise"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (177...214))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ RescueModifierNode (location: (177...214))
+        │   │           │           ├── expression:
+        │   │           │           │   @ StringNode (location: (177...191))
+        │   │           │           │   ├── opening_loc: (177...178) = "\""
+        │   │           │           │   ├── content_loc: (178...190) = "to be caught"
+        │   │           │           │   ├── closing_loc: (190...191) = "\""
+        │   │           │           │   └── unescaped: "to be caught"
+        │   │           │           ├── keyword_loc: (192...198) = "rescue"
+        │   │           │           └── rescue_expression:
+        │   │           │               @ InterpolatedStringNode (location: (199...214))
+        │   │           │               ├── opening_loc: (199...200) = "\""
+        │   │           │               ├── parts: (length: 2)
+        │   │           │               │   ├── @ StringNode (location: (200...209))
+        │   │           │               │   │   ├── opening_loc: ∅
+        │   │           │               │   │   ├── content_loc: (200...209) = "instance "
+        │   │           │               │   │   ├── closing_loc: ∅
+        │   │           │               │   │   └── unescaped: "instance "
+        │   │           │               │   └── @ EmbeddedStatementsNode (location: (209...213))
+        │   │           │               │       ├── opening_loc: (209...211) = "\#{"
+        │   │           │               │       ├── statements:
+        │   │           │               │       │   @ StatementsNode (location: (211...212))
+        │   │           │               │       │   └── body: (length: 1)
+        │   │           │               │       │       └── @ LocalVariableReadNode (location: (211...212))
+        │   │           │               │       │           ├── name: :x
+        │   │           │               │       │           └── depth: 0
+        │   │           │               │       └── closing_loc: (212...213) = "}"
+        │   │           │               └── closing_loc: (213...214) = "\""
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "raise"
+        │   ├── locals: [:x]
+        │   ├── def_keyword_loc: (154...157) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (165...166) = "("
+        │   ├── rparen_loc: (167...168) = ")"
+        │   ├── equal_loc: (169...170) = "="
+        │   └── end_keyword_loc: ∅
+        └── @ DefNode (location: (216...278))
+            ├── name: :rescued
+            ├── name_loc: (225...232) = "rescued"
+            ├── receiver:
+            │   @ SelfNode (location: (220...224))
+            ├── parameters:
+            │   @ ParametersNode (location: (233...234))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (233...234))
+            │   │       └── name: :x
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (238...278))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (238...278))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (238...243) = "raise"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (244...278))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ RescueModifierNode (location: (244...278))
+            │           │           ├── expression:
+            │           │           │   @ StringNode (location: (244...258))
+            │           │           │   ├── opening_loc: (244...245) = "\""
+            │           │           │   ├── content_loc: (245...257) = "to be caught"
+            │           │           │   ├── closing_loc: (257...258) = "\""
+            │           │           │   └── unescaped: "to be caught"
+            │           │           ├── keyword_loc: (259...265) = "rescue"
+            │           │           └── rescue_expression:
+            │           │               @ InterpolatedStringNode (location: (266...278))
+            │           │               ├── opening_loc: (266...267) = "\""
+            │           │               ├── parts: (length: 2)
+            │           │               │   ├── @ StringNode (location: (267...273))
+            │           │               │   │   ├── opening_loc: ∅
+            │           │               │   │   ├── content_loc: (267...273) = "class "
+            │           │               │   │   ├── closing_loc: ∅
+            │           │               │   │   └── unescaped: "class "
+            │           │               │   └── @ EmbeddedStatementsNode (location: (273...277))
+            │           │               │       ├── opening_loc: (273...275) = "\#{"
+            │           │               │       ├── statements:
+            │           │               │       │   @ StatementsNode (location: (275...276))
+            │           │               │       │   └── body: (length: 1)
+            │           │               │       │       └── @ LocalVariableReadNode (location: (275...276))
+            │           │               │       │           ├── name: :x
+            │           │               │       │           └── depth: 0
+            │           │               │       └── closing_loc: (276...277) = "}"
+            │           │               └── closing_loc: (277...278) = "\""
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "raise"
+            ├── locals: [:x]
+            ├── def_keyword_loc: (216...219) = "def"
+            ├── operator_loc: (224...225) = "."
+            ├── lparen_loc: (232...233) = "("
+            ├── rparen_loc: (234...235) = ")"
+            ├── equal_loc: (236...237) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/endless_method_forwarded_args_legacy.txt b/test/yarp/snapshots/whitequark/endless_method_forwarded_args_legacy.txt
index c60263dc9a..c11ad81adb 100644
--- a/test/yarp/snapshots/whitequark/endless_method_forwarded_args_legacy.txt
+++ b/test/yarp/snapshots/whitequark/endless_method_forwarded_args_legacy.txt
@@ -1,39 +1,42 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [DefNode(0...23)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...11)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(8...11)(),
-         nil
-       ),
-       StatementsNode(15...23)(
-         [CallNode(15...23)(
-            nil,
-            nil,
-            (15...18),
-            (18...19),
-            ArgumentsNode(19...22)([ForwardingArgumentsNode(19...22)()]),
-            (22...23),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:"..."],
-       (0...3),
-       nil,
-       (7...8),
-       (11...12),
-       (13...14),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...23))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...11))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ ForwardingParameterNode (location: (8...11))
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (15...23))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (15...23))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (15...18) = "bar"
+            │           ├── opening_loc: (18...19) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (19...22))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ ForwardingArgumentsNode (location: (19...22))
+            │           ├── closing_loc: (22...23) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:"..."]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (11...12) = ")"
+            ├── equal_loc: (13...14) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/endless_method_with_rescue_mod.txt b/test/yarp/snapshots/whitequark/endless_method_with_rescue_mod.txt
index 3f77cf8c23..f6d17432f3 100644
--- a/test/yarp/snapshots/whitequark/endless_method_with_rescue_mod.txt
+++ b/test/yarp/snapshots/whitequark/endless_method_with_rescue_mod.txt
@@ -1,45 +1,48 @@
-ProgramNode(0...47)(
-  [],
-  StatementsNode(0...47)(
-    [DefNode(0...20)(
-       :m,
-       (4...5),
-       nil,
-       nil,
-       StatementsNode(10...20)(
-         [RescueModifierNode(10...20)(
-            IntegerNode(10...11)(),
-            (12...18),
-            IntegerNode(19...20)()
-          )]
-       ),
-       [],
-       (0...3),
-       nil,
-       (5...6),
-       (6...7),
-       (8...9),
-       nil
-     ),
-     DefNode(22...47)(
-       :m,
-       (31...32),
-       SelfNode(26...30)(),
-       nil,
-       StatementsNode(37...47)(
-         [RescueModifierNode(37...47)(
-            IntegerNode(37...38)(),
-            (39...45),
-            IntegerNode(46...47)()
-          )]
-       ),
-       [],
-       (22...25),
-       (30...31),
-       (32...33),
-       (33...34),
-       (35...36),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...47))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...47))
+    └── body: (length: 2)
+        ├── @ DefNode (location: (0...20))
+        │   ├── name: :m
+        │   ├── name_loc: (4...5) = "m"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (10...20))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RescueModifierNode (location: (10...20))
+        │   │           ├── expression:
+        │   │           │   @ IntegerNode (location: (10...11))
+        │   │           ├── keyword_loc: (12...18) = "rescue"
+        │   │           └── rescue_expression:
+        │   │               @ IntegerNode (location: (19...20))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (5...6) = "("
+        │   ├── rparen_loc: (6...7) = ")"
+        │   ├── equal_loc: (8...9) = "="
+        │   └── end_keyword_loc: ∅
+        └── @ DefNode (location: (22...47))
+            ├── name: :m
+            ├── name_loc: (31...32) = "m"
+            ├── receiver:
+            │   @ SelfNode (location: (26...30))
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (37...47))
+            │   └── body: (length: 1)
+            │       └── @ RescueModifierNode (location: (37...47))
+            │           ├── expression:
+            │           │   @ IntegerNode (location: (37...38))
+            │           ├── keyword_loc: (39...45) = "rescue"
+            │           └── rescue_expression:
+            │               @ IntegerNode (location: (46...47))
+            ├── locals: []
+            ├── def_keyword_loc: (22...25) = "def"
+            ├── operator_loc: (30...31) = "."
+            ├── lparen_loc: (32...33) = "("
+            ├── rparen_loc: (33...34) = ")"
+            ├── equal_loc: (35...36) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/endless_method_without_args.txt b/test/yarp/snapshots/whitequark/endless_method_without_args.txt
index 7287c14cd8..a96b964d35 100644
--- a/test/yarp/snapshots/whitequark/endless_method_without_args.txt
+++ b/test/yarp/snapshots/whitequark/endless_method_without_args.txt
@@ -1,73 +1,81 @@
-ProgramNode(0...86)(
-  [],
-  StatementsNode(0...86)(
-    [DefNode(0...12)(
-       :foo,
-       (4...7),
-       nil,
-       nil,
-       StatementsNode(10...12)([IntegerNode(10...12)()]),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       (8...9),
-       nil
-     ),
-     DefNode(14...37)(
-       :foo,
-       (18...21),
-       nil,
-       nil,
-       StatementsNode(24...37)(
-         [RescueModifierNode(24...37)(
-            IntegerNode(24...26)(),
-            (27...33),
-            NilNode(34...37)()
-          )]
-       ),
-       [],
-       (14...17),
-       nil,
-       nil,
-       nil,
-       (22...23),
-       nil
-     ),
-     DefNode(39...56)(
-       :foo,
-       (48...51),
-       SelfNode(43...47)(),
-       nil,
-       StatementsNode(54...56)([IntegerNode(54...56)()]),
-       [],
-       (39...42),
-       (47...48),
-       nil,
-       nil,
-       (52...53),
-       nil
-     ),
-     DefNode(58...86)(
-       :foo,
-       (67...70),
-       SelfNode(62...66)(),
-       nil,
-       StatementsNode(73...86)(
-         [RescueModifierNode(73...86)(
-            IntegerNode(73...75)(),
-            (76...82),
-            NilNode(83...86)()
-          )]
-       ),
-       [],
-       (58...61),
-       (66...67),
-       nil,
-       nil,
-       (71...72),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...86))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...86))
+    └── body: (length: 4)
+        ├── @ DefNode (location: (0...12))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (10...12))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (10...12))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (8...9) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (14...37))
+        │   ├── name: :foo
+        │   ├── name_loc: (18...21) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (24...37))
+        │   │   └── body: (length: 1)
+        │   │       └── @ RescueModifierNode (location: (24...37))
+        │   │           ├── expression:
+        │   │           │   @ IntegerNode (location: (24...26))
+        │   │           ├── keyword_loc: (27...33) = "rescue"
+        │   │           └── rescue_expression:
+        │   │               @ NilNode (location: (34...37))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (14...17) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (22...23) = "="
+        │   └── end_keyword_loc: ∅
+        ├── @ DefNode (location: (39...56))
+        │   ├── name: :foo
+        │   ├── name_loc: (48...51) = "foo"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (43...47))
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (54...56))
+        │   │   └── body: (length: 1)
+        │   │       └── @ IntegerNode (location: (54...56))
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (39...42) = "def"
+        │   ├── operator_loc: (47...48) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: (52...53) = "="
+        │   └── end_keyword_loc: ∅
+        └── @ DefNode (location: (58...86))
+            ├── name: :foo
+            ├── name_loc: (67...70) = "foo"
+            ├── receiver:
+            │   @ SelfNode (location: (62...66))
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (73...86))
+            │   └── body: (length: 1)
+            │       └── @ RescueModifierNode (location: (73...86))
+            │           ├── expression:
+            │           │   @ IntegerNode (location: (73...75))
+            │           ├── keyword_loc: (76...82) = "rescue"
+            │           └── rescue_expression:
+            │               @ NilNode (location: (83...86))
+            ├── locals: []
+            ├── def_keyword_loc: (58...61) = "def"
+            ├── operator_loc: (66...67) = "."
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: (71...72) = "="
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/ensure.txt b/test/yarp/snapshots/whitequark/ensure.txt
index abc443a2bb..6912a3205c 100644
--- a/test/yarp/snapshots/whitequark/ensure.txt
+++ b/test/yarp/snapshots/whitequark/ensure.txt
@@ -1,31 +1,40 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [BeginNode(0...29)(
-       (0...5),
-       StatementsNode(7...11)(
-         [CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth")]
-       ),
-       nil,
-       nil,
-       EnsureNode(13...29)(
-         (13...19),
-         StatementsNode(21...24)(
-           [CallNode(21...24)(
-              nil,
-              nil,
-              (21...24),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         (26...29)
-       ),
-       (26...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...29))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (7...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (7...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (7...11) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            ├── rescue_clause: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause:
+            │   @ EnsureNode (location: (13...29))
+            │   ├── ensure_keyword_loc: (13...19) = "ensure"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (21...24))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (21...24))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (21...24) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   └── end_keyword_loc: (26...29) = "end"
+            └── end_keyword_loc: (26...29) = "end"
diff --git a/test/yarp/snapshots/whitequark/ensure_empty.txt b/test/yarp/snapshots/whitequark/ensure_empty.txt
index 39ac8bfea1..8a01f305dd 100644
--- a/test/yarp/snapshots/whitequark/ensure_empty.txt
+++ b/test/yarp/snapshots/whitequark/ensure_empty.txt
@@ -1,13 +1,16 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [BeginNode(0...16)(
-       (0...5),
-       nil,
-       nil,
-       nil,
-       EnsureNode(6...16)((6...12), nil, (13...16)),
-       (13...16)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...16))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements: ∅
+            ├── rescue_clause: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause:
+            │   @ EnsureNode (location: (6...16))
+            │   ├── ensure_keyword_loc: (6...12) = "ensure"
+            │   ├── statements: ∅
+            │   └── end_keyword_loc: (13...16) = "end"
+            └── end_keyword_loc: (13...16) = "end"
diff --git a/test/yarp/snapshots/whitequark/false.txt b/test/yarp/snapshots/whitequark/false.txt
index b435f45a62..71f241227e 100644
--- a/test/yarp/snapshots/whitequark/false.txt
+++ b/test/yarp/snapshots/whitequark/false.txt
@@ -1 +1,6 @@
-ProgramNode(0...5)([], StatementsNode(0...5)([FalseNode(0...5)()]))
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ FalseNode (location: (0...5))
diff --git a/test/yarp/snapshots/whitequark/float.txt b/test/yarp/snapshots/whitequark/float.txt
index dfeeb28697..60a1ea155d 100644
--- a/test/yarp/snapshots/whitequark/float.txt
+++ b/test/yarp/snapshots/whitequark/float.txt
@@ -1,4 +1,7 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)([FloatNode(0...5)(), FloatNode(7...11)()])
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 2)
+        ├── @ FloatNode (location: (0...5))
+        └── @ FloatNode (location: (7...11))
diff --git a/test/yarp/snapshots/whitequark/for.txt b/test/yarp/snapshots/whitequark/for.txt
index 67c75dcc92..4d126e3b20 100644
--- a/test/yarp/snapshots/whitequark/for.txt
+++ b/test/yarp/snapshots/whitequark/for.txt
@@ -1,55 +1,89 @@
-ProgramNode(0...48)(
-  [:a],
-  StatementsNode(0...48)(
-    [ForNode(0...24)(
-       MultiTargetNode(4...5)(
-         [LocalVariableTargetNode(4...5)(:a, 0)],
-         nil,
-         nil
-       ),
-       CallNode(9...12)(nil, nil, (9...12), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(16...19)(
-         [CallNode(16...19)(
-            nil,
-            nil,
-            (16...17),
-            nil,
-            ArgumentsNode(18...19)([LocalVariableReadNode(18...19)(:a, 0)]),
-            nil,
-            nil,
-            0,
-            "p"
-          )]
-       ),
-       (0...3),
-       (6...8),
-       (13...15),
-       (21...24)
-     ),
-     ForNode(26...48)(
-       MultiTargetNode(30...31)(
-         [LocalVariableTargetNode(30...31)(:a, 0)],
-         nil,
-         nil
-       ),
-       CallNode(35...38)(nil, nil, (35...38), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(40...43)(
-         [CallNode(40...43)(
-            nil,
-            nil,
-            (40...41),
-            nil,
-            ArgumentsNode(42...43)([LocalVariableReadNode(42...43)(:a, 0)]),
-            nil,
-            nil,
-            0,
-            "p"
-          )]
-       ),
-       (26...29),
-       (32...34),
-       nil,
-       (45...48)
-     )]
-  )
-)
+@ ProgramNode (location: (0...48))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...48))
+    └── body: (length: 2)
+        ├── @ ForNode (location: (0...24))
+        │   ├── index:
+        │   │   @ MultiTargetNode (location: (4...5))
+        │   │   ├── targets: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (4...5))
+        │   │   │       ├── name: :a
+        │   │   │       └── depth: 0
+        │   │   ├── lparen_loc: ∅
+        │   │   └── rparen_loc: ∅
+        │   ├── collection:
+        │   │   @ CallNode (location: (9...12))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (9...12) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (16...19))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (16...19))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (16...17) = "p"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (18...19))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ LocalVariableReadNode (location: (18...19))
+        │   │           │           ├── name: :a
+        │   │           │           └── depth: 0
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "p"
+        │   ├── for_keyword_loc: (0...3) = "for"
+        │   ├── in_keyword_loc: (6...8) = "in"
+        │   ├── do_keyword_loc: (13...15) = "do"
+        │   └── end_keyword_loc: (21...24) = "end"
+        └── @ ForNode (location: (26...48))
+            ├── index:
+            │   @ MultiTargetNode (location: (30...31))
+            │   ├── targets: (length: 1)
+            │   │   └── @ LocalVariableTargetNode (location: (30...31))
+            │   │       ├── name: :a
+            │   │       └── depth: 0
+            │   ├── lparen_loc: ∅
+            │   └── rparen_loc: ∅
+            ├── collection:
+            │   @ CallNode (location: (35...38))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (35...38) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (40...43))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (40...43))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (40...41) = "p"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (42...43))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ LocalVariableReadNode (location: (42...43))
+            │           │           ├── name: :a
+            │           │           └── depth: 0
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "p"
+            ├── for_keyword_loc: (26...29) = "for"
+            ├── in_keyword_loc: (32...34) = "in"
+            ├── do_keyword_loc: ∅
+            └── end_keyword_loc: (45...48) = "end"
diff --git a/test/yarp/snapshots/whitequark/for_mlhs.txt b/test/yarp/snapshots/whitequark/for_mlhs.txt
index 74b8f52e2c..49b758bd45 100644
--- a/test/yarp/snapshots/whitequark/for_mlhs.txt
+++ b/test/yarp/snapshots/whitequark/for_mlhs.txt
@@ -1,34 +1,53 @@
-ProgramNode(0...28)(
-  [:a, :b],
-  StatementsNode(0...28)(
-    [ForNode(0...28)(
-       MultiTargetNode(4...8)(
-         [LocalVariableTargetNode(4...5)(:a, 0),
-          LocalVariableTargetNode(7...8)(:b, 0)],
-         nil,
-         nil
-       ),
-       CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(17...23)(
-         [CallNode(17...23)(
-            nil,
-            nil,
-            (17...18),
-            nil,
-            ArgumentsNode(19...23)(
-              [LocalVariableReadNode(19...20)(:a, 0),
-               LocalVariableReadNode(22...23)(:b, 0)]
-            ),
-            nil,
-            nil,
-            0,
-            "p"
-          )]
-       ),
-       (0...3),
-       (9...11),
-       nil,
-       (25...28)
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ ForNode (location: (0...28))
+            ├── index:
+            │   @ MultiTargetNode (location: (4...8))
+            │   ├── targets: (length: 2)
+            │   │   ├── @ LocalVariableTargetNode (location: (4...5))
+            │   │   │   ├── name: :a
+            │   │   │   └── depth: 0
+            │   │   └── @ LocalVariableTargetNode (location: (7...8))
+            │   │       ├── name: :b
+            │   │       └── depth: 0
+            │   ├── lparen_loc: ∅
+            │   └── rparen_loc: ∅
+            ├── collection:
+            │   @ CallNode (location: (12...15))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (12...15) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (17...23))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (17...23))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (17...18) = "p"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (19...23))
+            │           │   └── arguments: (length: 2)
+            │           │       ├── @ LocalVariableReadNode (location: (19...20))
+            │           │       │   ├── name: :a
+            │           │       │   └── depth: 0
+            │           │       └── @ LocalVariableReadNode (location: (22...23))
+            │           │           ├── name: :b
+            │           │           └── depth: 0
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "p"
+            ├── for_keyword_loc: (0...3) = "for"
+            ├── in_keyword_loc: (9...11) = "in"
+            ├── do_keyword_loc: ∅
+            └── end_keyword_loc: (25...28) = "end"
diff --git a/test/yarp/snapshots/whitequark/forward_arg.txt b/test/yarp/snapshots/whitequark/forward_arg.txt
index 896555a27e..3af092a289 100644
--- a/test/yarp/snapshots/whitequark/forward_arg.txt
+++ b/test/yarp/snapshots/whitequark/forward_arg.txt
@@ -1,39 +1,42 @@
-ProgramNode(0...27)(
-  [],
-  StatementsNode(0...27)(
-    [DefNode(0...27)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...11)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(8...11)(),
-         nil
-       ),
-       StatementsNode(14...22)(
-         [CallNode(14...22)(
-            nil,
-            nil,
-            (14...17),
-            (17...18),
-            ArgumentsNode(18...21)([ForwardingArgumentsNode(18...21)()]),
-            (21...22),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:"..."],
-       (0...3),
-       nil,
-       (7...8),
-       (11...12),
-       nil,
-       (24...27)
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...27))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...11))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ ForwardingParameterNode (location: (8...11))
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (14...22))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (14...22))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (14...17) = "bar"
+            │           ├── opening_loc: (17...18) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (18...21))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ ForwardingArgumentsNode (location: (18...21))
+            │           ├── closing_loc: (21...22) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:"..."]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (11...12) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (24...27) = "end"
diff --git a/test/yarp/snapshots/whitequark/forward_arg_with_open_args.txt b/test/yarp/snapshots/whitequark/forward_arg_with_open_args.txt
index e4ebb2d950..a108ab1ecb 100644
--- a/test/yarp/snapshots/whitequark/forward_arg_with_open_args.txt
+++ b/test/yarp/snapshots/whitequark/forward_arg_with_open_args.txt
@@ -1,348 +1,383 @@
-ProgramNode(0...292)(
-  [],
-  StatementsNode(0...292)(
-    [ParenthesesNode(0...28)(
-       StatementsNode(1...27)(
-         [DefNode(1...27)(
-            :foo,
-            (5...8),
-            nil,
-            ParametersNode(9...12)(
-              [],
-              [],
-              [],
-              nil,
-              [],
-              ForwardingParameterNode(9...12)(),
-              nil
-            ),
-            StatementsNode(15...23)(
-              [CallNode(15...23)(
-                 nil,
-                 nil,
-                 (15...18),
-                 (18...19),
-                 ArgumentsNode(19...22)([ForwardingArgumentsNode(19...22)()]),
-                 (22...23),
-                 nil,
-                 0,
-                 "bar"
-               )]
-            ),
-            [:"..."],
-            (1...4),
-            nil,
-            nil,
-            nil,
-            nil,
-            (24...27)
-          )]
-       ),
-       (0...1),
-       (27...28)
-     ),
-     ParenthesesNode(30...58)(
-       StatementsNode(31...57)(
-         [DefNode(31...57)(
-            :foo,
-            (35...38),
-            nil,
-            ParametersNode(39...42)(
-              [],
-              [],
-              [],
-              nil,
-              [],
-              ForwardingParameterNode(39...42)(),
-              nil
-            ),
-            StatementsNode(44...52)(
-              [CallNode(44...52)(
-                 nil,
-                 nil,
-                 (44...47),
-                 (47...48),
-                 ArgumentsNode(48...51)([ForwardingArgumentsNode(48...51)()]),
-                 (51...52),
-                 nil,
-                 0,
-                 "bar"
-               )]
-            ),
-            [:"..."],
-            (31...34),
-            nil,
-            nil,
-            nil,
-            nil,
-            (54...57)
-          )]
-       ),
-       (30...31),
-       (57...58)
-     ),
-     DefNode(60...75)(
-       :foo,
-       (64...67),
-       nil,
-       ParametersNode(68...71)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(68...71)(),
-         nil
-       ),
-       nil,
-       [:"..."],
-       (60...63),
-       nil,
-       nil,
-       nil,
-       nil,
-       (72...75)
-     ),
-     DefNode(77...103)(
-       :foo,
-       (81...84),
-       nil,
-       ParametersNode(85...88)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(85...88)(),
-         nil
-       ),
-       StatementsNode(90...98)(
-         [CallNode(90...98)(
-            nil,
-            nil,
-            (90...93),
-            (93...94),
-            ArgumentsNode(94...97)([ForwardingArgumentsNode(94...97)()]),
-            (97...98),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:"..."],
-       (77...80),
-       nil,
-       nil,
-       nil,
-       nil,
-       (100...103)
-     ),
-     DefNode(105...134)(
-       :foo,
-       (109...112),
-       nil,
-       ParametersNode(113...119)(
-         [RequiredParameterNode(113...114)(:a)],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(116...119)(),
-         nil
-       ),
-       StatementsNode(122...130)(
-         [CallNode(122...130)(
-            nil,
-            nil,
-            (122...125),
-            (125...126),
-            ArgumentsNode(126...129)([ForwardingArgumentsNode(126...129)()]),
-            (129...130),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:a, :"..."],
-       (105...108),
-       nil,
-       nil,
-       nil,
-       nil,
-       (131...134)
-     ),
-     DefNode(136...165)(
-       :foo,
-       (140...143),
-       nil,
-       ParametersNode(144...150)(
-         [RequiredParameterNode(144...145)(:a)],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(147...150)(),
-         nil
-       ),
-       StatementsNode(152...160)(
-         [CallNode(152...160)(
-            nil,
-            nil,
-            (152...155),
-            (155...156),
-            ArgumentsNode(156...159)([ForwardingArgumentsNode(156...159)()]),
-            (159...160),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:a, :"..."],
-       (136...139),
-       nil,
-       nil,
-       nil,
-       nil,
-       (162...165)
-     ),
-     DefNode(167...192)(
-       :foo,
-       (171...174),
-       nil,
-       ParametersNode(175...188)(
-         [RequiredParameterNode(175...176)(:a)],
-         [OptionalParameterNode(178...183)(
-            :b,
-            (178...179),
-            (180...181),
-            IntegerNode(182...183)()
-          )],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(185...188)(),
-         nil
-       ),
-       nil,
-       [:a, :b, :"..."],
-       (167...170),
-       nil,
-       nil,
-       nil,
-       nil,
-       (189...192)
-     ),
-     DefNode(194...227)(
-       :foo,
-       (198...201),
-       nil,
-       ParametersNode(202...212)(
-         [],
-         [OptionalParameterNode(202...207)(
-            :b,
-            (202...203),
-            (204...205),
-            IntegerNode(206...207)()
-          )],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(209...212)(),
-         nil
-       ),
-       StatementsNode(215...223)(
-         [CallNode(215...223)(
-            nil,
-            nil,
-            (215...218),
-            (218...219),
-            ArgumentsNode(219...222)([ForwardingArgumentsNode(219...222)()]),
-            (222...223),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:b, :"..."],
-       (194...197),
-       nil,
-       nil,
-       nil,
-       nil,
-       (224...227)
-     ),
-     DefNode(229...262)(
-       :foo,
-       (233...236),
-       nil,
-       ParametersNode(237...247)(
-         [],
-         [OptionalParameterNode(237...242)(
-            :b,
-            (237...238),
-            (239...240),
-            IntegerNode(241...242)()
-          )],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(244...247)(),
-         nil
-       ),
-       StatementsNode(249...257)(
-         [CallNode(249...257)(
-            nil,
-            nil,
-            (249...252),
-            (252...253),
-            ArgumentsNode(253...256)([ForwardingArgumentsNode(253...256)()]),
-            (256...257),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:b, :"..."],
-       (229...232),
-       nil,
-       nil,
-       nil,
-       nil,
-       (259...262)
-     ),
-     DefNode(264...292)(
-       :foo,
-       (268...271),
-       nil,
-       ParametersNode(272...278)(
-         [RequiredParameterNode(272...273)(:a)],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(275...278)(),
-         nil
-       ),
-       StatementsNode(280...288)(
-         [CallNode(280...288)(
-            nil,
-            nil,
-            (280...283),
-            (283...284),
-            ArgumentsNode(284...287)([ForwardingArgumentsNode(284...287)()]),
-            (287...288),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:a, :"..."],
-       (264...267),
-       nil,
-       (271...272),
-       (278...279),
-       nil,
-       (289...292)
-     )]
-  )
-)
+@ ProgramNode (location: (0...292))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...292))
+    └── body: (length: 10)
+        ├── @ ParenthesesNode (location: (0...28))
+        │   ├── body:
+        │   │   @ StatementsNode (location: (1...27))
+        │   │   └── body: (length: 1)
+        │   │       └── @ DefNode (location: (1...27))
+        │   │           ├── name: :foo
+        │   │           ├── name_loc: (5...8) = "foo"
+        │   │           ├── receiver: ∅
+        │   │           ├── parameters:
+        │   │           │   @ ParametersNode (location: (9...12))
+        │   │           │   ├── requireds: (length: 0)
+        │   │           │   ├── optionals: (length: 0)
+        │   │           │   ├── posts: (length: 0)
+        │   │           │   ├── rest: ∅
+        │   │           │   ├── keywords: (length: 0)
+        │   │           │   ├── keyword_rest:
+        │   │           │   │   @ ForwardingParameterNode (location: (9...12))
+        │   │           │   └── block: ∅
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (15...23))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (15...23))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (15...18) = "bar"
+        │   │           │           ├── opening_loc: (18...19) = "("
+        │   │           │           ├── arguments:
+        │   │           │           │   @ ArgumentsNode (location: (19...22))
+        │   │           │           │   └── arguments: (length: 1)
+        │   │           │           │       └── @ ForwardingArgumentsNode (location: (19...22))
+        │   │           │           ├── closing_loc: (22...23) = ")"
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "bar"
+        │   │           ├── locals: [:"..."]
+        │   │           ├── def_keyword_loc: (1...4) = "def"
+        │   │           ├── operator_loc: ∅
+        │   │           ├── lparen_loc: ∅
+        │   │           ├── rparen_loc: ∅
+        │   │           ├── equal_loc: ∅
+        │   │           └── end_keyword_loc: (24...27) = "end"
+        │   ├── opening_loc: (0...1) = "("
+        │   └── closing_loc: (27...28) = ")"
+        ├── @ ParenthesesNode (location: (30...58))
+        │   ├── body:
+        │   │   @ StatementsNode (location: (31...57))
+        │   │   └── body: (length: 1)
+        │   │       └── @ DefNode (location: (31...57))
+        │   │           ├── name: :foo
+        │   │           ├── name_loc: (35...38) = "foo"
+        │   │           ├── receiver: ∅
+        │   │           ├── parameters:
+        │   │           │   @ ParametersNode (location: (39...42))
+        │   │           │   ├── requireds: (length: 0)
+        │   │           │   ├── optionals: (length: 0)
+        │   │           │   ├── posts: (length: 0)
+        │   │           │   ├── rest: ∅
+        │   │           │   ├── keywords: (length: 0)
+        │   │           │   ├── keyword_rest:
+        │   │           │   │   @ ForwardingParameterNode (location: (39...42))
+        │   │           │   └── block: ∅
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (44...52))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ CallNode (location: (44...52))
+        │   │           │           ├── receiver: ∅
+        │   │           │           ├── call_operator_loc: ∅
+        │   │           │           ├── message_loc: (44...47) = "bar"
+        │   │           │           ├── opening_loc: (47...48) = "("
+        │   │           │           ├── arguments:
+        │   │           │           │   @ ArgumentsNode (location: (48...51))
+        │   │           │           │   └── arguments: (length: 1)
+        │   │           │           │       └── @ ForwardingArgumentsNode (location: (48...51))
+        │   │           │           ├── closing_loc: (51...52) = ")"
+        │   │           │           ├── block: ∅
+        │   │           │           ├── flags: 
+        │   │           │           └── name: "bar"
+        │   │           ├── locals: [:"..."]
+        │   │           ├── def_keyword_loc: (31...34) = "def"
+        │   │           ├── operator_loc: ∅
+        │   │           ├── lparen_loc: ∅
+        │   │           ├── rparen_loc: ∅
+        │   │           ├── equal_loc: ∅
+        │   │           └── end_keyword_loc: (54...57) = "end"
+        │   ├── opening_loc: (30...31) = "("
+        │   └── closing_loc: (57...58) = ")"
+        ├── @ DefNode (location: (60...75))
+        │   ├── name: :foo
+        │   ├── name_loc: (64...67) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (68...71))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (68...71))
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:"..."]
+        │   ├── def_keyword_loc: (60...63) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (72...75) = "end"
+        ├── @ DefNode (location: (77...103))
+        │   ├── name: :foo
+        │   ├── name_loc: (81...84) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (85...88))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (85...88))
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (90...98))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (90...98))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (90...93) = "bar"
+        │   │           ├── opening_loc: (93...94) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (94...97))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ ForwardingArgumentsNode (location: (94...97))
+        │   │           ├── closing_loc: (97...98) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── locals: [:"..."]
+        │   ├── def_keyword_loc: (77...80) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (100...103) = "end"
+        ├── @ DefNode (location: (105...134))
+        │   ├── name: :foo
+        │   ├── name_loc: (109...112) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (113...119))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (113...114))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (116...119))
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (122...130))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (122...130))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (122...125) = "bar"
+        │   │           ├── opening_loc: (125...126) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (126...129))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ ForwardingArgumentsNode (location: (126...129))
+        │   │           ├── closing_loc: (129...130) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── locals: [:a, :"..."]
+        │   ├── def_keyword_loc: (105...108) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (131...134) = "end"
+        ├── @ DefNode (location: (136...165))
+        │   ├── name: :foo
+        │   ├── name_loc: (140...143) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (144...150))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (144...145))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (147...150))
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (152...160))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (152...160))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (152...155) = "bar"
+        │   │           ├── opening_loc: (155...156) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (156...159))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ ForwardingArgumentsNode (location: (156...159))
+        │   │           ├── closing_loc: (159...160) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── locals: [:a, :"..."]
+        │   ├── def_keyword_loc: (136...139) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (162...165) = "end"
+        ├── @ DefNode (location: (167...192))
+        │   ├── name: :foo
+        │   ├── name_loc: (171...174) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (175...188))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (175...176))
+        │   │   │       └── name: :a
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (178...183))
+        │   │   │       ├── name: :b
+        │   │   │       ├── name_loc: (178...179) = "b"
+        │   │   │       ├── operator_loc: (180...181) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (182...183))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (185...188))
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :b, :"..."]
+        │   ├── def_keyword_loc: (167...170) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (189...192) = "end"
+        ├── @ DefNode (location: (194...227))
+        │   ├── name: :foo
+        │   ├── name_loc: (198...201) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (202...212))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (202...207))
+        │   │   │       ├── name: :b
+        │   │   │       ├── name_loc: (202...203) = "b"
+        │   │   │       ├── operator_loc: (204...205) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (206...207))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (209...212))
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (215...223))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (215...223))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (215...218) = "bar"
+        │   │           ├── opening_loc: (218...219) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (219...222))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ ForwardingArgumentsNode (location: (219...222))
+        │   │           ├── closing_loc: (222...223) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── locals: [:b, :"..."]
+        │   ├── def_keyword_loc: (194...197) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (224...227) = "end"
+        ├── @ DefNode (location: (229...262))
+        │   ├── name: :foo
+        │   ├── name_loc: (233...236) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (237...247))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (237...242))
+        │   │   │       ├── name: :b
+        │   │   │       ├── name_loc: (237...238) = "b"
+        │   │   │       ├── operator_loc: (239...240) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (241...242))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (244...247))
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (249...257))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (249...257))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (249...252) = "bar"
+        │   │           ├── opening_loc: (252...253) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (253...256))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ ForwardingArgumentsNode (location: (253...256))
+        │   │           ├── closing_loc: (256...257) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── locals: [:b, :"..."]
+        │   ├── def_keyword_loc: (229...232) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (259...262) = "end"
+        └── @ DefNode (location: (264...292))
+            ├── name: :foo
+            ├── name_loc: (268...271) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (272...278))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (272...273))
+            │   │       └── name: :a
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ ForwardingParameterNode (location: (275...278))
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (280...288))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (280...288))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (280...283) = "bar"
+            │           ├── opening_loc: (283...284) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (284...287))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ ForwardingArgumentsNode (location: (284...287))
+            │           ├── closing_loc: (287...288) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:a, :"..."]
+            ├── def_keyword_loc: (264...267) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (271...272) = "("
+            ├── rparen_loc: (278...279) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (289...292) = "end"
diff --git a/test/yarp/snapshots/whitequark/forward_args_legacy.txt b/test/yarp/snapshots/whitequark/forward_args_legacy.txt
index 39b5cdbbaf..370e741c35 100644
--- a/test/yarp/snapshots/whitequark/forward_args_legacy.txt
+++ b/test/yarp/snapshots/whitequark/forward_args_legacy.txt
@@ -1,91 +1,97 @@
-ProgramNode(0...77)(
-  [],
-  StatementsNode(0...77)(
-    [DefNode(0...27)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...11)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(8...11)(),
-         nil
-       ),
-       StatementsNode(14...22)(
-         [CallNode(14...22)(
-            nil,
-            nil,
-            (14...17),
-            (17...18),
-            ArgumentsNode(18...21)([ForwardingArgumentsNode(18...21)()]),
-            (21...22),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:"..."],
-       (0...3),
-       nil,
-       (7...8),
-       (11...12),
-       nil,
-       (24...27)
-     ),
-     DefNode(29...46)(
-       :foo,
-       (33...36),
-       nil,
-       ParametersNode(37...40)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(37...40)(),
-         nil
-       ),
-       nil,
-       [:"..."],
-       (29...32),
-       nil,
-       (36...37),
-       (40...41),
-       nil,
-       (43...46)
-     ),
-     DefNode(48...77)(
-       :foo,
-       (52...55),
-       nil,
-       ParametersNode(56...59)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(56...59)(),
-         nil
-       ),
-       StatementsNode(62...72)(
-         [SuperNode(62...72)(
-            (62...67),
-            (67...68),
-            ArgumentsNode(68...71)([ForwardingArgumentsNode(68...71)()]),
-            (71...72),
-            nil
-          )]
-       ),
-       [:"..."],
-       (48...51),
-       nil,
-       (55...56),
-       (59...60),
-       nil,
-       (74...77)
-     )]
-  )
-)
+@ ProgramNode (location: (0...77))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...77))
+    └── body: (length: 3)
+        ├── @ DefNode (location: (0...27))
+        │   ├── name: :foo
+        │   ├── name_loc: (4...7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (8...11))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (8...11))
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (14...22))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (14...22))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (14...17) = "bar"
+        │   │           ├── opening_loc: (17...18) = "("
+        │   │           ├── arguments:
+        │   │           │   @ ArgumentsNode (location: (18...21))
+        │   │           │   └── arguments: (length: 1)
+        │   │           │       └── @ ForwardingArgumentsNode (location: (18...21))
+        │   │           ├── closing_loc: (21...22) = ")"
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "bar"
+        │   ├── locals: [:"..."]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (7...8) = "("
+        │   ├── rparen_loc: (11...12) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (24...27) = "end"
+        ├── @ DefNode (location: (29...46))
+        │   ├── name: :foo
+        │   ├── name_loc: (33...36) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (37...40))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ ForwardingParameterNode (location: (37...40))
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:"..."]
+        │   ├── def_keyword_loc: (29...32) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (36...37) = "("
+        │   ├── rparen_loc: (40...41) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (43...46) = "end"
+        └── @ DefNode (location: (48...77))
+            ├── name: :foo
+            ├── name_loc: (52...55) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (56...59))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ ForwardingParameterNode (location: (56...59))
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (62...72))
+            │   └── body: (length: 1)
+            │       └── @ SuperNode (location: (62...72))
+            │           ├── keyword_loc: (62...67) = "super"
+            │           ├── lparen_loc: (67...68) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (68...71))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ ForwardingArgumentsNode (location: (68...71))
+            │           ├── rparen_loc: (71...72) = ")"
+            │           └── block: ∅
+            ├── locals: [:"..."]
+            ├── def_keyword_loc: (48...51) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (55...56) = "("
+            ├── rparen_loc: (59...60) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (74...77) = "end"
diff --git a/test/yarp/snapshots/whitequark/forwarded_argument_with_kwrestarg.txt b/test/yarp/snapshots/whitequark/forwarded_argument_with_kwrestarg.txt
index 9008112a49..6fd9903e42 100644
--- a/test/yarp/snapshots/whitequark/forwarded_argument_with_kwrestarg.txt
+++ b/test/yarp/snapshots/whitequark/forwarded_argument_with_kwrestarg.txt
@@ -1,44 +1,54 @@
-ProgramNode(0...45)(
-  [],
-  StatementsNode(0...45)(
-    [DefNode(0...45)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...20)(
-         [RequiredParameterNode(8...16)(:argument)],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(18...20)(nil, nil, (18...20)),
-         nil
-       ),
-       StatementsNode(23...40)(
-         [CallNode(23...40)(
-            nil,
-            nil,
-            (23...26),
-            (26...27),
-            ArgumentsNode(27...39)(
-              [LocalVariableReadNode(27...35)(:argument, 0),
-               KeywordHashNode(37...39)(
-                 [AssocSplatNode(37...39)(nil, (37...39))]
-               )]
-            ),
-            (39...40),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:argument, :**],
-       (0...3),
-       nil,
-       (7...8),
-       (20...21),
-       nil,
-       (42...45)
-     )]
-  )
-)
+@ ProgramNode (location: (0...45))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...45))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...45))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...20))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (8...16))
+            │   │       └── name: :argument
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (18...20))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (18...20) = "**"
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (23...40))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (23...40))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (23...26) = "bar"
+            │           ├── opening_loc: (26...27) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (27...39))
+            │           │   └── arguments: (length: 2)
+            │           │       ├── @ LocalVariableReadNode (location: (27...35))
+            │           │       │   ├── name: :argument
+            │           │       │   └── depth: 0
+            │           │       └── @ KeywordHashNode (location: (37...39))
+            │           │           └── elements: (length: 1)
+            │           │               └── @ AssocSplatNode (location: (37...39))
+            │           │                   ├── value: ∅
+            │           │                   └── operator_loc: (37...39) = "**"
+            │           ├── closing_loc: (39...40) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:argument, :**]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (20...21) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (42...45) = "end"
diff --git a/test/yarp/snapshots/whitequark/forwarded_argument_with_restarg.txt b/test/yarp/snapshots/whitequark/forwarded_argument_with_restarg.txt
index 842def39c5..3e25002f45 100644
--- a/test/yarp/snapshots/whitequark/forwarded_argument_with_restarg.txt
+++ b/test/yarp/snapshots/whitequark/forwarded_argument_with_restarg.txt
@@ -1,42 +1,52 @@
-ProgramNode(0...43)(
-  [],
-  StatementsNode(0...43)(
-    [DefNode(0...43)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...19)(
-         [RequiredParameterNode(8...16)(:argument)],
-         [],
-         [],
-         RestParameterNode(18...19)(nil, nil, (18...19)),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(22...38)(
-         [CallNode(22...38)(
-            nil,
-            nil,
-            (22...25),
-            (25...26),
-            ArgumentsNode(26...37)(
-              [LocalVariableReadNode(26...34)(:argument, 0),
-               SplatNode(36...37)((36...37), nil)]
-            ),
-            (37...38),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:argument, :*],
-       (0...3),
-       nil,
-       (7...8),
-       (19...20),
-       nil,
-       (40...43)
-     )]
-  )
-)
+@ ProgramNode (location: (0...43))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...43))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...43))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...19))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (8...16))
+            │   │       └── name: :argument
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest:
+            │   │   @ RestParameterNode (location: (18...19))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (18...19) = "*"
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (22...38))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (22...38))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (22...25) = "bar"
+            │           ├── opening_loc: (25...26) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (26...37))
+            │           │   └── arguments: (length: 2)
+            │           │       ├── @ LocalVariableReadNode (location: (26...34))
+            │           │       │   ├── name: :argument
+            │           │       │   └── depth: 0
+            │           │       └── @ SplatNode (location: (36...37))
+            │           │           ├── operator_loc: (36...37) = "*"
+            │           │           └── expression: ∅
+            │           ├── closing_loc: (37...38) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:argument, :*]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (19...20) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (40...43) = "end"
diff --git a/test/yarp/snapshots/whitequark/forwarded_kwrestarg.txt b/test/yarp/snapshots/whitequark/forwarded_kwrestarg.txt
index 264c73a6c3..320f61bc88 100644
--- a/test/yarp/snapshots/whitequark/forwarded_kwrestarg.txt
+++ b/test/yarp/snapshots/whitequark/forwarded_kwrestarg.txt
@@ -1,43 +1,49 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [DefNode(0...25)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...10)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(8...10)(nil, nil, (8...10)),
-         nil
-       ),
-       StatementsNode(13...20)(
-         [CallNode(13...20)(
-            nil,
-            nil,
-            (13...16),
-            (16...17),
-            ArgumentsNode(17...19)(
-              [KeywordHashNode(17...19)(
-                 [AssocSplatNode(17...19)(nil, (17...19))]
-               )]
-            ),
-            (19...20),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:**],
-       (0...3),
-       nil,
-       (7...8),
-       (10...11),
-       nil,
-       (22...25)
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...25))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...10))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (8...10))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (8...10) = "**"
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (13...20))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (13...20))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (13...16) = "bar"
+            │           ├── opening_loc: (16...17) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (17...19))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ KeywordHashNode (location: (17...19))
+            │           │           └── elements: (length: 1)
+            │           │               └── @ AssocSplatNode (location: (17...19))
+            │           │                   ├── value: ∅
+            │           │                   └── operator_loc: (17...19) = "**"
+            │           ├── closing_loc: (19...20) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:**]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (10...11) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (22...25) = "end"
diff --git a/test/yarp/snapshots/whitequark/forwarded_kwrestarg_with_additional_kwarg.txt b/test/yarp/snapshots/whitequark/forwarded_kwrestarg_with_additional_kwarg.txt
index aa815fce8e..7999c9b7f5 100644
--- a/test/yarp/snapshots/whitequark/forwarded_kwrestarg_with_additional_kwarg.txt
+++ b/test/yarp/snapshots/whitequark/forwarded_kwrestarg_with_additional_kwarg.txt
@@ -1,48 +1,59 @@
-ProgramNode(0...41)(
-  [],
-  StatementsNode(0...41)(
-    [DefNode(0...41)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...10)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(8...10)(nil, nil, (8...10)),
-         nil
-       ),
-       StatementsNode(13...36)(
-         [CallNode(13...36)(
-            nil,
-            nil,
-            (13...16),
-            (16...17),
-            ArgumentsNode(17...35)(
-              [KeywordHashNode(17...35)(
-                 [AssocSplatNode(17...19)(nil, (17...19)),
-                  AssocNode(21...35)(
-                    SymbolNode(21...30)(nil, (21...29), (29...30), "from_foo"),
-                    TrueNode(31...35)(),
-                    nil
-                  )]
-               )]
-            ),
-            (35...36),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:**],
-       (0...3),
-       nil,
-       (7...8),
-       (10...11),
-       nil,
-       (38...41)
-     )]
-  )
-)
+@ ProgramNode (location: (0...41))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...41))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...41))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...10))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (8...10))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (8...10) = "**"
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (13...36))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (13...36))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (13...16) = "bar"
+            │           ├── opening_loc: (16...17) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (17...35))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ KeywordHashNode (location: (17...35))
+            │           │           └── elements: (length: 2)
+            │           │               ├── @ AssocSplatNode (location: (17...19))
+            │           │               │   ├── value: ∅
+            │           │               │   └── operator_loc: (17...19) = "**"
+            │           │               └── @ AssocNode (location: (21...35))
+            │           │                   ├── key:
+            │           │                   │   @ SymbolNode (location: (21...30))
+            │           │                   │   ├── opening_loc: ∅
+            │           │                   │   ├── value_loc: (21...29) = "from_foo"
+            │           │                   │   ├── closing_loc: (29...30) = ":"
+            │           │                   │   └── unescaped: "from_foo"
+            │           │                   ├── value:
+            │           │                   │   @ TrueNode (location: (31...35))
+            │           │                   └── operator_loc: ∅
+            │           ├── closing_loc: (35...36) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:**]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (10...11) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (38...41) = "end"
diff --git a/test/yarp/snapshots/whitequark/forwarded_restarg.txt b/test/yarp/snapshots/whitequark/forwarded_restarg.txt
index 40384fce94..d12d45e3af 100644
--- a/test/yarp/snapshots/whitequark/forwarded_restarg.txt
+++ b/test/yarp/snapshots/whitequark/forwarded_restarg.txt
@@ -1,39 +1,47 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [DefNode(0...23)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...9)(
-         [],
-         [],
-         [],
-         RestParameterNode(8...9)(nil, nil, (8...9)),
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(12...18)(
-         [CallNode(12...18)(
-            nil,
-            nil,
-            (12...15),
-            (15...16),
-            ArgumentsNode(16...17)([SplatNode(16...17)((16...17), nil)]),
-            (17...18),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:*],
-       (0...3),
-       nil,
-       (7...8),
-       (9...10),
-       nil,
-       (20...23)
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...23))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...9))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest:
+            │   │   @ RestParameterNode (location: (8...9))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (8...9) = "*"
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (12...18))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (12...18))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (12...15) = "bar"
+            │           ├── opening_loc: (15...16) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (16...17))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ SplatNode (location: (16...17))
+            │           │           ├── operator_loc: (16...17) = "*"
+            │           │           └── expression: ∅
+            │           ├── closing_loc: (17...18) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:*]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (9...10) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (20...23) = "end"
diff --git a/test/yarp/snapshots/whitequark/gvar.txt b/test/yarp/snapshots/whitequark/gvar.txt
index dbc16e65d8..a3e6d1afd4 100644
--- a/test/yarp/snapshots/whitequark/gvar.txt
+++ b/test/yarp/snapshots/whitequark/gvar.txt
@@ -1,4 +1,7 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)([GlobalVariableReadNode(0...4)(:$foo)])
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ GlobalVariableReadNode (location: (0...4))
+            └── name: :$foo
diff --git a/test/yarp/snapshots/whitequark/gvasgn.txt b/test/yarp/snapshots/whitequark/gvasgn.txt
index b416ac55ab..6d971d3950 100644
--- a/test/yarp/snapshots/whitequark/gvasgn.txt
+++ b/test/yarp/snapshots/whitequark/gvasgn.txt
@@ -1,11 +1,11 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [GlobalVariableWriteNode(0...9)(
-       :$var,
-       (0...4),
-       IntegerNode(7...9)(),
-       (5...6)
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ GlobalVariableWriteNode (location: (0...9))
+            ├── name: :$var
+            ├── name_loc: (0...4) = "$var"
+            ├── value:
+            │   @ IntegerNode (location: (7...9))
+            └── operator_loc: (5...6) = "="
diff --git a/test/yarp/snapshots/whitequark/hash_empty.txt b/test/yarp/snapshots/whitequark/hash_empty.txt
index b06b9d299b..2d3b813f11 100644
--- a/test/yarp/snapshots/whitequark/hash_empty.txt
+++ b/test/yarp/snapshots/whitequark/hash_empty.txt
@@ -1,4 +1,9 @@
-ProgramNode(0...3)(
-  [],
-  StatementsNode(0...3)([HashNode(0...3)((0...1), [], (2...3))])
-)
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ HashNode (location: (0...3))
+            ├── opening_loc: (0...1) = "{"
+            ├── elements: (length: 0)
+            └── closing_loc: (2...3) = "}"
diff --git a/test/yarp/snapshots/whitequark/hash_hashrocket.txt b/test/yarp/snapshots/whitequark/hash_hashrocket.txt
index 9b96268c01..b1483e48c3 100644
--- a/test/yarp/snapshots/whitequark/hash_hashrocket.txt
+++ b/test/yarp/snapshots/whitequark/hash_hashrocket.txt
@@ -1,24 +1,39 @@
-ProgramNode(0...37)(
-  [],
-  StatementsNode(0...37)(
-    [HashNode(0...10)(
-       (0...1),
-       [AssocNode(2...8)(IntegerNode(2...3)(), IntegerNode(7...8)(), (4...6))],
-       (9...10)
-     ),
-     HashNode(12...37)(
-       (12...13),
-       [AssocNode(14...20)(
-          IntegerNode(14...15)(),
-          IntegerNode(19...20)(),
-          (16...18)
-        ),
-        AssocNode(22...35)(
-          SymbolNode(22...26)((22...23), (23...26), nil, "foo"),
-          StringNode(30...35)((30...31), (31...34), (34...35), "bar"),
-          (27...29)
-        )],
-       (36...37)
-     )]
-  )
-)
+@ ProgramNode (location: (0...37))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...37))
+    └── body: (length: 2)
+        ├── @ HashNode (location: (0...10))
+        │   ├── opening_loc: (0...1) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (2...8))
+        │   │       ├── key:
+        │   │       │   @ IntegerNode (location: (2...3))
+        │   │       ├── value:
+        │   │       │   @ IntegerNode (location: (7...8))
+        │   │       └── operator_loc: (4...6) = "=>"
+        │   └── closing_loc: (9...10) = "}"
+        └── @ HashNode (location: (12...37))
+            ├── opening_loc: (12...13) = "{"
+            ├── elements: (length: 2)
+            │   ├── @ AssocNode (location: (14...20))
+            │   │   ├── key:
+            │   │   │   @ IntegerNode (location: (14...15))
+            │   │   ├── value:
+            │   │   │   @ IntegerNode (location: (19...20))
+            │   │   └── operator_loc: (16...18) = "=>"
+            │   └── @ AssocNode (location: (22...35))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (22...26))
+            │       │   ├── opening_loc: (22...23) = ":"
+            │       │   ├── value_loc: (23...26) = "foo"
+            │       │   ├── closing_loc: ∅
+            │       │   └── unescaped: "foo"
+            │       ├── value:
+            │       │   @ StringNode (location: (30...35))
+            │       │   ├── opening_loc: (30...31) = "\""
+            │       │   ├── content_loc: (31...34) = "bar"
+            │       │   ├── closing_loc: (34...35) = "\""
+            │       │   └── unescaped: "bar"
+            │       └── operator_loc: (27...29) = "=>"
+            └── closing_loc: (36...37) = "}"
diff --git a/test/yarp/snapshots/whitequark/hash_kwsplat.txt b/test/yarp/snapshots/whitequark/hash_kwsplat.txt
index bb56b81800..b576a93ddc 100644
--- a/test/yarp/snapshots/whitequark/hash_kwsplat.txt
+++ b/test/yarp/snapshots/whitequark/hash_kwsplat.txt
@@ -1,18 +1,32 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [HashNode(0...17)(
-       (0...1),
-       [AssocNode(2...8)(
-          SymbolNode(2...6)(nil, (2...5), (5...6), "foo"),
-          IntegerNode(7...8)(),
-          nil
-        ),
-        AssocSplatNode(10...15)(
-          CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "bar"),
-          (10...12)
-        )],
-       (16...17)
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ HashNode (location: (0...17))
+            ├── opening_loc: (0...1) = "{"
+            ├── elements: (length: 2)
+            │   ├── @ AssocNode (location: (2...8))
+            │   │   ├── key:
+            │   │   │   @ SymbolNode (location: (2...6))
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── value_loc: (2...5) = "foo"
+            │   │   │   ├── closing_loc: (5...6) = ":"
+            │   │   │   └── unescaped: "foo"
+            │   │   ├── value:
+            │   │   │   @ IntegerNode (location: (7...8))
+            │   │   └── operator_loc: ∅
+            │   └── @ AssocSplatNode (location: (10...15))
+            │       ├── value:
+            │       │   @ CallNode (location: (12...15))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (12...15) = "bar"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "bar"
+            │       └── operator_loc: (10...12) = "**"
+            └── closing_loc: (16...17) = "}"
diff --git a/test/yarp/snapshots/whitequark/hash_label.txt b/test/yarp/snapshots/whitequark/hash_label.txt
index cfebb4b70c..ca63d89c8d 100644
--- a/test/yarp/snapshots/whitequark/hash_label.txt
+++ b/test/yarp/snapshots/whitequark/hash_label.txt
@@ -1,14 +1,19 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [HashNode(0...10)(
-       (0...1),
-       [AssocNode(2...8)(
-          SymbolNode(2...6)(nil, (2...5), (5...6), "foo"),
-          IntegerNode(7...8)(),
-          nil
-        )],
-       (9...10)
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ HashNode (location: (0...10))
+            ├── opening_loc: (0...1) = "{"
+            ├── elements: (length: 1)
+            │   └── @ AssocNode (location: (2...8))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (2...6))
+            │       │   ├── opening_loc: ∅
+            │       │   ├── value_loc: (2...5) = "foo"
+            │       │   ├── closing_loc: (5...6) = ":"
+            │       │   └── unescaped: "foo"
+            │       ├── value:
+            │       │   @ IntegerNode (location: (7...8))
+            │       └── operator_loc: ∅
+            └── closing_loc: (9...10) = "}"
diff --git a/test/yarp/snapshots/whitequark/hash_label_end.txt b/test/yarp/snapshots/whitequark/hash_label_end.txt
index b5d4273d5b..ed00728147 100644
--- a/test/yarp/snapshots/whitequark/hash_label_end.txt
+++ b/test/yarp/snapshots/whitequark/hash_label_end.txt
@@ -1,53 +1,88 @@
-ProgramNode(0...50)(
-  [],
-  StatementsNode(0...50)(
-    [CallNode(0...12)(
-       nil,
-       nil,
-       (0...1),
-       (1...2),
-       ArgumentsNode(2...11)(
-         [IfNode(2...11)(
-            nil,
-            CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "a"),
-            StatementsNode(6...9)(
-              [StringNode(6...9)((6...7), (7...8), (8...9), "a")]
-            ),
-            ElseNode(9...11)(
-              (9...10),
-              StatementsNode(10...11)([IntegerNode(10...11)()]),
-              nil
-            ),
-            nil
-          )]
-       ),
-       (11...12),
-       nil,
-       0,
-       "f"
-     ),
-     HashNode(14...26)(
-       (14...15),
-       [AssocNode(16...24)(
-          SymbolNode(16...22)((16...17), (17...20), (20...22), "foo"),
-          IntegerNode(23...24)(),
-          nil
-        )],
-       (25...26)
-     ),
-     HashNode(28...50)(
-       (28...29),
-       [AssocNode(30...38)(
-          SymbolNode(30...36)((30...31), (31...34), (34...36), "foo"),
-          IntegerNode(37...38)(),
-          nil
-        ),
-        AssocNode(40...49)(
-          SymbolNode(40...46)((40...41), (41...44), (44...46), "bar"),
-          HashNode(47...49)((47...48), [], (48...49)),
-          nil
-        )],
-       (49...50)
-     )]
-  )
-)
+@ ProgramNode (location: (0...50))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...50))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...12))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "f"
+        │   ├── opening_loc: (1...2) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...11))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IfNode (location: (2...11))
+        │   │           ├── if_keyword_loc: ∅
+        │   │           ├── predicate:
+        │   │           │   @ CallNode (location: (2...3))
+        │   │           │   ├── receiver: ∅
+        │   │           │   ├── call_operator_loc: ∅
+        │   │           │   ├── message_loc: (2...3) = "a"
+        │   │           │   ├── opening_loc: ∅
+        │   │           │   ├── arguments: ∅
+        │   │           │   ├── closing_loc: ∅
+        │   │           │   ├── block: ∅
+        │   │           │   ├── flags: variable_call
+        │   │           │   └── name: "a"
+        │   │           ├── statements:
+        │   │           │   @ StatementsNode (location: (6...9))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ StringNode (location: (6...9))
+        │   │           │           ├── opening_loc: (6...7) = "\""
+        │   │           │           ├── content_loc: (7...8) = "a"
+        │   │           │           ├── closing_loc: (8...9) = "\""
+        │   │           │           └── unescaped: "a"
+        │   │           ├── consequent:
+        │   │           │   @ ElseNode (location: (9...11))
+        │   │           │   ├── else_keyword_loc: (9...10) = ":"
+        │   │           │   ├── statements:
+        │   │           │   │   @ StatementsNode (location: (10...11))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ IntegerNode (location: (10...11))
+        │   │           │   └── end_keyword_loc: ∅
+        │   │           └── end_keyword_loc: ∅
+        │   ├── closing_loc: (11...12) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "f"
+        ├── @ HashNode (location: (14...26))
+        │   ├── opening_loc: (14...15) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (16...24))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (16...22))
+        │   │       │   ├── opening_loc: (16...17) = "'"
+        │   │       │   ├── value_loc: (17...20) = "foo"
+        │   │       │   ├── closing_loc: (20...22) = "':"
+        │   │       │   └── unescaped: "foo"
+        │   │       ├── value:
+        │   │       │   @ IntegerNode (location: (23...24))
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (25...26) = "}"
+        └── @ HashNode (location: (28...50))
+            ├── opening_loc: (28...29) = "{"
+            ├── elements: (length: 2)
+            │   ├── @ AssocNode (location: (30...38))
+            │   │   ├── key:
+            │   │   │   @ SymbolNode (location: (30...36))
+            │   │   │   ├── opening_loc: (30...31) = "'"
+            │   │   │   ├── value_loc: (31...34) = "foo"
+            │   │   │   ├── closing_loc: (34...36) = "':"
+            │   │   │   └── unescaped: "foo"
+            │   │   ├── value:
+            │   │   │   @ IntegerNode (location: (37...38))
+            │   │   └── operator_loc: ∅
+            │   └── @ AssocNode (location: (40...49))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (40...46))
+            │       │   ├── opening_loc: (40...41) = "'"
+            │       │   ├── value_loc: (41...44) = "bar"
+            │       │   ├── closing_loc: (44...46) = "':"
+            │       │   └── unescaped: "bar"
+            │       ├── value:
+            │       │   @ HashNode (location: (47...49))
+            │       │   ├── opening_loc: (47...48) = "{"
+            │       │   ├── elements: (length: 0)
+            │       │   └── closing_loc: (48...49) = "}"
+            │       └── operator_loc: ∅
+            └── closing_loc: (49...50) = "}"
diff --git a/test/yarp/snapshots/whitequark/hash_pair_value_omission.txt b/test/yarp/snapshots/whitequark/hash_pair_value_omission.txt
index 825fe1beaa..09d4853a51 100644
--- a/test/yarp/snapshots/whitequark/hash_pair_value_omission.txt
+++ b/test/yarp/snapshots/whitequark/hash_pair_value_omission.txt
@@ -1,37 +1,53 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [HashNode(0...6)(
-       (0...1),
-       [AssocNode(1...5)(
-          SymbolNode(1...5)(nil, (1...4), (4...5), "BAR"),
-          nil,
-          nil
-        )],
-       (5...6)
-     ),
-     HashNode(8...16)(
-       (8...9),
-       [AssocNode(9...11)(
-          SymbolNode(9...11)(nil, (9...10), (10...11), "a"),
-          nil,
-          nil
-        ),
-        AssocNode(13...15)(
-          SymbolNode(13...15)(nil, (13...14), (14...15), "b"),
-          nil,
-          nil
-        )],
-       (15...16)
-     ),
-     HashNode(18...25)(
-       (18...19),
-       [AssocNode(19...24)(
-          SymbolNode(19...24)(nil, (19...23), (23...24), "puts"),
-          nil,
-          nil
-        )],
-       (24...25)
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 3)
+        ├── @ HashNode (location: (0...6))
+        │   ├── opening_loc: (0...1) = "{"
+        │   ├── elements: (length: 1)
+        │   │   └── @ AssocNode (location: (1...5))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (1...5))
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── value_loc: (1...4) = "BAR"
+        │   │       │   ├── closing_loc: (4...5) = ":"
+        │   │       │   └── unescaped: "BAR"
+        │   │       ├── value: ∅
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (5...6) = "}"
+        ├── @ HashNode (location: (8...16))
+        │   ├── opening_loc: (8...9) = "{"
+        │   ├── elements: (length: 2)
+        │   │   ├── @ AssocNode (location: (9...11))
+        │   │   │   ├── key:
+        │   │   │   │   @ SymbolNode (location: (9...11))
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   ├── value_loc: (9...10) = "a"
+        │   │   │   │   ├── closing_loc: (10...11) = ":"
+        │   │   │   │   └── unescaped: "a"
+        │   │   │   ├── value: ∅
+        │   │   │   └── operator_loc: ∅
+        │   │   └── @ AssocNode (location: (13...15))
+        │   │       ├── key:
+        │   │       │   @ SymbolNode (location: (13...15))
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── value_loc: (13...14) = "b"
+        │   │       │   ├── closing_loc: (14...15) = ":"
+        │   │       │   └── unescaped: "b"
+        │   │       ├── value: ∅
+        │   │       └── operator_loc: ∅
+        │   └── closing_loc: (15...16) = "}"
+        └── @ HashNode (location: (18...25))
+            ├── opening_loc: (18...19) = "{"
+            ├── elements: (length: 1)
+            │   └── @ AssocNode (location: (19...24))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (19...24))
+            │       │   ├── opening_loc: ∅
+            │       │   ├── value_loc: (19...23) = "puts"
+            │       │   ├── closing_loc: (23...24) = ":"
+            │       │   └── unescaped: "puts"
+            │       ├── value: ∅
+            │       └── operator_loc: ∅
+            └── closing_loc: (24...25) = "}"
diff --git a/test/yarp/snapshots/whitequark/heredoc.txt b/test/yarp/snapshots/whitequark/heredoc.txt
index c61829ebd4..082e23926e 100644
--- a/test/yarp/snapshots/whitequark/heredoc.txt
+++ b/test/yarp/snapshots/whitequark/heredoc.txt
@@ -1,20 +1,32 @@
-ProgramNode(0...52)(
-  [],
-  StatementsNode(0...52)(
-    [InterpolatedStringNode(0...8)(
-       (0...8),
-       [StringNode(9...17)(nil, (9...17), nil, "foo\n" + "bar\n")],
-       (17...22)
-     ),
-     InterpolatedStringNode(23...29)(
-       (23...29),
-       [StringNode(30...38)(nil, (30...38), nil, "foo\n" + "bar\n")],
-       (38...43)
-     ),
-     InterpolatedXStringNode(44...52)(
-       (44...52),
-       [StringNode(53...61)(nil, (53...61), nil, "foo\n" + "bar\n")],
-       (61...66)
-     )]
-  )
-)
+@ ProgramNode (location: (0...52))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...52))
+    └── body: (length: 3)
+        ├── @ InterpolatedStringNode (location: (0...8))
+        │   ├── opening_loc: (0...8) = "<<'HERE'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (9...17))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (9...17) = "foo\nbar\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "foo\nbar\n"
+        │   └── closing_loc: (17...22) = "HERE\n"
+        ├── @ InterpolatedStringNode (location: (23...29))
+        │   ├── opening_loc: (23...29) = "<<HERE"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (30...38))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (30...38) = "foo\nbar\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "foo\nbar\n"
+        │   └── closing_loc: (38...43) = "HERE\n"
+        └── @ InterpolatedXStringNode (location: (44...52))
+            ├── opening_loc: (44...52) = "<<`HERE`"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (53...61))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (53...61) = "foo\nbar\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "foo\nbar\n"
+            └── closing_loc: (61...66) = "HERE\n"
diff --git a/test/yarp/snapshots/whitequark/if.txt b/test/yarp/snapshots/whitequark/if.txt
index 069eb07f25..cf2bb5ab5f 100644
--- a/test/yarp/snapshots/whitequark/if.txt
+++ b/test/yarp/snapshots/whitequark/if.txt
@@ -1,23 +1,61 @@
-ProgramNode(0...38)(
-  [],
-  StatementsNode(0...38)(
-    [IfNode(0...20)(
-       (0...2),
-       CallNode(3...6)(nil, nil, (3...6), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(12...15)(
-         [CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       (17...20)
-     ),
-     IfNode(22...38)(
-       (22...24),
-       CallNode(25...28)(nil, nil, (25...28), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(30...33)(
-         [CallNode(30...33)(nil, nil, (30...33), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       (35...38)
-     )]
-  )
-)
+@ ProgramNode (location: (0...38))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...38))
+    └── body: (length: 2)
+        ├── @ IfNode (location: (0...20))
+        │   ├── if_keyword_loc: (0...2) = "if"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3...6))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3...6) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (12...15))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (12...15))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (12...15) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (17...20) = "end"
+        └── @ IfNode (location: (22...38))
+            ├── if_keyword_loc: (22...24) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (25...28))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (25...28) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (30...33))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (30...33))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (30...33) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── consequent: ∅
+            └── end_keyword_loc: (35...38) = "end"
diff --git a/test/yarp/snapshots/whitequark/if_else.txt b/test/yarp/snapshots/whitequark/if_else.txt
index d8799a330c..0581f9bf66 100644
--- a/test/yarp/snapshots/whitequark/if_else.txt
+++ b/test/yarp/snapshots/whitequark/if_else.txt
@@ -1,55 +1,93 @@
-ProgramNode(0...58)(
-  [],
-  StatementsNode(0...58)(
-    [IfNode(0...30)(
-       (0...2),
-       CallNode(3...6)(nil, nil, (3...6), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(12...15)(
-         [CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "bar")]
-       ),
-       ElseNode(17...30)(
-         (17...21),
-         StatementsNode(22...25)(
-           [CallNode(22...25)(
-              nil,
-              nil,
-              (22...25),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         (27...30)
-       ),
-       (27...30)
-     ),
-     IfNode(32...58)(
-       (32...34),
-       CallNode(35...38)(nil, nil, (35...38), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(40...43)(
-         [CallNode(40...43)(nil, nil, (40...43), nil, nil, nil, nil, 2, "bar")]
-       ),
-       ElseNode(45...58)(
-         (45...49),
-         StatementsNode(50...53)(
-           [CallNode(50...53)(
-              nil,
-              nil,
-              (50...53),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         (55...58)
-       ),
-       (55...58)
-     )]
-  )
-)
+@ ProgramNode (location: (0...58))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...58))
+    └── body: (length: 2)
+        ├── @ IfNode (location: (0...30))
+        │   ├── if_keyword_loc: (0...2) = "if"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (3...6))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (3...6) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (12...15))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (12...15))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (12...15) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (17...30))
+        │   │   ├── else_keyword_loc: (17...21) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (22...25))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (22...25))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (22...25) = "baz"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "baz"
+        │   │   └── end_keyword_loc: (27...30) = "end"
+        │   └── end_keyword_loc: (27...30) = "end"
+        └── @ IfNode (location: (32...58))
+            ├── if_keyword_loc: (32...34) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (35...38))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (35...38) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (40...43))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (40...43))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (40...43) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── consequent:
+            │   @ ElseNode (location: (45...58))
+            │   ├── else_keyword_loc: (45...49) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (50...53))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (50...53))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (50...53) = "baz"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "baz"
+            │   └── end_keyword_loc: (55...58) = "end"
+            └── end_keyword_loc: (55...58) = "end"
diff --git a/test/yarp/snapshots/whitequark/if_elsif.txt b/test/yarp/snapshots/whitequark/if_elsif.txt
index 953d565bf6..0911f744bf 100644
--- a/test/yarp/snapshots/whitequark/if_elsif.txt
+++ b/test/yarp/snapshots/whitequark/if_elsif.txt
@@ -1,24 +1,59 @@
-ProgramNode(0...38)(
-  [],
-  StatementsNode(0...38)(
-    [IfNode(0...38)(
-       (0...2),
-       CallNode(3...6)(nil, nil, (3...6), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(8...11)(
-         [CallNode(8...11)(nil, nil, (8...11), nil, nil, nil, nil, 2, "bar")]
-       ),
-       IfNode(13...38)(
-         (13...18),
-         CallNode(19...22)(nil, nil, (19...22), nil, nil, nil, nil, 2, "baz"),
-         StatementsNode(24...25)([IntegerNode(24...25)()]),
-         ElseNode(27...38)(
-           (27...31),
-           StatementsNode(32...33)([IntegerNode(32...33)()]),
-           (35...38)
-         ),
-         (35...38)
-       ),
-       (35...38)
-     )]
-  )
-)
+@ ProgramNode (location: (0...38))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...38))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...38))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (3...6))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (3...6) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (8...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (8...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (8...11) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── consequent:
+            │   @ IfNode (location: (13...38))
+            │   ├── if_keyword_loc: (13...18) = "elsif"
+            │   ├── predicate:
+            │   │   @ CallNode (location: (19...22))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (19...22) = "baz"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "baz"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (24...25))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (24...25))
+            │   ├── consequent:
+            │   │   @ ElseNode (location: (27...38))
+            │   │   ├── else_keyword_loc: (27...31) = "else"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (32...33))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ IntegerNode (location: (32...33))
+            │   │   └── end_keyword_loc: (35...38) = "end"
+            │   └── end_keyword_loc: (35...38) = "end"
+            └── end_keyword_loc: (35...38) = "end"
diff --git a/test/yarp/snapshots/whitequark/if_masgn__24.txt b/test/yarp/snapshots/whitequark/if_masgn__24.txt
index 1bdfd7bff6..5754b89103 100644
--- a/test/yarp/snapshots/whitequark/if_masgn__24.txt
+++ b/test/yarp/snapshots/whitequark/if_masgn__24.txt
@@ -1,35 +1,39 @@
-ProgramNode(0...20)(
-  [:a, :b],
-  StatementsNode(0...20)(
-    [IfNode(0...20)(
-       (0...2),
-       ParenthesesNode(3...15)(
-         StatementsNode(4...14)(
-           [MultiWriteNode(4...14)(
-              [LocalVariableTargetNode(4...5)(:a, 0),
-               LocalVariableTargetNode(7...8)(:b, 0)],
-              nil,
-              nil,
-              (9...10),
-              CallNode(11...14)(
-                nil,
-                nil,
-                (11...14),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "foo"
-              )
-            )]
-         ),
-         (3...4),
-         (14...15)
-       ),
-       nil,
-       nil,
-       (17...20)
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...20))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ ParenthesesNode (location: (3...15))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (4...14))
+            │   │   └── body: (length: 1)
+            │   │       └── @ MultiWriteNode (location: (4...14))
+            │   │           ├── targets: (length: 2)
+            │   │           │   ├── @ LocalVariableTargetNode (location: (4...5))
+            │   │           │   │   ├── name: :a
+            │   │           │   │   └── depth: 0
+            │   │           │   └── @ LocalVariableTargetNode (location: (7...8))
+            │   │           │       ├── name: :b
+            │   │           │       └── depth: 0
+            │   │           ├── lparen_loc: ∅
+            │   │           ├── rparen_loc: ∅
+            │   │           ├── operator_loc: (9...10) = "="
+            │   │           └── value:
+            │   │               @ CallNode (location: (11...14))
+            │   │               ├── receiver: ∅
+            │   │               ├── call_operator_loc: ∅
+            │   │               ├── message_loc: (11...14) = "foo"
+            │   │               ├── opening_loc: ∅
+            │   │               ├── arguments: ∅
+            │   │               ├── closing_loc: ∅
+            │   │               ├── block: ∅
+            │   │               ├── flags: variable_call
+            │   │               └── name: "foo"
+            │   ├── opening_loc: (3...4) = "("
+            │   └── closing_loc: (14...15) = ")"
+            ├── statements: ∅
+            ├── consequent: ∅
+            └── end_keyword_loc: (17...20) = "end"
diff --git a/test/yarp/snapshots/whitequark/if_mod.txt b/test/yarp/snapshots/whitequark/if_mod.txt
index 9a6575b5d1..1238560a84 100644
--- a/test/yarp/snapshots/whitequark/if_mod.txt
+++ b/test/yarp/snapshots/whitequark/if_mod.txt
@@ -1,14 +1,33 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [IfNode(0...10)(
-       (4...6),
-       CallNode(7...10)(nil, nil, (7...10), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(0...3)(
-         [CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...10))
+            ├── if_keyword_loc: (4...6) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (7...10))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (7...10) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (0...3))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (0...3))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (0...3) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── consequent: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/if_nl_then.txt b/test/yarp/snapshots/whitequark/if_nl_then.txt
index db1b5231ef..4ce61a73b7 100644
--- a/test/yarp/snapshots/whitequark/if_nl_then.txt
+++ b/test/yarp/snapshots/whitequark/if_nl_then.txt
@@ -1,14 +1,33 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [IfNode(0...19)(
-       (0...2),
-       CallNode(3...6)(nil, nil, (3...6), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(12...15)(
-         [CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       (16...19)
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...19))
+            ├── if_keyword_loc: (0...2) = "if"
+            ├── predicate:
+            │   @ CallNode (location: (3...6))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (3...6) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (12...15))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (12...15))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (12...15) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── consequent: ∅
+            └── end_keyword_loc: (16...19) = "end"
diff --git a/test/yarp/snapshots/whitequark/if_while_after_class__since_32.txt b/test/yarp/snapshots/whitequark/if_while_after_class__since_32.txt
index f2ba2a1245..f058ec456a 100644
--- a/test/yarp/snapshots/whitequark/if_while_after_class__since_32.txt
+++ b/test/yarp/snapshots/whitequark/if_while_after_class__since_32.txt
@@ -1,93 +1,115 @@
-ProgramNode(0...178)(
-  [],
-  StatementsNode(0...178)(
-    [ClassNode(0...38)(
-       [],
-       (0...5),
-       ConstantPathNode(6...33)(
-         IfNode(6...25)(
-           (6...8),
-           TrueNode(9...13)(),
-           StatementsNode(15...21)([ConstantReadNode(15...21)(:Object)]),
-           nil,
-           (22...25)
-         ),
-         ConstantReadNode(27...33)(:Kernel),
-         (25...27)
-       ),
-       nil,
-       nil,
-       nil,
-       (35...38),
-       :Kernel
-     ),
-     ClassNode(40...87)(
-       [],
-       (40...45),
-       ConstantPathNode(46...82)(
-         WhileNode(46...74)(
-           (46...51),
-           (71...74),
-           TrueNode(52...56)(),
-           StatementsNode(58...70)(
-             [BreakNode(58...70)(
-                ArgumentsNode(64...70)([ConstantReadNode(64...70)(:Object)]),
-                (58...63)
-              )]
-           ),
-           0
-         ),
-         ConstantReadNode(76...82)(:Kernel),
-         (74...76)
-       ),
-       nil,
-       nil,
-       nil,
-       (84...87),
-       :Kernel
-     ),
-     ModuleNode(89...128)(
-       [],
-       (89...95),
-       ConstantPathNode(96...123)(
-         IfNode(96...115)(
-           (96...98),
-           TrueNode(99...103)(),
-           StatementsNode(105...111)([ConstantReadNode(105...111)(:Object)]),
-           nil,
-           (112...115)
-         ),
-         ConstantReadNode(117...123)(:Kernel),
-         (115...117)
-       ),
-       nil,
-       (125...128),
-       :Kernel
-     ),
-     ModuleNode(130...178)(
-       [],
-       (130...136),
-       ConstantPathNode(137...173)(
-         WhileNode(137...165)(
-           (137...142),
-           (162...165),
-           TrueNode(143...147)(),
-           StatementsNode(149...161)(
-             [BreakNode(149...161)(
-                ArgumentsNode(155...161)(
-                  [ConstantReadNode(155...161)(:Object)]
-                ),
-                (149...154)
-              )]
-           ),
-           0
-         ),
-         ConstantReadNode(167...173)(:Kernel),
-         (165...167)
-       ),
-       nil,
-       (175...178),
-       :Kernel
-     )]
-  )
-)
+@ ProgramNode (location: (0...178))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...178))
+    └── body: (length: 4)
+        ├── @ ClassNode (location: (0...38))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (0...5) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (6...33))
+        │   │   ├── parent:
+        │   │   │   @ IfNode (location: (6...25))
+        │   │   │   ├── if_keyword_loc: (6...8) = "if"
+        │   │   │   ├── predicate:
+        │   │   │   │   @ TrueNode (location: (9...13))
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (15...21))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ ConstantReadNode (location: (15...21))
+        │   │   │   │           └── name: :Object
+        │   │   │   ├── consequent: ∅
+        │   │   │   └── end_keyword_loc: (22...25) = "end"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (27...33))
+        │   │   │   └── name: :Kernel
+        │   │   └── delimiter_loc: (25...27) = "::"
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (35...38) = "end"
+        │   └── name: :Kernel
+        ├── @ ClassNode (location: (40...87))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (40...45) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (46...82))
+        │   │   ├── parent:
+        │   │   │   @ WhileNode (location: (46...74))
+        │   │   │   ├── keyword_loc: (46...51) = "while"
+        │   │   │   ├── closing_loc: (71...74) = "end"
+        │   │   │   ├── predicate:
+        │   │   │   │   @ TrueNode (location: (52...56))
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (58...70))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ BreakNode (location: (58...70))
+        │   │   │   │           ├── arguments:
+        │   │   │   │           │   @ ArgumentsNode (location: (64...70))
+        │   │   │   │           │   └── arguments: (length: 1)
+        │   │   │   │           │       └── @ ConstantReadNode (location: (64...70))
+        │   │   │   │           │           └── name: :Object
+        │   │   │   │           └── keyword_loc: (58...63) = "break"
+        │   │   │   └── flags: 
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (76...82))
+        │   │   │   └── name: :Kernel
+        │   │   └── delimiter_loc: (74...76) = "::"
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (84...87) = "end"
+        │   └── name: :Kernel
+        ├── @ ModuleNode (location: (89...128))
+        │   ├── locals: []
+        │   ├── module_keyword_loc: (89...95) = "module"
+        │   ├── constant_path:
+        │   │   @ ConstantPathNode (location: (96...123))
+        │   │   ├── parent:
+        │   │   │   @ IfNode (location: (96...115))
+        │   │   │   ├── if_keyword_loc: (96...98) = "if"
+        │   │   │   ├── predicate:
+        │   │   │   │   @ TrueNode (location: (99...103))
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (105...111))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ ConstantReadNode (location: (105...111))
+        │   │   │   │           └── name: :Object
+        │   │   │   ├── consequent: ∅
+        │   │   │   └── end_keyword_loc: (112...115) = "end"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (117...123))
+        │   │   │   └── name: :Kernel
+        │   │   └── delimiter_loc: (115...117) = "::"
+        │   ├── body: ∅
+        │   ├── end_keyword_loc: (125...128) = "end"
+        │   └── name: :Kernel
+        └── @ ModuleNode (location: (130...178))
+            ├── locals: []
+            ├── module_keyword_loc: (130...136) = "module"
+            ├── constant_path:
+            │   @ ConstantPathNode (location: (137...173))
+            │   ├── parent:
+            │   │   @ WhileNode (location: (137...165))
+            │   │   ├── keyword_loc: (137...142) = "while"
+            │   │   ├── closing_loc: (162...165) = "end"
+            │   │   ├── predicate:
+            │   │   │   @ TrueNode (location: (143...147))
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (149...161))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ BreakNode (location: (149...161))
+            │   │   │           ├── arguments:
+            │   │   │           │   @ ArgumentsNode (location: (155...161))
+            │   │   │           │   └── arguments: (length: 1)
+            │   │   │           │       └── @ ConstantReadNode (location: (155...161))
+            │   │   │           │           └── name: :Object
+            │   │   │           └── keyword_loc: (149...154) = "break"
+            │   │   └── flags: 
+            │   ├── child:
+            │   │   @ ConstantReadNode (location: (167...173))
+            │   │   └── name: :Kernel
+            │   └── delimiter_loc: (165...167) = "::"
+            ├── body: ∅
+            ├── end_keyword_loc: (175...178) = "end"
+            └── name: :Kernel
diff --git a/test/yarp/snapshots/whitequark/int.txt b/test/yarp/snapshots/whitequark/int.txt
index a99820ad33..3a88dd5c02 100644
--- a/test/yarp/snapshots/whitequark/int.txt
+++ b/test/yarp/snapshots/whitequark/int.txt
@@ -1,6 +1,8 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [IntegerNode(0...3)(), IntegerNode(5...8)(), IntegerNode(10...12)()]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 3)
+        ├── @ IntegerNode (location: (0...3))
+        ├── @ IntegerNode (location: (5...8))
+        └── @ IntegerNode (location: (10...12))
diff --git a/test/yarp/snapshots/whitequark/int___LINE__.txt b/test/yarp/snapshots/whitequark/int___LINE__.txt
index 0f6e7aa884..1c50f292af 100644
--- a/test/yarp/snapshots/whitequark/int___LINE__.txt
+++ b/test/yarp/snapshots/whitequark/int___LINE__.txt
@@ -1 +1,6 @@
-ProgramNode(0...8)([], StatementsNode(0...8)([SourceLineNode(0...8)()]))
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ SourceLineNode (location: (0...8))
diff --git a/test/yarp/snapshots/whitequark/interp_digit_var.txt b/test/yarp/snapshots/whitequark/interp_digit_var.txt
index 48d7ac9671..91c3664bfb 100644
--- a/test/yarp/snapshots/whitequark/interp_digit_var.txt
+++ b/test/yarp/snapshots/whitequark/interp_digit_var.txt
@@ -1,123 +1,255 @@
-ProgramNode(1...465)(
-  [],
-  StatementsNode(1...465)(
-    [StringNode(1...6)((1...2), (2...5), (5...6), "\#@1"),
-     StringNode(10...16)((10...11), (11...15), (15...16), "\#@@1"),
-     ArrayNode(20...27)(
-       [SymbolNode(23...26)(nil, (23...26), nil, "\#@1")],
-       (20...23),
-       (26...27)
-     ),
-     ArrayNode(31...39)(
-       [SymbolNode(34...38)(nil, (34...38), nil, "\#@@1")],
-       (31...34),
-       (38...39)
-     ),
-     StringNode(43...50)((43...46), (46...49), (49...50), "\#@1"),
-     StringNode(54...62)((54...57), (57...61), (61...62), "\#@@1"),
-     ArrayNode(66...73)(
-       [StringNode(69...72)(nil, (69...72), nil, "\#@1")],
-       (66...69),
-       (72...73)
-     ),
-     ArrayNode(77...85)(
-       [StringNode(80...84)(nil, (80...84), nil, "\#@@1")],
-       (77...80),
-       (84...85)
-     ),
-     ArrayNode(89...98)(
-       [SymbolNode(93...96)(nil, (93...96), nil, "\#@1")],
-       (89...92),
-       (97...98)
-     ),
-     ArrayNode(102...112)(
-       [SymbolNode(106...110)(nil, (106...110), nil, "\#@@1")],
-       (102...105),
-       (111...112)
-     ),
-     StringNode(116...123)((116...119), (119...122), (122...123), "\#@1"),
-     StringNode(127...135)((127...130), (130...134), (134...135), "\#@@1"),
-     RegularExpressionNode(139...146)(
-       (139...142),
-       (142...145),
-       (145...146),
-       "\#@1",
-       0
-     ),
-     RegularExpressionNode(150...158)(
-       (150...153),
-       (153...157),
-       (157...158),
-       "\#@@1",
-       0
-     ),
-     SymbolNode(162...169)((162...165), (165...168), (168...169), "\#@1"),
-     SymbolNode(173...181)((173...176), (176...180), (180...181), "\#@@1"),
-     ArrayNode(185...194)(
-       [StringNode(189...192)(nil, (189...192), nil, "\#@1")],
-       (185...188),
-       (193...194)
-     ),
-     ArrayNode(198...208)(
-       [StringNode(202...206)(nil, (202...206), nil, "\#@@1")],
-       (198...201),
-       (207...208)
-     ),
-     XStringNode(212...219)((212...215), (215...218), (218...219), "\#@1"),
-     XStringNode(223...231)((223...226), (226...230), (230...231), "\#@@1"),
-     StringNode(235...241)((235...237), (237...240), (240...241), "\#@1"),
-     StringNode(245...252)((245...247), (247...251), (251...252), "\#@@1"),
-     StringNode(256...261)((256...257), (257...260), (260...261), "\#@1"),
-     StringNode(265...271)((265...266), (266...270), (270...271), "\#@@1"),
-     RegularExpressionNode(275...280)(
-       (275...276),
-       (276...279),
-       (279...280),
-       "\#@1",
-       0
-     ),
-     RegularExpressionNode(284...290)(
-       (284...285),
-       (285...289),
-       (289...290),
-       "\#@@1",
-       0
-     ),
-     SymbolNode(294...300)((294...296), (296...299), (299...300), "\#@1"),
-     SymbolNode(304...311)((304...306), (306...310), (310...311), "\#@@1"),
-     SymbolNode(315...321)((315...317), (317...320), (320...321), "\#@1"),
-     SymbolNode(325...332)((325...327), (327...331), (331...332), "\#@@1"),
-     XStringNode(336...341)((336...337), (337...340), (340...341), "\#@1"),
-     XStringNode(345...351)((345...346), (346...350), (350...351), "\#@@1"),
-     InterpolatedStringNode(354...363)(
-       (354...363),
-       [StringNode(364...368)(nil, (364...368), nil, "\#@1\n")],
-       (368...373)
-     ),
-     InterpolatedStringNode(374...383)(
-       (374...383),
-       [StringNode(384...389)(nil, (384...389), nil, "\#@@1\n")],
-       (389...394)
-     ),
-     InterpolatedStringNode(395...404)(
-       (395...404),
-       [StringNode(405...409)(nil, (405...409), nil, "\#@1\n")],
-       (409...414)
-     ),
-     InterpolatedStringNode(415...424)(
-       (415...424),
-       [StringNode(425...430)(nil, (425...430), nil, "\#@@1\n")],
-       (430...435)
-     ),
-     InterpolatedXStringNode(436...445)(
-       (436...445),
-       [StringNode(446...450)(nil, (446...450), nil, "\#@1\n")],
-       (450...455)
-     ),
-     InterpolatedXStringNode(456...465)(
-       (456...465),
-       [StringNode(466...471)(nil, (466...471), nil, "\#@@1\n")],
-       (471...476)
-     )]
-  )
-)
+@ ProgramNode (location: (1...465))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (1...465))
+    └── body: (length: 38)
+        ├── @ StringNode (location: (1...6))
+        │   ├── opening_loc: (1...2) = "\""
+        │   ├── content_loc: (2...5) = "\#@1"
+        │   ├── closing_loc: (5...6) = "\""
+        │   └── unescaped: "\#@1"
+        ├── @ StringNode (location: (10...16))
+        │   ├── opening_loc: (10...11) = "\""
+        │   ├── content_loc: (11...15) = "\#@@1"
+        │   ├── closing_loc: (15...16) = "\""
+        │   └── unescaped: "\#@@1"
+        ├── @ ArrayNode (location: (20...27))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SymbolNode (location: (23...26))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (23...26) = "\#@1"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@1"
+        │   ├── opening_loc: (20...23) = "%I["
+        │   └── closing_loc: (26...27) = "]"
+        ├── @ ArrayNode (location: (31...39))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SymbolNode (location: (34...38))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (34...38) = "\#@@1"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@@1"
+        │   ├── opening_loc: (31...34) = "%I["
+        │   └── closing_loc: (38...39) = "]"
+        ├── @ StringNode (location: (43...50))
+        │   ├── opening_loc: (43...46) = "%Q{"
+        │   ├── content_loc: (46...49) = "\#@1"
+        │   ├── closing_loc: (49...50) = "}"
+        │   └── unescaped: "\#@1"
+        ├── @ StringNode (location: (54...62))
+        │   ├── opening_loc: (54...57) = "%Q{"
+        │   ├── content_loc: (57...61) = "\#@@1"
+        │   ├── closing_loc: (61...62) = "}"
+        │   └── unescaped: "\#@@1"
+        ├── @ ArrayNode (location: (66...73))
+        │   ├── elements: (length: 1)
+        │   │   └── @ StringNode (location: (69...72))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (69...72) = "\#@1"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@1"
+        │   ├── opening_loc: (66...69) = "%W["
+        │   └── closing_loc: (72...73) = "]"
+        ├── @ ArrayNode (location: (77...85))
+        │   ├── elements: (length: 1)
+        │   │   └── @ StringNode (location: (80...84))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (80...84) = "\#@@1"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@@1"
+        │   ├── opening_loc: (77...80) = "%W["
+        │   └── closing_loc: (84...85) = "]"
+        ├── @ ArrayNode (location: (89...98))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SymbolNode (location: (93...96))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (93...96) = "\#@1"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@1"
+        │   ├── opening_loc: (89...92) = "%i["
+        │   └── closing_loc: (97...98) = "]"
+        ├── @ ArrayNode (location: (102...112))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SymbolNode (location: (106...110))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (106...110) = "\#@@1"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@@1"
+        │   ├── opening_loc: (102...105) = "%i["
+        │   └── closing_loc: (111...112) = "]"
+        ├── @ StringNode (location: (116...123))
+        │   ├── opening_loc: (116...119) = "%q{"
+        │   ├── content_loc: (119...122) = "\#@1"
+        │   ├── closing_loc: (122...123) = "}"
+        │   └── unescaped: "\#@1"
+        ├── @ StringNode (location: (127...135))
+        │   ├── opening_loc: (127...130) = "%q{"
+        │   ├── content_loc: (130...134) = "\#@@1"
+        │   ├── closing_loc: (134...135) = "}"
+        │   └── unescaped: "\#@@1"
+        ├── @ RegularExpressionNode (location: (139...146))
+        │   ├── opening_loc: (139...142) = "%r{"
+        │   ├── content_loc: (142...145) = "\#@1"
+        │   ├── closing_loc: (145...146) = "}"
+        │   ├── unescaped: "\#@1"
+        │   └── flags: 
+        ├── @ RegularExpressionNode (location: (150...158))
+        │   ├── opening_loc: (150...153) = "%r{"
+        │   ├── content_loc: (153...157) = "\#@@1"
+        │   ├── closing_loc: (157...158) = "}"
+        │   ├── unescaped: "\#@@1"
+        │   └── flags: 
+        ├── @ SymbolNode (location: (162...169))
+        │   ├── opening_loc: (162...165) = "%s{"
+        │   ├── value_loc: (165...168) = "\#@1"
+        │   ├── closing_loc: (168...169) = "}"
+        │   └── unescaped: "\#@1"
+        ├── @ SymbolNode (location: (173...181))
+        │   ├── opening_loc: (173...176) = "%s{"
+        │   ├── value_loc: (176...180) = "\#@@1"
+        │   ├── closing_loc: (180...181) = "}"
+        │   └── unescaped: "\#@@1"
+        ├── @ ArrayNode (location: (185...194))
+        │   ├── elements: (length: 1)
+        │   │   └── @ StringNode (location: (189...192))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (189...192) = "\#@1"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@1"
+        │   ├── opening_loc: (185...188) = "%w["
+        │   └── closing_loc: (193...194) = "]"
+        ├── @ ArrayNode (location: (198...208))
+        │   ├── elements: (length: 1)
+        │   │   └── @ StringNode (location: (202...206))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (202...206) = "\#@@1"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@@1"
+        │   ├── opening_loc: (198...201) = "%w["
+        │   └── closing_loc: (207...208) = "]"
+        ├── @ XStringNode (location: (212...219))
+        │   ├── opening_loc: (212...215) = "%x{"
+        │   ├── content_loc: (215...218) = "\#@1"
+        │   ├── closing_loc: (218...219) = "}"
+        │   └── unescaped: "\#@1"
+        ├── @ XStringNode (location: (223...231))
+        │   ├── opening_loc: (223...226) = "%x{"
+        │   ├── content_loc: (226...230) = "\#@@1"
+        │   ├── closing_loc: (230...231) = "}"
+        │   └── unescaped: "\#@@1"
+        ├── @ StringNode (location: (235...241))
+        │   ├── opening_loc: (235...237) = "%{"
+        │   ├── content_loc: (237...240) = "\#@1"
+        │   ├── closing_loc: (240...241) = "}"
+        │   └── unescaped: "\#@1"
+        ├── @ StringNode (location: (245...252))
+        │   ├── opening_loc: (245...247) = "%{"
+        │   ├── content_loc: (247...251) = "\#@@1"
+        │   ├── closing_loc: (251...252) = "}"
+        │   └── unescaped: "\#@@1"
+        ├── @ StringNode (location: (256...261))
+        │   ├── opening_loc: (256...257) = "'"
+        │   ├── content_loc: (257...260) = "\#@1"
+        │   ├── closing_loc: (260...261) = "'"
+        │   └── unescaped: "\#@1"
+        ├── @ StringNode (location: (265...271))
+        │   ├── opening_loc: (265...266) = "'"
+        │   ├── content_loc: (266...270) = "\#@@1"
+        │   ├── closing_loc: (270...271) = "'"
+        │   └── unescaped: "\#@@1"
+        ├── @ RegularExpressionNode (location: (275...280))
+        │   ├── opening_loc: (275...276) = "/"
+        │   ├── content_loc: (276...279) = "\#@1"
+        │   ├── closing_loc: (279...280) = "/"
+        │   ├── unescaped: "\#@1"
+        │   └── flags: 
+        ├── @ RegularExpressionNode (location: (284...290))
+        │   ├── opening_loc: (284...285) = "/"
+        │   ├── content_loc: (285...289) = "\#@@1"
+        │   ├── closing_loc: (289...290) = "/"
+        │   ├── unescaped: "\#@@1"
+        │   └── flags: 
+        ├── @ SymbolNode (location: (294...300))
+        │   ├── opening_loc: (294...296) = ":\""
+        │   ├── value_loc: (296...299) = "\#@1"
+        │   ├── closing_loc: (299...300) = "\""
+        │   └── unescaped: "\#@1"
+        ├── @ SymbolNode (location: (304...311))
+        │   ├── opening_loc: (304...306) = ":\""
+        │   ├── value_loc: (306...310) = "\#@@1"
+        │   ├── closing_loc: (310...311) = "\""
+        │   └── unescaped: "\#@@1"
+        ├── @ SymbolNode (location: (315...321))
+        │   ├── opening_loc: (315...317) = ":'"
+        │   ├── value_loc: (317...320) = "\#@1"
+        │   ├── closing_loc: (320...321) = "'"
+        │   └── unescaped: "\#@1"
+        ├── @ SymbolNode (location: (325...332))
+        │   ├── opening_loc: (325...327) = ":'"
+        │   ├── value_loc: (327...331) = "\#@@1"
+        │   ├── closing_loc: (331...332) = "'"
+        │   └── unescaped: "\#@@1"
+        ├── @ XStringNode (location: (336...341))
+        │   ├── opening_loc: (336...337) = "`"
+        │   ├── content_loc: (337...340) = "\#@1"
+        │   ├── closing_loc: (340...341) = "`"
+        │   └── unescaped: "\#@1"
+        ├── @ XStringNode (location: (345...351))
+        │   ├── opening_loc: (345...346) = "`"
+        │   ├── content_loc: (346...350) = "\#@@1"
+        │   ├── closing_loc: (350...351) = "`"
+        │   └── unescaped: "\#@@1"
+        ├── @ InterpolatedStringNode (location: (354...363))
+        │   ├── opening_loc: (354...363) = "<<-\"HERE\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (364...368))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (364...368) = "\#@1\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@1\n"
+        │   └── closing_loc: (368...373) = "HERE\n"
+        ├── @ InterpolatedStringNode (location: (374...383))
+        │   ├── opening_loc: (374...383) = "<<-\"HERE\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (384...389))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (384...389) = "\#@@1\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@@1\n"
+        │   └── closing_loc: (389...394) = "HERE\n"
+        ├── @ InterpolatedStringNode (location: (395...404))
+        │   ├── opening_loc: (395...404) = "<<-'HERE'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (405...409))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (405...409) = "\#@1\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@1\n"
+        │   └── closing_loc: (409...414) = "HERE\n"
+        ├── @ InterpolatedStringNode (location: (415...424))
+        │   ├── opening_loc: (415...424) = "<<-'HERE'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (425...430))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (425...430) = "\#@@1\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@@1\n"
+        │   └── closing_loc: (430...435) = "HERE\n"
+        ├── @ InterpolatedXStringNode (location: (436...445))
+        │   ├── opening_loc: (436...445) = "<<-`HERE`"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (446...450))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (446...450) = "\#@1\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "\#@1\n"
+        │   └── closing_loc: (450...455) = "HERE\n"
+        └── @ InterpolatedXStringNode (location: (456...465))
+            ├── opening_loc: (456...465) = "<<-`HERE`"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (466...471))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (466...471) = "\#@@1\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\#@@1\n"
+            └── closing_loc: (471...476) = "HERE\n"
diff --git a/test/yarp/snapshots/whitequark/ivar.txt b/test/yarp/snapshots/whitequark/ivar.txt
index ae2c8c34b4..6f5a45e15a 100644
--- a/test/yarp/snapshots/whitequark/ivar.txt
+++ b/test/yarp/snapshots/whitequark/ivar.txt
@@ -1,4 +1,7 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)([InstanceVariableReadNode(0...4)(:@foo)])
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ InstanceVariableReadNode (location: (0...4))
+            └── name: :@foo
diff --git a/test/yarp/snapshots/whitequark/ivasgn.txt b/test/yarp/snapshots/whitequark/ivasgn.txt
index 8e952de246..653d93ae0a 100644
--- a/test/yarp/snapshots/whitequark/ivasgn.txt
+++ b/test/yarp/snapshots/whitequark/ivasgn.txt
@@ -1,11 +1,11 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [InstanceVariableWriteNode(0...9)(
-       :@var,
-       (0...4),
-       IntegerNode(7...9)(),
-       (5...6)
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ InstanceVariableWriteNode (location: (0...9))
+            ├── name: :@var
+            ├── name_loc: (0...4) = "@var"
+            ├── value:
+            │   @ IntegerNode (location: (7...9))
+            └── operator_loc: (5...6) = "="
diff --git a/test/yarp/snapshots/whitequark/keyword_argument_omission.txt b/test/yarp/snapshots/whitequark/keyword_argument_omission.txt
index c1b3b8800d..3efdfeab13 100644
--- a/test/yarp/snapshots/whitequark/keyword_argument_omission.txt
+++ b/test/yarp/snapshots/whitequark/keyword_argument_omission.txt
@@ -1,29 +1,37 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallNode(0...11)(
-       nil,
-       nil,
-       (0...3),
-       (3...4),
-       ArgumentsNode(4...10)(
-         [KeywordHashNode(4...10)(
-            [AssocNode(4...6)(
-               SymbolNode(4...6)(nil, (4...5), (5...6), "a"),
-               nil,
-               nil
-             ),
-             AssocNode(8...10)(
-               SymbolNode(8...10)(nil, (8...9), (9...10), "b"),
-               nil,
-               nil
-             )]
-          )]
-       ),
-       (10...11),
-       nil,
-       0,
-       "foo"
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...11))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "foo"
+            ├── opening_loc: (3...4) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...10))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (4...10))
+            │           └── elements: (length: 2)
+            │               ├── @ AssocNode (location: (4...6))
+            │               │   ├── key:
+            │               │   │   @ SymbolNode (location: (4...6))
+            │               │   │   ├── opening_loc: ∅
+            │               │   │   ├── value_loc: (4...5) = "a"
+            │               │   │   ├── closing_loc: (5...6) = ":"
+            │               │   │   └── unescaped: "a"
+            │               │   ├── value: ∅
+            │               │   └── operator_loc: ∅
+            │               └── @ AssocNode (location: (8...10))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (8...10))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (8...9) = "b"
+            │                   │   ├── closing_loc: (9...10) = ":"
+            │                   │   └── unescaped: "b"
+            │                   ├── value: ∅
+            │                   └── operator_loc: ∅
+            ├── closing_loc: (10...11) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "foo"
diff --git a/test/yarp/snapshots/whitequark/kwarg.txt b/test/yarp/snapshots/whitequark/kwarg.txt
index b63c7ac9f5..6552b4c405 100644
--- a/test/yarp/snapshots/whitequark/kwarg.txt
+++ b/test/yarp/snapshots/whitequark/kwarg.txt
@@ -1,27 +1,30 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [DefNode(0...16)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...10)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...10)(:foo, (6...10), nil)],
-         nil,
-         nil
-       ),
-       nil,
-       [:foo],
-       (0...3),
-       nil,
-       (5...6),
-       (10...11),
-       nil,
-       (13...16)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...16))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...10))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (6...10))
+            │   │       ├── name: :foo
+            │   │       ├── name_loc: (6...10) = "foo:"
+            │   │       └── value: ∅
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:foo]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (10...11) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (13...16) = "end"
diff --git a/test/yarp/snapshots/whitequark/kwbegin_compstmt.txt b/test/yarp/snapshots/whitequark/kwbegin_compstmt.txt
index 0d05407aad..82468dc388 100644
--- a/test/yarp/snapshots/whitequark/kwbegin_compstmt.txt
+++ b/test/yarp/snapshots/whitequark/kwbegin_compstmt.txt
@@ -1,26 +1,34 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [BeginNode(0...20)(
-       (0...5),
-       StatementsNode(6...16)(
-         [CallNode(6...10)(nil, nil, (6...10), nil, nil, nil, nil, 0, "foo!"),
-          CallNode(12...16)(
-            nil,
-            nil,
-            (12...16),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "bar!"
-          )]
-       ),
-       nil,
-       nil,
-       nil,
-       (17...20)
-     )]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...20))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (6...16))
+            │   └── body: (length: 2)
+            │       ├── @ CallNode (location: (6...10))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (6...10) = "foo!"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: 
+            │       │   └── name: "foo!"
+            │       └── @ CallNode (location: (12...16))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (12...16) = "bar!"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar!"
+            ├── rescue_clause: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (17...20) = "end"
diff --git a/test/yarp/snapshots/whitequark/kwnilarg.txt b/test/yarp/snapshots/whitequark/kwnilarg.txt
index 402d0d3fb2..7db20c2b3c 100644
--- a/test/yarp/snapshots/whitequark/kwnilarg.txt
+++ b/test/yarp/snapshots/whitequark/kwnilarg.txt
@@ -1,78 +1,84 @@
-ProgramNode(0...46)(
-  [],
-  StatementsNode(0...46)(
-    [LambdaNode(0...12)(
-       [],
-       (0...2),
-       (10...11),
-       (11...12),
-       BlockParametersNode(2...9)(
-         ParametersNode(3...8)(
-           [],
-           [],
-           [],
-           nil,
-           [],
-           NoKeywordsParameterNode(3...8)((3...5), (5...8)),
-           nil
-         ),
-         [],
-         (2...3),
-         (8...9)
-       ),
-       nil
-     ),
-     DefNode(14...31)(
-       :f,
-       (18...19),
-       nil,
-       ParametersNode(20...25)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         NoKeywordsParameterNode(20...25)((20...22), (22...25)),
-         nil
-       ),
-       nil,
-       [],
-       (14...17),
-       nil,
-       (19...20),
-       (25...26),
-       nil,
-       (28...31)
-     ),
-     CallNode(33...46)(
-       nil,
-       nil,
-       (33...34),
-       nil,
-       nil,
-       nil,
-       BlockNode(35...46)(
-         [],
-         BlockParametersNode(37...44)(
-           ParametersNode(38...43)(
-             [],
-             [],
-             [],
-             nil,
-             [],
-             NoKeywordsParameterNode(38...43)((38...40), (40...43)),
-             nil
-           ),
-           [],
-           (37...38),
-           (43...44)
-         ),
-         nil,
-         (35...36),
-         (45...46)
-       ),
-       0,
-       "m"
-     )]
-  )
-)
+@ ProgramNode (location: (0...46))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...46))
+    └── body: (length: 3)
+        ├── @ LambdaNode (location: (0...12))
+        │   ├── locals: []
+        │   ├── operator_loc: (0...2) = "->"
+        │   ├── opening_loc: (10...11) = "{"
+        │   ├── closing_loc: (11...12) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (2...9))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (3...8))
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest:
+        │   │   │   │   @ NoKeywordsParameterNode (location: (3...8))
+        │   │   │   │   ├── operator_loc: (3...5) = "**"
+        │   │   │   │   └── keyword_loc: (5...8) = "nil"
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (2...3) = "("
+        │   │   └── closing_loc: (8...9) = ")"
+        │   └── body: ∅
+        ├── @ DefNode (location: (14...31))
+        │   ├── name: :f
+        │   ├── name_loc: (18...19) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (20...25))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ NoKeywordsParameterNode (location: (20...25))
+        │   │   │   ├── operator_loc: (20...22) = "**"
+        │   │   │   └── keyword_loc: (22...25) = "nil"
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (14...17) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (19...20) = "("
+        │   ├── rparen_loc: (25...26) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (28...31) = "end"
+        └── @ CallNode (location: (33...46))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (33...34) = "m"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (35...46))
+            │   ├── locals: []
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (37...44))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (38...43))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest:
+            │   │   │   │   @ NoKeywordsParameterNode (location: (38...43))
+            │   │   │   │   ├── operator_loc: (38...40) = "**"
+            │   │   │   │   └── keyword_loc: (40...43) = "nil"
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (37...38) = "|"
+            │   │   └── closing_loc: (43...44) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (35...36) = "{"
+            │   └── closing_loc: (45...46) = "}"
+            ├── flags: 
+            └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/kwoptarg.txt b/test/yarp/snapshots/whitequark/kwoptarg.txt
index 06ad798523..b25ce1dee9 100644
--- a/test/yarp/snapshots/whitequark/kwoptarg.txt
+++ b/test/yarp/snapshots/whitequark/kwoptarg.txt
@@ -1,31 +1,31 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [DefNode(0...18)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...12)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...12)(
-            :foo,
-            (6...10),
-            IntegerNode(11...12)()
-          )],
-         nil,
-         nil
-       ),
-       nil,
-       [:foo],
-       (0...3),
-       nil,
-       (5...6),
-       (12...13),
-       nil,
-       (15...18)
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...18))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...12))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (6...12))
+            │   │       ├── name: :foo
+            │   │       ├── name_loc: (6...10) = "foo:"
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (11...12))
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:foo]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (12...13) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (15...18) = "end"
diff --git a/test/yarp/snapshots/whitequark/kwoptarg_with_kwrestarg_and_forwarded_args.txt b/test/yarp/snapshots/whitequark/kwoptarg_with_kwrestarg_and_forwarded_args.txt
index dfc20df0b4..44a5d4b03b 100644
--- a/test/yarp/snapshots/whitequark/kwoptarg_with_kwrestarg_and_forwarded_args.txt
+++ b/test/yarp/snapshots/whitequark/kwoptarg_with_kwrestarg_and_forwarded_args.txt
@@ -1,43 +1,54 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [DefNode(0...28)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...16)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...12)(:a, (6...8), NilNode(9...12)())],
-         KeywordRestParameterNode(14...16)(nil, nil, (14...16)),
-         nil
-       ),
-       StatementsNode(19...24)(
-         [CallNode(19...24)(
-            nil,
-            nil,
-            (19...20),
-            (20...21),
-            ArgumentsNode(21...23)(
-              [KeywordHashNode(21...23)(
-                 [AssocSplatNode(21...23)(nil, (21...23))]
-               )]
-            ),
-            (23...24),
-            nil,
-            0,
-            "b"
-          )]
-       ),
-       [:a, :**],
-       (0...3),
-       nil,
-       (5...6),
-       (16...17),
-       nil,
-       (25...28)
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...28))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...16))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 1)
+            │   │   └── @ KeywordParameterNode (location: (6...12))
+            │   │       ├── name: :a
+            │   │       ├── name_loc: (6...8) = "a:"
+            │   │       └── value:
+            │   │           @ NilNode (location: (9...12))
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (14...16))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (14...16) = "**"
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (19...24))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (19...24))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (19...20) = "b"
+            │           ├── opening_loc: (20...21) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (21...23))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ KeywordHashNode (location: (21...23))
+            │           │           └── elements: (length: 1)
+            │           │               └── @ AssocSplatNode (location: (21...23))
+            │           │                   ├── value: ∅
+            │           │                   └── operator_loc: (21...23) = "**"
+            │           ├── closing_loc: (23...24) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "b"
+            ├── locals: [:a, :**]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (16...17) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (25...28) = "end"
diff --git a/test/yarp/snapshots/whitequark/kwrestarg_named.txt b/test/yarp/snapshots/whitequark/kwrestarg_named.txt
index cf0086619f..59b2b4d3ac 100644
--- a/test/yarp/snapshots/whitequark/kwrestarg_named.txt
+++ b/test/yarp/snapshots/whitequark/kwrestarg_named.txt
@@ -1,27 +1,30 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [DefNode(0...17)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...11)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(6...11)(:foo, (8...11), (6...8)),
-         nil
-       ),
-       nil,
-       [:foo],
-       (0...3),
-       nil,
-       (5...6),
-       (11...12),
-       nil,
-       (14...17)
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...17))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...11))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (6...11))
+            │   │   ├── name: :foo
+            │   │   ├── name_loc: (8...11) = "foo"
+            │   │   └── operator_loc: (6...8) = "**"
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:foo]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (11...12) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (14...17) = "end"
diff --git a/test/yarp/snapshots/whitequark/kwrestarg_unnamed.txt b/test/yarp/snapshots/whitequark/kwrestarg_unnamed.txt
index e59e72c304..e85e700313 100644
--- a/test/yarp/snapshots/whitequark/kwrestarg_unnamed.txt
+++ b/test/yarp/snapshots/whitequark/kwrestarg_unnamed.txt
@@ -1,27 +1,30 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [DefNode(0...14)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...8)(
-         [],
-         [],
-         [],
-         nil,
-         [],
-         KeywordRestParameterNode(6...8)(nil, nil, (6...8)),
-         nil
-       ),
-       nil,
-       [:**],
-       (0...3),
-       nil,
-       (5...6),
-       (8...9),
-       nil,
-       (11...14)
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...14))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...8))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ KeywordRestParameterNode (location: (6...8))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (6...8) = "**"
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:**]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (8...9) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (11...14) = "end"
diff --git a/test/yarp/snapshots/whitequark/lbrace_arg_after_command_args.txt b/test/yarp/snapshots/whitequark/lbrace_arg_after_command_args.txt
index 0b2c12417d..3ceaa20b2d 100644
--- a/test/yarp/snapshots/whitequark/lbrace_arg_after_command_args.txt
+++ b/test/yarp/snapshots/whitequark/lbrace_arg_after_command_args.txt
@@ -1,42 +1,52 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [CallNode(0...22)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...8)(
-         [ParenthesesNode(4...8)(
-            StatementsNode(5...7)(
-              [SymbolNode(5...7)((5...6), (6...7), nil, "a")]
-            ),
-            (4...5),
-            (7...8)
-          )]
-       ),
-       nil,
-       BlockNode(9...22)(
-         [],
-         nil,
-         StatementsNode(11...20)(
-           [CallNode(11...20)(
-              nil,
-              nil,
-              (11...12),
-              nil,
-              nil,
-              nil,
-              BlockNode(13...20)([], nil, nil, (13...15), (17...20)),
-              0,
-              "m"
-            )]
-         ),
-         (9...10),
-         (21...22)
-       ),
-       0,
-       "let"
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...22))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "let"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...8))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (4...8))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (5...7))
+            │           │   └── body: (length: 1)
+            │           │       └── @ SymbolNode (location: (5...7))
+            │           │           ├── opening_loc: (5...6) = ":"
+            │           │           ├── value_loc: (6...7) = "a"
+            │           │           ├── closing_loc: ∅
+            │           │           └── unescaped: "a"
+            │           ├── opening_loc: (4...5) = "("
+            │           └── closing_loc: (7...8) = ")"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (9...22))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (11...20))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (11...20))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (11...12) = "m"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block:
+            │   │           │   @ BlockNode (location: (13...20))
+            │   │           │   ├── locals: []
+            │   │           │   ├── parameters: ∅
+            │   │           │   ├── body: ∅
+            │   │           │   ├── opening_loc: (13...15) = "do"
+            │   │           │   └── closing_loc: (17...20) = "end"
+            │   │           ├── flags: 
+            │   │           └── name: "m"
+            │   ├── opening_loc: (9...10) = "{"
+            │   └── closing_loc: (21...22) = "}"
+            ├── flags: 
+            └── name: "let"
diff --git a/test/yarp/snapshots/whitequark/lparenarg_after_lvar__since_25.txt b/test/yarp/snapshots/whitequark/lparenarg_after_lvar__since_25.txt
index 027c04f092..c84366fd23 100644
--- a/test/yarp/snapshots/whitequark/lparenarg_after_lvar__since_25.txt
+++ b/test/yarp/snapshots/whitequark/lparenarg_after_lvar__since_25.txt
@@ -1,59 +1,63 @@
-ProgramNode(0...31)(
-  [],
-  StatementsNode(0...31)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...14)(
-         [CallNode(4...14)(
-            ParenthesesNode(4...10)(
-              StatementsNode(5...9)([FloatNode(5...9)()]),
-              (4...5),
-              (9...10)
-            ),
-            (10...11),
-            (11...14),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "abs"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "foo"
-     ),
-     CallNode(16...31)(
-       nil,
-       nil,
-       (16...20),
-       nil,
-       ArgumentsNode(21...31)(
-         [CallNode(21...31)(
-            ParenthesesNode(21...27)(
-              StatementsNode(22...26)([FloatNode(22...26)()]),
-              (21...22),
-              (26...27)
-            ),
-            (27...28),
-            (28...31),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "abs"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "meth"
-     )]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...14))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (4...14))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (4...14))
+        │   │           ├── receiver:
+        │   │           │   @ ParenthesesNode (location: (4...10))
+        │   │           │   ├── body:
+        │   │           │   │   @ StatementsNode (location: (5...9))
+        │   │           │   │   └── body: (length: 1)
+        │   │           │   │       └── @ FloatNode (location: (5...9))
+        │   │           │   ├── opening_loc: (4...5) = "("
+        │   │           │   └── closing_loc: (9...10) = ")"
+        │   │           ├── call_operator_loc: (10...11) = "."
+        │   │           ├── message_loc: (11...14) = "abs"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: 
+        │   │           └── name: "abs"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "foo"
+        └── @ CallNode (location: (16...31))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (16...20) = "meth"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (21...31))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (21...31))
+            │           ├── receiver:
+            │           │   @ ParenthesesNode (location: (21...27))
+            │           │   ├── body:
+            │           │   │   @ StatementsNode (location: (22...26))
+            │           │   │   └── body: (length: 1)
+            │           │   │       └── @ FloatNode (location: (22...26))
+            │           │   ├── opening_loc: (21...22) = "("
+            │           │   └── closing_loc: (26...27) = ")"
+            │           ├── call_operator_loc: (27...28) = "."
+            │           ├── message_loc: (28...31) = "abs"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "abs"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "meth"
diff --git a/test/yarp/snapshots/whitequark/lvar.txt b/test/yarp/snapshots/whitequark/lvar.txt
index 24f27ad073..cab1da577b 100644
--- a/test/yarp/snapshots/whitequark/lvar.txt
+++ b/test/yarp/snapshots/whitequark/lvar.txt
@@ -1,6 +1,15 @@
-ProgramNode(0...3)(
-  [],
-  StatementsNode(0...3)(
-    [CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo")]
-  )
-)
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...3))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "foo"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: variable_call
+            └── name: "foo"
diff --git a/test/yarp/snapshots/whitequark/lvar_injecting_match.txt b/test/yarp/snapshots/whitequark/lvar_injecting_match.txt
index 924b997bc7..6213094721 100644
--- a/test/yarp/snapshots/whitequark/lvar_injecting_match.txt
+++ b/test/yarp/snapshots/whitequark/lvar_injecting_match.txt
@@ -1,25 +1,31 @@
-ProgramNode(0...31)(
-  [:match],
-  StatementsNode(0...31)(
-    [CallNode(0...24)(
-       RegularExpressionNode(0...15)(
-         (0...1),
-         (1...14),
-         (14...15),
-         "(?<match>bar)",
-         0
-       ),
-       nil,
-       (16...18),
-       nil,
-       ArgumentsNode(19...24)(
-         [StringNode(19...24)((19...20), (20...23), (23...24), "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "=~"
-     ),
-     LocalVariableReadNode(26...31)(:match, 0)]
-  )
-)
+@ ProgramNode (location: (0...31))
+├── locals: [:match]
+└── statements:
+    @ StatementsNode (location: (0...31))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...24))
+        │   ├── receiver:
+        │   │   @ RegularExpressionNode (location: (0...15))
+        │   │   ├── opening_loc: (0...1) = "/"
+        │   │   ├── content_loc: (1...14) = "(?<match>bar)"
+        │   │   ├── closing_loc: (14...15) = "/"
+        │   │   ├── unescaped: "(?<match>bar)"
+        │   │   └── flags: 
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (16...18) = "=~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (19...24))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ StringNode (location: (19...24))
+        │   │           ├── opening_loc: (19...20) = "'"
+        │   │           ├── content_loc: (20...23) = "bar"
+        │   │           ├── closing_loc: (23...24) = "'"
+        │   │           └── unescaped: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=~"
+        └── @ LocalVariableReadNode (location: (26...31))
+            ├── name: :match
+            └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/lvasgn.txt b/test/yarp/snapshots/whitequark/lvasgn.txt
index bb762001ba..0c968b9830 100644
--- a/test/yarp/snapshots/whitequark/lvasgn.txt
+++ b/test/yarp/snapshots/whitequark/lvasgn.txt
@@ -1,13 +1,15 @@
-ProgramNode(0...13)(
-  [:var],
-  StatementsNode(0...13)(
-    [LocalVariableWriteNode(0...8)(
-       :var,
-       0,
-       (0...3),
-       IntegerNode(6...8)(),
-       (4...5)
-     ),
-     LocalVariableReadNode(10...13)(:var, 0)]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: [:var]
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 2)
+        ├── @ LocalVariableWriteNode (location: (0...8))
+        │   ├── name: :var
+        │   ├── depth: 0
+        │   ├── name_loc: (0...3) = "var"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (6...8))
+        │   └── operator_loc: (4...5) = "="
+        └── @ LocalVariableReadNode (location: (10...13))
+            ├── name: :var
+            └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/masgn.txt b/test/yarp/snapshots/whitequark/masgn.txt
index 419d68ee7b..301544a653 100644
--- a/test/yarp/snapshots/whitequark/masgn.txt
+++ b/test/yarp/snapshots/whitequark/masgn.txt
@@ -1,42 +1,62 @@
-ProgramNode(0...56)(
-  [:foo, :bar, :baz],
-  StatementsNode(0...56)(
-    [MultiWriteNode(0...17)(
-       [LocalVariableTargetNode(1...4)(:foo, 0),
-        LocalVariableTargetNode(6...9)(:bar, 0)],
-       (0...1),
-       (9...10),
-       (11...12),
-       ArrayNode(13...17)(
-         [IntegerNode(13...14)(), IntegerNode(16...17)()],
-         nil,
-         nil
-       )
-     ),
-     MultiWriteNode(19...34)(
-       [LocalVariableTargetNode(19...22)(:foo, 0),
-        LocalVariableTargetNode(24...27)(:bar, 0)],
-       nil,
-       nil,
-       (28...29),
-       ArrayNode(30...34)(
-         [IntegerNode(30...31)(), IntegerNode(33...34)()],
-         nil,
-         nil
-       )
-     ),
-     MultiWriteNode(36...56)(
-       [LocalVariableTargetNode(36...39)(:foo, 0),
-        LocalVariableTargetNode(41...44)(:bar, 0),
-        LocalVariableTargetNode(46...49)(:baz, 0)],
-       nil,
-       nil,
-       (50...51),
-       ArrayNode(52...56)(
-         [IntegerNode(52...53)(), IntegerNode(55...56)()],
-         nil,
-         nil
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...56))
+├── locals: [:foo, :bar, :baz]
+└── statements:
+    @ StatementsNode (location: (0...56))
+    └── body: (length: 3)
+        ├── @ MultiWriteNode (location: (0...17))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (1...4))
+        │   │   │   ├── name: :foo
+        │   │   │   └── depth: 0
+        │   │   └── @ LocalVariableTargetNode (location: (6...9))
+        │   │       ├── name: :bar
+        │   │       └── depth: 0
+        │   ├── lparen_loc: (0...1) = "("
+        │   ├── rparen_loc: (9...10) = ")"
+        │   ├── operator_loc: (11...12) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (13...17))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (13...14))
+        │       │   └── @ IntegerNode (location: (16...17))
+        │       ├── opening_loc: ∅
+        │       └── closing_loc: ∅
+        ├── @ MultiWriteNode (location: (19...34))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (19...22))
+        │   │   │   ├── name: :foo
+        │   │   │   └── depth: 0
+        │   │   └── @ LocalVariableTargetNode (location: (24...27))
+        │   │       ├── name: :bar
+        │   │       └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (28...29) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (30...34))
+        │       ├── elements: (length: 2)
+        │       │   ├── @ IntegerNode (location: (30...31))
+        │       │   └── @ IntegerNode (location: (33...34))
+        │       ├── opening_loc: ∅
+        │       └── closing_loc: ∅
+        └── @ MultiWriteNode (location: (36...56))
+            ├── targets: (length: 3)
+            │   ├── @ LocalVariableTargetNode (location: (36...39))
+            │   │   ├── name: :foo
+            │   │   └── depth: 0
+            │   ├── @ LocalVariableTargetNode (location: (41...44))
+            │   │   ├── name: :bar
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (46...49))
+            │       ├── name: :baz
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (50...51) = "="
+            └── value:
+                @ ArrayNode (location: (52...56))
+                ├── elements: (length: 2)
+                │   ├── @ IntegerNode (location: (52...53))
+                │   └── @ IntegerNode (location: (55...56))
+                ├── opening_loc: ∅
+                └── closing_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/masgn_attr.txt b/test/yarp/snapshots/whitequark/masgn_attr.txt
index 5ad893c96d..ac43b74c38 100644
--- a/test/yarp/snapshots/whitequark/masgn_attr.txt
+++ b/test/yarp/snapshots/whitequark/masgn_attr.txt
@@ -1,71 +1,86 @@
-ProgramNode(0...63)(
-  [:foo],
-  StatementsNode(0...63)(
-    [MultiWriteNode(0...17)(
-       [CallNode(0...6)(
-          SelfNode(0...4)(),
-          (4...5),
-          (5...6),
-          nil,
-          nil,
-          nil,
-          nil,
-          0,
-          "A="
-        ),
-        LocalVariableTargetNode(8...11)(:foo, 0)],
-       nil,
-       nil,
-       (12...13),
-       LocalVariableReadNode(14...17)(:foo, 0)
-     ),
-     MultiWriteNode(19...43)(
-       [CallNode(19...25)(
-          SelfNode(19...23)(),
-          (23...24),
-          (24...25),
-          nil,
-          nil,
-          nil,
-          nil,
-          0,
-          "a="
-        ),
-        CallNode(27...37)(
-          SelfNode(27...31)(),
-          nil,
-          (31...37),
-          (31...32),
-          ArgumentsNode(32...36)(
-            [IntegerNode(32...33)(), IntegerNode(35...36)()]
-          ),
-          (36...37),
-          nil,
-          0,
-          "[]="
-        )],
-       nil,
-       nil,
-       (38...39),
-       LocalVariableReadNode(40...43)(:foo, 0)
-     ),
-     MultiWriteNode(45...63)(
-       [CallNode(45...52)(
-          SelfNode(45...49)(),
-          (49...51),
-          (51...52),
-          nil,
-          nil,
-          nil,
-          nil,
-          0,
-          "a="
-        ),
-        LocalVariableTargetNode(54...57)(:foo, 0)],
-       nil,
-       nil,
-       (58...59),
-       LocalVariableReadNode(60...63)(:foo, 0)
-     )]
-  )
-)
+@ ProgramNode (location: (0...63))
+├── locals: [:foo]
+└── statements:
+    @ StatementsNode (location: (0...63))
+    └── body: (length: 3)
+        ├── @ MultiWriteNode (location: (0...17))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ CallNode (location: (0...6))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ SelfNode (location: (0...4))
+        │   │   │   ├── call_operator_loc: (4...5) = "."
+        │   │   │   ├── message_loc: (5...6) = "A"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "A="
+        │   │   └── @ LocalVariableTargetNode (location: (8...11))
+        │   │       ├── name: :foo
+        │   │       └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (12...13) = "="
+        │   └── value:
+        │       @ LocalVariableReadNode (location: (14...17))
+        │       ├── name: :foo
+        │       └── depth: 0
+        ├── @ MultiWriteNode (location: (19...43))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ CallNode (location: (19...25))
+        │   │   │   ├── receiver:
+        │   │   │   │   @ SelfNode (location: (19...23))
+        │   │   │   ├── call_operator_loc: (23...24) = "."
+        │   │   │   ├── message_loc: (24...25) = "a"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "a="
+        │   │   └── @ CallNode (location: (27...37))
+        │   │       ├── receiver:
+        │   │       │   @ SelfNode (location: (27...31))
+        │   │       ├── call_operator_loc: ∅
+        │   │       ├── message_loc: (31...37) = "[1, 2]"
+        │   │       ├── opening_loc: (31...32) = "["
+        │   │       ├── arguments:
+        │   │       │   @ ArgumentsNode (location: (32...36))
+        │   │       │   └── arguments: (length: 2)
+        │   │       │       ├── @ IntegerNode (location: (32...33))
+        │   │       │       └── @ IntegerNode (location: (35...36))
+        │   │       ├── closing_loc: (36...37) = "]"
+        │   │       ├── block: ∅
+        │   │       ├── flags: 
+        │   │       └── name: "[]="
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (38...39) = "="
+        │   └── value:
+        │       @ LocalVariableReadNode (location: (40...43))
+        │       ├── name: :foo
+        │       └── depth: 0
+        └── @ MultiWriteNode (location: (45...63))
+            ├── targets: (length: 2)
+            │   ├── @ CallNode (location: (45...52))
+            │   │   ├── receiver:
+            │   │   │   @ SelfNode (location: (45...49))
+            │   │   ├── call_operator_loc: (49...51) = "::"
+            │   │   ├── message_loc: (51...52) = "a"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "a="
+            │   └── @ LocalVariableTargetNode (location: (54...57))
+            │       ├── name: :foo
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (58...59) = "="
+            └── value:
+                @ LocalVariableReadNode (location: (60...63))
+                ├── name: :foo
+                └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/masgn_cmd.txt b/test/yarp/snapshots/whitequark/masgn_cmd.txt
index 5b9b9b03ce..4abcb4ca9f 100644
--- a/test/yarp/snapshots/whitequark/masgn_cmd.txt
+++ b/test/yarp/snapshots/whitequark/masgn_cmd.txt
@@ -1,23 +1,32 @@
-ProgramNode(0...16)(
-  [:foo, :bar],
-  StatementsNode(0...16)(
-    [MultiWriteNode(0...16)(
-       [LocalVariableTargetNode(0...3)(:foo, 0),
-        LocalVariableTargetNode(5...8)(:bar, 0)],
-       nil,
-       nil,
-       (9...10),
-       CallNode(11...16)(
-         nil,
-         nil,
-         (11...12),
-         nil,
-         ArgumentsNode(13...16)([LocalVariableReadNode(13...16)(:foo, 0)]),
-         nil,
-         nil,
-         0,
-         "m"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: [:foo, :bar]
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...16))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (0...3))
+            │   │   ├── name: :foo
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (5...8))
+            │       ├── name: :bar
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (9...10) = "="
+            └── value:
+                @ CallNode (location: (11...16))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (11...12) = "m"
+                ├── opening_loc: ∅
+                ├── arguments:
+                │   @ ArgumentsNode (location: (13...16))
+                │   └── arguments: (length: 1)
+                │       └── @ LocalVariableReadNode (location: (13...16))
+                │           ├── name: :foo
+                │           └── depth: 0
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/masgn_const.txt b/test/yarp/snapshots/whitequark/masgn_const.txt
index 8515552618..ed6f4b151c 100644
--- a/test/yarp/snapshots/whitequark/masgn_const.txt
+++ b/test/yarp/snapshots/whitequark/masgn_const.txt
@@ -1,29 +1,42 @@
-ProgramNode(0...34)(
-  [:foo],
-  StatementsNode(0...34)(
-    [MultiWriteNode(0...14)(
-       [ConstantPathTargetNode(0...3)(
-          nil,
-          ConstantReadNode(2...3)(:A),
-          (0...2)
-        ),
-        LocalVariableTargetNode(5...8)(:foo, 0)],
-       nil,
-       nil,
-       (9...10),
-       LocalVariableReadNode(11...14)(:foo, 0)
-     ),
-     MultiWriteNode(16...34)(
-       [ConstantPathTargetNode(16...23)(
-          SelfNode(16...20)(),
-          ConstantReadNode(22...23)(:A),
-          (20...22)
-        ),
-        LocalVariableTargetNode(25...28)(:foo, 0)],
-       nil,
-       nil,
-       (29...30),
-       LocalVariableReadNode(31...34)(:foo, 0)
-     )]
-  )
-)
+@ ProgramNode (location: (0...34))
+├── locals: [:foo]
+└── statements:
+    @ StatementsNode (location: (0...34))
+    └── body: (length: 2)
+        ├── @ MultiWriteNode (location: (0...14))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ ConstantPathTargetNode (location: (0...3))
+        │   │   │   ├── parent: ∅
+        │   │   │   ├── child:
+        │   │   │   │   @ ConstantReadNode (location: (2...3))
+        │   │   │   │   └── name: :A
+        │   │   │   └── delimiter_loc: (0...2) = "::"
+        │   │   └── @ LocalVariableTargetNode (location: (5...8))
+        │   │       ├── name: :foo
+        │   │       └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (9...10) = "="
+        │   └── value:
+        │       @ LocalVariableReadNode (location: (11...14))
+        │       ├── name: :foo
+        │       └── depth: 0
+        └── @ MultiWriteNode (location: (16...34))
+            ├── targets: (length: 2)
+            │   ├── @ ConstantPathTargetNode (location: (16...23))
+            │   │   ├── parent:
+            │   │   │   @ SelfNode (location: (16...20))
+            │   │   ├── child:
+            │   │   │   @ ConstantReadNode (location: (22...23))
+            │   │   │   └── name: :A
+            │   │   └── delimiter_loc: (20...22) = "::"
+            │   └── @ LocalVariableTargetNode (location: (25...28))
+            │       ├── name: :foo
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (29...30) = "="
+            └── value:
+                @ LocalVariableReadNode (location: (31...34))
+                ├── name: :foo
+                └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/masgn_nested.txt b/test/yarp/snapshots/whitequark/masgn_nested.txt
index 00f4eb1ef4..30982bf9b7 100644
--- a/test/yarp/snapshots/whitequark/masgn_nested.txt
+++ b/test/yarp/snapshots/whitequark/masgn_nested.txt
@@ -1,30 +1,60 @@
-ProgramNode(1...30)(
-  [:b, :a, :c],
-  StatementsNode(1...30)(
-    [MultiWriteNode(1...13)(
-       [MultiTargetNode(1...6)(
-          [LocalVariableTargetNode(2...3)(:b, 0),
-           SplatNode(3...4)((3...4), nil)],
-          (1...2),
-          (5...6)
-        )],
-       nil,
-       nil,
-       (8...9),
-       CallNode(10...13)(nil, nil, (10...13), nil, nil, nil, nil, 2, "foo")
-     ),
-     MultiWriteNode(15...30)(
-       [LocalVariableTargetNode(15...16)(:a, 0),
-        MultiTargetNode(18...24)(
-          [LocalVariableTargetNode(19...20)(:b, 0),
-           LocalVariableTargetNode(22...23)(:c, 0)],
-          (18...19),
-          (23...24)
-        )],
-       nil,
-       nil,
-       (25...26),
-       CallNode(27...30)(nil, nil, (27...30), nil, nil, nil, nil, 2, "foo")
-     )]
-  )
-)
+@ ProgramNode (location: (1...30))
+├── locals: [:b, :a, :c]
+└── statements:
+    @ StatementsNode (location: (1...30))
+    └── body: (length: 2)
+        ├── @ MultiWriteNode (location: (1...13))
+        │   ├── targets: (length: 1)
+        │   │   └── @ MultiTargetNode (location: (1...6))
+        │   │       ├── targets: (length: 2)
+        │   │       │   ├── @ LocalVariableTargetNode (location: (2...3))
+        │   │       │   │   ├── name: :b
+        │   │       │   │   └── depth: 0
+        │   │       │   └── @ SplatNode (location: (3...4))
+        │   │       │       ├── operator_loc: (3...4) = ","
+        │   │       │       └── expression: ∅
+        │   │       ├── lparen_loc: (1...2) = "("
+        │   │       └── rparen_loc: (5...6) = ")"
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (8...9) = "="
+        │   └── value:
+        │       @ CallNode (location: (10...13))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (10...13) = "foo"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "foo"
+        └── @ MultiWriteNode (location: (15...30))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (15...16))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   └── @ MultiTargetNode (location: (18...24))
+            │       ├── targets: (length: 2)
+            │       │   ├── @ LocalVariableTargetNode (location: (19...20))
+            │       │   │   ├── name: :b
+            │       │   │   └── depth: 0
+            │       │   └── @ LocalVariableTargetNode (location: (22...23))
+            │       │       ├── name: :c
+            │       │       └── depth: 0
+            │       ├── lparen_loc: (18...19) = "("
+            │       └── rparen_loc: (23...24) = ")"
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (25...26) = "="
+            └── value:
+                @ CallNode (location: (27...30))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (27...30) = "foo"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "foo"
diff --git a/test/yarp/snapshots/whitequark/masgn_splat.txt b/test/yarp/snapshots/whitequark/masgn_splat.txt
index c6cbe9ee70..ef0b003988 100644
--- a/test/yarp/snapshots/whitequark/masgn_splat.txt
+++ b/test/yarp/snapshots/whitequark/masgn_splat.txt
@@ -1,147 +1,270 @@
-ProgramNode(0...139)(
-  [:c, :d, :b, :a],
-  StatementsNode(0...139)(
-    [MultiWriteNode(0...7)(
-       [SplatNode(0...1)((0...1), nil)],
-       nil,
-       nil,
-       (2...3),
-       CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "bar")
-     ),
-     MultiWriteNode(9...22)(
-       [MultiTargetNode(9...10)([SplatNode(9...10)((9...10), nil)], nil, nil),
-        LocalVariableTargetNode(12...13)(:c, 0),
-        LocalVariableTargetNode(15...16)(:d, 0)],
-       nil,
-       nil,
-       (17...18),
-       CallNode(19...22)(nil, nil, (19...22), nil, nil, nil, nil, 2, "bar")
-     ),
-     MultiWriteNode(24...32)(
-       [SplatNode(24...26)(
-          (24...25),
-          LocalVariableTargetNode(25...26)(:b, 0)
-        )],
-       nil,
-       nil,
-       (27...28),
-       CallNode(29...32)(nil, nil, (29...32), nil, nil, nil, nil, 2, "bar")
-     ),
-     MultiWriteNode(34...45)(
-       [MultiTargetNode(34...36)(
-          [SplatNode(34...36)(
-             (34...35),
-             LocalVariableTargetNode(35...36)(:b, 0)
-           )],
-          nil,
-          nil
-        ),
-        LocalVariableTargetNode(38...39)(:c, 0)],
-       nil,
-       nil,
-       (40...41),
-       CallNode(42...45)(nil, nil, (42...45), nil, nil, nil, nil, 2, "bar")
-     ),
-     MultiWriteNode(47...65)(
-       [InstanceVariableTargetNode(47...51)(:@foo),
-        ClassVariableTargetNode(53...58)(:@@bar)],
-       nil,
-       nil,
-       (59...60),
-       ArrayNode(61...65)(
-         [SplatNode(61...65)(
-            (61...62),
-            CallNode(62...65)(
-              nil,
-              nil,
-              (62...65),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )
-          )],
-         nil,
-         nil
-       )
-     ),
-     MultiWriteNode(67...77)(
-       [LocalVariableTargetNode(67...68)(:a, 0),
-        SplatNode(70...71)((70...71), nil)],
-       nil,
-       nil,
-       (72...73),
-       CallNode(74...77)(nil, nil, (74...77), nil, nil, nil, nil, 2, "bar")
-     ),
-     MultiWriteNode(79...92)(
-       [LocalVariableTargetNode(79...80)(:a, 0),
-        SplatNode(82...83)((82...83), nil),
-        LocalVariableTargetNode(85...86)(:c, 0)],
-       nil,
-       nil,
-       (87...88),
-       CallNode(89...92)(nil, nil, (89...92), nil, nil, nil, nil, 2, "bar")
-     ),
-     MultiWriteNode(94...105)(
-       [LocalVariableTargetNode(94...95)(:a, 0),
-        SplatNode(97...99)(
-          (97...98),
-          LocalVariableTargetNode(98...99)(:b, 0)
-        )],
-       nil,
-       nil,
-       (100...101),
-       CallNode(102...105)(nil, nil, (102...105), nil, nil, nil, nil, 2, "bar")
-     ),
-     MultiWriteNode(107...121)(
-       [LocalVariableTargetNode(107...108)(:a, 0),
-        SplatNode(110...112)(
-          (110...111),
-          LocalVariableTargetNode(111...112)(:b, 0)
-        ),
-        LocalVariableTargetNode(114...115)(:c, 0)],
-       nil,
-       nil,
-       (116...117),
-       CallNode(118...121)(nil, nil, (118...121), nil, nil, nil, nil, 2, "bar")
-     ),
-     MultiWriteNode(123...139)(
-       [LocalVariableTargetNode(123...124)(:a, 0),
-        LocalVariableTargetNode(126...127)(:b, 0)],
-       nil,
-       nil,
-       (128...129),
-       ArrayNode(130...139)(
-         [SplatNode(130...134)(
-            (130...131),
-            CallNode(131...134)(
-              nil,
-              nil,
-              (131...134),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )
-          ),
-          CallNode(136...139)(
-            nil,
-            nil,
-            (136...139),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )],
-         nil,
-         nil
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...139))
+├── locals: [:c, :d, :b, :a]
+└── statements:
+    @ StatementsNode (location: (0...139))
+    └── body: (length: 10)
+        ├── @ MultiWriteNode (location: (0...7))
+        │   ├── targets: (length: 1)
+        │   │   └── @ SplatNode (location: (0...1))
+        │   │       ├── operator_loc: (0...1) = "*"
+        │   │       └── expression: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (2...3) = "="
+        │   └── value:
+        │       @ CallNode (location: (4...7))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (4...7) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        ├── @ MultiWriteNode (location: (9...22))
+        │   ├── targets: (length: 3)
+        │   │   ├── @ MultiTargetNode (location: (9...10))
+        │   │   │   ├── targets: (length: 1)
+        │   │   │   │   └── @ SplatNode (location: (9...10))
+        │   │   │   │       ├── operator_loc: (9...10) = "*"
+        │   │   │   │       └── expression: ∅
+        │   │   │   ├── lparen_loc: ∅
+        │   │   │   └── rparen_loc: ∅
+        │   │   ├── @ LocalVariableTargetNode (location: (12...13))
+        │   │   │   ├── name: :c
+        │   │   │   └── depth: 0
+        │   │   └── @ LocalVariableTargetNode (location: (15...16))
+        │   │       ├── name: :d
+        │   │       └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (17...18) = "="
+        │   └── value:
+        │       @ CallNode (location: (19...22))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (19...22) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        ├── @ MultiWriteNode (location: (24...32))
+        │   ├── targets: (length: 1)
+        │   │   └── @ SplatNode (location: (24...26))
+        │   │       ├── operator_loc: (24...25) = "*"
+        │   │       └── expression:
+        │   │           @ LocalVariableTargetNode (location: (25...26))
+        │   │           ├── name: :b
+        │   │           └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (27...28) = "="
+        │   └── value:
+        │       @ CallNode (location: (29...32))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (29...32) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        ├── @ MultiWriteNode (location: (34...45))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ MultiTargetNode (location: (34...36))
+        │   │   │   ├── targets: (length: 1)
+        │   │   │   │   └── @ SplatNode (location: (34...36))
+        │   │   │   │       ├── operator_loc: (34...35) = "*"
+        │   │   │   │       └── expression:
+        │   │   │   │           @ LocalVariableTargetNode (location: (35...36))
+        │   │   │   │           ├── name: :b
+        │   │   │   │           └── depth: 0
+        │   │   │   ├── lparen_loc: ∅
+        │   │   │   └── rparen_loc: ∅
+        │   │   └── @ LocalVariableTargetNode (location: (38...39))
+        │   │       ├── name: :c
+        │   │       └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (40...41) = "="
+        │   └── value:
+        │       @ CallNode (location: (42...45))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (42...45) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        ├── @ MultiWriteNode (location: (47...65))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ InstanceVariableTargetNode (location: (47...51))
+        │   │   │   └── name: :@foo
+        │   │   └── @ ClassVariableTargetNode (location: (53...58))
+        │   │       └── name: :@@bar
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (59...60) = "="
+        │   └── value:
+        │       @ ArrayNode (location: (61...65))
+        │       ├── elements: (length: 1)
+        │       │   └── @ SplatNode (location: (61...65))
+        │       │       ├── operator_loc: (61...62) = "*"
+        │       │       └── expression:
+        │       │           @ CallNode (location: (62...65))
+        │       │           ├── receiver: ∅
+        │       │           ├── call_operator_loc: ∅
+        │       │           ├── message_loc: (62...65) = "foo"
+        │       │           ├── opening_loc: ∅
+        │       │           ├── arguments: ∅
+        │       │           ├── closing_loc: ∅
+        │       │           ├── block: ∅
+        │       │           ├── flags: variable_call
+        │       │           └── name: "foo"
+        │       ├── opening_loc: ∅
+        │       └── closing_loc: ∅
+        ├── @ MultiWriteNode (location: (67...77))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (67...68))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   └── @ SplatNode (location: (70...71))
+        │   │       ├── operator_loc: (70...71) = "*"
+        │   │       └── expression: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (72...73) = "="
+        │   └── value:
+        │       @ CallNode (location: (74...77))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (74...77) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        ├── @ MultiWriteNode (location: (79...92))
+        │   ├── targets: (length: 3)
+        │   │   ├── @ LocalVariableTargetNode (location: (79...80))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   ├── @ SplatNode (location: (82...83))
+        │   │   │   ├── operator_loc: (82...83) = "*"
+        │   │   │   └── expression: ∅
+        │   │   └── @ LocalVariableTargetNode (location: (85...86))
+        │   │       ├── name: :c
+        │   │       └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (87...88) = "="
+        │   └── value:
+        │       @ CallNode (location: (89...92))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (89...92) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        ├── @ MultiWriteNode (location: (94...105))
+        │   ├── targets: (length: 2)
+        │   │   ├── @ LocalVariableTargetNode (location: (94...95))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   └── @ SplatNode (location: (97...99))
+        │   │       ├── operator_loc: (97...98) = "*"
+        │   │       └── expression:
+        │   │           @ LocalVariableTargetNode (location: (98...99))
+        │   │           ├── name: :b
+        │   │           └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (100...101) = "="
+        │   └── value:
+        │       @ CallNode (location: (102...105))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (102...105) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        ├── @ MultiWriteNode (location: (107...121))
+        │   ├── targets: (length: 3)
+        │   │   ├── @ LocalVariableTargetNode (location: (107...108))
+        │   │   │   ├── name: :a
+        │   │   │   └── depth: 0
+        │   │   ├── @ SplatNode (location: (110...112))
+        │   │   │   ├── operator_loc: (110...111) = "*"
+        │   │   │   └── expression:
+        │   │   │       @ LocalVariableTargetNode (location: (111...112))
+        │   │   │       ├── name: :b
+        │   │   │       └── depth: 0
+        │   │   └── @ LocalVariableTargetNode (location: (114...115))
+        │   │       ├── name: :c
+        │   │       └── depth: 0
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── operator_loc: (116...117) = "="
+        │   └── value:
+        │       @ CallNode (location: (118...121))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (118...121) = "bar"
+        │       ├── opening_loc: ∅
+        │       ├── arguments: ∅
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: variable_call
+        │       └── name: "bar"
+        └── @ MultiWriteNode (location: (123...139))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (123...124))
+            │   │   ├── name: :a
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (126...127))
+            │       ├── name: :b
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (128...129) = "="
+            └── value:
+                @ ArrayNode (location: (130...139))
+                ├── elements: (length: 2)
+                │   ├── @ SplatNode (location: (130...134))
+                │   │   ├── operator_loc: (130...131) = "*"
+                │   │   └── expression:
+                │   │       @ CallNode (location: (131...134))
+                │   │       ├── receiver: ∅
+                │   │       ├── call_operator_loc: ∅
+                │   │       ├── message_loc: (131...134) = "foo"
+                │   │       ├── opening_loc: ∅
+                │   │       ├── arguments: ∅
+                │   │       ├── closing_loc: ∅
+                │   │       ├── block: ∅
+                │   │       ├── flags: variable_call
+                │   │       └── name: "foo"
+                │   └── @ CallNode (location: (136...139))
+                │       ├── receiver: ∅
+                │       ├── call_operator_loc: ∅
+                │       ├── message_loc: (136...139) = "bar"
+                │       ├── opening_loc: ∅
+                │       ├── arguments: ∅
+                │       ├── closing_loc: ∅
+                │       ├── block: ∅
+                │       ├── flags: variable_call
+                │       └── name: "bar"
+                ├── opening_loc: ∅
+                └── closing_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/method_definition_in_while_cond.txt b/test/yarp/snapshots/whitequark/method_definition_in_while_cond.txt
index 099ae93986..5173d31f35 100644
--- a/test/yarp/snapshots/whitequark/method_definition_in_while_cond.txt
+++ b/test/yarp/snapshots/whitequark/method_definition_in_while_cond.txt
@@ -1,155 +1,197 @@
-ProgramNode(0...190)(
-  [],
-  StatementsNode(0...190)(
-    [WhileNode(0...45)(
-       (0...5),
-       (42...45),
-       DefNode(6...33)(
-         :foo,
-         (10...13),
-         nil,
-         ParametersNode(14...28)(
-           [],
-           [OptionalParameterNode(14...28)(
-              :a,
-              (14...15),
-              (16...17),
-              CallNode(18...28)(
-                nil,
-                nil,
-                (18...21),
-                nil,
-                nil,
-                nil,
-                BlockNode(22...28)([], nil, nil, (22...24), (25...28)),
-                0,
-                "tap"
-              )
-            )],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         nil,
-         [:a],
-         (6...9),
-         nil,
-         nil,
-         nil,
-         nil,
-         (30...33)
-       ),
-       StatementsNode(35...40)([BreakNode(35...40)(nil, (35...40))]),
-       0
-     ),
-     WhileNode(47...89)(
-       (47...52),
-       (86...89),
-       DefNode(53...77)(
-         :foo,
-         (57...60),
-         nil,
-         nil,
-         StatementsNode(62...72)(
-           [CallNode(62...72)(
-              nil,
-              nil,
-              (62...65),
-              nil,
-              nil,
-              nil,
-              BlockNode(66...72)([], nil, nil, (66...68), (69...72)),
-              0,
-              "tap"
-            )]
-         ),
-         [],
-         (53...56),
-         nil,
-         nil,
-         nil,
-         nil,
-         (74...77)
-       ),
-       StatementsNode(79...84)([BreakNode(79...84)(nil, (79...84))]),
-       0
-     ),
-     WhileNode(91...141)(
-       (91...96),
-       (138...141),
-       DefNode(97...129)(
-         :foo,
-         (106...109),
-         SelfNode(101...105)(),
-         ParametersNode(110...124)(
-           [],
-           [OptionalParameterNode(110...124)(
-              :a,
-              (110...111),
-              (112...113),
-              CallNode(114...124)(
-                nil,
-                nil,
-                (114...117),
-                nil,
-                nil,
-                nil,
-                BlockNode(118...124)([], nil, nil, (118...120), (121...124)),
-                0,
-                "tap"
-              )
-            )],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         nil,
-         [:a],
-         (97...100),
-         (105...106),
-         nil,
-         nil,
-         nil,
-         (126...129)
-       ),
-       StatementsNode(131...136)([BreakNode(131...136)(nil, (131...136))]),
-       0
-     ),
-     WhileNode(143...190)(
-       (143...148),
-       (187...190),
-       DefNode(149...178)(
-         :foo,
-         (158...161),
-         SelfNode(153...157)(),
-         nil,
-         StatementsNode(163...173)(
-           [CallNode(163...173)(
-              nil,
-              nil,
-              (163...166),
-              nil,
-              nil,
-              nil,
-              BlockNode(167...173)([], nil, nil, (167...169), (170...173)),
-              0,
-              "tap"
-            )]
-         ),
-         [],
-         (149...152),
-         (157...158),
-         nil,
-         nil,
-         nil,
-         (175...178)
-       ),
-       StatementsNode(180...185)([BreakNode(180...185)(nil, (180...185))]),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...190))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...190))
+    └── body: (length: 4)
+        ├── @ WhileNode (location: (0...45))
+        │   ├── keyword_loc: (0...5) = "while"
+        │   ├── closing_loc: (42...45) = "end"
+        │   ├── predicate:
+        │   │   @ DefNode (location: (6...33))
+        │   │   ├── name: :foo
+        │   │   ├── name_loc: (10...13) = "foo"
+        │   │   ├── receiver: ∅
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (14...28))
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   └── @ OptionalParameterNode (location: (14...28))
+        │   │   │   │       ├── name: :a
+        │   │   │   │       ├── name_loc: (14...15) = "a"
+        │   │   │   │       ├── operator_loc: (16...17) = "="
+        │   │   │   │       └── value:
+        │   │   │   │           @ CallNode (location: (18...28))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (18...21) = "tap"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block:
+        │   │   │   │           │   @ BlockNode (location: (22...28))
+        │   │   │   │           │   ├── locals: []
+        │   │   │   │           │   ├── parameters: ∅
+        │   │   │   │           │   ├── body: ∅
+        │   │   │   │           │   ├── opening_loc: (22...24) = "do"
+        │   │   │   │           │   └── closing_loc: (25...28) = "end"
+        │   │   │   │           ├── flags: 
+        │   │   │   │           └── name: "tap"
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── body: ∅
+        │   │   ├── locals: [:a]
+        │   │   ├── def_keyword_loc: (6...9) = "def"
+        │   │   ├── operator_loc: ∅
+        │   │   ├── lparen_loc: ∅
+        │   │   ├── rparen_loc: ∅
+        │   │   ├── equal_loc: ∅
+        │   │   └── end_keyword_loc: (30...33) = "end"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (35...40))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (35...40))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (35...40) = "break"
+        │   └── flags: 
+        ├── @ WhileNode (location: (47...89))
+        │   ├── keyword_loc: (47...52) = "while"
+        │   ├── closing_loc: (86...89) = "end"
+        │   ├── predicate:
+        │   │   @ DefNode (location: (53...77))
+        │   │   ├── name: :foo
+        │   │   ├── name_loc: (57...60) = "foo"
+        │   │   ├── receiver: ∅
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (62...72))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (62...72))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (62...65) = "tap"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block:
+        │   │   │           │   @ BlockNode (location: (66...72))
+        │   │   │           │   ├── locals: []
+        │   │   │           │   ├── parameters: ∅
+        │   │   │           │   ├── body: ∅
+        │   │   │           │   ├── opening_loc: (66...68) = "do"
+        │   │   │           │   └── closing_loc: (69...72) = "end"
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "tap"
+        │   │   ├── locals: []
+        │   │   ├── def_keyword_loc: (53...56) = "def"
+        │   │   ├── operator_loc: ∅
+        │   │   ├── lparen_loc: ∅
+        │   │   ├── rparen_loc: ∅
+        │   │   ├── equal_loc: ∅
+        │   │   └── end_keyword_loc: (74...77) = "end"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (79...84))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (79...84))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (79...84) = "break"
+        │   └── flags: 
+        ├── @ WhileNode (location: (91...141))
+        │   ├── keyword_loc: (91...96) = "while"
+        │   ├── closing_loc: (138...141) = "end"
+        │   ├── predicate:
+        │   │   @ DefNode (location: (97...129))
+        │   │   ├── name: :foo
+        │   │   ├── name_loc: (106...109) = "foo"
+        │   │   ├── receiver:
+        │   │   │   @ SelfNode (location: (101...105))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (110...124))
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── optionals: (length: 1)
+        │   │   │   │   └── @ OptionalParameterNode (location: (110...124))
+        │   │   │   │       ├── name: :a
+        │   │   │   │       ├── name_loc: (110...111) = "a"
+        │   │   │   │       ├── operator_loc: (112...113) = "="
+        │   │   │   │       └── value:
+        │   │   │   │           @ CallNode (location: (114...124))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (114...117) = "tap"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block:
+        │   │   │   │           │   @ BlockNode (location: (118...124))
+        │   │   │   │           │   ├── locals: []
+        │   │   │   │           │   ├── parameters: ∅
+        │   │   │   │           │   ├── body: ∅
+        │   │   │   │           │   ├── opening_loc: (118...120) = "do"
+        │   │   │   │           │   └── closing_loc: (121...124) = "end"
+        │   │   │   │           ├── flags: 
+        │   │   │   │           └── name: "tap"
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── body: ∅
+        │   │   ├── locals: [:a]
+        │   │   ├── def_keyword_loc: (97...100) = "def"
+        │   │   ├── operator_loc: (105...106) = "."
+        │   │   ├── lparen_loc: ∅
+        │   │   ├── rparen_loc: ∅
+        │   │   ├── equal_loc: ∅
+        │   │   └── end_keyword_loc: (126...129) = "end"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (131...136))
+        │   │   └── body: (length: 1)
+        │   │       └── @ BreakNode (location: (131...136))
+        │   │           ├── arguments: ∅
+        │   │           └── keyword_loc: (131...136) = "break"
+        │   └── flags: 
+        └── @ WhileNode (location: (143...190))
+            ├── keyword_loc: (143...148) = "while"
+            ├── closing_loc: (187...190) = "end"
+            ├── predicate:
+            │   @ DefNode (location: (149...178))
+            │   ├── name: :foo
+            │   ├── name_loc: (158...161) = "foo"
+            │   ├── receiver:
+            │   │   @ SelfNode (location: (153...157))
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (163...173))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (163...173))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (163...166) = "tap"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block:
+            │   │           │   @ BlockNode (location: (167...173))
+            │   │           │   ├── locals: []
+            │   │           │   ├── parameters: ∅
+            │   │           │   ├── body: ∅
+            │   │           │   ├── opening_loc: (167...169) = "do"
+            │   │           │   └── closing_loc: (170...173) = "end"
+            │   │           ├── flags: 
+            │   │           └── name: "tap"
+            │   ├── locals: []
+            │   ├── def_keyword_loc: (149...152) = "def"
+            │   ├── operator_loc: (157...158) = "."
+            │   ├── lparen_loc: ∅
+            │   ├── rparen_loc: ∅
+            │   ├── equal_loc: ∅
+            │   └── end_keyword_loc: (175...178) = "end"
+            ├── statements:
+            │   @ StatementsNode (location: (180...185))
+            │   └── body: (length: 1)
+            │       └── @ BreakNode (location: (180...185))
+            │           ├── arguments: ∅
+            │           └── keyword_loc: (180...185) = "break"
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/module.txt b/test/yarp/snapshots/whitequark/module.txt
index 18d3d2e9b5..739fea688b 100644
--- a/test/yarp/snapshots/whitequark/module.txt
+++ b/test/yarp/snapshots/whitequark/module.txt
@@ -1,13 +1,14 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [ModuleNode(0...15)(
-       [],
-       (0...6),
-       ConstantReadNode(7...10)(:Foo),
-       nil,
-       (12...15),
-       :Foo
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ ModuleNode (location: (0...15))
+            ├── locals: []
+            ├── module_keyword_loc: (0...6) = "module"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (7...10))
+            │   └── name: :Foo
+            ├── body: ∅
+            ├── end_keyword_loc: (12...15) = "end"
+            └── name: :Foo
diff --git a/test/yarp/snapshots/whitequark/multiple_pattern_matches.txt b/test/yarp/snapshots/whitequark/multiple_pattern_matches.txt
index 7f655240cd..c122576853 100644
--- a/test/yarp/snapshots/whitequark/multiple_pattern_matches.txt
+++ b/test/yarp/snapshots/whitequark/multiple_pattern_matches.txt
@@ -1,97 +1,137 @@
-ProgramNode(0...52)(
-  [:a],
-  StatementsNode(0...52)(
-    [MatchRequiredNode(0...12)(
-       HashNode(0...6)(
-         (0...1),
-         [AssocNode(1...5)(
-            SymbolNode(1...3)(nil, (1...2), (2...3), "a"),
-            IntegerNode(4...5)(),
-            nil
-          )],
-         (5...6)
-       ),
-       HashPatternNode(10...12)(
-         nil,
-         [AssocNode(10...12)(
-            SymbolNode(10...12)(nil, (10...11), (11...12), "a"),
-            nil,
-            nil
-          )],
-         nil,
-         nil,
-         nil
-       ),
-       (7...9)
-     ),
-     MatchRequiredNode(13...25)(
-       HashNode(13...19)(
-         (13...14),
-         [AssocNode(14...18)(
-            SymbolNode(14...16)(nil, (14...15), (15...16), "a"),
-            IntegerNode(17...18)(),
-            nil
-          )],
-         (18...19)
-       ),
-       HashPatternNode(23...25)(
-         nil,
-         [AssocNode(23...25)(
-            SymbolNode(23...25)(nil, (23...24), (24...25), "a"),
-            nil,
-            nil
-          )],
-         nil,
-         nil,
-         nil
-       ),
-       (20...22)
-     ),
-     MatchPredicateNode(27...39)(
-       HashNode(27...33)(
-         (27...28),
-         [AssocNode(28...32)(
-            SymbolNode(28...30)(nil, (28...29), (29...30), "a"),
-            IntegerNode(31...32)(),
-            nil
-          )],
-         (32...33)
-       ),
-       HashPatternNode(37...39)(
-         nil,
-         [AssocNode(37...39)(
-            SymbolNode(37...39)(nil, (37...38), (38...39), "a"),
-            nil,
-            nil
-          )],
-         nil,
-         nil,
-         nil
-       ),
-       (34...36)
-     ),
-     MatchPredicateNode(40...52)(
-       HashNode(40...46)(
-         (40...41),
-         [AssocNode(41...45)(
-            SymbolNode(41...43)(nil, (41...42), (42...43), "a"),
-            IntegerNode(44...45)(),
-            nil
-          )],
-         (45...46)
-       ),
-       HashPatternNode(50...52)(
-         nil,
-         [AssocNode(50...52)(
-            SymbolNode(50...52)(nil, (50...51), (51...52), "a"),
-            nil,
-            nil
-          )],
-         nil,
-         nil,
-         nil
-       ),
-       (47...49)
-     )]
-  )
-)
+@ ProgramNode (location: (0...52))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...52))
+    └── body: (length: 4)
+        ├── @ MatchRequiredNode (location: (0...12))
+        │   ├── value:
+        │   │   @ HashNode (location: (0...6))
+        │   │   ├── opening_loc: (0...1) = "{"
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ AssocNode (location: (1...5))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (1...3))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (1...2) = "a"
+        │   │   │       │   ├── closing_loc: (2...3) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value:
+        │   │   │       │   @ IntegerNode (location: (4...5))
+        │   │   │       └── operator_loc: ∅
+        │   │   └── closing_loc: (5...6) = "}"
+        │   ├── pattern:
+        │   │   @ HashPatternNode (location: (10...12))
+        │   │   ├── constant: ∅
+        │   │   ├── assocs: (length: 1)
+        │   │   │   └── @ AssocNode (location: (10...12))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (10...12))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (10...11) = "a"
+        │   │   │       │   ├── closing_loc: (11...12) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value: ∅
+        │   │   │       └── operator_loc: ∅
+        │   │   ├── kwrest: ∅
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (7...9) = "=>"
+        ├── @ MatchRequiredNode (location: (13...25))
+        │   ├── value:
+        │   │   @ HashNode (location: (13...19))
+        │   │   ├── opening_loc: (13...14) = "{"
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ AssocNode (location: (14...18))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (14...16))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (14...15) = "a"
+        │   │   │       │   ├── closing_loc: (15...16) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value:
+        │   │   │       │   @ IntegerNode (location: (17...18))
+        │   │   │       └── operator_loc: ∅
+        │   │   └── closing_loc: (18...19) = "}"
+        │   ├── pattern:
+        │   │   @ HashPatternNode (location: (23...25))
+        │   │   ├── constant: ∅
+        │   │   ├── assocs: (length: 1)
+        │   │   │   └── @ AssocNode (location: (23...25))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (23...25))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (23...24) = "a"
+        │   │   │       │   ├── closing_loc: (24...25) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value: ∅
+        │   │   │       └── operator_loc: ∅
+        │   │   ├── kwrest: ∅
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (20...22) = "=>"
+        ├── @ MatchPredicateNode (location: (27...39))
+        │   ├── value:
+        │   │   @ HashNode (location: (27...33))
+        │   │   ├── opening_loc: (27...28) = "{"
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ AssocNode (location: (28...32))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (28...30))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (28...29) = "a"
+        │   │   │       │   ├── closing_loc: (29...30) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value:
+        │   │   │       │   @ IntegerNode (location: (31...32))
+        │   │   │       └── operator_loc: ∅
+        │   │   └── closing_loc: (32...33) = "}"
+        │   ├── pattern:
+        │   │   @ HashPatternNode (location: (37...39))
+        │   │   ├── constant: ∅
+        │   │   ├── assocs: (length: 1)
+        │   │   │   └── @ AssocNode (location: (37...39))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (37...39))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (37...38) = "a"
+        │   │   │       │   ├── closing_loc: (38...39) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value: ∅
+        │   │   │       └── operator_loc: ∅
+        │   │   ├── kwrest: ∅
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (34...36) = "in"
+        └── @ MatchPredicateNode (location: (40...52))
+            ├── value:
+            │   @ HashNode (location: (40...46))
+            │   ├── opening_loc: (40...41) = "{"
+            │   ├── elements: (length: 1)
+            │   │   └── @ AssocNode (location: (41...45))
+            │   │       ├── key:
+            │   │       │   @ SymbolNode (location: (41...43))
+            │   │       │   ├── opening_loc: ∅
+            │   │       │   ├── value_loc: (41...42) = "a"
+            │   │       │   ├── closing_loc: (42...43) = ":"
+            │   │       │   └── unescaped: "a"
+            │   │       ├── value:
+            │   │       │   @ IntegerNode (location: (44...45))
+            │   │       └── operator_loc: ∅
+            │   └── closing_loc: (45...46) = "}"
+            ├── pattern:
+            │   @ HashPatternNode (location: (50...52))
+            │   ├── constant: ∅
+            │   ├── assocs: (length: 1)
+            │   │   └── @ AssocNode (location: (50...52))
+            │   │       ├── key:
+            │   │       │   @ SymbolNode (location: (50...52))
+            │   │       │   ├── opening_loc: ∅
+            │   │       │   ├── value_loc: (50...51) = "a"
+            │   │       │   ├── closing_loc: (51...52) = ":"
+            │   │       │   └── unescaped: "a"
+            │   │       ├── value: ∅
+            │   │       └── operator_loc: ∅
+            │   ├── kwrest: ∅
+            │   ├── opening_loc: ∅
+            │   └── closing_loc: ∅
+            └── operator_loc: (47...49) = "in"
diff --git a/test/yarp/snapshots/whitequark/newline_in_hash_argument.txt b/test/yarp/snapshots/whitequark/newline_in_hash_argument.txt
index fad1c85494..f28205b846 100644
--- a/test/yarp/snapshots/whitequark/newline_in_hash_argument.txt
+++ b/test/yarp/snapshots/whitequark/newline_in_hash_argument.txt
@@ -1,85 +1,137 @@
-ProgramNode(0...74)(
-  [:a, :b],
-  StatementsNode(0...74)(
-    [CaseNode(0...40)(
-       CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "foo"),
-       [InNode(9...21)(
-          HashPatternNode(12...14)(
-            nil,
-            [AssocNode(12...14)(
-               SymbolNode(12...14)(nil, (12...13), (13...14), "a"),
-               nil,
-               nil
-             )],
-            nil,
-            nil,
-            nil
-          ),
-          StatementsNode(15...21)(
-            [IntegerNode(15...16)(), TrueNode(17...21)()]
-          ),
-          (9...11),
-          nil
-        ),
-        InNode(22...36)(
-          HashPatternNode(25...29)(
-            nil,
-            [AssocNode(25...29)(
-               SymbolNode(25...29)((25...26), (26...27), (27...29), "b"),
-               nil,
-               nil
-             )],
-            nil,
-            nil,
-            nil
-          ),
-          StatementsNode(30...36)(
-            [IntegerNode(30...31)(), TrueNode(32...36)()]
-          ),
-          (22...24),
-          nil
-        )],
-       nil,
-       (0...4),
-       (37...40)
-     ),
-     CallNode(42...58)(
-       CallNode(42...45)(nil, nil, (42...45), nil, nil, nil, nil, 2, "obj"),
-       (45...46),
-       (46...49),
-       nil,
-       ArgumentsNode(50...58)(
-         [KeywordHashNode(50...58)(
-            [AssocNode(50...58)(
-               SymbolNode(50...56)((50...51), (51...54), (54...56), "foo"),
-               IntegerNode(57...58)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "set"
-     ),
-     CallNode(60...74)(
-       CallNode(60...63)(nil, nil, (60...63), nil, nil, nil, nil, 2, "obj"),
-       (63...64),
-       (64...67),
-       nil,
-       ArgumentsNode(68...74)(
-         [KeywordHashNode(68...74)(
-            [AssocNode(68...74)(
-               SymbolNode(68...72)(nil, (68...71), (71...72), "foo"),
-               IntegerNode(73...74)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "set"
-     )]
-  )
-)
+@ ProgramNode (location: (0...74))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...74))
+    └── body: (length: 3)
+        ├── @ CaseNode (location: (0...40))
+        │   ├── predicate:
+        │   │   @ CallNode (location: (5...8))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (5...8) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── conditions: (length: 2)
+        │   │   ├── @ InNode (location: (9...21))
+        │   │   │   ├── pattern:
+        │   │   │   │   @ HashPatternNode (location: (12...14))
+        │   │   │   │   ├── constant: ∅
+        │   │   │   │   ├── assocs: (length: 1)
+        │   │   │   │   │   └── @ AssocNode (location: (12...14))
+        │   │   │   │   │       ├── key:
+        │   │   │   │   │       │   @ SymbolNode (location: (12...14))
+        │   │   │   │   │       │   ├── opening_loc: ∅
+        │   │   │   │   │       │   ├── value_loc: (12...13) = "a"
+        │   │   │   │   │       │   ├── closing_loc: (13...14) = ":"
+        │   │   │   │   │       │   └── unescaped: "a"
+        │   │   │   │   │       ├── value: ∅
+        │   │   │   │   │       └── operator_loc: ∅
+        │   │   │   │   ├── kwrest: ∅
+        │   │   │   │   ├── opening_loc: ∅
+        │   │   │   │   └── closing_loc: ∅
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (15...21))
+        │   │   │   │   └── body: (length: 2)
+        │   │   │   │       ├── @ IntegerNode (location: (15...16))
+        │   │   │   │       └── @ TrueNode (location: (17...21))
+        │   │   │   ├── in_loc: (9...11) = "in"
+        │   │   │   └── then_loc: ∅
+        │   │   └── @ InNode (location: (22...36))
+        │   │       ├── pattern:
+        │   │       │   @ HashPatternNode (location: (25...29))
+        │   │       │   ├── constant: ∅
+        │   │       │   ├── assocs: (length: 1)
+        │   │       │   │   └── @ AssocNode (location: (25...29))
+        │   │       │   │       ├── key:
+        │   │       │   │       │   @ SymbolNode (location: (25...29))
+        │   │       │   │       │   ├── opening_loc: (25...26) = "\""
+        │   │       │   │       │   ├── value_loc: (26...27) = "b"
+        │   │       │   │       │   ├── closing_loc: (27...29) = "\":"
+        │   │       │   │       │   └── unescaped: "b"
+        │   │       │   │       ├── value: ∅
+        │   │       │   │       └── operator_loc: ∅
+        │   │       │   ├── kwrest: ∅
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   └── closing_loc: ∅
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (30...36))
+        │   │       │   └── body: (length: 2)
+        │   │       │       ├── @ IntegerNode (location: (30...31))
+        │   │       │       └── @ TrueNode (location: (32...36))
+        │   │       ├── in_loc: (22...24) = "in"
+        │   │       └── then_loc: ∅
+        │   ├── consequent: ∅
+        │   ├── case_keyword_loc: (0...4) = "case"
+        │   └── end_keyword_loc: (37...40) = "end"
+        ├── @ CallNode (location: (42...58))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (42...45))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (42...45) = "obj"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "obj"
+        │   ├── call_operator_loc: (45...46) = "."
+        │   ├── message_loc: (46...49) = "set"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (50...58))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (50...58))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (50...58))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (50...56))
+        │   │                   │   ├── opening_loc: (50...51) = "\""
+        │   │                   │   ├── value_loc: (51...54) = "foo"
+        │   │                   │   ├── closing_loc: (54...56) = "\":"
+        │   │                   │   └── unescaped: "foo"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (57...58))
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "set"
+        └── @ CallNode (location: (60...74))
+            ├── receiver:
+            │   @ CallNode (location: (60...63))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (60...63) = "obj"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "obj"
+            ├── call_operator_loc: (63...64) = "."
+            ├── message_loc: (64...67) = "set"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (68...74))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (68...74))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (68...74))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (68...72))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (68...71) = "foo"
+            │                   │   ├── closing_loc: (71...72) = ":"
+            │                   │   └── unescaped: "foo"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (73...74))
+            │                   └── operator_loc: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "set"
diff --git a/test/yarp/snapshots/whitequark/next.txt b/test/yarp/snapshots/whitequark/next.txt
index 07dbb690da..277d3e81bb 100644
--- a/test/yarp/snapshots/whitequark/next.txt
+++ b/test/yarp/snapshots/whitequark/next.txt
@@ -1,40 +1,53 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [NextNode(0...4)(nil, (0...4)),
-     NextNode(6...14)(
-       ArgumentsNode(11...14)(
-         [CallNode(11...14)(nil, nil, (11...14), nil, nil, nil, nil, 2, "foo")]
-       ),
-       (6...10)
-     ),
-     NextNode(16...22)(
-       ArgumentsNode(20...22)(
-         [ParenthesesNode(20...22)(nil, (20...21), (21...22))]
-       ),
-       (16...20)
-     ),
-     NextNode(24...33)(
-       ArgumentsNode(28...33)(
-         [ParenthesesNode(28...33)(
-            StatementsNode(29...32)(
-              [CallNode(29...32)(
-                 nil,
-                 nil,
-                 (29...32),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               )]
-            ),
-            (28...29),
-            (32...33)
-          )]
-       ),
-       (24...28)
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 4)
+        ├── @ NextNode (location: (0...4))
+        │   ├── arguments: ∅
+        │   └── keyword_loc: (0...4) = "next"
+        ├── @ NextNode (location: (6...14))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (11...14))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (11...14))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (11...14) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "foo"
+        │   └── keyword_loc: (6...10) = "next"
+        ├── @ NextNode (location: (16...22))
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (20...22))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (20...22))
+        │   │           ├── body: ∅
+        │   │           ├── opening_loc: (20...21) = "("
+        │   │           └── closing_loc: (21...22) = ")"
+        │   └── keyword_loc: (16...20) = "next"
+        └── @ NextNode (location: (24...33))
+            ├── arguments:
+            │   @ ArgumentsNode (location: (28...33))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (28...33))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (29...32))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (29...32))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (29...32) = "foo"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "foo"
+            │           ├── opening_loc: (28...29) = "("
+            │           └── closing_loc: (32...33) = ")"
+            └── keyword_loc: (24...28) = "next"
diff --git a/test/yarp/snapshots/whitequark/next_block.txt b/test/yarp/snapshots/whitequark/next_block.txt
index 20cbe0d837..54c368892c 100644
--- a/test/yarp/snapshots/whitequark/next_block.txt
+++ b/test/yarp/snapshots/whitequark/next_block.txt
@@ -1,33 +1,38 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [NextNode(0...19)(
-       ArgumentsNode(5...19)(
-         [CallNode(5...19)(
-            nil,
-            nil,
-            (5...8),
-            nil,
-            ArgumentsNode(9...12)(
-              [CallNode(9...12)(
-                 nil,
-                 nil,
-                 (9...12),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               )]
-            ),
-            nil,
-            BlockNode(13...19)([], nil, nil, (13...15), (16...19)),
-            0,
-            "fun"
-          )]
-       ),
-       (0...4)
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ NextNode (location: (0...19))
+            ├── arguments:
+            │   @ ArgumentsNode (location: (5...19))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (5...19))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (5...8) = "fun"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (9...12))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ CallNode (location: (9...12))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (9...12) = "foo"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "foo"
+            │           ├── closing_loc: ∅
+            │           ├── block:
+            │           │   @ BlockNode (location: (13...19))
+            │           │   ├── locals: []
+            │           │   ├── parameters: ∅
+            │           │   ├── body: ∅
+            │           │   ├── opening_loc: (13...15) = "do"
+            │           │   └── closing_loc: (16...19) = "end"
+            │           ├── flags: 
+            │           └── name: "fun"
+            └── keyword_loc: (0...4) = "next"
diff --git a/test/yarp/snapshots/whitequark/nil.txt b/test/yarp/snapshots/whitequark/nil.txt
index 4af940de66..b60212bd94 100644
--- a/test/yarp/snapshots/whitequark/nil.txt
+++ b/test/yarp/snapshots/whitequark/nil.txt
@@ -1 +1,6 @@
-ProgramNode(0...3)([], StatementsNode(0...3)([NilNode(0...3)()]))
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ NilNode (location: (0...3))
diff --git a/test/yarp/snapshots/whitequark/nil_expression.txt b/test/yarp/snapshots/whitequark/nil_expression.txt
index b9e8d19adb..d20c80ce4c 100644
--- a/test/yarp/snapshots/whitequark/nil_expression.txt
+++ b/test/yarp/snapshots/whitequark/nil_expression.txt
@@ -1,7 +1,16 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [ParenthesesNode(0...2)(nil, (0...1), (1...2)),
-     BeginNode(4...13)((4...9), nil, nil, nil, nil, (10...13))]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 2)
+        ├── @ ParenthesesNode (location: (0...2))
+        │   ├── body: ∅
+        │   ├── opening_loc: (0...1) = "("
+        │   └── closing_loc: (1...2) = ")"
+        └── @ BeginNode (location: (4...13))
+            ├── begin_keyword_loc: (4...9) = "begin"
+            ├── statements: ∅
+            ├── rescue_clause: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (10...13) = "end"
diff --git a/test/yarp/snapshots/whitequark/non_lvar_injecting_match.txt b/test/yarp/snapshots/whitequark/non_lvar_injecting_match.txt
index e44f5db294..03ca1477f9 100644
--- a/test/yarp/snapshots/whitequark/non_lvar_injecting_match.txt
+++ b/test/yarp/snapshots/whitequark/non_lvar_injecting_match.txt
@@ -1,28 +1,39 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CallNode(0...28)(
-       InterpolatedRegularExpressionNode(0...19)(
-         (0...1),
-         [EmbeddedStatementsNode(1...5)(
-            (1...3),
-            StatementsNode(3...4)([IntegerNode(3...4)()]),
-            (4...5)
-          ),
-          StringNode(5...18)(nil, (5...18), nil, "(?<match>bar)")],
-         (18...19),
-         0
-       ),
-       nil,
-       (20...22),
-       nil,
-       ArgumentsNode(23...28)(
-         [StringNode(23...28)((23...24), (24...27), (27...28), "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "=~"
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...28))
+            ├── receiver:
+            │   @ InterpolatedRegularExpressionNode (location: (0...19))
+            │   ├── opening_loc: (0...1) = "/"
+            │   ├── parts: (length: 2)
+            │   │   ├── @ EmbeddedStatementsNode (location: (1...5))
+            │   │   │   ├── opening_loc: (1...3) = "\#{"
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (3...4))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ IntegerNode (location: (3...4))
+            │   │   │   └── closing_loc: (4...5) = "}"
+            │   │   └── @ StringNode (location: (5...18))
+            │   │       ├── opening_loc: ∅
+            │   │       ├── content_loc: (5...18) = "(?<match>bar)"
+            │   │       ├── closing_loc: ∅
+            │   │       └── unescaped: "(?<match>bar)"
+            │   ├── closing_loc: (18...19) = "/"
+            │   └── flags: 
+            ├── call_operator_loc: ∅
+            ├── message_loc: (20...22) = "=~"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (23...28))
+            │   └── arguments: (length: 1)
+            │       └── @ StringNode (location: (23...28))
+            │           ├── opening_loc: (23...24) = "'"
+            │           ├── content_loc: (24...27) = "bar"
+            │           ├── closing_loc: (27...28) = "'"
+            │           └── unescaped: "bar"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "=~"
diff --git a/test/yarp/snapshots/whitequark/not.txt b/test/yarp/snapshots/whitequark/not.txt
index 1dc7b381cd..f3286ebeff 100644
--- a/test/yarp/snapshots/whitequark/not.txt
+++ b/test/yarp/snapshots/whitequark/not.txt
@@ -1,38 +1,55 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [CallNode(0...7)(
-       CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(9...14)(
-       nil,
-       nil,
-       (9...12),
-       (12...13),
-       nil,
-       (13...14),
-       nil,
-       0,
-       "!"
-     ),
-     CallNode(16...24)(
-       CallNode(20...23)(nil, nil, (20...23), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (16...19),
-       (19...20),
-       nil,
-       (23...24),
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...7))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (4...7))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (4...7) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "not"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        ├── @ CallNode (location: (9...14))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (9...12) = "not"
+        │   ├── opening_loc: (12...13) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (13...14) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!"
+        └── @ CallNode (location: (16...24))
+            ├── receiver:
+            │   @ CallNode (location: (20...23))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (20...23) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (16...19) = "not"
+            ├── opening_loc: (19...20) = "("
+            ├── arguments: ∅
+            ├── closing_loc: (23...24) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/whitequark/not_cmd.txt b/test/yarp/snapshots/whitequark/not_cmd.txt
index ff2acd00f5..9457f321ab 100644
--- a/test/yarp/snapshots/whitequark/not_cmd.txt
+++ b/test/yarp/snapshots/whitequark/not_cmd.txt
@@ -1,28 +1,37 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       CallNode(4...9)(
-         nil,
-         nil,
-         (4...5),
-         nil,
-         ArgumentsNode(6...9)(
-           [CallNode(6...9)(nil, nil, (6...9), nil, nil, nil, nil, 2, "foo")]
-         ),
-         nil,
-         nil,
-         0,
-         "m"
-       ),
-       nil,
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver:
+            │   @ CallNode (location: (4...9))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (4...5) = "m"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (6...9))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ CallNode (location: (6...9))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (6...9) = "foo"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "foo"
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "m"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "not"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/whitequark/not_masgn__24.txt b/test/yarp/snapshots/whitequark/not_masgn__24.txt
index c208968263..d5e5d3c088 100644
--- a/test/yarp/snapshots/whitequark/not_masgn__24.txt
+++ b/test/yarp/snapshots/whitequark/not_masgn__24.txt
@@ -1,39 +1,43 @@
-ProgramNode(0...13)(
-  [:a, :b],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       ParenthesesNode(1...13)(
-         StatementsNode(2...12)(
-           [MultiWriteNode(2...12)(
-              [LocalVariableTargetNode(2...3)(:a, 0),
-               LocalVariableTargetNode(5...6)(:b, 0)],
-              nil,
-              nil,
-              (7...8),
-              CallNode(9...12)(
-                nil,
-                nil,
-                (9...12),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "foo"
-              )
-            )]
-         ),
-         (1...2),
-         (12...13)
-       ),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "!"
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver:
+            │   @ ParenthesesNode (location: (1...13))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (2...12))
+            │   │   └── body: (length: 1)
+            │   │       └── @ MultiWriteNode (location: (2...12))
+            │   │           ├── targets: (length: 2)
+            │   │           │   ├── @ LocalVariableTargetNode (location: (2...3))
+            │   │           │   │   ├── name: :a
+            │   │           │   │   └── depth: 0
+            │   │           │   └── @ LocalVariableTargetNode (location: (5...6))
+            │   │           │       ├── name: :b
+            │   │           │       └── depth: 0
+            │   │           ├── lparen_loc: ∅
+            │   │           ├── rparen_loc: ∅
+            │   │           ├── operator_loc: (7...8) = "="
+            │   │           └── value:
+            │   │               @ CallNode (location: (9...12))
+            │   │               ├── receiver: ∅
+            │   │               ├── call_operator_loc: ∅
+            │   │               ├── message_loc: (9...12) = "foo"
+            │   │               ├── opening_loc: ∅
+            │   │               ├── arguments: ∅
+            │   │               ├── closing_loc: ∅
+            │   │               ├── block: ∅
+            │   │               ├── flags: variable_call
+            │   │               └── name: "foo"
+            │   ├── opening_loc: (1...2) = "("
+            │   └── closing_loc: (12...13) = ")"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "!"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "!"
diff --git a/test/yarp/snapshots/whitequark/nth_ref.txt b/test/yarp/snapshots/whitequark/nth_ref.txt
index ca131a208c..56f5aabea9 100644
--- a/test/yarp/snapshots/whitequark/nth_ref.txt
+++ b/test/yarp/snapshots/whitequark/nth_ref.txt
@@ -1,4 +1,7 @@
-ProgramNode(0...3)(
-  [],
-  StatementsNode(0...3)([NumberedReferenceReadNode(0...3)(10)])
-)
+@ ProgramNode (location: (0...3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...3))
+    └── body: (length: 1)
+        └── @ NumberedReferenceReadNode (location: (0...3))
+            └── number: 10
diff --git a/test/yarp/snapshots/whitequark/numbered_args_after_27.txt b/test/yarp/snapshots/whitequark/numbered_args_after_27.txt
index c2a67b4cc3..376da483c4 100644
--- a/test/yarp/snapshots/whitequark/numbered_args_after_27.txt
+++ b/test/yarp/snapshots/whitequark/numbered_args_after_27.txt
@@ -1,181 +1,187 @@
-ProgramNode(0...65)(
-  [],
-  StatementsNode(0...65)(
-    [LambdaNode(0...17)(
-       [],
-       (0...2),
-       (3...5),
-       (14...17),
-       nil,
-       StatementsNode(6...13)(
-         [CallNode(6...13)(
-            CallNode(6...8)(nil, nil, (6...8), nil, nil, nil, nil, 2, "_1"),
-            nil,
-            (9...10),
-            nil,
-            ArgumentsNode(11...13)(
-              [CallNode(11...13)(
-                 nil,
-                 nil,
-                 (11...13),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "_9"
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       )
-     ),
-     LambdaNode(19...32)(
-       [],
-       (19...21),
-       (22...23),
-       (31...32),
-       nil,
-       StatementsNode(24...31)(
-         [CallNode(24...31)(
-            CallNode(24...26)(
-              nil,
-              nil,
-              (24...26),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "_1"
-            ),
-            nil,
-            (27...28),
-            nil,
-            ArgumentsNode(29...31)(
-              [CallNode(29...31)(
-                 nil,
-                 nil,
-                 (29...31),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "_9"
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       )
-     ),
-     CallNode(34...50)(
-       nil,
-       nil,
-       (34...35),
-       nil,
-       nil,
-       nil,
-       BlockNode(36...50)(
-         [],
-         nil,
-         StatementsNode(39...46)(
-           [CallNode(39...46)(
-              CallNode(39...41)(
-                nil,
-                nil,
-                (39...41),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "_1"
-              ),
-              nil,
-              (42...43),
-              nil,
-              ArgumentsNode(44...46)(
-                [CallNode(44...46)(
-                   nil,
-                   nil,
-                   (44...46),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "_9"
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "+"
-            )]
-         ),
-         (36...38),
-         (47...50)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(52...65)(
-       nil,
-       nil,
-       (52...53),
-       nil,
-       nil,
-       nil,
-       BlockNode(54...65)(
-         [],
-         nil,
-         StatementsNode(56...63)(
-           [CallNode(56...63)(
-              CallNode(56...58)(
-                nil,
-                nil,
-                (56...58),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "_1"
-              ),
-              nil,
-              (59...60),
-              nil,
-              ArgumentsNode(61...63)(
-                [CallNode(61...63)(
-                   nil,
-                   nil,
-                   (61...63),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "_9"
-                 )]
-              ),
-              nil,
-              nil,
-              0,
-              "+"
-            )]
-         ),
-         (54...55),
-         (64...65)
-       ),
-       0,
-       "m"
-     )]
-  )
-)
+@ ProgramNode (location: (0...65))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...65))
+    └── body: (length: 4)
+        ├── @ LambdaNode (location: (0...17))
+        │   ├── locals: []
+        │   ├── operator_loc: (0...2) = "->"
+        │   ├── opening_loc: (3...5) = "do"
+        │   ├── closing_loc: (14...17) = "end"
+        │   ├── parameters: ∅
+        │   └── body:
+        │       @ StatementsNode (location: (6...13))
+        │       └── body: (length: 1)
+        │           └── @ CallNode (location: (6...13))
+        │               ├── receiver:
+        │               │   @ CallNode (location: (6...8))
+        │               │   ├── receiver: ∅
+        │               │   ├── call_operator_loc: ∅
+        │               │   ├── message_loc: (6...8) = "_1"
+        │               │   ├── opening_loc: ∅
+        │               │   ├── arguments: ∅
+        │               │   ├── closing_loc: ∅
+        │               │   ├── block: ∅
+        │               │   ├── flags: variable_call
+        │               │   └── name: "_1"
+        │               ├── call_operator_loc: ∅
+        │               ├── message_loc: (9...10) = "+"
+        │               ├── opening_loc: ∅
+        │               ├── arguments:
+        │               │   @ ArgumentsNode (location: (11...13))
+        │               │   └── arguments: (length: 1)
+        │               │       └── @ CallNode (location: (11...13))
+        │               │           ├── receiver: ∅
+        │               │           ├── call_operator_loc: ∅
+        │               │           ├── message_loc: (11...13) = "_9"
+        │               │           ├── opening_loc: ∅
+        │               │           ├── arguments: ∅
+        │               │           ├── closing_loc: ∅
+        │               │           ├── block: ∅
+        │               │           ├── flags: variable_call
+        │               │           └── name: "_9"
+        │               ├── closing_loc: ∅
+        │               ├── block: ∅
+        │               ├── flags: 
+        │               └── name: "+"
+        ├── @ LambdaNode (location: (19...32))
+        │   ├── locals: []
+        │   ├── operator_loc: (19...21) = "->"
+        │   ├── opening_loc: (22...23) = "{"
+        │   ├── closing_loc: (31...32) = "}"
+        │   ├── parameters: ∅
+        │   └── body:
+        │       @ StatementsNode (location: (24...31))
+        │       └── body: (length: 1)
+        │           └── @ CallNode (location: (24...31))
+        │               ├── receiver:
+        │               │   @ CallNode (location: (24...26))
+        │               │   ├── receiver: ∅
+        │               │   ├── call_operator_loc: ∅
+        │               │   ├── message_loc: (24...26) = "_1"
+        │               │   ├── opening_loc: ∅
+        │               │   ├── arguments: ∅
+        │               │   ├── closing_loc: ∅
+        │               │   ├── block: ∅
+        │               │   ├── flags: variable_call
+        │               │   └── name: "_1"
+        │               ├── call_operator_loc: ∅
+        │               ├── message_loc: (27...28) = "+"
+        │               ├── opening_loc: ∅
+        │               ├── arguments:
+        │               │   @ ArgumentsNode (location: (29...31))
+        │               │   └── arguments: (length: 1)
+        │               │       └── @ CallNode (location: (29...31))
+        │               │           ├── receiver: ∅
+        │               │           ├── call_operator_loc: ∅
+        │               │           ├── message_loc: (29...31) = "_9"
+        │               │           ├── opening_loc: ∅
+        │               │           ├── arguments: ∅
+        │               │           ├── closing_loc: ∅
+        │               │           ├── block: ∅
+        │               │           ├── flags: variable_call
+        │               │           └── name: "_9"
+        │               ├── closing_loc: ∅
+        │               ├── block: ∅
+        │               ├── flags: 
+        │               └── name: "+"
+        ├── @ CallNode (location: (34...50))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (34...35) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (36...50))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body:
+        │   │   │   @ StatementsNode (location: (39...46))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (39...46))
+        │   │   │           ├── receiver:
+        │   │   │           │   @ CallNode (location: (39...41))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (39...41) = "_1"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "_1"
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (42...43) = "+"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments:
+        │   │   │           │   @ ArgumentsNode (location: (44...46))
+        │   │   │           │   └── arguments: (length: 1)
+        │   │   │           │       └── @ CallNode (location: (44...46))
+        │   │   │           │           ├── receiver: ∅
+        │   │   │           │           ├── call_operator_loc: ∅
+        │   │   │           │           ├── message_loc: (44...46) = "_9"
+        │   │   │           │           ├── opening_loc: ∅
+        │   │   │           │           ├── arguments: ∅
+        │   │   │           │           ├── closing_loc: ∅
+        │   │   │           │           ├── block: ∅
+        │   │   │           │           ├── flags: variable_call
+        │   │   │           │           └── name: "_9"
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "+"
+        │   │   ├── opening_loc: (36...38) = "do"
+        │   │   └── closing_loc: (47...50) = "end"
+        │   ├── flags: 
+        │   └── name: "m"
+        └── @ CallNode (location: (52...65))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (52...53) = "m"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (54...65))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (56...63))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (56...63))
+            │   │           ├── receiver:
+            │   │           │   @ CallNode (location: (56...58))
+            │   │           │   ├── receiver: ∅
+            │   │           │   ├── call_operator_loc: ∅
+            │   │           │   ├── message_loc: (56...58) = "_1"
+            │   │           │   ├── opening_loc: ∅
+            │   │           │   ├── arguments: ∅
+            │   │           │   ├── closing_loc: ∅
+            │   │           │   ├── block: ∅
+            │   │           │   ├── flags: variable_call
+            │   │           │   └── name: "_1"
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (59...60) = "+"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments:
+            │   │           │   @ ArgumentsNode (location: (61...63))
+            │   │           │   └── arguments: (length: 1)
+            │   │           │       └── @ CallNode (location: (61...63))
+            │   │           │           ├── receiver: ∅
+            │   │           │           ├── call_operator_loc: ∅
+            │   │           │           ├── message_loc: (61...63) = "_9"
+            │   │           │           ├── opening_loc: ∅
+            │   │           │           ├── arguments: ∅
+            │   │           │           ├── closing_loc: ∅
+            │   │           │           ├── block: ∅
+            │   │           │           ├── flags: variable_call
+            │   │           │           └── name: "_9"
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: 
+            │   │           └── name: "+"
+            │   ├── opening_loc: (54...55) = "{"
+            │   └── closing_loc: (64...65) = "}"
+            ├── flags: 
+            └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/numparam_outside_block.txt b/test/yarp/snapshots/whitequark/numparam_outside_block.txt
index 0dff33b0a9..6d20126a21 100644
--- a/test/yarp/snapshots/whitequark/numparam_outside_block.txt
+++ b/test/yarp/snapshots/whitequark/numparam_outside_block.txt
@@ -1,54 +1,114 @@
-ProgramNode(0...83)(
-  [],
-  StatementsNode(0...83)(
-    [CallNode(0...2)(nil, nil, (0...2), nil, nil, nil, nil, 2, "_1"),
-     SingletonClassNode(4...25)(
-       [],
-       (4...9),
-       (10...12),
-       CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(18...20)(
-         [CallNode(18...20)(nil, nil, (18...20), nil, nil, nil, nil, 2, "_1")]
-       ),
-       (22...25)
-     ),
-     ClassNode(27...43)(
-       [],
-       (27...32),
-       ConstantReadNode(33...34)(:A),
-       nil,
-       nil,
-       StatementsNode(36...38)(
-         [CallNode(36...38)(nil, nil, (36...38), nil, nil, nil, nil, 2, "_1")]
-       ),
-       (40...43),
-       :A
-     ),
-     DefNode(45...64)(
-       :m,
-       (54...55),
-       SelfNode(49...53)(),
-       nil,
-       StatementsNode(57...59)(
-         [CallNode(57...59)(nil, nil, (57...59), nil, nil, nil, nil, 2, "_1")]
-       ),
-       [],
-       (45...48),
-       (53...54),
-       nil,
-       nil,
-       nil,
-       (61...64)
-     ),
-     ModuleNode(66...83)(
-       [],
-       (66...72),
-       ConstantReadNode(73...74)(:A),
-       StatementsNode(76...78)(
-         [CallNode(76...78)(nil, nil, (76...78), nil, nil, nil, nil, 2, "_1")]
-       ),
-       (80...83),
-       :A
-     )]
-  )
-)
+@ ProgramNode (location: (0...83))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...83))
+    └── body: (length: 5)
+        ├── @ CallNode (location: (0...2))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...2) = "_1"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "_1"
+        ├── @ SingletonClassNode (location: (4...25))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (4...9) = "class"
+        │   ├── operator_loc: (10...12) = "<<"
+        │   ├── expression:
+        │   │   @ CallNode (location: (13...16))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (13...16) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── body:
+        │   │   @ StatementsNode (location: (18...20))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (18...20))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (18...20) = "_1"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "_1"
+        │   └── end_keyword_loc: (22...25) = "end"
+        ├── @ ClassNode (location: (27...43))
+        │   ├── locals: []
+        │   ├── class_keyword_loc: (27...32) = "class"
+        │   ├── constant_path:
+        │   │   @ ConstantReadNode (location: (33...34))
+        │   │   └── name: :A
+        │   ├── inheritance_operator_loc: ∅
+        │   ├── superclass: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (36...38))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (36...38))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (36...38) = "_1"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "_1"
+        │   ├── end_keyword_loc: (40...43) = "end"
+        │   └── name: :A
+        ├── @ DefNode (location: (45...64))
+        │   ├── name: :m
+        │   ├── name_loc: (54...55) = "m"
+        │   ├── receiver:
+        │   │   @ SelfNode (location: (49...53))
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (57...59))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (57...59))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (57...59) = "_1"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "_1"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (45...48) = "def"
+        │   ├── operator_loc: (53...54) = "."
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (61...64) = "end"
+        └── @ ModuleNode (location: (66...83))
+            ├── locals: []
+            ├── module_keyword_loc: (66...72) = "module"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (73...74))
+            │   └── name: :A
+            ├── body:
+            │   @ StatementsNode (location: (76...78))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (76...78))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (76...78) = "_1"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "_1"
+            ├── end_keyword_loc: (80...83) = "end"
+            └── name: :A
diff --git a/test/yarp/snapshots/whitequark/op_asgn.txt b/test/yarp/snapshots/whitequark/op_asgn.txt
index 44e3694392..34671f4cab 100644
--- a/test/yarp/snapshots/whitequark/op_asgn.txt
+++ b/test/yarp/snapshots/whitequark/op_asgn.txt
@@ -1,47 +1,77 @@
-ProgramNode(0...35)(
-  [],
-  StatementsNode(0...35)(
-    [CallOperatorWriteNode(0...10)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       (4...5),
-       nil,
-       nil,
-       nil,
-       0,
-       "A",
-       "A=",
-       :+,
-       (6...8),
-       IntegerNode(9...10)()
-     ),
-     CallOperatorWriteNode(12...22)(
-       CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "foo"),
-       (15...16),
-       (16...17),
-       nil,
-       nil,
-       nil,
-       0,
-       "a",
-       "a=",
-       :+,
-       (18...20),
-       IntegerNode(21...22)()
-     ),
-     CallOperatorWriteNode(24...35)(
-       CallNode(24...27)(nil, nil, (24...27), nil, nil, nil, nil, 2, "foo"),
-       (27...29),
-       (29...30),
-       nil,
-       nil,
-       nil,
-       0,
-       "a",
-       "a=",
-       :+,
-       (31...33),
-       IntegerNode(34...35)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...35))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...35))
+    └── body: (length: 3)
+        ├── @ CallOperatorWriteNode (location: (0...10))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: (4...5) = "A"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "A"
+        │   ├── write_name: "A="
+        │   ├── operator: :+
+        │   ├── operator_loc: (6...8) = "+="
+        │   └── value:
+        │       @ IntegerNode (location: (9...10))
+        ├── @ CallOperatorWriteNode (location: (12...22))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (12...15))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (12...15) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (15...16) = "."
+        │   ├── message_loc: (16...17) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "a"
+        │   ├── write_name: "a="
+        │   ├── operator: :+
+        │   ├── operator_loc: (18...20) = "+="
+        │   └── value:
+        │       @ IntegerNode (location: (21...22))
+        └── @ CallOperatorWriteNode (location: (24...35))
+            ├── receiver:
+            │   @ CallNode (location: (24...27))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (24...27) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: (27...29) = "::"
+            ├── message_loc: (29...30) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: 
+            ├── read_name: "a"
+            ├── write_name: "a="
+            ├── operator: :+
+            ├── operator_loc: (31...33) = "+="
+            └── value:
+                @ IntegerNode (location: (34...35))
diff --git a/test/yarp/snapshots/whitequark/op_asgn_cmd.txt b/test/yarp/snapshots/whitequark/op_asgn_cmd.txt
index 9c15e15cde..d0a522d966 100644
--- a/test/yarp/snapshots/whitequark/op_asgn_cmd.txt
+++ b/test/yarp/snapshots/whitequark/op_asgn_cmd.txt
@@ -1,145 +1,183 @@
-ProgramNode(0...64)(
-  [],
-  StatementsNode(0...64)(
-    [CallOperatorWriteNode(0...14)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       (4...5),
-       nil,
-       nil,
-       nil,
-       0,
-       "A",
-       "A=",
-       :+,
-       (6...8),
-       CallNode(9...14)(
-         nil,
-         nil,
-         (9...10),
-         nil,
-         ArgumentsNode(11...14)(
-           [CallNode(11...14)(
-              nil,
-              nil,
-              (11...14),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "m"
-       )
-     ),
-     CallOperatorWriteNode(16...30)(
-       CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "foo"),
-       (19...20),
-       (20...21),
-       nil,
-       nil,
-       nil,
-       0,
-       "a",
-       "a=",
-       :+,
-       (22...24),
-       CallNode(25...30)(
-         nil,
-         nil,
-         (25...26),
-         nil,
-         ArgumentsNode(27...30)(
-           [CallNode(27...30)(
-              nil,
-              nil,
-              (27...30),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "m"
-       )
-     ),
-     ConstantPathOperatorWriteNode(32...47)(
-       ConstantPathNode(32...38)(
-         CallNode(32...35)(nil, nil, (32...35), nil, nil, nil, nil, 2, "foo"),
-         ConstantReadNode(37...38)(:A),
-         (35...37)
-       ),
-       (39...41),
-       CallNode(42...47)(
-         nil,
-         nil,
-         (42...43),
-         nil,
-         ArgumentsNode(44...47)(
-           [CallNode(44...47)(
-              nil,
-              nil,
-              (44...47),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "m"
-       ),
-       :+
-     ),
-     CallOperatorWriteNode(49...64)(
-       CallNode(49...52)(nil, nil, (49...52), nil, nil, nil, nil, 2, "foo"),
-       (52...54),
-       (54...55),
-       nil,
-       nil,
-       nil,
-       0,
-       "a",
-       "a=",
-       :+,
-       (56...58),
-       CallNode(59...64)(
-         nil,
-         nil,
-         (59...60),
-         nil,
-         ArgumentsNode(61...64)(
-           [CallNode(61...64)(
-              nil,
-              nil,
-              (61...64),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "m"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...64))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...64))
+    └── body: (length: 4)
+        ├── @ CallOperatorWriteNode (location: (0...14))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: (4...5) = "A"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "A"
+        │   ├── write_name: "A="
+        │   ├── operator: :+
+        │   ├── operator_loc: (6...8) = "+="
+        │   └── value:
+        │       @ CallNode (location: (9...14))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (9...10) = "m"
+        │       ├── opening_loc: ∅
+        │       ├── arguments:
+        │       │   @ ArgumentsNode (location: (11...14))
+        │       │   └── arguments: (length: 1)
+        │       │       └── @ CallNode (location: (11...14))
+        │       │           ├── receiver: ∅
+        │       │           ├── call_operator_loc: ∅
+        │       │           ├── message_loc: (11...14) = "foo"
+        │       │           ├── opening_loc: ∅
+        │       │           ├── arguments: ∅
+        │       │           ├── closing_loc: ∅
+        │       │           ├── block: ∅
+        │       │           ├── flags: variable_call
+        │       │           └── name: "foo"
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: 
+        │       └── name: "m"
+        ├── @ CallOperatorWriteNode (location: (16...30))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (16...19))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (16...19) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (19...20) = "."
+        │   ├── message_loc: (20...21) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "a"
+        │   ├── write_name: "a="
+        │   ├── operator: :+
+        │   ├── operator_loc: (22...24) = "+="
+        │   └── value:
+        │       @ CallNode (location: (25...30))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (25...26) = "m"
+        │       ├── opening_loc: ∅
+        │       ├── arguments:
+        │       │   @ ArgumentsNode (location: (27...30))
+        │       │   └── arguments: (length: 1)
+        │       │       └── @ CallNode (location: (27...30))
+        │       │           ├── receiver: ∅
+        │       │           ├── call_operator_loc: ∅
+        │       │           ├── message_loc: (27...30) = "foo"
+        │       │           ├── opening_loc: ∅
+        │       │           ├── arguments: ∅
+        │       │           ├── closing_loc: ∅
+        │       │           ├── block: ∅
+        │       │           ├── flags: variable_call
+        │       │           └── name: "foo"
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: 
+        │       └── name: "m"
+        ├── @ ConstantPathOperatorWriteNode (location: (32...47))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (32...38))
+        │   │   ├── parent:
+        │   │   │   @ CallNode (location: (32...35))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (32...35) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (37...38))
+        │   │   │   └── name: :A
+        │   │   └── delimiter_loc: (35...37) = "::"
+        │   ├── operator_loc: (39...41) = "+="
+        │   ├── value:
+        │   │   @ CallNode (location: (42...47))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (42...43) = "m"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (44...47))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ CallNode (location: (44...47))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (44...47) = "foo"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "foo"
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "m"
+        │   └── operator: :+
+        └── @ CallOperatorWriteNode (location: (49...64))
+            ├── receiver:
+            │   @ CallNode (location: (49...52))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (49...52) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: (52...54) = "::"
+            ├── message_loc: (54...55) = "a"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: 
+            ├── read_name: "a"
+            ├── write_name: "a="
+            ├── operator: :+
+            ├── operator_loc: (56...58) = "+="
+            └── value:
+                @ CallNode (location: (59...64))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (59...60) = "m"
+                ├── opening_loc: ∅
+                ├── arguments:
+                │   @ ArgumentsNode (location: (61...64))
+                │   └── arguments: (length: 1)
+                │       └── @ CallNode (location: (61...64))
+                │           ├── receiver: ∅
+                │           ├── call_operator_loc: ∅
+                │           ├── message_loc: (61...64) = "foo"
+                │           ├── opening_loc: ∅
+                │           ├── arguments: ∅
+                │           ├── closing_loc: ∅
+                │           ├── block: ∅
+                │           ├── flags: variable_call
+                │           └── name: "foo"
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/op_asgn_index.txt b/test/yarp/snapshots/whitequark/op_asgn_index.txt
index 153077be96..a2055783fb 100644
--- a/test/yarp/snapshots/whitequark/op_asgn_index.txt
+++ b/test/yarp/snapshots/whitequark/op_asgn_index.txt
@@ -1,19 +1,33 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallOperatorWriteNode(0...14)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...9),
-       (3...4),
-       ArgumentsNode(4...8)([IntegerNode(4...5)(), IntegerNode(7...8)()]),
-       (8...9),
-       0,
-       "[]",
-       "[]=",
-       :+,
-       (10...12),
-       IntegerNode(13...14)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallOperatorWriteNode (location: (0...14))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...9) = "[0, 1]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...8))
+            │   └── arguments: (length: 2)
+            │       ├── @ IntegerNode (location: (4...5))
+            │       └── @ IntegerNode (location: (7...8))
+            ├── closing_loc: (8...9) = "]"
+            ├── flags: 
+            ├── read_name: "[]"
+            ├── write_name: "[]="
+            ├── operator: :+
+            ├── operator_loc: (10...12) = "+="
+            └── value:
+                @ IntegerNode (location: (13...14))
diff --git a/test/yarp/snapshots/whitequark/op_asgn_index_cmd.txt b/test/yarp/snapshots/whitequark/op_asgn_index_cmd.txt
index 9dda56d651..6280b1bfc3 100644
--- a/test/yarp/snapshots/whitequark/op_asgn_index_cmd.txt
+++ b/test/yarp/snapshots/whitequark/op_asgn_index_cmd.txt
@@ -1,41 +1,54 @@
-ProgramNode(0...18)(
-  [],
-  StatementsNode(0...18)(
-    [CallOperatorWriteNode(0...18)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...9),
-       (3...4),
-       ArgumentsNode(4...8)([IntegerNode(4...5)(), IntegerNode(7...8)()]),
-       (8...9),
-       0,
-       "[]",
-       "[]=",
-       :+,
-       (10...12),
-       CallNode(13...18)(
-         nil,
-         nil,
-         (13...14),
-         nil,
-         ArgumentsNode(15...18)(
-           [CallNode(15...18)(
-              nil,
-              nil,
-              (15...18),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "m"
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...18))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...18))
+    └── body: (length: 1)
+        └── @ CallOperatorWriteNode (location: (0...18))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...9) = "[0, 1]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...8))
+            │   └── arguments: (length: 2)
+            │       ├── @ IntegerNode (location: (4...5))
+            │       └── @ IntegerNode (location: (7...8))
+            ├── closing_loc: (8...9) = "]"
+            ├── flags: 
+            ├── read_name: "[]"
+            ├── write_name: "[]="
+            ├── operator: :+
+            ├── operator_loc: (10...12) = "+="
+            └── value:
+                @ CallNode (location: (13...18))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (13...14) = "m"
+                ├── opening_loc: ∅
+                ├── arguments:
+                │   @ ArgumentsNode (location: (15...18))
+                │   └── arguments: (length: 1)
+                │       └── @ CallNode (location: (15...18))
+                │           ├── receiver: ∅
+                │           ├── call_operator_loc: ∅
+                │           ├── message_loc: (15...18) = "foo"
+                │           ├── opening_loc: ∅
+                │           ├── arguments: ∅
+                │           ├── closing_loc: ∅
+                │           ├── block: ∅
+                │           ├── flags: variable_call
+                │           └── name: "foo"
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: 
+                └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/optarg.txt b/test/yarp/snapshots/whitequark/optarg.txt
index f2a0dd2437..20a4288191 100644
--- a/test/yarp/snapshots/whitequark/optarg.txt
+++ b/test/yarp/snapshots/whitequark/optarg.txt
@@ -1,65 +1,65 @@
-ProgramNode(0...44)(
-  [],
-  StatementsNode(0...44)(
-    [DefNode(0...18)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...13)(
-         [],
-         [OptionalParameterNode(6...13)(
-            :foo,
-            (6...9),
-            (10...11),
-            IntegerNode(12...13)()
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:foo],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (15...18)
-     ),
-     DefNode(20...44)(
-       :f,
-       (24...25),
-       nil,
-       ParametersNode(26...38)(
-         [],
-         [OptionalParameterNode(26...31)(
-            :foo,
-            (26...29),
-            (29...30),
-            IntegerNode(30...31)()
-          ),
-          OptionalParameterNode(33...38)(
-            :bar,
-            (33...36),
-            (36...37),
-            IntegerNode(37...38)()
-          )],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:foo, :bar],
-       (20...23),
-       nil,
-       (25...26),
-       (38...39),
-       nil,
-       (41...44)
-     )]
-  )
-)
+@ ProgramNode (location: (0...44))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...44))
+    └── body: (length: 2)
+        ├── @ DefNode (location: (0...18))
+        │   ├── name: :f
+        │   ├── name_loc: (4...5) = "f"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (6...13))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 1)
+        │   │   │   └── @ OptionalParameterNode (location: (6...13))
+        │   │   │       ├── name: :foo
+        │   │   │       ├── name_loc: (6...9) = "foo"
+        │   │   │       ├── operator_loc: (10...11) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (12...13))
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:foo]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (15...18) = "end"
+        └── @ DefNode (location: (20...44))
+            ├── name: :f
+            ├── name_loc: (24...25) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (26...38))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 2)
+            │   │   ├── @ OptionalParameterNode (location: (26...31))
+            │   │   │   ├── name: :foo
+            │   │   │   ├── name_loc: (26...29) = "foo"
+            │   │   │   ├── operator_loc: (29...30) = "="
+            │   │   │   └── value:
+            │   │   │       @ IntegerNode (location: (30...31))
+            │   │   └── @ OptionalParameterNode (location: (33...38))
+            │   │       ├── name: :bar
+            │   │       ├── name_loc: (33...36) = "bar"
+            │   │       ├── operator_loc: (36...37) = "="
+            │   │       └── value:
+            │   │           @ IntegerNode (location: (37...38))
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:foo, :bar]
+            ├── def_keyword_loc: (20...23) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (25...26) = "("
+            ├── rparen_loc: (38...39) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (41...44) = "end"
diff --git a/test/yarp/snapshots/whitequark/or.txt b/test/yarp/snapshots/whitequark/or.txt
index fb1599df1d..c86cd9a95a 100644
--- a/test/yarp/snapshots/whitequark/or.txt
+++ b/test/yarp/snapshots/whitequark/or.txt
@@ -1,15 +1,53 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [OrNode(0...10)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       CallNode(7...10)(nil, nil, (7...10), nil, nil, nil, nil, 2, "bar"),
-       (4...6)
-     ),
-     OrNode(12...22)(
-       CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "foo"),
-       CallNode(19...22)(nil, nil, (19...22), nil, nil, nil, nil, 2, "bar"),
-       (16...18)
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 2)
+        ├── @ OrNode (location: (0...10))
+        │   ├── left:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── right:
+        │   │   @ CallNode (location: (7...10))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (7...10) = "bar"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "bar"
+        │   └── operator_loc: (4...6) = "or"
+        └── @ OrNode (location: (12...22))
+            ├── left:
+            │   @ CallNode (location: (12...15))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (12...15) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── right:
+            │   @ CallNode (location: (19...22))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (19...22) = "bar"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "bar"
+            └── operator_loc: (16...18) = "||"
diff --git a/test/yarp/snapshots/whitequark/or_asgn.txt b/test/yarp/snapshots/whitequark/or_asgn.txt
index f681a31982..a97ea26848 100644
--- a/test/yarp/snapshots/whitequark/or_asgn.txt
+++ b/test/yarp/snapshots/whitequark/or_asgn.txt
@@ -1,33 +1,55 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CallOrWriteNode(0...11)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       (4...5),
-       nil,
-       nil,
-       nil,
-       0,
-       "a",
-       "a=",
-       (6...9),
-       IntegerNode(10...11)()
-     ),
-     CallOrWriteNode(13...28)(
-       CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (16...22),
-       (16...17),
-       ArgumentsNode(17...21)(
-         [IntegerNode(17...18)(), IntegerNode(20...21)()]
-       ),
-       (21...22),
-       0,
-       "[]",
-       "[]=",
-       (23...26),
-       IntegerNode(27...28)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 2)
+        ├── @ CallOrWriteNode (location: (0...11))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: (4...5) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "a"
+        │   ├── write_name: "a="
+        │   ├── operator_loc: (6...9) = "||="
+        │   └── value:
+        │       @ IntegerNode (location: (10...11))
+        └── @ CallOrWriteNode (location: (13...28))
+            ├── receiver:
+            │   @ CallNode (location: (13...16))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (13...16) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (16...22) = "[0, 1]"
+            ├── opening_loc: (16...17) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (17...21))
+            │   └── arguments: (length: 2)
+            │       ├── @ IntegerNode (location: (17...18))
+            │       └── @ IntegerNode (location: (20...21))
+            ├── closing_loc: (21...22) = "]"
+            ├── flags: 
+            ├── read_name: "[]"
+            ├── write_name: "[]="
+            ├── operator_loc: (23...26) = "||="
+            └── value:
+                @ IntegerNode (location: (27...28))
diff --git a/test/yarp/snapshots/whitequark/parser_bug_272.txt b/test/yarp/snapshots/whitequark/parser_bug_272.txt
index 0cb194d1ae..22d71b77c7 100644
--- a/test/yarp/snapshots/whitequark/parser_bug_272.txt
+++ b/test/yarp/snapshots/whitequark/parser_bug_272.txt
@@ -1,35 +1,40 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [CallNode(0...15)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...4)([InstanceVariableReadNode(2...4)(:@b)]),
-       nil,
-       BlockNode(5...15)(
-         [:c],
-         BlockParametersNode(8...11)(
-           ParametersNode(9...10)(
-             [RequiredParameterNode(9...10)(:c)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (8...9),
-           (10...11)
-         ),
-         nil,
-         (5...7),
-         (12...15)
-       ),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...15))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...4))
+            │   └── arguments: (length: 1)
+            │       └── @ InstanceVariableReadNode (location: (2...4))
+            │           └── name: :@b
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (5...15))
+            │   ├── locals: [:c]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (8...11))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (9...10))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (9...10))
+            │   │   │   │       └── name: :c
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (8...9) = "|"
+            │   │   └── closing_loc: (10...11) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (5...7) = "do"
+            │   └── closing_loc: (12...15) = "end"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/whitequark/parser_bug_490.txt b/test/yarp/snapshots/whitequark/parser_bug_490.txt
index 5c087b60f6..e9f66337cb 100644
--- a/test/yarp/snapshots/whitequark/parser_bug_490.txt
+++ b/test/yarp/snapshots/whitequark/parser_bug_490.txt
@@ -1,101 +1,106 @@
-ProgramNode(0...132)(
-  [],
-  StatementsNode(0...132)(
-    [DefNode(0...39)(
-       :m,
-       (4...5),
-       nil,
-       nil,
-       StatementsNode(7...34)(
-         [SingletonClassNode(7...34)(
-            [],
-            (7...12),
-            (13...15),
-            SelfNode(16...20)(),
-            StatementsNode(22...29)(
-              [ConstantWriteNode(22...29)(
-                 :A,
-                 (22...23),
-                 NilNode(26...29)(),
-                 (24...25)
-               )]
-            ),
-            (31...34)
-          )]
-       ),
-       [],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (36...39)
-     ),
-     DefNode(41...85)(
-       :m,
-       (45...46),
-       nil,
-       nil,
-       StatementsNode(48...80)(
-         [SingletonClassNode(48...80)(
-            [],
-            (48...53),
-            (54...56),
-            SelfNode(57...61)(),
-            StatementsNode(63...75)(
-              [ClassNode(63...75)(
-                 [],
-                 (63...68),
-                 ConstantReadNode(69...70)(:C),
-                 nil,
-                 nil,
-                 nil,
-                 (72...75),
-                 :C
-               )]
-            ),
-            (77...80)
-          )]
-       ),
-       [],
-       (41...44),
-       nil,
-       nil,
-       nil,
-       nil,
-       (82...85)
-     ),
-     DefNode(87...132)(
-       :m,
-       (91...92),
-       nil,
-       nil,
-       StatementsNode(94...127)(
-         [SingletonClassNode(94...127)(
-            [],
-            (94...99),
-            (100...102),
-            SelfNode(103...107)(),
-            StatementsNode(109...122)(
-              [ModuleNode(109...122)(
-                 [],
-                 (109...115),
-                 ConstantReadNode(116...117)(:M),
-                 nil,
-                 (119...122),
-                 :M
-               )]
-            ),
-            (124...127)
-          )]
-       ),
-       [],
-       (87...90),
-       nil,
-       nil,
-       nil,
-       nil,
-       (129...132)
-     )]
-  )
-)
+@ ProgramNode (location: (0...132))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...132))
+    └── body: (length: 3)
+        ├── @ DefNode (location: (0...39))
+        │   ├── name: :m
+        │   ├── name_loc: (4...5) = "m"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (7...34))
+        │   │   └── body: (length: 1)
+        │   │       └── @ SingletonClassNode (location: (7...34))
+        │   │           ├── locals: []
+        │   │           ├── class_keyword_loc: (7...12) = "class"
+        │   │           ├── operator_loc: (13...15) = "<<"
+        │   │           ├── expression:
+        │   │           │   @ SelfNode (location: (16...20))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (22...29))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ ConstantWriteNode (location: (22...29))
+        │   │           │           ├── name: :A
+        │   │           │           ├── name_loc: (22...23) = "A"
+        │   │           │           ├── value:
+        │   │           │           │   @ NilNode (location: (26...29))
+        │   │           │           └── operator_loc: (24...25) = "="
+        │   │           └── end_keyword_loc: (31...34) = "end"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (36...39) = "end"
+        ├── @ DefNode (location: (41...85))
+        │   ├── name: :m
+        │   ├── name_loc: (45...46) = "m"
+        │   ├── receiver: ∅
+        │   ├── parameters: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (48...80))
+        │   │   └── body: (length: 1)
+        │   │       └── @ SingletonClassNode (location: (48...80))
+        │   │           ├── locals: []
+        │   │           ├── class_keyword_loc: (48...53) = "class"
+        │   │           ├── operator_loc: (54...56) = "<<"
+        │   │           ├── expression:
+        │   │           │   @ SelfNode (location: (57...61))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (63...75))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ ClassNode (location: (63...75))
+        │   │           │           ├── locals: []
+        │   │           │           ├── class_keyword_loc: (63...68) = "class"
+        │   │           │           ├── constant_path:
+        │   │           │           │   @ ConstantReadNode (location: (69...70))
+        │   │           │           │   └── name: :C
+        │   │           │           ├── inheritance_operator_loc: ∅
+        │   │           │           ├── superclass: ∅
+        │   │           │           ├── body: ∅
+        │   │           │           ├── end_keyword_loc: (72...75) = "end"
+        │   │           │           └── name: :C
+        │   │           └── end_keyword_loc: (77...80) = "end"
+        │   ├── locals: []
+        │   ├── def_keyword_loc: (41...44) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (82...85) = "end"
+        └── @ DefNode (location: (87...132))
+            ├── name: :m
+            ├── name_loc: (91...92) = "m"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (94...127))
+            │   └── body: (length: 1)
+            │       └── @ SingletonClassNode (location: (94...127))
+            │           ├── locals: []
+            │           ├── class_keyword_loc: (94...99) = "class"
+            │           ├── operator_loc: (100...102) = "<<"
+            │           ├── expression:
+            │           │   @ SelfNode (location: (103...107))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (109...122))
+            │           │   └── body: (length: 1)
+            │           │       └── @ ModuleNode (location: (109...122))
+            │           │           ├── locals: []
+            │           │           ├── module_keyword_loc: (109...115) = "module"
+            │           │           ├── constant_path:
+            │           │           │   @ ConstantReadNode (location: (116...117))
+            │           │           │   └── name: :M
+            │           │           ├── body: ∅
+            │           │           ├── end_keyword_loc: (119...122) = "end"
+            │           │           └── name: :M
+            │           └── end_keyword_loc: (124...127) = "end"
+            ├── locals: []
+            ├── def_keyword_loc: (87...90) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (129...132) = "end"
diff --git a/test/yarp/snapshots/whitequark/parser_bug_507.txt b/test/yarp/snapshots/whitequark/parser_bug_507.txt
index 07e5d8ed60..2d2200365c 100644
--- a/test/yarp/snapshots/whitequark/parser_bug_507.txt
+++ b/test/yarp/snapshots/whitequark/parser_bug_507.txt
@@ -1,32 +1,35 @@
-ProgramNode(0...19)(
-  [:m],
-  StatementsNode(0...19)(
-    [LocalVariableWriteNode(0...19)(
-       :m,
-       0,
-       (0...1),
-       LambdaNode(4...19)(
-         [:args],
-         (4...6),
-         (13...15),
-         (16...19),
-         BlockParametersNode(7...12)(
-           ParametersNode(7...12)(
-             [],
-             [],
-             [],
-             RestParameterNode(7...12)(:args, (8...12), (7...8)),
-             [],
-             nil,
-             nil
-           ),
-           [],
-           nil,
-           nil
-         ),
-         nil
-       ),
-       (2...3)
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: [:m]
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...19))
+            ├── name: :m
+            ├── depth: 0
+            ├── name_loc: (0...1) = "m"
+            ├── value:
+            │   @ LambdaNode (location: (4...19))
+            │   ├── locals: [:args]
+            │   ├── operator_loc: (4...6) = "->"
+            │   ├── opening_loc: (13...15) = "do"
+            │   ├── closing_loc: (16...19) = "end"
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (7...12))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (7...12))
+            │   │   │   ├── requireds: (length: 0)
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest:
+            │   │   │   │   @ RestParameterNode (location: (7...12))
+            │   │   │   │   ├── name: :args
+            │   │   │   │   ├── name_loc: (8...12) = "args"
+            │   │   │   │   └── operator_loc: (7...8) = "*"
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: ∅
+            │   │   └── closing_loc: ∅
+            │   └── body: ∅
+            └── operator_loc: (2...3) = "="
diff --git a/test/yarp/snapshots/whitequark/parser_bug_518.txt b/test/yarp/snapshots/whitequark/parser_bug_518.txt
index 1f2cca8d1d..841045e342 100644
--- a/test/yarp/snapshots/whitequark/parser_bug_518.txt
+++ b/test/yarp/snapshots/whitequark/parser_bug_518.txt
@@ -1,15 +1,18 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [ClassNode(0...15)(
-       [],
-       (0...5),
-       ConstantReadNode(6...7)(:A),
-       (8...9),
-       ConstantReadNode(10...11)(:B),
-       nil,
-       (12...15),
-       :A
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ ClassNode (location: (0...15))
+            ├── locals: []
+            ├── class_keyword_loc: (0...5) = "class"
+            ├── constant_path:
+            │   @ ConstantReadNode (location: (6...7))
+            │   └── name: :A
+            ├── inheritance_operator_loc: (8...9) = "<"
+            ├── superclass:
+            │   @ ConstantReadNode (location: (10...11))
+            │   └── name: :B
+            ├── body: ∅
+            ├── end_keyword_loc: (12...15) = "end"
+            └── name: :A
diff --git a/test/yarp/snapshots/whitequark/parser_bug_525.txt b/test/yarp/snapshots/whitequark/parser_bug_525.txt
index 0b5c2a5a44..127a7d48b9 100644
--- a/test/yarp/snapshots/whitequark/parser_bug_525.txt
+++ b/test/yarp/snapshots/whitequark/parser_bug_525.txt
@@ -1,52 +1,62 @@
-ProgramNode(0...32)(
-  [],
-  StatementsNode(0...32)(
-    [CallNode(0...32)(
-       nil,
-       nil,
-       (0...2),
-       nil,
-       ArgumentsNode(3...11)(
-         [KeywordHashNode(3...11)(
-            [AssocNode(3...11)(
-               SymbolNode(3...5)((3...4), (4...5), nil, "k"),
-               CallNode(9...11)(
-                 nil,
-                 nil,
-                 (9...11),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "m2"
-               ),
-               (6...8)
-             )]
-          )]
-       ),
-       nil,
-       BlockNode(12...32)(
-         [],
-         nil,
-         StatementsNode(16...27)(
-           [CallNode(16...27)(
-              nil,
-              nil,
-              (16...18),
-              (18...19),
-              nil,
-              (19...20),
-              BlockNode(21...27)([], nil, nil, (21...23), (24...27)),
-              0,
-              "m3"
-            )]
-         ),
-         (12...14),
-         (29...32)
-       ),
-       0,
-       "m1"
-     )]
-  )
-)
+@ ProgramNode (location: (0...32))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...32))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...32))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...2) = "m1"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (3...11))
+            │   └── arguments: (length: 1)
+            │       └── @ KeywordHashNode (location: (3...11))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (3...11))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (3...5))
+            │                   │   ├── opening_loc: (3...4) = ":"
+            │                   │   ├── value_loc: (4...5) = "k"
+            │                   │   ├── closing_loc: ∅
+            │                   │   └── unescaped: "k"
+            │                   ├── value:
+            │                   │   @ CallNode (location: (9...11))
+            │                   │   ├── receiver: ∅
+            │                   │   ├── call_operator_loc: ∅
+            │                   │   ├── message_loc: (9...11) = "m2"
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── arguments: ∅
+            │                   │   ├── closing_loc: ∅
+            │                   │   ├── block: ∅
+            │                   │   ├── flags: variable_call
+            │                   │   └── name: "m2"
+            │                   └── operator_loc: (6...8) = "=>"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (12...32))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (16...27))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (16...27))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (16...18) = "m3"
+            │   │           ├── opening_loc: (18...19) = "("
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: (19...20) = ")"
+            │   │           ├── block:
+            │   │           │   @ BlockNode (location: (21...27))
+            │   │           │   ├── locals: []
+            │   │           │   ├── parameters: ∅
+            │   │           │   ├── body: ∅
+            │   │           │   ├── opening_loc: (21...23) = "do"
+            │   │           │   └── closing_loc: (24...27) = "end"
+            │   │           ├── flags: 
+            │   │           └── name: "m3"
+            │   ├── opening_loc: (12...14) = "do"
+            │   └── closing_loc: (29...32) = "end"
+            ├── flags: 
+            └── name: "m1"
diff --git a/test/yarp/snapshots/whitequark/parser_bug_604.txt b/test/yarp/snapshots/whitequark/parser_bug_604.txt
index ff732e34c5..558c202863 100644
--- a/test/yarp/snapshots/whitequark/parser_bug_604.txt
+++ b/test/yarp/snapshots/whitequark/parser_bug_604.txt
@@ -1,30 +1,55 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [CallNode(0...14)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...7)(
-         [CallNode(2...7)(
-            CallNode(2...3)(nil, nil, (2...3), nil, nil, nil, nil, 2, "a"),
-            nil,
-            (4...5),
-            nil,
-            ArgumentsNode(6...7)(
-              [CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b")]
-            ),
-            nil,
-            nil,
-            0,
-            "+"
-          )]
-       ),
-       nil,
-       BlockNode(8...14)([], nil, nil, (8...10), (11...14)),
-       0,
-       "m"
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...14))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "m"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...7))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (2...7))
+            │           ├── receiver:
+            │           │   @ CallNode (location: (2...3))
+            │           │   ├── receiver: ∅
+            │           │   ├── call_operator_loc: ∅
+            │           │   ├── message_loc: (2...3) = "a"
+            │           │   ├── opening_loc: ∅
+            │           │   ├── arguments: ∅
+            │           │   ├── closing_loc: ∅
+            │           │   ├── block: ∅
+            │           │   ├── flags: variable_call
+            │           │   └── name: "a"
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (4...5) = "+"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (6...7))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ CallNode (location: (6...7))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (6...7) = "b"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "b"
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "+"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (8...14))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (8...10) = "do"
+            │   └── closing_loc: (11...14) = "end"
+            ├── flags: 
+            └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/parser_bug_640.txt b/test/yarp/snapshots/whitequark/parser_bug_640.txt
index 5ca73c08a5..773d288079 100644
--- a/test/yarp/snapshots/whitequark/parser_bug_640.txt
+++ b/test/yarp/snapshots/whitequark/parser_bug_640.txt
@@ -1,10 +1,14 @@
-ProgramNode(0...6)(
-  [],
-  StatementsNode(0...6)(
-    [InterpolatedStringNode(0...6)(
-       (0...6),
-       [StringNode(7...20)(nil, (7...20), nil, "bazqux\n")],
-       (20...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...6))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...6))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...6))
+            ├── opening_loc: (0...6) = "<<~FOO"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (7...20))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (7...20) = "  baz\\\n  qux\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "bazqux\n"
+            └── closing_loc: (20...24) = "FOO\n"
diff --git a/test/yarp/snapshots/whitequark/parser_bug_645.txt b/test/yarp/snapshots/whitequark/parser_bug_645.txt
index 27680b00ae..458c443a9f 100644
--- a/test/yarp/snapshots/whitequark/parser_bug_645.txt
+++ b/test/yarp/snapshots/whitequark/parser_bug_645.txt
@@ -1,31 +1,34 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [LambdaNode(0...14)(
-       [:arg],
-       (0...2),
-       (12...13),
-       (13...14),
-       BlockParametersNode(3...11)(
-         ParametersNode(4...10)(
-           [],
-           [OptionalParameterNode(4...10)(
-              :arg,
-              (4...7),
-              (7...8),
-              HashNode(8...10)((8...9), [], (9...10))
-            )],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (3...4),
-         (10...11)
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...14))
+            ├── locals: [:arg]
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (12...13) = "{"
+            ├── closing_loc: (13...14) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (3...11))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (4...10))
+            │   │   ├── requireds: (length: 0)
+            │   │   ├── optionals: (length: 1)
+            │   │   │   └── @ OptionalParameterNode (location: (4...10))
+            │   │   │       ├── name: :arg
+            │   │   │       ├── name_loc: (4...7) = "arg"
+            │   │   │       ├── operator_loc: (7...8) = "="
+            │   │   │       └── value:
+            │   │   │           @ HashNode (location: (8...10))
+            │   │   │           ├── opening_loc: (8...9) = "{"
+            │   │   │           ├── elements: (length: 0)
+            │   │   │           └── closing_loc: (9...10) = "}"
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 0)
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: (3...4) = "("
+            │   └── closing_loc: (10...11) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/whitequark/parser_bug_830.txt b/test/yarp/snapshots/whitequark/parser_bug_830.txt
index c8f0c34e7d..003f1cae27 100644
--- a/test/yarp/snapshots/whitequark/parser_bug_830.txt
+++ b/test/yarp/snapshots/whitequark/parser_bug_830.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [RegularExpressionNode(0...4)((0...1), (1...3), (3...4), "(", 0)]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ RegularExpressionNode (location: (0...4))
+            ├── opening_loc: (0...1) = "/"
+            ├── content_loc: (1...3) = "\\("
+            ├── closing_loc: (3...4) = "/"
+            ├── unescaped: "("
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/parser_drops_truncated_parts_of_squiggly_heredoc.txt b/test/yarp/snapshots/whitequark/parser_drops_truncated_parts_of_squiggly_heredoc.txt
index d2fe26f163..505df968c3 100644
--- a/test/yarp/snapshots/whitequark/parser_drops_truncated_parts_of_squiggly_heredoc.txt
+++ b/test/yarp/snapshots/whitequark/parser_drops_truncated_parts_of_squiggly_heredoc.txt
@@ -1,11 +1,18 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [InterpolatedStringNode(0...7)(
-       (0...7),
-       [EmbeddedStatementsNode(10...13)((10...12), nil, (12...13)),
-        StringNode(13...14)(nil, (13...14), nil, "\n")],
-       (14...19)
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...7))
+            ├── opening_loc: (0...7) = "<<~HERE"
+            ├── parts: (length: 2)
+            │   ├── @ EmbeddedStatementsNode (location: (10...13))
+            │   │   ├── opening_loc: (10...12) = "\#{"
+            │   │   ├── statements: ∅
+            │   │   └── closing_loc: (12...13) = "}"
+            │   └── @ StringNode (location: (13...14))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (13...14) = "\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "\n"
+            └── closing_loc: (14...19) = "HERE\n"
diff --git a/test/yarp/snapshots/whitequark/parser_slash_slash_n_escaping_in_literals.txt b/test/yarp/snapshots/whitequark/parser_slash_slash_n_escaping_in_literals.txt
index 3a3377f96d..c76b8f98bb 100644
--- a/test/yarp/snapshots/whitequark/parser_slash_slash_n_escaping_in_literals.txt
+++ b/test/yarp/snapshots/whitequark/parser_slash_slash_n_escaping_in_literals.txt
@@ -1,63 +1,130 @@
-ProgramNode(0...210)(
-  [],
-  StatementsNode(0...210)(
-    [StringNode(0...6)((0...1), (1...5), (5...6), "ab"),
-     ArrayNode(8...16)(
-       [SymbolNode(11...15)(nil, (11...15), nil, "ab")],
-       (8...11),
-       (15...16)
-     ),
-     StringNode(18...26)((18...21), (21...25), (25...26), "ab"),
-     ArrayNode(28...36)(
-       [StringNode(31...35)(nil, (31...35), nil, "ab")],
-       (28...31),
-       (35...36)
-     ),
-     ArrayNode(38...46)(
-       [SymbolNode(41...45)(nil, (41...45), nil, "a\\\n" + "b")],
-       (38...41),
-       (45...46)
-     ),
-     StringNode(48...56)((48...51), (51...55), (55...56), "a\\\n" + "b"),
-     RegularExpressionNode(58...66)((58...61), (61...65), (65...66), "ab", 0),
-     SymbolNode(68...76)((68...71), (71...75), (75...76), "ab"),
-     ArrayNode(78...86)(
-       [StringNode(81...85)(nil, (81...85), nil, "a\\\n" + "b")],
-       (78...81),
-       (85...86)
-     ),
-     XStringNode(88...96)((88...91), (91...95), (95...96), "ab"),
-     StringNode(98...105)((98...100), (100...104), (104...105), "ab"),
-     StringNode(107...113)(
-       (107...108),
-       (108...112),
-       (112...113),
-       "a\\\n" + "b"
-     ),
-     RegularExpressionNode(115...121)(
-       (115...116),
-       (116...120),
-       (120...121),
-       "ab",
-       0
-     ),
-     SymbolNode(123...130)((123...125), (125...129), (129...130), "ab"),
-     SymbolNode(132...139)((132...134), (134...138), (138...139), "ab"),
-     InterpolatedStringNode(141...150)(
-       (141...150),
-       [StringNode(151...156)(nil, (151...156), nil, "ab\n")],
-       (156...161)
-     ),
-     InterpolatedStringNode(162...171)(
-       (162...171),
-       [StringNode(172...177)(nil, (172...177), nil, "a\\\n" + "b\n")],
-       (177...182)
-     ),
-     InterpolatedXStringNode(183...192)(
-       (183...192),
-       [StringNode(193...198)(nil, (193...198), nil, "ab\n")],
-       (198...203)
-     ),
-     XStringNode(204...210)((204...205), (205...209), (209...210), "ab")]
-  )
-)
+@ ProgramNode (location: (0...210))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...210))
+    └── body: (length: 19)
+        ├── @ StringNode (location: (0...6))
+        │   ├── opening_loc: (0...1) = "\""
+        │   ├── content_loc: (1...5) = "a\\\nb"
+        │   ├── closing_loc: (5...6) = "\""
+        │   └── unescaped: "ab"
+        ├── @ ArrayNode (location: (8...16))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SymbolNode (location: (11...15))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (11...15) = "a\\\nb"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "ab"
+        │   ├── opening_loc: (8...11) = "%I{"
+        │   └── closing_loc: (15...16) = "}"
+        ├── @ StringNode (location: (18...26))
+        │   ├── opening_loc: (18...21) = "%Q{"
+        │   ├── content_loc: (21...25) = "a\\\nb"
+        │   ├── closing_loc: (25...26) = "}"
+        │   └── unescaped: "ab"
+        ├── @ ArrayNode (location: (28...36))
+        │   ├── elements: (length: 1)
+        │   │   └── @ StringNode (location: (31...35))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (31...35) = "a\\\nb"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "ab"
+        │   ├── opening_loc: (28...31) = "%W{"
+        │   └── closing_loc: (35...36) = "}"
+        ├── @ ArrayNode (location: (38...46))
+        │   ├── elements: (length: 1)
+        │   │   └── @ SymbolNode (location: (41...45))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── value_loc: (41...45) = "a\\\nb"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\\\nb"
+        │   ├── opening_loc: (38...41) = "%i{"
+        │   └── closing_loc: (45...46) = "}"
+        ├── @ StringNode (location: (48...56))
+        │   ├── opening_loc: (48...51) = "%q{"
+        │   ├── content_loc: (51...55) = "a\\\nb"
+        │   ├── closing_loc: (55...56) = "}"
+        │   └── unescaped: "a\\\nb"
+        ├── @ RegularExpressionNode (location: (58...66))
+        │   ├── opening_loc: (58...61) = "%r{"
+        │   ├── content_loc: (61...65) = "a\\\nb"
+        │   ├── closing_loc: (65...66) = "}"
+        │   ├── unescaped: "ab"
+        │   └── flags: 
+        ├── @ SymbolNode (location: (68...76))
+        │   ├── opening_loc: (68...71) = "%s{"
+        │   ├── value_loc: (71...75) = "a\\\nb"
+        │   ├── closing_loc: (75...76) = "}"
+        │   └── unescaped: "ab"
+        ├── @ ArrayNode (location: (78...86))
+        │   ├── elements: (length: 1)
+        │   │   └── @ StringNode (location: (81...85))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (81...85) = "a\\\nb"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\\\nb"
+        │   ├── opening_loc: (78...81) = "%w{"
+        │   └── closing_loc: (85...86) = "}"
+        ├── @ XStringNode (location: (88...96))
+        │   ├── opening_loc: (88...91) = "%x{"
+        │   ├── content_loc: (91...95) = "a\\\nb"
+        │   ├── closing_loc: (95...96) = "}"
+        │   └── unescaped: "ab"
+        ├── @ StringNode (location: (98...105))
+        │   ├── opening_loc: (98...100) = "%{"
+        │   ├── content_loc: (100...104) = "a\\\nb"
+        │   ├── closing_loc: (104...105) = "}"
+        │   └── unescaped: "ab"
+        ├── @ StringNode (location: (107...113))
+        │   ├── opening_loc: (107...108) = "'"
+        │   ├── content_loc: (108...112) = "a\\\nb"
+        │   ├── closing_loc: (112...113) = "'"
+        │   └── unescaped: "a\\\nb"
+        ├── @ RegularExpressionNode (location: (115...121))
+        │   ├── opening_loc: (115...116) = "/"
+        │   ├── content_loc: (116...120) = "a\\\nb"
+        │   ├── closing_loc: (120...121) = "/"
+        │   ├── unescaped: "ab"
+        │   └── flags: 
+        ├── @ SymbolNode (location: (123...130))
+        │   ├── opening_loc: (123...125) = ":\""
+        │   ├── value_loc: (125...129) = "a\\\nb"
+        │   ├── closing_loc: (129...130) = "\""
+        │   └── unescaped: "ab"
+        ├── @ SymbolNode (location: (132...139))
+        │   ├── opening_loc: (132...134) = ":'"
+        │   ├── value_loc: (134...138) = "a\\\nb"
+        │   ├── closing_loc: (138...139) = "'"
+        │   └── unescaped: "ab"
+        ├── @ InterpolatedStringNode (location: (141...150))
+        │   ├── opening_loc: (141...150) = "<<-\"HERE\""
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (151...156))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (151...156) = "a\\\nb\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "ab\n"
+        │   └── closing_loc: (156...161) = "HERE\n"
+        ├── @ InterpolatedStringNode (location: (162...171))
+        │   ├── opening_loc: (162...171) = "<<-'HERE'"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (172...177))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (172...177) = "a\\\nb\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "a\\\nb\n"
+        │   └── closing_loc: (177...182) = "HERE\n"
+        ├── @ InterpolatedXStringNode (location: (183...192))
+        │   ├── opening_loc: (183...192) = "<<-`HERE`"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (193...198))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (193...198) = "a\\\nb\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "ab\n"
+        │   └── closing_loc: (198...203) = "HERE\n"
+        └── @ XStringNode (location: (204...210))
+            ├── opening_loc: (204...205) = "`"
+            ├── content_loc: (205...209) = "a\\\nb"
+            ├── closing_loc: (209...210) = "`"
+            └── unescaped: "ab"
diff --git a/test/yarp/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt b/test/yarp/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt
index 55938adfd8..8521e21dab 100644
--- a/test/yarp/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt
+++ b/test/yarp/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt
@@ -1,46 +1,48 @@
-ProgramNode(8...111)(
-  [],
-  StatementsNode(8...111)(
-    [CaseNode(8...111)(
-       ArrayNode(13...51)(
-         [SourceFileNode(14...22)(
-            "whitequark/pattern_matching__FILE__LINE_literals.txt"
-          ),
-          CallNode(24...36)(
-            SourceLineNode(24...32)(),
-            nil,
-            (33...34),
-            nil,
-            ArgumentsNode(35...36)([IntegerNode(35...36)()]),
-            nil,
-            nil,
-            0,
-            "+"
-          ),
-          SourceEncodingNode(38...50)()],
-         (13...14),
-         (50...51)
-       ),
-       [InNode(62...99)(
-          ArrayPatternNode(65...99)(
-            nil,
-            [SourceFileNode(66...74)(
-               "whitequark/pattern_matching__FILE__LINE_literals.txt"
-             ),
-             SourceLineNode(76...84)(),
-             SourceEncodingNode(86...98)()],
-            nil,
-            [],
-            (65...66),
-            (98...99)
-          ),
-          nil,
-          (62...64),
-          nil
-        )],
-       nil,
-       (8...12),
-       (108...111)
-     )]
-  )
-)
+@ ProgramNode (location: (8...111))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (8...111))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (8...111))
+            ├── predicate:
+            │   @ ArrayNode (location: (13...51))
+            │   ├── elements: (length: 3)
+            │   │   ├── @ SourceFileNode (location: (14...22))
+            │   │   │   └── filepath: "whitequark/pattern_matching__FILE__LINE_literals.txt"
+            │   │   ├── @ CallNode (location: (24...36))
+            │   │   │   ├── receiver:
+            │   │   │   │   @ SourceLineNode (location: (24...32))
+            │   │   │   ├── call_operator_loc: ∅
+            │   │   │   ├── message_loc: (33...34) = "+"
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── arguments:
+            │   │   │   │   @ ArgumentsNode (location: (35...36))
+            │   │   │   │   └── arguments: (length: 1)
+            │   │   │   │       └── @ IntegerNode (location: (35...36))
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   ├── block: ∅
+            │   │   │   ├── flags: 
+            │   │   │   └── name: "+"
+            │   │   └── @ SourceEncodingNode (location: (38...50))
+            │   ├── opening_loc: (13...14) = "["
+            │   └── closing_loc: (50...51) = "]"
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (62...99))
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (65...99))
+            │       │   ├── constant: ∅
+            │       │   ├── requireds: (length: 3)
+            │       │   │   ├── @ SourceFileNode (location: (66...74))
+            │       │   │   │   └── filepath: "whitequark/pattern_matching__FILE__LINE_literals.txt"
+            │       │   │   ├── @ SourceLineNode (location: (76...84))
+            │       │   │   └── @ SourceEncodingNode (location: (86...98))
+            │       │   ├── rest: ∅
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: (65...66) = "["
+            │       │   └── closing_loc: (98...99) = "]"
+            │       ├── statements: ∅
+            │       ├── in_loc: (62...64) = "in"
+            │       └── then_loc: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (8...12) = "case"
+            └── end_keyword_loc: (108...111) = "end"
diff --git a/test/yarp/snapshots/whitequark/pattern_matching_blank_else.txt b/test/yarp/snapshots/whitequark/pattern_matching_blank_else.txt
index df949e90b0..169f62b7c1 100644
--- a/test/yarp/snapshots/whitequark/pattern_matching_blank_else.txt
+++ b/test/yarp/snapshots/whitequark/pattern_matching_blank_else.txt
@@ -1,17 +1,25 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [CaseNode(0...26)(
-       IntegerNode(5...6)(),
-       [InNode(8...15)(
-          IntegerNode(11...12)(),
-          StatementsNode(14...15)([IntegerNode(14...15)()]),
-          (8...10),
-          nil
-        )],
-       ElseNode(17...26)((17...21), nil, (23...26)),
-       (0...4),
-       (23...26)
-     )]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...26))
+            ├── predicate:
+            │   @ IntegerNode (location: (5...6))
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...15))
+            │       ├── pattern:
+            │       │   @ IntegerNode (location: (11...12))
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (14...15))
+            │       │   └── body: (length: 1)
+            │       │       └── @ IntegerNode (location: (14...15))
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent:
+            │   @ ElseNode (location: (17...26))
+            │   ├── else_keyword_loc: (17...21) = "else"
+            │   ├── statements: ∅
+            │   └── end_keyword_loc: (23...26) = "end"
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (23...26) = "end"
diff --git a/test/yarp/snapshots/whitequark/pattern_matching_else.txt b/test/yarp/snapshots/whitequark/pattern_matching_else.txt
index d776a0ba1e..028e46497e 100644
--- a/test/yarp/snapshots/whitequark/pattern_matching_else.txt
+++ b/test/yarp/snapshots/whitequark/pattern_matching_else.txt
@@ -1,21 +1,28 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [CaseNode(0...29)(
-       IntegerNode(5...6)(),
-       [InNode(8...15)(
-          IntegerNode(11...12)(),
-          StatementsNode(14...15)([IntegerNode(14...15)()]),
-          (8...10),
-          nil
-        )],
-       ElseNode(17...29)(
-         (17...21),
-         StatementsNode(23...24)([IntegerNode(23...24)()]),
-         (26...29)
-       ),
-       (0...4),
-       (26...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...29))
+            ├── predicate:
+            │   @ IntegerNode (location: (5...6))
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (8...15))
+            │       ├── pattern:
+            │       │   @ IntegerNode (location: (11...12))
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (14...15))
+            │       │   └── body: (length: 1)
+            │       │       └── @ IntegerNode (location: (14...15))
+            │       ├── in_loc: (8...10) = "in"
+            │       └── then_loc: ∅
+            ├── consequent:
+            │   @ ElseNode (location: (17...29))
+            │   ├── else_keyword_loc: (17...21) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (23...24))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (23...24))
+            │   └── end_keyword_loc: (26...29) = "end"
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (26...29) = "end"
diff --git a/test/yarp/snapshots/whitequark/pattern_matching_single_line.txt b/test/yarp/snapshots/whitequark/pattern_matching_single_line.txt
index c428d83cda..c9afd9374c 100644
--- a/test/yarp/snapshots/whitequark/pattern_matching_single_line.txt
+++ b/test/yarp/snapshots/whitequark/pattern_matching_single_line.txt
@@ -1,31 +1,41 @@
-ProgramNode(0...24)(
-  [:a],
-  StatementsNode(0...24)(
-    [MatchRequiredNode(0...8)(
-       IntegerNode(0...1)(),
-       ArrayPatternNode(5...8)(
-         nil,
-         [LocalVariableTargetNode(6...7)(:a, 0)],
-         nil,
-         [],
-         (5...6),
-         (7...8)
-       ),
-       (2...4)
-     ),
-     LocalVariableReadNode(10...11)(:a, 0),
-     MatchPredicateNode(13...21)(
-       IntegerNode(13...14)(),
-       ArrayPatternNode(18...21)(
-         nil,
-         [LocalVariableTargetNode(19...20)(:a, 0)],
-         nil,
-         [],
-         (18...19),
-         (20...21)
-       ),
-       (15...17)
-     ),
-     LocalVariableReadNode(23...24)(:a, 0)]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 4)
+        ├── @ MatchRequiredNode (location: (0...8))
+        │   ├── value:
+        │   │   @ IntegerNode (location: (0...1))
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (5...8))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (6...7))
+        │   │   │       ├── name: :a
+        │   │   │       └── depth: 0
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (5...6) = "["
+        │   │   └── closing_loc: (7...8) = "]"
+        │   └── operator_loc: (2...4) = "=>"
+        ├── @ LocalVariableReadNode (location: (10...11))
+        │   ├── name: :a
+        │   └── depth: 0
+        ├── @ MatchPredicateNode (location: (13...21))
+        │   ├── value:
+        │   │   @ IntegerNode (location: (13...14))
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (18...21))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ LocalVariableTargetNode (location: (19...20))
+        │   │   │       ├── name: :a
+        │   │   │       └── depth: 0
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: (18...19) = "["
+        │   │   └── closing_loc: (20...21) = "]"
+        │   └── operator_loc: (15...17) = "in"
+        └── @ LocalVariableReadNode (location: (23...24))
+            ├── name: :a
+            └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt b/test/yarp/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt
index 1e009aa3db..badaa3b8e2 100644
--- a/test/yarp/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt
+++ b/test/yarp/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt
@@ -1,137 +1,215 @@
-ProgramNode(0...142)(
-  [:a, :b, :value],
-  StatementsNode(0...142)(
-    [MatchRequiredNode(0...14)(
-       ArrayNode(0...6)(
-         [IntegerNode(1...2)(), IntegerNode(4...5)()],
-         (0...1),
-         (5...6)
-       ),
-       ArrayPatternNode(10...14)(
-         nil,
-         [LocalVariableTargetNode(10...11)(:a, 0),
-          LocalVariableTargetNode(13...14)(:b, 0)],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       (7...9)
-     ),
-     LocalVariableReadNode(16...17)(:a, 0),
-     MatchPredicateNode(19...33)(
-       ArrayNode(19...25)(
-         [IntegerNode(20...21)(), IntegerNode(23...24)()],
-         (19...20),
-         (24...25)
-       ),
-       ArrayPatternNode(29...33)(
-         nil,
-         [LocalVariableTargetNode(29...30)(:a, 0),
-          LocalVariableTargetNode(32...33)(:b, 0)],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       (26...28)
-     ),
-     LocalVariableReadNode(35...36)(:a, 0),
-     MatchRequiredNode(38...50)(
-       HashNode(38...44)(
-         (38...39),
-         [AssocNode(39...43)(
-            SymbolNode(39...41)(nil, (39...40), (40...41), "a"),
-            IntegerNode(42...43)(),
-            nil
-          )],
-         (43...44)
-       ),
-       HashPatternNode(48...50)(
-         nil,
-         [AssocNode(48...50)(
-            SymbolNode(48...50)(nil, (48...49), (49...50), "a"),
-            nil,
-            nil
-          )],
-         nil,
-         nil,
-         nil
-       ),
-       (45...47)
-     ),
-     LocalVariableReadNode(52...53)(:a, 0),
-     MatchPredicateNode(55...67)(
-       HashNode(55...61)(
-         (55...56),
-         [AssocNode(56...60)(
-            SymbolNode(56...58)(nil, (56...57), (57...58), "a"),
-            IntegerNode(59...60)(),
-            nil
-          )],
-         (60...61)
-       ),
-       HashPatternNode(65...67)(
-         nil,
-         [AssocNode(65...67)(
-            SymbolNode(65...67)(nil, (65...66), (66...67), "a"),
-            nil,
-            nil
-          )],
-         nil,
-         nil,
-         nil
-       ),
-       (62...64)
-     ),
-     LocalVariableReadNode(69...70)(:a, 0),
-     MatchRequiredNode(72...99)(
-       HashNode(72...85)(
-         (72...73),
-         [AssocNode(73...84)(
-            SymbolNode(73...77)(nil, (73...76), (76...77), "key"),
-            SymbolNode(78...84)((78...79), (79...84), nil, "value"),
-            nil
-          )],
-         (84...85)
-       ),
-       HashPatternNode(89...99)(
-         nil,
-         [AssocNode(89...99)(
-            SymbolNode(89...93)(nil, (89...92), (92...93), "key"),
-            LocalVariableTargetNode(94...99)(:value, 0),
-            nil
-          )],
-         nil,
-         nil,
-         nil
-       ),
-       (86...88)
-     ),
-     LocalVariableReadNode(101...106)(:value, 0),
-     MatchPredicateNode(108...135)(
-       HashNode(108...121)(
-         (108...109),
-         [AssocNode(109...120)(
-            SymbolNode(109...113)(nil, (109...112), (112...113), "key"),
-            SymbolNode(114...120)((114...115), (115...120), nil, "value"),
-            nil
-          )],
-         (120...121)
-       ),
-       HashPatternNode(125...135)(
-         nil,
-         [AssocNode(125...135)(
-            SymbolNode(125...129)(nil, (125...128), (128...129), "key"),
-            LocalVariableTargetNode(130...135)(:value, 0),
-            nil
-          )],
-         nil,
-         nil,
-         nil
-       ),
-       (122...124)
-     ),
-     LocalVariableReadNode(137...142)(:value, 0)]
-  )
-)
+@ ProgramNode (location: (0...142))
+├── locals: [:a, :b, :value]
+└── statements:
+    @ StatementsNode (location: (0...142))
+    └── body: (length: 12)
+        ├── @ MatchRequiredNode (location: (0...14))
+        │   ├── value:
+        │   │   @ ArrayNode (location: (0...6))
+        │   │   ├── elements: (length: 2)
+        │   │   │   ├── @ IntegerNode (location: (1...2))
+        │   │   │   └── @ IntegerNode (location: (4...5))
+        │   │   ├── opening_loc: (0...1) = "["
+        │   │   └── closing_loc: (5...6) = "]"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (10...14))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 2)
+        │   │   │   ├── @ LocalVariableTargetNode (location: (10...11))
+        │   │   │   │   ├── name: :a
+        │   │   │   │   └── depth: 0
+        │   │   │   └── @ LocalVariableTargetNode (location: (13...14))
+        │   │   │       ├── name: :b
+        │   │   │       └── depth: 0
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (7...9) = "=>"
+        ├── @ LocalVariableReadNode (location: (16...17))
+        │   ├── name: :a
+        │   └── depth: 0
+        ├── @ MatchPredicateNode (location: (19...33))
+        │   ├── value:
+        │   │   @ ArrayNode (location: (19...25))
+        │   │   ├── elements: (length: 2)
+        │   │   │   ├── @ IntegerNode (location: (20...21))
+        │   │   │   └── @ IntegerNode (location: (23...24))
+        │   │   ├── opening_loc: (19...20) = "["
+        │   │   └── closing_loc: (24...25) = "]"
+        │   ├── pattern:
+        │   │   @ ArrayPatternNode (location: (29...33))
+        │   │   ├── constant: ∅
+        │   │   ├── requireds: (length: 2)
+        │   │   │   ├── @ LocalVariableTargetNode (location: (29...30))
+        │   │   │   │   ├── name: :a
+        │   │   │   │   └── depth: 0
+        │   │   │   └── @ LocalVariableTargetNode (location: (32...33))
+        │   │   │       ├── name: :b
+        │   │   │       └── depth: 0
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (26...28) = "in"
+        ├── @ LocalVariableReadNode (location: (35...36))
+        │   ├── name: :a
+        │   └── depth: 0
+        ├── @ MatchRequiredNode (location: (38...50))
+        │   ├── value:
+        │   │   @ HashNode (location: (38...44))
+        │   │   ├── opening_loc: (38...39) = "{"
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ AssocNode (location: (39...43))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (39...41))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (39...40) = "a"
+        │   │   │       │   ├── closing_loc: (40...41) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value:
+        │   │   │       │   @ IntegerNode (location: (42...43))
+        │   │   │       └── operator_loc: ∅
+        │   │   └── closing_loc: (43...44) = "}"
+        │   ├── pattern:
+        │   │   @ HashPatternNode (location: (48...50))
+        │   │   ├── constant: ∅
+        │   │   ├── assocs: (length: 1)
+        │   │   │   └── @ AssocNode (location: (48...50))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (48...50))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (48...49) = "a"
+        │   │   │       │   ├── closing_loc: (49...50) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value: ∅
+        │   │   │       └── operator_loc: ∅
+        │   │   ├── kwrest: ∅
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (45...47) = "=>"
+        ├── @ LocalVariableReadNode (location: (52...53))
+        │   ├── name: :a
+        │   └── depth: 0
+        ├── @ MatchPredicateNode (location: (55...67))
+        │   ├── value:
+        │   │   @ HashNode (location: (55...61))
+        │   │   ├── opening_loc: (55...56) = "{"
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ AssocNode (location: (56...60))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (56...58))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (56...57) = "a"
+        │   │   │       │   ├── closing_loc: (57...58) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value:
+        │   │   │       │   @ IntegerNode (location: (59...60))
+        │   │   │       └── operator_loc: ∅
+        │   │   └── closing_loc: (60...61) = "}"
+        │   ├── pattern:
+        │   │   @ HashPatternNode (location: (65...67))
+        │   │   ├── constant: ∅
+        │   │   ├── assocs: (length: 1)
+        │   │   │   └── @ AssocNode (location: (65...67))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (65...67))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (65...66) = "a"
+        │   │   │       │   ├── closing_loc: (66...67) = ":"
+        │   │   │       │   └── unescaped: "a"
+        │   │   │       ├── value: ∅
+        │   │   │       └── operator_loc: ∅
+        │   │   ├── kwrest: ∅
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (62...64) = "in"
+        ├── @ LocalVariableReadNode (location: (69...70))
+        │   ├── name: :a
+        │   └── depth: 0
+        ├── @ MatchRequiredNode (location: (72...99))
+        │   ├── value:
+        │   │   @ HashNode (location: (72...85))
+        │   │   ├── opening_loc: (72...73) = "{"
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ AssocNode (location: (73...84))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (73...77))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (73...76) = "key"
+        │   │   │       │   ├── closing_loc: (76...77) = ":"
+        │   │   │       │   └── unescaped: "key"
+        │   │   │       ├── value:
+        │   │   │       │   @ SymbolNode (location: (78...84))
+        │   │   │       │   ├── opening_loc: (78...79) = ":"
+        │   │   │       │   ├── value_loc: (79...84) = "value"
+        │   │   │       │   ├── closing_loc: ∅
+        │   │   │       │   └── unescaped: "value"
+        │   │   │       └── operator_loc: ∅
+        │   │   └── closing_loc: (84...85) = "}"
+        │   ├── pattern:
+        │   │   @ HashPatternNode (location: (89...99))
+        │   │   ├── constant: ∅
+        │   │   ├── assocs: (length: 1)
+        │   │   │   └── @ AssocNode (location: (89...99))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (89...93))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (89...92) = "key"
+        │   │   │       │   ├── closing_loc: (92...93) = ":"
+        │   │   │       │   └── unescaped: "key"
+        │   │   │       ├── value:
+        │   │   │       │   @ LocalVariableTargetNode (location: (94...99))
+        │   │   │       │   ├── name: :value
+        │   │   │       │   └── depth: 0
+        │   │   │       └── operator_loc: ∅
+        │   │   ├── kwrest: ∅
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (86...88) = "=>"
+        ├── @ LocalVariableReadNode (location: (101...106))
+        │   ├── name: :value
+        │   └── depth: 0
+        ├── @ MatchPredicateNode (location: (108...135))
+        │   ├── value:
+        │   │   @ HashNode (location: (108...121))
+        │   │   ├── opening_loc: (108...109) = "{"
+        │   │   ├── elements: (length: 1)
+        │   │   │   └── @ AssocNode (location: (109...120))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (109...113))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (109...112) = "key"
+        │   │   │       │   ├── closing_loc: (112...113) = ":"
+        │   │   │       │   └── unescaped: "key"
+        │   │   │       ├── value:
+        │   │   │       │   @ SymbolNode (location: (114...120))
+        │   │   │       │   ├── opening_loc: (114...115) = ":"
+        │   │   │       │   ├── value_loc: (115...120) = "value"
+        │   │   │       │   ├── closing_loc: ∅
+        │   │   │       │   └── unescaped: "value"
+        │   │   │       └── operator_loc: ∅
+        │   │   └── closing_loc: (120...121) = "}"
+        │   ├── pattern:
+        │   │   @ HashPatternNode (location: (125...135))
+        │   │   ├── constant: ∅
+        │   │   ├── assocs: (length: 1)
+        │   │   │   └── @ AssocNode (location: (125...135))
+        │   │   │       ├── key:
+        │   │   │       │   @ SymbolNode (location: (125...129))
+        │   │   │       │   ├── opening_loc: ∅
+        │   │   │       │   ├── value_loc: (125...128) = "key"
+        │   │   │       │   ├── closing_loc: (128...129) = ":"
+        │   │   │       │   └── unescaped: "key"
+        │   │   │       ├── value:
+        │   │   │       │   @ LocalVariableTargetNode (location: (130...135))
+        │   │   │       │   ├── name: :value
+        │   │   │       │   └── depth: 0
+        │   │   │       └── operator_loc: ∅
+        │   │   ├── kwrest: ∅
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── operator_loc: (122...124) = "in"
+        └── @ LocalVariableReadNode (location: (137...142))
+            ├── name: :value
+            └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/postexe.txt b/test/yarp/snapshots/whitequark/postexe.txt
index d6af82bf15..222b925765 100644
--- a/test/yarp/snapshots/whitequark/postexe.txt
+++ b/test/yarp/snapshots/whitequark/postexe.txt
@@ -1,11 +1,13 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [PostExecutionNode(0...9)(
-       StatementsNode(6...7)([IntegerNode(6...7)()]),
-       (0...3),
-       (4...5),
-       (8...9)
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ PostExecutionNode (location: (0...9))
+            ├── statements:
+            │   @ StatementsNode (location: (6...7))
+            │   └── body: (length: 1)
+            │       └── @ IntegerNode (location: (6...7))
+            ├── keyword_loc: (0...3) = "END"
+            ├── opening_loc: (4...5) = "{"
+            └── closing_loc: (8...9) = "}"
diff --git a/test/yarp/snapshots/whitequark/preexe.txt b/test/yarp/snapshots/whitequark/preexe.txt
index bfa071f72c..7089a7fde8 100644
--- a/test/yarp/snapshots/whitequark/preexe.txt
+++ b/test/yarp/snapshots/whitequark/preexe.txt
@@ -1,11 +1,13 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [PreExecutionNode(0...11)(
-       StatementsNode(8...9)([IntegerNode(8...9)()]),
-       (0...5),
-       (6...7),
-       (10...11)
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ PreExecutionNode (location: (0...11))
+            ├── statements:
+            │   @ StatementsNode (location: (8...9))
+            │   └── body: (length: 1)
+            │       └── @ IntegerNode (location: (8...9))
+            ├── keyword_loc: (0...5) = "BEGIN"
+            ├── opening_loc: (6...7) = "{"
+            └── closing_loc: (10...11) = "}"
diff --git a/test/yarp/snapshots/whitequark/procarg0.txt b/test/yarp/snapshots/whitequark/procarg0.txt
index fb43e87210..b64e9273e8 100644
--- a/test/yarp/snapshots/whitequark/procarg0.txt
+++ b/test/yarp/snapshots/whitequark/procarg0.txt
@@ -1,70 +1,73 @@
-ProgramNode(0...32)(
-  [],
-  StatementsNode(0...32)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       BlockNode(2...18)(
-         [:foo, :bar],
-         BlockParametersNode(4...16)(
-           ParametersNode(5...15)(
-             [RequiredDestructuredParameterNode(5...15)(
-                [RequiredParameterNode(6...9)(:foo),
-                 RequiredParameterNode(11...14)(:bar)],
-                (5...6),
-                (14...15)
-              )],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (4...5),
-           (15...16)
-         ),
-         nil,
-         (2...3),
-         (17...18)
-       ),
-       0,
-       "m"
-     ),
-     CallNode(21...32)(
-       nil,
-       nil,
-       (21...22),
-       nil,
-       nil,
-       nil,
-       BlockNode(23...32)(
-         [:foo],
-         BlockParametersNode(25...30)(
-           ParametersNode(26...29)(
-             [RequiredParameterNode(26...29)(:foo)],
-             [],
-             [],
-             nil,
-             [],
-             nil,
-             nil
-           ),
-           [],
-           (25...26),
-           (29...30)
-         ),
-         nil,
-         (23...24),
-         (31...32)
-       ),
-       0,
-       "m"
-     )]
-  )
-)
+@ ProgramNode (location: (0...32))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...32))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...18))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (2...18))
+        │   │   ├── locals: [:foo, :bar]
+        │   │   ├── parameters:
+        │   │   │   @ BlockParametersNode (location: (4...16))
+        │   │   │   ├── parameters:
+        │   │   │   │   @ ParametersNode (location: (5...15))
+        │   │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   │   └── @ RequiredDestructuredParameterNode (location: (5...15))
+        │   │   │   │   │       ├── parameters: (length: 2)
+        │   │   │   │   │       │   ├── @ RequiredParameterNode (location: (6...9))
+        │   │   │   │   │       │   │   └── name: :foo
+        │   │   │   │   │       │   └── @ RequiredParameterNode (location: (11...14))
+        │   │   │   │   │       │       └── name: :bar
+        │   │   │   │   │       ├── opening_loc: (5...6) = "("
+        │   │   │   │   │       └── closing_loc: (14...15) = ")"
+        │   │   │   │   ├── optionals: (length: 0)
+        │   │   │   │   ├── posts: (length: 0)
+        │   │   │   │   ├── rest: ∅
+        │   │   │   │   ├── keywords: (length: 0)
+        │   │   │   │   ├── keyword_rest: ∅
+        │   │   │   │   └── block: ∅
+        │   │   │   ├── locals: (length: 0)
+        │   │   │   ├── opening_loc: (4...5) = "|"
+        │   │   │   └── closing_loc: (15...16) = "|"
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (2...3) = "{"
+        │   │   └── closing_loc: (17...18) = "}"
+        │   ├── flags: 
+        │   └── name: "m"
+        └── @ CallNode (location: (21...32))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (21...22) = "m"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (23...32))
+            │   ├── locals: [:foo]
+            │   ├── parameters:
+            │   │   @ BlockParametersNode (location: (25...30))
+            │   │   ├── parameters:
+            │   │   │   @ ParametersNode (location: (26...29))
+            │   │   │   ├── requireds: (length: 1)
+            │   │   │   │   └── @ RequiredParameterNode (location: (26...29))
+            │   │   │   │       └── name: :foo
+            │   │   │   ├── optionals: (length: 0)
+            │   │   │   ├── posts: (length: 0)
+            │   │   │   ├── rest: ∅
+            │   │   │   ├── keywords: (length: 0)
+            │   │   │   ├── keyword_rest: ∅
+            │   │   │   └── block: ∅
+            │   │   ├── locals: (length: 0)
+            │   │   ├── opening_loc: (25...26) = "|"
+            │   │   └── closing_loc: (29...30) = "|"
+            │   ├── body: ∅
+            │   ├── opening_loc: (23...24) = "{"
+            │   └── closing_loc: (31...32) = "}"
+            ├── flags: 
+            └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/range_exclusive.txt b/test/yarp/snapshots/whitequark/range_exclusive.txt
index 4571ea317a..556bf3c332 100644
--- a/test/yarp/snapshots/whitequark/range_exclusive.txt
+++ b/test/yarp/snapshots/whitequark/range_exclusive.txt
@@ -1,6 +1,12 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [RangeNode(0...5)(IntegerNode(0...1)(), IntegerNode(4...5)(), (1...4), 1)]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ RangeNode (location: (0...5))
+            ├── left:
+            │   @ IntegerNode (location: (0...1))
+            ├── right:
+            │   @ IntegerNode (location: (4...5))
+            ├── operator_loc: (1...4) = "..."
+            └── flags: exclude_end
diff --git a/test/yarp/snapshots/whitequark/range_inclusive.txt b/test/yarp/snapshots/whitequark/range_inclusive.txt
index 021f010a66..cf3c477130 100644
--- a/test/yarp/snapshots/whitequark/range_inclusive.txt
+++ b/test/yarp/snapshots/whitequark/range_inclusive.txt
@@ -1,6 +1,12 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [RangeNode(0...4)(IntegerNode(0...1)(), IntegerNode(3...4)(), (1...3), 0)]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ RangeNode (location: (0...4))
+            ├── left:
+            │   @ IntegerNode (location: (0...1))
+            ├── right:
+            │   @ IntegerNode (location: (3...4))
+            ├── operator_loc: (1...3) = ".."
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/rational.txt b/test/yarp/snapshots/whitequark/rational.txt
index dfa7d0c29f..1aab887633 100644
--- a/test/yarp/snapshots/whitequark/rational.txt
+++ b/test/yarp/snapshots/whitequark/rational.txt
@@ -1,7 +1,11 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [RationalNode(0...5)(FloatNode(0...4)()),
-     RationalNode(7...10)(IntegerNode(7...9)())]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 2)
+        ├── @ RationalNode (location: (0...5))
+        │   └── numeric:
+        │       @ FloatNode (location: (0...4))
+        └── @ RationalNode (location: (7...10))
+            └── numeric:
+                @ IntegerNode (location: (7...9))
diff --git a/test/yarp/snapshots/whitequark/redo.txt b/test/yarp/snapshots/whitequark/redo.txt
index 99ab66873b..181cddb6b5 100644
--- a/test/yarp/snapshots/whitequark/redo.txt
+++ b/test/yarp/snapshots/whitequark/redo.txt
@@ -1 +1,6 @@
-ProgramNode(0...4)([], StatementsNode(0...4)([RedoNode(0...4)()]))
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ RedoNode (location: (0...4))
diff --git a/test/yarp/snapshots/whitequark/regex_interp.txt b/test/yarp/snapshots/whitequark/regex_interp.txt
index d314875cc4..e33362a7d7 100644
--- a/test/yarp/snapshots/whitequark/regex_interp.txt
+++ b/test/yarp/snapshots/whitequark/regex_interp.txt
@@ -1,19 +1,36 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [InterpolatedRegularExpressionNode(0...14)(
-       (0...1),
-       [StringNode(1...4)(nil, (1...4), nil, "foo"),
-        EmbeddedStatementsNode(4...10)(
-          (4...6),
-          StatementsNode(6...9)(
-            [CallNode(6...9)(nil, nil, (6...9), nil, nil, nil, nil, 2, "bar")]
-          ),
-          (9...10)
-        ),
-        StringNode(10...13)(nil, (10...13), nil, "baz")],
-       (13...14),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ InterpolatedRegularExpressionNode (location: (0...14))
+            ├── opening_loc: (0...1) = "/"
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (1...4))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (1...4) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   ├── @ EmbeddedStatementsNode (location: (4...10))
+            │   │   ├── opening_loc: (4...6) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (6...9))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (6...9))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (6...9) = "bar"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "bar"
+            │   │   └── closing_loc: (9...10) = "}"
+            │   └── @ StringNode (location: (10...13))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (10...13) = "baz"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "baz"
+            ├── closing_loc: (13...14) = "/"
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/regex_plain.txt b/test/yarp/snapshots/whitequark/regex_plain.txt
index 695adbaf5a..8f6633b947 100644
--- a/test/yarp/snapshots/whitequark/regex_plain.txt
+++ b/test/yarp/snapshots/whitequark/regex_plain.txt
@@ -1,6 +1,11 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [RegularExpressionNode(0...10)((0...1), (1...7), (7...10), "source", 5)]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ RegularExpressionNode (location: (0...10))
+            ├── opening_loc: (0...1) = "/"
+            ├── content_loc: (1...7) = "source"
+            ├── closing_loc: (7...10) = "/im"
+            ├── unescaped: "source"
+            └── flags: ignore_case, multi_line
diff --git a/test/yarp/snapshots/whitequark/resbody_list.txt b/test/yarp/snapshots/whitequark/resbody_list.txt
index 8456996663..1b37edf833 100644
--- a/test/yarp/snapshots/whitequark/resbody_list.txt
+++ b/test/yarp/snapshots/whitequark/resbody_list.txt
@@ -1,34 +1,45 @@
-ProgramNode(0...39)(
-  [],
-  StatementsNode(0...39)(
-    [BeginNode(0...39)(
-       (0...5),
-       StatementsNode(7...11)(
-         [CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth")]
-       ),
-       RescueNode(13...34)(
-         (13...19),
-         [ConstantReadNode(20...29)(:Exception)],
-         nil,
-         nil,
-         StatementsNode(31...34)(
-           [CallNode(31...34)(
-              nil,
-              nil,
-              (31...34),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (36...39)
-     )]
-  )
-)
+@ ProgramNode (location: (0...39))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...39))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...39))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (7...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (7...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (7...11) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (13...34))
+            │   ├── keyword_loc: (13...19) = "rescue"
+            │   ├── exceptions: (length: 1)
+            │   │   └── @ ConstantReadNode (location: (20...29))
+            │   │       └── name: :Exception
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (31...34))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (31...34))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (31...34) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (36...39) = "end"
diff --git a/test/yarp/snapshots/whitequark/resbody_list_mrhs.txt b/test/yarp/snapshots/whitequark/resbody_list_mrhs.txt
index f4160d82da..08e5d0f884 100644
--- a/test/yarp/snapshots/whitequark/resbody_list_mrhs.txt
+++ b/test/yarp/snapshots/whitequark/resbody_list_mrhs.txt
@@ -1,45 +1,55 @@
-ProgramNode(0...44)(
-  [],
-  StatementsNode(0...44)(
-    [BeginNode(0...44)(
-       (0...5),
-       StatementsNode(7...11)(
-         [CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth")]
-       ),
-       RescueNode(13...39)(
-         (13...19),
-         [ConstantReadNode(20...29)(:Exception),
-          CallNode(31...34)(
-            nil,
-            nil,
-            (31...34),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          )],
-         nil,
-         nil,
-         StatementsNode(36...39)(
-           [CallNode(36...39)(
-              nil,
-              nil,
-              (36...39),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (41...44)
-     )]
-  )
-)
+@ ProgramNode (location: (0...44))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...44))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...44))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (7...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (7...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (7...11) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (13...39))
+            │   ├── keyword_loc: (13...19) = "rescue"
+            │   ├── exceptions: (length: 2)
+            │   │   ├── @ ConstantReadNode (location: (20...29))
+            │   │   │   └── name: :Exception
+            │   │   └── @ CallNode (location: (31...34))
+            │   │       ├── receiver: ∅
+            │   │       ├── call_operator_loc: ∅
+            │   │       ├── message_loc: (31...34) = "foo"
+            │   │       ├── opening_loc: ∅
+            │   │       ├── arguments: ∅
+            │   │       ├── closing_loc: ∅
+            │   │       ├── block: ∅
+            │   │       ├── flags: variable_call
+            │   │       └── name: "foo"
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (36...39))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (36...39))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (36...39) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (41...44) = "end"
diff --git a/test/yarp/snapshots/whitequark/resbody_list_var.txt b/test/yarp/snapshots/whitequark/resbody_list_var.txt
index 660abcc181..b96efda258 100644
--- a/test/yarp/snapshots/whitequark/resbody_list_var.txt
+++ b/test/yarp/snapshots/whitequark/resbody_list_var.txt
@@ -1,44 +1,56 @@
-ProgramNode(0...39)(
-  [:ex],
-  StatementsNode(0...39)(
-    [BeginNode(0...39)(
-       (0...5),
-       StatementsNode(7...11)(
-         [CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth")]
-       ),
-       RescueNode(13...34)(
-         (13...19),
-         [CallNode(20...23)(
-            nil,
-            nil,
-            (20...23),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "foo"
-          )],
-         (24...26),
-         LocalVariableTargetNode(27...29)(:ex, 0),
-         StatementsNode(31...34)(
-           [CallNode(31...34)(
-              nil,
-              nil,
-              (31...34),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (36...39)
-     )]
-  )
-)
+@ ProgramNode (location: (0...39))
+├── locals: [:ex]
+└── statements:
+    @ StatementsNode (location: (0...39))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...39))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (7...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (7...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (7...11) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (13...34))
+            │   ├── keyword_loc: (13...19) = "rescue"
+            │   ├── exceptions: (length: 1)
+            │   │   └── @ CallNode (location: (20...23))
+            │   │       ├── receiver: ∅
+            │   │       ├── call_operator_loc: ∅
+            │   │       ├── message_loc: (20...23) = "foo"
+            │   │       ├── opening_loc: ∅
+            │   │       ├── arguments: ∅
+            │   │       ├── closing_loc: ∅
+            │   │       ├── block: ∅
+            │   │       ├── flags: variable_call
+            │   │       └── name: "foo"
+            │   ├── operator_loc: (24...26) = "=>"
+            │   ├── reference:
+            │   │   @ LocalVariableTargetNode (location: (27...29))
+            │   │   ├── name: :ex
+            │   │   └── depth: 0
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (31...34))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (31...34))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (31...34) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (36...39) = "end"
diff --git a/test/yarp/snapshots/whitequark/resbody_var.txt b/test/yarp/snapshots/whitequark/resbody_var.txt
index e88a7612dc..2e92335925 100644
--- a/test/yarp/snapshots/whitequark/resbody_var.txt
+++ b/test/yarp/snapshots/whitequark/resbody_var.txt
@@ -1,73 +1,86 @@
-ProgramNode(0...73)(
-  [:ex],
-  StatementsNode(0...73)(
-    [BeginNode(0...36)(
-       (0...5),
-       StatementsNode(7...11)(
-         [CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth")]
-       ),
-       RescueNode(13...31)(
-         (13...19),
-         [],
-         (20...22),
-         InstanceVariableTargetNode(23...26)(:@ex),
-         StatementsNode(28...31)(
-           [CallNode(28...31)(
-              nil,
-              nil,
-              (28...31),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (33...36)
-     ),
-     BeginNode(38...73)(
-       (38...43),
-       StatementsNode(45...49)(
-         [CallNode(45...49)(
-            nil,
-            nil,
-            (45...49),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "meth"
-          )]
-       ),
-       RescueNode(51...68)(
-         (51...57),
-         [],
-         (58...60),
-         LocalVariableTargetNode(61...63)(:ex, 0),
-         StatementsNode(65...68)(
-           [CallNode(65...68)(
-              nil,
-              nil,
-              (65...68),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (70...73)
-     )]
-  )
-)
+@ ProgramNode (location: (0...73))
+├── locals: [:ex]
+└── statements:
+    @ StatementsNode (location: (0...73))
+    └── body: (length: 2)
+        ├── @ BeginNode (location: (0...36))
+        │   ├── begin_keyword_loc: (0...5) = "begin"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (7...11))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (7...11))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (7...11) = "meth"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "meth"
+        │   ├── rescue_clause:
+        │   │   @ RescueNode (location: (13...31))
+        │   │   ├── keyword_loc: (13...19) = "rescue"
+        │   │   ├── exceptions: (length: 0)
+        │   │   ├── operator_loc: (20...22) = "=>"
+        │   │   ├── reference:
+        │   │   │   @ InstanceVariableTargetNode (location: (23...26))
+        │   │   │   └── name: :@ex
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (28...31))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (28...31))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (28...31) = "bar"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "bar"
+        │   │   └── consequent: ∅
+        │   ├── else_clause: ∅
+        │   ├── ensure_clause: ∅
+        │   └── end_keyword_loc: (33...36) = "end"
+        └── @ BeginNode (location: (38...73))
+            ├── begin_keyword_loc: (38...43) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (45...49))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (45...49))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (45...49) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (51...68))
+            │   ├── keyword_loc: (51...57) = "rescue"
+            │   ├── exceptions: (length: 0)
+            │   ├── operator_loc: (58...60) = "=>"
+            │   ├── reference:
+            │   │   @ LocalVariableTargetNode (location: (61...63))
+            │   │   ├── name: :ex
+            │   │   └── depth: 0
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (65...68))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (65...68))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (65...68) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (70...73) = "end"
diff --git a/test/yarp/snapshots/whitequark/rescue.txt b/test/yarp/snapshots/whitequark/rescue.txt
index 6a14aa0803..a4ccd9bed2 100644
--- a/test/yarp/snapshots/whitequark/rescue.txt
+++ b/test/yarp/snapshots/whitequark/rescue.txt
@@ -1,34 +1,43 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [BeginNode(0...29)(
-       (0...5),
-       StatementsNode(7...11)(
-         [CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth")]
-       ),
-       RescueNode(13...24)(
-         (13...19),
-         [],
-         nil,
-         nil,
-         StatementsNode(21...24)(
-           [CallNode(21...24)(
-              nil,
-              nil,
-              (21...24),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       nil,
-       (26...29)
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...29))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (7...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (7...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (7...11) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (13...24))
+            │   ├── keyword_loc: (13...19) = "rescue"
+            │   ├── exceptions: (length: 0)
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (21...24))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (21...24))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (21...24) = "foo"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "foo"
+            │   └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (26...29) = "end"
diff --git a/test/yarp/snapshots/whitequark/rescue_else.txt b/test/yarp/snapshots/whitequark/rescue_else.txt
index 5359bb2a62..3ede36e138 100644
--- a/test/yarp/snapshots/whitequark/rescue_else.txt
+++ b/test/yarp/snapshots/whitequark/rescue_else.txt
@@ -1,50 +1,59 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [BeginNode(0...40)(
-       (0...5),
-       StatementsNode(7...11)(
-         [CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth")]
-       ),
-       RescueNode(13...24)(
-         (13...19),
-         [],
-         nil,
-         nil,
-         StatementsNode(21...24)(
-           [CallNode(21...24)(
-              nil,
-              nil,
-              (21...24),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         nil
-       ),
-       ElseNode(26...40)(
-         (26...30),
-         StatementsNode(32...35)(
-           [CallNode(32...35)(
-              nil,
-              nil,
-              (32...35),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         (37...40)
-       ),
-       nil,
-       (37...40)
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...40))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (7...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (7...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (7...11) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (13...24))
+            │   ├── keyword_loc: (13...19) = "rescue"
+            │   ├── exceptions: (length: 0)
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (21...24))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (21...24))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (21...24) = "foo"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "foo"
+            │   └── consequent: ∅
+            ├── else_clause:
+            │   @ ElseNode (location: (26...40))
+            │   ├── else_keyword_loc: (26...30) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (32...35))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (32...35))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (32...35) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   └── end_keyword_loc: (37...40) = "end"
+            ├── ensure_clause: ∅
+            └── end_keyword_loc: (37...40) = "end"
diff --git a/test/yarp/snapshots/whitequark/rescue_else_ensure.txt b/test/yarp/snapshots/whitequark/rescue_else_ensure.txt
index 89fc124784..c6415dd3fd 100644
--- a/test/yarp/snapshots/whitequark/rescue_else_ensure.txt
+++ b/test/yarp/snapshots/whitequark/rescue_else_ensure.txt
@@ -1,66 +1,75 @@
-ProgramNode(0...51)(
-  [],
-  StatementsNode(0...51)(
-    [BeginNode(0...51)(
-       (0...5),
-       StatementsNode(7...11)(
-         [CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth")]
-       ),
-       RescueNode(13...24)(
-         (13...19),
-         [],
-         nil,
-         nil,
-         StatementsNode(21...24)(
-           [CallNode(21...24)(
-              nil,
-              nil,
-              (21...24),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         nil
-       ),
-       ElseNode(26...42)(
-         (26...30),
-         StatementsNode(31...34)(
-           [CallNode(31...34)(
-              nil,
-              nil,
-              (31...34),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "foo"
-            )]
-         ),
-         (36...42)
-       ),
-       EnsureNode(36...51)(
-         (36...42),
-         StatementsNode(44...47)(
-           [CallNode(44...47)(
-              nil,
-              nil,
-              (44...47),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         (48...51)
-       ),
-       (48...51)
-     )]
-  )
-)
+@ ProgramNode (location: (0...51))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...51))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...51))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (7...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (7...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (7...11) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (13...24))
+            │   ├── keyword_loc: (13...19) = "rescue"
+            │   ├── exceptions: (length: 0)
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (21...24))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (21...24))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (21...24) = "baz"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "baz"
+            │   └── consequent: ∅
+            ├── else_clause:
+            │   @ ElseNode (location: (26...42))
+            │   ├── else_keyword_loc: (26...30) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (31...34))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (31...34))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (31...34) = "foo"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "foo"
+            │   └── end_keyword_loc: (36...42) = "ensure"
+            ├── ensure_clause:
+            │   @ EnsureNode (location: (36...51))
+            │   ├── ensure_keyword_loc: (36...42) = "ensure"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (44...47))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (44...47))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (44...47) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   └── end_keyword_loc: (48...51) = "end"
+            └── end_keyword_loc: (48...51) = "end"
diff --git a/test/yarp/snapshots/whitequark/rescue_ensure.txt b/test/yarp/snapshots/whitequark/rescue_ensure.txt
index 719ed167fe..0600875da4 100644
--- a/test/yarp/snapshots/whitequark/rescue_ensure.txt
+++ b/test/yarp/snapshots/whitequark/rescue_ensure.txt
@@ -1,50 +1,59 @@
-ProgramNode(0...42)(
-  [],
-  StatementsNode(0...42)(
-    [BeginNode(0...42)(
-       (0...5),
-       StatementsNode(7...11)(
-         [CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth")]
-       ),
-       RescueNode(13...24)(
-         (13...19),
-         [],
-         nil,
-         nil,
-         StatementsNode(21...24)(
-           [CallNode(21...24)(
-              nil,
-              nil,
-              (21...24),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         nil
-       ),
-       nil,
-       EnsureNode(26...42)(
-         (26...32),
-         StatementsNode(34...37)(
-           [CallNode(34...37)(
-              nil,
-              nil,
-              (34...37),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "bar"
-            )]
-         ),
-         (39...42)
-       ),
-       (39...42)
-     )]
-  )
-)
+@ ProgramNode (location: (0...42))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...42))
+    └── body: (length: 1)
+        └── @ BeginNode (location: (0...42))
+            ├── begin_keyword_loc: (0...5) = "begin"
+            ├── statements:
+            │   @ StatementsNode (location: (7...11))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (7...11))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (7...11) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            ├── rescue_clause:
+            │   @ RescueNode (location: (13...24))
+            │   ├── keyword_loc: (13...19) = "rescue"
+            │   ├── exceptions: (length: 0)
+            │   ├── operator_loc: ∅
+            │   ├── reference: ∅
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (21...24))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (21...24))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (21...24) = "baz"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "baz"
+            │   └── consequent: ∅
+            ├── else_clause: ∅
+            ├── ensure_clause:
+            │   @ EnsureNode (location: (26...42))
+            │   ├── ensure_keyword_loc: (26...32) = "ensure"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (34...37))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (34...37))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (34...37) = "bar"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "bar"
+            │   └── end_keyword_loc: (39...42) = "end"
+            └── end_keyword_loc: (39...42) = "end"
diff --git a/test/yarp/snapshots/whitequark/rescue_in_lambda_block.txt b/test/yarp/snapshots/whitequark/rescue_in_lambda_block.txt
index 89825a7ac4..990ce225f4 100644
--- a/test/yarp/snapshots/whitequark/rescue_in_lambda_block.txt
+++ b/test/yarp/snapshots/whitequark/rescue_in_lambda_block.txt
@@ -1,20 +1,26 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [LambdaNode(0...17)(
-       [],
-       (0...2),
-       (3...5),
-       (14...17),
-       nil,
-       BeginNode(6...17)(
-         nil,
-         nil,
-         RescueNode(6...12)((6...12), [], nil, nil, nil, nil),
-         nil,
-         nil,
-         (14...17)
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...17))
+            ├── locals: []
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (3...5) = "do"
+            ├── closing_loc: (14...17) = "end"
+            ├── parameters: ∅
+            └── body:
+                @ BeginNode (location: (6...17))
+                ├── begin_keyword_loc: ∅
+                ├── statements: ∅
+                ├── rescue_clause:
+                │   @ RescueNode (location: (6...12))
+                │   ├── keyword_loc: (6...12) = "rescue"
+                │   ├── exceptions: (length: 0)
+                │   ├── operator_loc: ∅
+                │   ├── reference: ∅
+                │   ├── statements: ∅
+                │   └── consequent: ∅
+                ├── else_clause: ∅
+                ├── ensure_clause: ∅
+                └── end_keyword_loc: (14...17) = "end"
diff --git a/test/yarp/snapshots/whitequark/rescue_mod.txt b/test/yarp/snapshots/whitequark/rescue_mod.txt
index e755977e7d..90980579c4 100644
--- a/test/yarp/snapshots/whitequark/rescue_mod.txt
+++ b/test/yarp/snapshots/whitequark/rescue_mod.txt
@@ -1,10 +1,29 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [RescueModifierNode(0...15)(
-       CallNode(0...4)(nil, nil, (0...4), nil, nil, nil, nil, 2, "meth"),
-       (5...11),
-       CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "bar")
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ RescueModifierNode (location: (0...15))
+            ├── expression:
+            │   @ CallNode (location: (0...4))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...4) = "meth"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "meth"
+            ├── keyword_loc: (5...11) = "rescue"
+            └── rescue_expression:
+                @ CallNode (location: (12...15))
+                ├── receiver: ∅
+                ├── call_operator_loc: ∅
+                ├── message_loc: (12...15) = "bar"
+                ├── opening_loc: ∅
+                ├── arguments: ∅
+                ├── closing_loc: ∅
+                ├── block: ∅
+                ├── flags: variable_call
+                └── name: "bar"
diff --git a/test/yarp/snapshots/whitequark/rescue_mod_asgn.txt b/test/yarp/snapshots/whitequark/rescue_mod_asgn.txt
index b0ca3f6c95..263cf29a11 100644
--- a/test/yarp/snapshots/whitequark/rescue_mod_asgn.txt
+++ b/test/yarp/snapshots/whitequark/rescue_mod_asgn.txt
@@ -1,16 +1,35 @@
-ProgramNode(0...21)(
-  [:foo],
-  StatementsNode(0...21)(
-    [LocalVariableWriteNode(0...21)(
-       :foo,
-       0,
-       (0...3),
-       RescueModifierNode(6...21)(
-         CallNode(6...10)(nil, nil, (6...10), nil, nil, nil, nil, 2, "meth"),
-         (11...17),
-         CallNode(18...21)(nil, nil, (18...21), nil, nil, nil, nil, 2, "bar")
-       ),
-       (4...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: [:foo]
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 1)
+        └── @ LocalVariableWriteNode (location: (0...21))
+            ├── name: :foo
+            ├── depth: 0
+            ├── name_loc: (0...3) = "foo"
+            ├── value:
+            │   @ RescueModifierNode (location: (6...21))
+            │   ├── expression:
+            │   │   @ CallNode (location: (6...10))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (6...10) = "meth"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "meth"
+            │   ├── keyword_loc: (11...17) = "rescue"
+            │   └── rescue_expression:
+            │       @ CallNode (location: (18...21))
+            │       ├── receiver: ∅
+            │       ├── call_operator_loc: ∅
+            │       ├── message_loc: (18...21) = "bar"
+            │       ├── opening_loc: ∅
+            │       ├── arguments: ∅
+            │       ├── closing_loc: ∅
+            │       ├── block: ∅
+            │       ├── flags: variable_call
+            │       └── name: "bar"
+            └── operator_loc: (4...5) = "="
diff --git a/test/yarp/snapshots/whitequark/rescue_mod_masgn.txt b/test/yarp/snapshots/whitequark/rescue_mod_masgn.txt
index 82b1220cd7..b62027fc1f 100644
--- a/test/yarp/snapshots/whitequark/rescue_mod_masgn.txt
+++ b/test/yarp/snapshots/whitequark/rescue_mod_masgn.txt
@@ -1,21 +1,37 @@
-ProgramNode(0...29)(
-  [:foo, :bar],
-  StatementsNode(0...29)(
-    [MultiWriteNode(0...29)(
-       [LocalVariableTargetNode(0...3)(:foo, 0),
-        LocalVariableTargetNode(5...8)(:bar, 0)],
-       nil,
-       nil,
-       (9...10),
-       RescueModifierNode(11...29)(
-         CallNode(11...15)(nil, nil, (11...15), nil, nil, nil, nil, 2, "meth"),
-         (16...22),
-         ArrayNode(23...29)(
-           [IntegerNode(24...25)(), IntegerNode(27...28)()],
-           (23...24),
-           (28...29)
-         )
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: [:foo, :bar]
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 1)
+        └── @ MultiWriteNode (location: (0...29))
+            ├── targets: (length: 2)
+            │   ├── @ LocalVariableTargetNode (location: (0...3))
+            │   │   ├── name: :foo
+            │   │   └── depth: 0
+            │   └── @ LocalVariableTargetNode (location: (5...8))
+            │       ├── name: :bar
+            │       └── depth: 0
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── operator_loc: (9...10) = "="
+            └── value:
+                @ RescueModifierNode (location: (11...29))
+                ├── expression:
+                │   @ CallNode (location: (11...15))
+                │   ├── receiver: ∅
+                │   ├── call_operator_loc: ∅
+                │   ├── message_loc: (11...15) = "meth"
+                │   ├── opening_loc: ∅
+                │   ├── arguments: ∅
+                │   ├── closing_loc: ∅
+                │   ├── block: ∅
+                │   ├── flags: variable_call
+                │   └── name: "meth"
+                ├── keyword_loc: (16...22) = "rescue"
+                └── rescue_expression:
+                    @ ArrayNode (location: (23...29))
+                    ├── elements: (length: 2)
+                    │   ├── @ IntegerNode (location: (24...25))
+                    │   └── @ IntegerNode (location: (27...28))
+                    ├── opening_loc: (23...24) = "["
+                    └── closing_loc: (28...29) = "]"
diff --git a/test/yarp/snapshots/whitequark/rescue_mod_op_assign.txt b/test/yarp/snapshots/whitequark/rescue_mod_op_assign.txt
index f9bfc7bfeb..eb08d94dae 100644
--- a/test/yarp/snapshots/whitequark/rescue_mod_op_assign.txt
+++ b/test/yarp/snapshots/whitequark/rescue_mod_op_assign.txt
@@ -1,17 +1,36 @@
-ProgramNode(0...22)(
-  [:foo],
-  StatementsNode(0...22)(
-    [LocalVariableOperatorWriteNode(0...22)(
-       (0...3),
-       (4...6),
-       RescueModifierNode(7...22)(
-         CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth"),
-         (12...18),
-         CallNode(19...22)(nil, nil, (19...22), nil, nil, nil, nil, 2, "bar")
-       ),
-       :foo,
-       :+,
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: [:foo]
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ LocalVariableOperatorWriteNode (location: (0...22))
+            ├── name_loc: (0...3) = "foo"
+            ├── operator_loc: (4...6) = "+="
+            ├── value:
+            │   @ RescueModifierNode (location: (7...22))
+            │   ├── expression:
+            │   │   @ CallNode (location: (7...11))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (7...11) = "meth"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments: ∅
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: variable_call
+            │   │   └── name: "meth"
+            │   ├── keyword_loc: (12...18) = "rescue"
+            │   └── rescue_expression:
+            │       @ CallNode (location: (19...22))
+            │       ├── receiver: ∅
+            │       ├── call_operator_loc: ∅
+            │       ├── message_loc: (19...22) = "bar"
+            │       ├── opening_loc: ∅
+            │       ├── arguments: ∅
+            │       ├── closing_loc: ∅
+            │       ├── block: ∅
+            │       ├── flags: variable_call
+            │       └── name: "bar"
+            ├── name: :foo
+            ├── operator: :+
+            └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/rescue_without_begin_end.txt b/test/yarp/snapshots/whitequark/rescue_without_begin_end.txt
index 038219dc1f..5fbd3eb2df 100644
--- a/test/yarp/snapshots/whitequark/rescue_without_begin_end.txt
+++ b/test/yarp/snapshots/whitequark/rescue_without_begin_end.txt
@@ -1,60 +1,59 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [CallNode(0...30)(
-       nil,
-       nil,
-       (0...4),
-       nil,
-       nil,
-       nil,
-       BlockNode(5...30)(
-         [],
-         nil,
-         BeginNode(9...30)(
-           nil,
-           StatementsNode(9...12)(
-             [CallNode(9...12)(
-                nil,
-                nil,
-                (9...12),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "foo"
-              )]
-           ),
-           RescueNode(14...25)(
-             (14...20),
-             [],
-             nil,
-             nil,
-             StatementsNode(22...25)(
-               [CallNode(22...25)(
-                  nil,
-                  nil,
-                  (22...25),
-                  nil,
-                  nil,
-                  nil,
-                  nil,
-                  2,
-                  "bar"
-                )]
-             ),
-             nil
-           ),
-           nil,
-           nil,
-           (27...30)
-         ),
-         (5...7),
-         (27...30)
-       ),
-       0,
-       "meth"
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...30))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...4) = "meth"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (5...30))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ BeginNode (location: (9...30))
+            │   │   ├── begin_keyword_loc: ∅
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (9...12))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (9...12))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (9...12) = "foo"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "foo"
+            │   │   ├── rescue_clause:
+            │   │   │   @ RescueNode (location: (14...25))
+            │   │   │   ├── keyword_loc: (14...20) = "rescue"
+            │   │   │   ├── exceptions: (length: 0)
+            │   │   │   ├── operator_loc: ∅
+            │   │   │   ├── reference: ∅
+            │   │   │   ├── statements:
+            │   │   │   │   @ StatementsNode (location: (22...25))
+            │   │   │   │   └── body: (length: 1)
+            │   │   │   │       └── @ CallNode (location: (22...25))
+            │   │   │   │           ├── receiver: ∅
+            │   │   │   │           ├── call_operator_loc: ∅
+            │   │   │   │           ├── message_loc: (22...25) = "bar"
+            │   │   │   │           ├── opening_loc: ∅
+            │   │   │   │           ├── arguments: ∅
+            │   │   │   │           ├── closing_loc: ∅
+            │   │   │   │           ├── block: ∅
+            │   │   │   │           ├── flags: variable_call
+            │   │   │   │           └── name: "bar"
+            │   │   │   └── consequent: ∅
+            │   │   ├── else_clause: ∅
+            │   │   ├── ensure_clause: ∅
+            │   │   └── end_keyword_loc: (27...30) = "end"
+            │   ├── opening_loc: (5...7) = "do"
+            │   └── closing_loc: (27...30) = "end"
+            ├── flags: 
+            └── name: "meth"
diff --git a/test/yarp/snapshots/whitequark/restarg_named.txt b/test/yarp/snapshots/whitequark/restarg_named.txt
index d3eed889c6..0a55e75a6d 100644
--- a/test/yarp/snapshots/whitequark/restarg_named.txt
+++ b/test/yarp/snapshots/whitequark/restarg_named.txt
@@ -1,27 +1,30 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [DefNode(0...16)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...10)(
-         [],
-         [],
-         [],
-         RestParameterNode(6...10)(:foo, (7...10), (6...7)),
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:foo],
-       (0...3),
-       nil,
-       (5...6),
-       (10...11),
-       nil,
-       (13...16)
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...16))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...10))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest:
+            │   │   @ RestParameterNode (location: (6...10))
+            │   │   ├── name: :foo
+            │   │   ├── name_loc: (7...10) = "foo"
+            │   │   └── operator_loc: (6...7) = "*"
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:foo]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (10...11) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (13...16) = "end"
diff --git a/test/yarp/snapshots/whitequark/restarg_unnamed.txt b/test/yarp/snapshots/whitequark/restarg_unnamed.txt
index a15f667603..df6ef70f10 100644
--- a/test/yarp/snapshots/whitequark/restarg_unnamed.txt
+++ b/test/yarp/snapshots/whitequark/restarg_unnamed.txt
@@ -1,27 +1,30 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [DefNode(0...13)(
-       :f,
-       (4...5),
-       nil,
-       ParametersNode(6...7)(
-         [],
-         [],
-         [],
-         RestParameterNode(6...7)(nil, nil, (6...7)),
-         [],
-         nil,
-         nil
-       ),
-       nil,
-       [:*],
-       (0...3),
-       nil,
-       (5...6),
-       (7...8),
-       nil,
-       (10...13)
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...13))
+            ├── name: :f
+            ├── name_loc: (4...5) = "f"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (6...7))
+            │   ├── requireds: (length: 0)
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest:
+            │   │   @ RestParameterNode (location: (6...7))
+            │   │   ├── name: nil
+            │   │   ├── name_loc: ∅
+            │   │   └── operator_loc: (6...7) = "*"
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:*]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (5...6) = "("
+            ├── rparen_loc: (7...8) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (10...13) = "end"
diff --git a/test/yarp/snapshots/whitequark/retry.txt b/test/yarp/snapshots/whitequark/retry.txt
index 8963228e67..e324e95e85 100644
--- a/test/yarp/snapshots/whitequark/retry.txt
+++ b/test/yarp/snapshots/whitequark/retry.txt
@@ -1 +1,6 @@
-ProgramNode(0...5)([], StatementsNode(0...5)([RetryNode(0...5)()]))
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ RetryNode (location: (0...5))
diff --git a/test/yarp/snapshots/whitequark/return.txt b/test/yarp/snapshots/whitequark/return.txt
index 0afc3de823..13afe5d1d9 100644
--- a/test/yarp/snapshots/whitequark/return.txt
+++ b/test/yarp/snapshots/whitequark/return.txt
@@ -1,40 +1,53 @@
-ProgramNode(0...41)(
-  [],
-  StatementsNode(0...41)(
-    [ReturnNode(0...6)((0...6), nil),
-     ReturnNode(8...18)(
-       (8...14),
-       ArgumentsNode(15...18)(
-         [CallNode(15...18)(nil, nil, (15...18), nil, nil, nil, nil, 2, "foo")]
-       )
-     ),
-     ReturnNode(20...28)(
-       (20...26),
-       ArgumentsNode(26...28)(
-         [ParenthesesNode(26...28)(nil, (26...27), (27...28))]
-       )
-     ),
-     ReturnNode(30...41)(
-       (30...36),
-       ArgumentsNode(36...41)(
-         [ParenthesesNode(36...41)(
-            StatementsNode(37...40)(
-              [CallNode(37...40)(
-                 nil,
-                 nil,
-                 (37...40),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               )]
-            ),
-            (36...37),
-            (40...41)
-          )]
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...41))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...41))
+    └── body: (length: 4)
+        ├── @ ReturnNode (location: (0...6))
+        │   ├── keyword_loc: (0...6) = "return"
+        │   └── arguments: ∅
+        ├── @ ReturnNode (location: (8...18))
+        │   ├── keyword_loc: (8...14) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (15...18))
+        │       └── arguments: (length: 1)
+        │           └── @ CallNode (location: (15...18))
+        │               ├── receiver: ∅
+        │               ├── call_operator_loc: ∅
+        │               ├── message_loc: (15...18) = "foo"
+        │               ├── opening_loc: ∅
+        │               ├── arguments: ∅
+        │               ├── closing_loc: ∅
+        │               ├── block: ∅
+        │               ├── flags: variable_call
+        │               └── name: "foo"
+        ├── @ ReturnNode (location: (20...28))
+        │   ├── keyword_loc: (20...26) = "return"
+        │   └── arguments:
+        │       @ ArgumentsNode (location: (26...28))
+        │       └── arguments: (length: 1)
+        │           └── @ ParenthesesNode (location: (26...28))
+        │               ├── body: ∅
+        │               ├── opening_loc: (26...27) = "("
+        │               └── closing_loc: (27...28) = ")"
+        └── @ ReturnNode (location: (30...41))
+            ├── keyword_loc: (30...36) = "return"
+            └── arguments:
+                @ ArgumentsNode (location: (36...41))
+                └── arguments: (length: 1)
+                    └── @ ParenthesesNode (location: (36...41))
+                        ├── body:
+                        │   @ StatementsNode (location: (37...40))
+                        │   └── body: (length: 1)
+                        │       └── @ CallNode (location: (37...40))
+                        │           ├── receiver: ∅
+                        │           ├── call_operator_loc: ∅
+                        │           ├── message_loc: (37...40) = "foo"
+                        │           ├── opening_loc: ∅
+                        │           ├── arguments: ∅
+                        │           ├── closing_loc: ∅
+                        │           ├── block: ∅
+                        │           ├── flags: variable_call
+                        │           └── name: "foo"
+                        ├── opening_loc: (36...37) = "("
+                        └── closing_loc: (40...41) = ")"
diff --git a/test/yarp/snapshots/whitequark/return_block.txt b/test/yarp/snapshots/whitequark/return_block.txt
index 60f2406295..6282fa328a 100644
--- a/test/yarp/snapshots/whitequark/return_block.txt
+++ b/test/yarp/snapshots/whitequark/return_block.txt
@@ -1,33 +1,38 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [ReturnNode(0...21)(
-       (0...6),
-       ArgumentsNode(7...21)(
-         [CallNode(7...21)(
-            nil,
-            nil,
-            (7...10),
-            nil,
-            ArgumentsNode(11...14)(
-              [CallNode(11...14)(
-                 nil,
-                 nil,
-                 (11...14),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "foo"
-               )]
-            ),
-            nil,
-            BlockNode(15...21)([], nil, nil, (15...17), (18...21)),
-            0,
-            "fun"
-          )]
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 1)
+        └── @ ReturnNode (location: (0...21))
+            ├── keyword_loc: (0...6) = "return"
+            └── arguments:
+                @ ArgumentsNode (location: (7...21))
+                └── arguments: (length: 1)
+                    └── @ CallNode (location: (7...21))
+                        ├── receiver: ∅
+                        ├── call_operator_loc: ∅
+                        ├── message_loc: (7...10) = "fun"
+                        ├── opening_loc: ∅
+                        ├── arguments:
+                        │   @ ArgumentsNode (location: (11...14))
+                        │   └── arguments: (length: 1)
+                        │       └── @ CallNode (location: (11...14))
+                        │           ├── receiver: ∅
+                        │           ├── call_operator_loc: ∅
+                        │           ├── message_loc: (11...14) = "foo"
+                        │           ├── opening_loc: ∅
+                        │           ├── arguments: ∅
+                        │           ├── closing_loc: ∅
+                        │           ├── block: ∅
+                        │           ├── flags: variable_call
+                        │           └── name: "foo"
+                        ├── closing_loc: ∅
+                        ├── block:
+                        │   @ BlockNode (location: (15...21))
+                        │   ├── locals: []
+                        │   ├── parameters: ∅
+                        │   ├── body: ∅
+                        │   ├── opening_loc: (15...17) = "do"
+                        │   └── closing_loc: (18...21) = "end"
+                        ├── flags: 
+                        └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_10279.txt b/test/yarp/snapshots/whitequark/ruby_bug_10279.txt
index 74c9d70fa3..5406280cc4 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_10279.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_10279.txt
@@ -1,20 +1,28 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [HashNode(0...24)(
-       (0...1),
-       [AssocNode(1...23)(
-          SymbolNode(1...3)(nil, (1...2), (2...3), "a"),
-          IfNode(4...23)(
-            (4...6),
-            TrueNode(7...11)(),
-            StatementsNode(17...19)([IntegerNode(17...19)()]),
-            nil,
-            (20...23)
-          ),
-          nil
-        )],
-       (23...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ HashNode (location: (0...24))
+            ├── opening_loc: (0...1) = "{"
+            ├── elements: (length: 1)
+            │   └── @ AssocNode (location: (1...23))
+            │       ├── key:
+            │       │   @ SymbolNode (location: (1...3))
+            │       │   ├── opening_loc: ∅
+            │       │   ├── value_loc: (1...2) = "a"
+            │       │   ├── closing_loc: (2...3) = ":"
+            │       │   └── unescaped: "a"
+            │       ├── value:
+            │       │   @ IfNode (location: (4...23))
+            │       │   ├── if_keyword_loc: (4...6) = "if"
+            │       │   ├── predicate:
+            │       │   │   @ TrueNode (location: (7...11))
+            │       │   ├── statements:
+            │       │   │   @ StatementsNode (location: (17...19))
+            │       │   │   └── body: (length: 1)
+            │       │   │       └── @ IntegerNode (location: (17...19))
+            │       │   ├── consequent: ∅
+            │       │   └── end_keyword_loc: (20...23) = "end"
+            │       └── operator_loc: ∅
+            └── closing_loc: (23...24) = "}"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_10653.txt b/test/yarp/snapshots/whitequark/ruby_bug_10653.txt
index 9223db088b..d9a52bc813 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_10653.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_10653.txt
@@ -1,131 +1,164 @@
-ProgramNode(0...93)(
-  [],
-  StatementsNode(0...93)(
-    [IfNode(0...33)(
-       nil,
-       FalseNode(0...5)(),
-       StatementsNode(8...20)(
-         [CallNode(8...20)(
-            nil,
-            nil,
-            (8...13),
-            nil,
-            nil,
-            nil,
-            BlockNode(14...20)([], nil, nil, (14...16), (17...20)),
-            0,
-            "raise"
-          )]
-       ),
-       ElseNode(21...33)(
-         (21...22),
-         StatementsNode(23...33)(
-           [CallNode(23...33)(
-              nil,
-              nil,
-              (23...26),
-              nil,
-              nil,
-              nil,
-              BlockNode(27...33)([], nil, nil, (27...29), (30...33)),
-              0,
-              "tap"
-            )]
-         ),
-         nil
-       ),
-       nil
-     ),
-     IfNode(35...60)(
-       nil,
-       FalseNode(35...40)(),
-       StatementsNode(43...51)(
-         [CallNode(43...51)(
-            nil,
-            nil,
-            (43...48),
-            nil,
-            nil,
-            nil,
-            BlockNode(49...51)([], nil, nil, (49...50), (50...51)),
-            0,
-            "raise"
-          )]
-       ),
-       ElseNode(52...60)(
-         (52...53),
-         StatementsNode(54...60)(
-           [CallNode(54...60)(
-              nil,
-              nil,
-              (54...57),
-              nil,
-              nil,
-              nil,
-              BlockNode(58...60)([], nil, nil, (58...59), (59...60)),
-              0,
-              "tap"
-            )]
-         ),
-         nil
-       ),
-       nil
-     ),
-     IfNode(62...93)(
-       nil,
-       TrueNode(62...66)(),
-       StatementsNode(69...89)(
-         [CallNode(69...89)(
-            IntegerNode(69...70)(),
-            (70...71),
-            (71...74),
-            nil,
-            nil,
-            nil,
-            BlockNode(75...89)(
-              [:n],
-              BlockParametersNode(78...81)(
-                ParametersNode(79...80)(
-                  [RequiredParameterNode(79...80)(:n)],
-                  [],
-                  [],
-                  nil,
-                  [],
-                  nil,
-                  nil
-                ),
-                [],
-                (78...79),
-                (80...81)
-              ),
-              StatementsNode(82...85)(
-                [CallNode(82...85)(
-                   nil,
-                   nil,
-                   (82...83),
-                   nil,
-                   ArgumentsNode(84...85)(
-                     [LocalVariableReadNode(84...85)(:n, 0)]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "p"
-                 )]
-              ),
-              (75...77),
-              (86...89)
-            ),
-            0,
-            "tap"
-          )]
-       ),
-       ElseNode(90...93)(
-         (90...91),
-         StatementsNode(92...93)([IntegerNode(92...93)()]),
-         nil
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...93))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...93))
+    └── body: (length: 3)
+        ├── @ IfNode (location: (0...33))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ FalseNode (location: (0...5))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (8...20))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (8...20))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (8...13) = "raise"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (14...20))
+        │   │           │   ├── locals: []
+        │   │           │   ├── parameters: ∅
+        │   │           │   ├── body: ∅
+        │   │           │   ├── opening_loc: (14...16) = "do"
+        │   │           │   └── closing_loc: (17...20) = "end"
+        │   │           ├── flags: 
+        │   │           └── name: "raise"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (21...33))
+        │   │   ├── else_keyword_loc: (21...22) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (23...33))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (23...33))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (23...26) = "tap"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block:
+        │   │   │           │   @ BlockNode (location: (27...33))
+        │   │   │           │   ├── locals: []
+        │   │   │           │   ├── parameters: ∅
+        │   │   │           │   ├── body: ∅
+        │   │   │           │   ├── opening_loc: (27...29) = "do"
+        │   │   │           │   └── closing_loc: (30...33) = "end"
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "tap"
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        ├── @ IfNode (location: (35...60))
+        │   ├── if_keyword_loc: ∅
+        │   ├── predicate:
+        │   │   @ FalseNode (location: (35...40))
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (43...51))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (43...51))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (43...48) = "raise"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block:
+        │   │           │   @ BlockNode (location: (49...51))
+        │   │           │   ├── locals: []
+        │   │           │   ├── parameters: ∅
+        │   │           │   ├── body: ∅
+        │   │           │   ├── opening_loc: (49...50) = "{"
+        │   │           │   └── closing_loc: (50...51) = "}"
+        │   │           ├── flags: 
+        │   │           └── name: "raise"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (52...60))
+        │   │   ├── else_keyword_loc: (52...53) = ":"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (54...60))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (54...60))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (54...57) = "tap"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block:
+        │   │   │           │   @ BlockNode (location: (58...60))
+        │   │   │           │   ├── locals: []
+        │   │   │           │   ├── parameters: ∅
+        │   │   │           │   ├── body: ∅
+        │   │   │           │   ├── opening_loc: (58...59) = "{"
+        │   │   │           │   └── closing_loc: (59...60) = "}"
+        │   │   │           ├── flags: 
+        │   │   │           └── name: "tap"
+        │   │   └── end_keyword_loc: ∅
+        │   └── end_keyword_loc: ∅
+        └── @ IfNode (location: (62...93))
+            ├── if_keyword_loc: ∅
+            ├── predicate:
+            │   @ TrueNode (location: (62...66))
+            ├── statements:
+            │   @ StatementsNode (location: (69...89))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (69...89))
+            │           ├── receiver:
+            │           │   @ IntegerNode (location: (69...70))
+            │           ├── call_operator_loc: (70...71) = "."
+            │           ├── message_loc: (71...74) = "tap"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block:
+            │           │   @ BlockNode (location: (75...89))
+            │           │   ├── locals: [:n]
+            │           │   ├── parameters:
+            │           │   │   @ BlockParametersNode (location: (78...81))
+            │           │   │   ├── parameters:
+            │           │   │   │   @ ParametersNode (location: (79...80))
+            │           │   │   │   ├── requireds: (length: 1)
+            │           │   │   │   │   └── @ RequiredParameterNode (location: (79...80))
+            │           │   │   │   │       └── name: :n
+            │           │   │   │   ├── optionals: (length: 0)
+            │           │   │   │   ├── posts: (length: 0)
+            │           │   │   │   ├── rest: ∅
+            │           │   │   │   ├── keywords: (length: 0)
+            │           │   │   │   ├── keyword_rest: ∅
+            │           │   │   │   └── block: ∅
+            │           │   │   ├── locals: (length: 0)
+            │           │   │   ├── opening_loc: (78...79) = "|"
+            │           │   │   └── closing_loc: (80...81) = "|"
+            │           │   ├── body:
+            │           │   │   @ StatementsNode (location: (82...85))
+            │           │   │   └── body: (length: 1)
+            │           │   │       └── @ CallNode (location: (82...85))
+            │           │   │           ├── receiver: ∅
+            │           │   │           ├── call_operator_loc: ∅
+            │           │   │           ├── message_loc: (82...83) = "p"
+            │           │   │           ├── opening_loc: ∅
+            │           │   │           ├── arguments:
+            │           │   │           │   @ ArgumentsNode (location: (84...85))
+            │           │   │           │   └── arguments: (length: 1)
+            │           │   │           │       └── @ LocalVariableReadNode (location: (84...85))
+            │           │   │           │           ├── name: :n
+            │           │   │           │           └── depth: 0
+            │           │   │           ├── closing_loc: ∅
+            │           │   │           ├── block: ∅
+            │           │   │           ├── flags: 
+            │           │   │           └── name: "p"
+            │           │   ├── opening_loc: (75...77) = "do"
+            │           │   └── closing_loc: (86...89) = "end"
+            │           ├── flags: 
+            │           └── name: "tap"
+            ├── consequent:
+            │   @ ElseNode (location: (90...93))
+            │   ├── else_keyword_loc: (90...91) = ":"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (92...93))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (92...93))
+            │   └── end_keyword_loc: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_11107.txt b/test/yarp/snapshots/whitequark/ruby_bug_11107.txt
index c61ee9ef80..b243fc8dea 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_11107.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_11107.txt
@@ -1,37 +1,47 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [CallNode(0...24)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...24)(
-         [LambdaNode(2...24)(
-            [],
-            (2...4),
-            (7...9),
-            (21...24),
-            BlockParametersNode(4...6)(nil, [], (4...5), (5...6)),
-            StatementsNode(10...20)(
-              [CallNode(10...20)(
-                 nil,
-                 nil,
-                 (10...11),
-                 (11...12),
-                 nil,
-                 (12...13),
-                 BlockNode(14...20)([], nil, nil, (14...16), (17...20)),
-                 0,
-                 "a"
-               )]
-            )
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...24))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...24))
+            │   └── arguments: (length: 1)
+            │       └── @ LambdaNode (location: (2...24))
+            │           ├── locals: []
+            │           ├── operator_loc: (2...4) = "->"
+            │           ├── opening_loc: (7...9) = "do"
+            │           ├── closing_loc: (21...24) = "end"
+            │           ├── parameters:
+            │           │   @ BlockParametersNode (location: (4...6))
+            │           │   ├── parameters: ∅
+            │           │   ├── locals: (length: 0)
+            │           │   ├── opening_loc: (4...5) = "("
+            │           │   └── closing_loc: (5...6) = ")"
+            │           └── body:
+            │               @ StatementsNode (location: (10...20))
+            │               └── body: (length: 1)
+            │                   └── @ CallNode (location: (10...20))
+            │                       ├── receiver: ∅
+            │                       ├── call_operator_loc: ∅
+            │                       ├── message_loc: (10...11) = "a"
+            │                       ├── opening_loc: (11...12) = "("
+            │                       ├── arguments: ∅
+            │                       ├── closing_loc: (12...13) = ")"
+            │                       ├── block:
+            │                       │   @ BlockNode (location: (14...20))
+            │                       │   ├── locals: []
+            │                       │   ├── parameters: ∅
+            │                       │   ├── body: ∅
+            │                       │   ├── opening_loc: (14...16) = "do"
+            │                       │   └── closing_loc: (17...20) = "end"
+            │                       ├── flags: 
+            │                       └── name: "a"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_11380.txt b/test/yarp/snapshots/whitequark/ruby_bug_11380.txt
index 9e89161e78..c93fb9132f 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_11380.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_11380.txt
@@ -1,34 +1,49 @@
-ProgramNode(0...28)(
-  [],
-  StatementsNode(0...28)(
-    [CallNode(0...28)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...21)(
-         [LambdaNode(2...15)(
-            [],
-            (2...4),
-            (5...6),
-            (14...15),
-            nil,
-            StatementsNode(7...13)(
-              [SymbolNode(7...13)((7...8), (8...13), nil, "hello")]
-            )
-          ),
-          KeywordHashNode(17...21)(
-            [AssocNode(17...21)(
-               SymbolNode(17...19)(nil, (17...18), (18...19), "a"),
-               IntegerNode(20...21)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       BlockNode(22...28)([], nil, nil, (22...24), (25...28)),
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...28))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...28))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...28))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...21))
+            │   └── arguments: (length: 2)
+            │       ├── @ LambdaNode (location: (2...15))
+            │       │   ├── locals: []
+            │       │   ├── operator_loc: (2...4) = "->"
+            │       │   ├── opening_loc: (5...6) = "{"
+            │       │   ├── closing_loc: (14...15) = "}"
+            │       │   ├── parameters: ∅
+            │       │   └── body:
+            │       │       @ StatementsNode (location: (7...13))
+            │       │       └── body: (length: 1)
+            │       │           └── @ SymbolNode (location: (7...13))
+            │       │               ├── opening_loc: (7...8) = ":"
+            │       │               ├── value_loc: (8...13) = "hello"
+            │       │               ├── closing_loc: ∅
+            │       │               └── unescaped: "hello"
+            │       └── @ KeywordHashNode (location: (17...21))
+            │           └── elements: (length: 1)
+            │               └── @ AssocNode (location: (17...21))
+            │                   ├── key:
+            │                   │   @ SymbolNode (location: (17...19))
+            │                   │   ├── opening_loc: ∅
+            │                   │   ├── value_loc: (17...18) = "a"
+            │                   │   ├── closing_loc: (18...19) = ":"
+            │                   │   └── unescaped: "a"
+            │                   ├── value:
+            │                   │   @ IntegerNode (location: (20...21))
+            │                   └── operator_loc: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (22...28))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (22...24) = "do"
+            │   └── closing_loc: (25...28) = "end"
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_11873.txt b/test/yarp/snapshots/whitequark/ruby_bug_11873.txt
index 9c988bcfff..55c6a8d68a 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_11873.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_11873.txt
@@ -1,665 +1,733 @@
-ProgramNode(0...272)(
-  [],
-  StatementsNode(0...272)(
-    [CallNode(0...20)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...13)(
-         [CallNode(2...8)(
-            nil,
-            nil,
-            (2...3),
-            (3...4),
-            ArgumentsNode(4...7)(
-              [CallNode(4...7)(
-                 nil,
-                 nil,
-                 (4...5),
-                 nil,
-                 ArgumentsNode(6...7)(
-                   [CallNode(6...7)(
-                      nil,
-                      nil,
-                      (6...7),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (7...8),
-            nil,
-            0,
-            "b"
-          ),
-          StringNode(10...13)((10...11), (11...12), (12...13), "x")]
-       ),
-       nil,
-       BlockNode(14...20)([], nil, nil, (14...16), (17...20)),
-       0,
-       "a"
-     ),
-     CallNode(22...42)(
-       nil,
-       nil,
-       (22...23),
-       nil,
-       ArgumentsNode(24...35)(
-         [CallNode(24...30)(
-            nil,
-            nil,
-            (24...25),
-            (25...26),
-            ArgumentsNode(26...29)(
-              [CallNode(26...29)(
-                 nil,
-                 nil,
-                 (26...27),
-                 nil,
-                 ArgumentsNode(28...29)(
-                   [CallNode(28...29)(
-                      nil,
-                      nil,
-                      (28...29),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (29...30),
-            nil,
-            0,
-            "b"
-          ),
-          RegularExpressionNode(32...35)(
-            (32...33),
-            (33...34),
-            (34...35),
-            "x",
-            0
-          )]
-       ),
-       nil,
-       BlockNode(36...42)([], nil, nil, (36...38), (39...42)),
-       0,
-       "a"
-     ),
-     CallNode(44...65)(
-       nil,
-       nil,
-       (44...45),
-       nil,
-       ArgumentsNode(46...58)(
-         [CallNode(46...52)(
-            nil,
-            nil,
-            (46...47),
-            (47...48),
-            ArgumentsNode(48...51)(
-              [CallNode(48...51)(
-                 nil,
-                 nil,
-                 (48...49),
-                 nil,
-                 ArgumentsNode(50...51)(
-                   [CallNode(50...51)(
-                      nil,
-                      nil,
-                      (50...51),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (51...52),
-            nil,
-            0,
-            "b"
-          ),
-          RegularExpressionNode(54...58)(
-            (54...55),
-            (55...56),
-            (56...58),
-            "x",
-            4
-          )]
-       ),
-       nil,
-       BlockNode(59...65)([], nil, nil, (59...61), (62...65)),
-       0,
-       "a"
-     ),
-     CallNode(67...88)(
-       nil,
-       nil,
-       (67...68),
-       nil,
-       ArgumentsNode(69...81)(
-         [CallNode(69...76)(
-            nil,
-            nil,
-            (69...70),
-            (70...71),
-            ArgumentsNode(71...75)(
-              [CallNode(71...75)(
-                 nil,
-                 nil,
-                 (71...72),
-                 (72...73),
-                 ArgumentsNode(73...74)(
-                   [CallNode(73...74)(
-                      nil,
-                      nil,
-                      (73...74),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 (74...75),
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (75...76),
-            nil,
-            0,
-            "b"
-          ),
-          StringNode(78...81)((78...79), (79...80), (80...81), "x")]
-       ),
-       nil,
-       BlockNode(82...88)([], nil, nil, (82...84), (85...88)),
-       0,
-       "a"
-     ),
-     CallNode(90...111)(
-       nil,
-       nil,
-       (90...91),
-       nil,
-       ArgumentsNode(92...104)(
-         [CallNode(92...99)(
-            nil,
-            nil,
-            (92...93),
-            (93...94),
-            ArgumentsNode(94...98)(
-              [CallNode(94...98)(
-                 nil,
-                 nil,
-                 (94...95),
-                 (95...96),
-                 ArgumentsNode(96...97)(
-                   [CallNode(96...97)(
-                      nil,
-                      nil,
-                      (96...97),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 (97...98),
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (98...99),
-            nil,
-            0,
-            "b"
-          ),
-          RegularExpressionNode(101...104)(
-            (101...102),
-            (102...103),
-            (103...104),
-            "x",
-            0
-          )]
-       ),
-       nil,
-       BlockNode(105...111)([], nil, nil, (105...107), (108...111)),
-       0,
-       "a"
-     ),
-     CallNode(113...135)(
-       nil,
-       nil,
-       (113...114),
-       nil,
-       ArgumentsNode(115...128)(
-         [CallNode(115...122)(
-            nil,
-            nil,
-            (115...116),
-            (116...117),
-            ArgumentsNode(117...121)(
-              [CallNode(117...121)(
-                 nil,
-                 nil,
-                 (117...118),
-                 (118...119),
-                 ArgumentsNode(119...120)(
-                   [CallNode(119...120)(
-                      nil,
-                      nil,
-                      (119...120),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 (120...121),
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (121...122),
-            nil,
-            0,
-            "b"
-          ),
-          RegularExpressionNode(124...128)(
-            (124...125),
-            (125...126),
-            (126...128),
-            "x",
-            4
-          )]
-       ),
-       nil,
-       BlockNode(129...135)([], nil, nil, (129...131), (132...135)),
-       0,
-       "a"
-     ),
-     CallNode(137...157)(
-       nil,
-       nil,
-       (137...138),
-       nil,
-       ArgumentsNode(139...150)(
-         [CallNode(139...145)(
-            nil,
-            nil,
-            (139...140),
-            nil,
-            nil,
-            nil,
-            BlockNode(140...145)(
-              [],
-              nil,
-              StatementsNode(141...144)(
-                [CallNode(141...144)(
-                   nil,
-                   nil,
-                   (141...142),
-                   nil,
-                   ArgumentsNode(143...144)(
-                     [CallNode(143...144)(
-                        nil,
-                        nil,
-                        (143...144),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (140...141),
-              (144...145)
-            ),
-            0,
-            "b"
-          ),
-          StringNode(147...150)((147...148), (148...149), (149...150), "x")]
-       ),
-       nil,
-       BlockNode(151...157)([], nil, nil, (151...153), (154...157)),
-       0,
-       "a"
-     ),
-     CallNode(159...179)(
-       nil,
-       nil,
-       (159...160),
-       nil,
-       ArgumentsNode(161...172)(
-         [CallNode(161...167)(
-            nil,
-            nil,
-            (161...162),
-            nil,
-            nil,
-            nil,
-            BlockNode(162...167)(
-              [],
-              nil,
-              StatementsNode(163...166)(
-                [CallNode(163...166)(
-                   nil,
-                   nil,
-                   (163...164),
-                   nil,
-                   ArgumentsNode(165...166)(
-                     [CallNode(165...166)(
-                        nil,
-                        nil,
-                        (165...166),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (162...163),
-              (166...167)
-            ),
-            0,
-            "b"
-          ),
-          RegularExpressionNode(169...172)(
-            (169...170),
-            (170...171),
-            (171...172),
-            "x",
-            0
-          )]
-       ),
-       nil,
-       BlockNode(173...179)([], nil, nil, (173...175), (176...179)),
-       0,
-       "a"
-     ),
-     CallNode(181...202)(
-       nil,
-       nil,
-       (181...182),
-       nil,
-       ArgumentsNode(183...195)(
-         [CallNode(183...189)(
-            nil,
-            nil,
-            (183...184),
-            nil,
-            nil,
-            nil,
-            BlockNode(184...189)(
-              [],
-              nil,
-              StatementsNode(185...188)(
-                [CallNode(185...188)(
-                   nil,
-                   nil,
-                   (185...186),
-                   nil,
-                   ArgumentsNode(187...188)(
-                     [CallNode(187...188)(
-                        nil,
-                        nil,
-                        (187...188),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (184...185),
-              (188...189)
-            ),
-            0,
-            "b"
-          ),
-          RegularExpressionNode(191...195)(
-            (191...192),
-            (192...193),
-            (193...195),
-            "x",
-            4
-          )]
-       ),
-       nil,
-       BlockNode(196...202)([], nil, nil, (196...198), (199...202)),
-       0,
-       "a"
-     ),
-     CallNode(204...225)(
-       nil,
-       nil,
-       (204...205),
-       nil,
-       ArgumentsNode(206...218)(
-         [CallNode(206...213)(
-            nil,
-            nil,
-            (206...207),
-            nil,
-            nil,
-            nil,
-            BlockNode(207...213)(
-              [],
-              nil,
-              StatementsNode(208...212)(
-                [CallNode(208...212)(
-                   nil,
-                   nil,
-                   (208...209),
-                   (209...210),
-                   ArgumentsNode(210...211)(
-                     [CallNode(210...211)(
-                        nil,
-                        nil,
-                        (210...211),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   (211...212),
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (207...208),
-              (212...213)
-            ),
-            0,
-            "b"
-          ),
-          StringNode(215...218)((215...216), (216...217), (217...218), "x")]
-       ),
-       nil,
-       BlockNode(219...225)([], nil, nil, (219...221), (222...225)),
-       0,
-       "a"
-     ),
-     CallNode(227...248)(
-       nil,
-       nil,
-       (227...228),
-       nil,
-       ArgumentsNode(229...241)(
-         [CallNode(229...236)(
-            nil,
-            nil,
-            (229...230),
-            nil,
-            nil,
-            nil,
-            BlockNode(230...236)(
-              [],
-              nil,
-              StatementsNode(231...235)(
-                [CallNode(231...235)(
-                   nil,
-                   nil,
-                   (231...232),
-                   (232...233),
-                   ArgumentsNode(233...234)(
-                     [CallNode(233...234)(
-                        nil,
-                        nil,
-                        (233...234),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   (234...235),
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (230...231),
-              (235...236)
-            ),
-            0,
-            "b"
-          ),
-          RegularExpressionNode(238...241)(
-            (238...239),
-            (239...240),
-            (240...241),
-            "x",
-            0
-          )]
-       ),
-       nil,
-       BlockNode(242...248)([], nil, nil, (242...244), (245...248)),
-       0,
-       "a"
-     ),
-     CallNode(250...272)(
-       nil,
-       nil,
-       (250...251),
-       nil,
-       ArgumentsNode(252...265)(
-         [CallNode(252...259)(
-            nil,
-            nil,
-            (252...253),
-            nil,
-            nil,
-            nil,
-            BlockNode(253...259)(
-              [],
-              nil,
-              StatementsNode(254...258)(
-                [CallNode(254...258)(
-                   nil,
-                   nil,
-                   (254...255),
-                   (255...256),
-                   ArgumentsNode(256...257)(
-                     [CallNode(256...257)(
-                        nil,
-                        nil,
-                        (256...257),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   (257...258),
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (253...254),
-              (258...259)
-            ),
-            0,
-            "b"
-          ),
-          RegularExpressionNode(261...265)(
-            (261...262),
-            (262...263),
-            (263...265),
-            "x",
-            4
-          )]
-       ),
-       nil,
-       BlockNode(266...272)([], nil, nil, (266...268), (269...272)),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...272))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...272))
+    └── body: (length: 12)
+        ├── @ CallNode (location: (0...20))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...13))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (2...8))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (2...3) = "b"
+        │   │       │   ├── opening_loc: (3...4) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (4...7))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (4...7))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (4...5) = "c"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (6...7))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (6...7))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (6...7) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (7...8) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ StringNode (location: (10...13))
+        │   │           ├── opening_loc: (10...11) = "\""
+        │   │           ├── content_loc: (11...12) = "x"
+        │   │           ├── closing_loc: (12...13) = "\""
+        │   │           └── unescaped: "x"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (14...20))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (14...16) = "do"
+        │   │   └── closing_loc: (17...20) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (22...42))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (22...23) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (24...35))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (24...30))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (24...25) = "b"
+        │   │       │   ├── opening_loc: (25...26) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (26...29))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (26...29))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (26...27) = "c"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (28...29))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (28...29))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (28...29) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (29...30) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RegularExpressionNode (location: (32...35))
+        │   │           ├── opening_loc: (32...33) = "/"
+        │   │           ├── content_loc: (33...34) = "x"
+        │   │           ├── closing_loc: (34...35) = "/"
+        │   │           ├── unescaped: "x"
+        │   │           └── flags: 
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (36...42))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (36...38) = "do"
+        │   │   └── closing_loc: (39...42) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (44...65))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (44...45) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (46...58))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (46...52))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (46...47) = "b"
+        │   │       │   ├── opening_loc: (47...48) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (48...51))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (48...51))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (48...49) = "c"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (50...51))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (50...51))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (50...51) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (51...52) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RegularExpressionNode (location: (54...58))
+        │   │           ├── opening_loc: (54...55) = "/"
+        │   │           ├── content_loc: (55...56) = "x"
+        │   │           ├── closing_loc: (56...58) = "/m"
+        │   │           ├── unescaped: "x"
+        │   │           └── flags: multi_line
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (59...65))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (59...61) = "do"
+        │   │   └── closing_loc: (62...65) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (67...88))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (67...68) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (69...81))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (69...76))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (69...70) = "b"
+        │   │       │   ├── opening_loc: (70...71) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (71...75))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (71...75))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (71...72) = "c"
+        │   │       │   │           ├── opening_loc: (72...73) = "("
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (73...74))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (73...74))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (73...74) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: (74...75) = ")"
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (75...76) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ StringNode (location: (78...81))
+        │   │           ├── opening_loc: (78...79) = "\""
+        │   │           ├── content_loc: (79...80) = "x"
+        │   │           ├── closing_loc: (80...81) = "\""
+        │   │           └── unescaped: "x"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (82...88))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (82...84) = "do"
+        │   │   └── closing_loc: (85...88) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (90...111))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (90...91) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (92...104))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (92...99))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (92...93) = "b"
+        │   │       │   ├── opening_loc: (93...94) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (94...98))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (94...98))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (94...95) = "c"
+        │   │       │   │           ├── opening_loc: (95...96) = "("
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (96...97))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (96...97))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (96...97) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: (97...98) = ")"
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (98...99) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RegularExpressionNode (location: (101...104))
+        │   │           ├── opening_loc: (101...102) = "/"
+        │   │           ├── content_loc: (102...103) = "x"
+        │   │           ├── closing_loc: (103...104) = "/"
+        │   │           ├── unescaped: "x"
+        │   │           └── flags: 
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (105...111))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (105...107) = "do"
+        │   │   └── closing_loc: (108...111) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (113...135))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (113...114) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (115...128))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (115...122))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (115...116) = "b"
+        │   │       │   ├── opening_loc: (116...117) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (117...121))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (117...121))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (117...118) = "c"
+        │   │       │   │           ├── opening_loc: (118...119) = "("
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (119...120))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (119...120))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (119...120) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: (120...121) = ")"
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (121...122) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RegularExpressionNode (location: (124...128))
+        │   │           ├── opening_loc: (124...125) = "/"
+        │   │           ├── content_loc: (125...126) = "x"
+        │   │           ├── closing_loc: (126...128) = "/m"
+        │   │           ├── unescaped: "x"
+        │   │           └── flags: multi_line
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (129...135))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (129...131) = "do"
+        │   │   └── closing_loc: (132...135) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (137...157))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (137...138) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (139...150))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (139...145))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (139...140) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (140...145))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (141...144))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (141...144))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (141...142) = "c"
+        │   │       │   │   │           ├── opening_loc: ∅
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (143...144))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (143...144))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (143...144) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: ∅
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (140...141) = "{"
+        │   │       │   │   └── closing_loc: (144...145) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ StringNode (location: (147...150))
+        │   │           ├── opening_loc: (147...148) = "\""
+        │   │           ├── content_loc: (148...149) = "x"
+        │   │           ├── closing_loc: (149...150) = "\""
+        │   │           └── unescaped: "x"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (151...157))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (151...153) = "do"
+        │   │   └── closing_loc: (154...157) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (159...179))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (159...160) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (161...172))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (161...167))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (161...162) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (162...167))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (163...166))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (163...166))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (163...164) = "c"
+        │   │       │   │   │           ├── opening_loc: ∅
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (165...166))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (165...166))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (165...166) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: ∅
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (162...163) = "{"
+        │   │       │   │   └── closing_loc: (166...167) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RegularExpressionNode (location: (169...172))
+        │   │           ├── opening_loc: (169...170) = "/"
+        │   │           ├── content_loc: (170...171) = "x"
+        │   │           ├── closing_loc: (171...172) = "/"
+        │   │           ├── unescaped: "x"
+        │   │           └── flags: 
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (173...179))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (173...175) = "do"
+        │   │   └── closing_loc: (176...179) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (181...202))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (181...182) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (183...195))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (183...189))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (183...184) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (184...189))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (185...188))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (185...188))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (185...186) = "c"
+        │   │       │   │   │           ├── opening_loc: ∅
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (187...188))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (187...188))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (187...188) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: ∅
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (184...185) = "{"
+        │   │       │   │   └── closing_loc: (188...189) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RegularExpressionNode (location: (191...195))
+        │   │           ├── opening_loc: (191...192) = "/"
+        │   │           ├── content_loc: (192...193) = "x"
+        │   │           ├── closing_loc: (193...195) = "/m"
+        │   │           ├── unescaped: "x"
+        │   │           └── flags: multi_line
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (196...202))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (196...198) = "do"
+        │   │   └── closing_loc: (199...202) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (204...225))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (204...205) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (206...218))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (206...213))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (206...207) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (207...213))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (208...212))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (208...212))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (208...209) = "c"
+        │   │       │   │   │           ├── opening_loc: (209...210) = "("
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (210...211))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (210...211))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (210...211) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: (211...212) = ")"
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (207...208) = "{"
+        │   │       │   │   └── closing_loc: (212...213) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ StringNode (location: (215...218))
+        │   │           ├── opening_loc: (215...216) = "\""
+        │   │           ├── content_loc: (216...217) = "x"
+        │   │           ├── closing_loc: (217...218) = "\""
+        │   │           └── unescaped: "x"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (219...225))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (219...221) = "do"
+        │   │   └── closing_loc: (222...225) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (227...248))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (227...228) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (229...241))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (229...236))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (229...230) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (230...236))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (231...235))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (231...235))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (231...232) = "c"
+        │   │       │   │   │           ├── opening_loc: (232...233) = "("
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (233...234))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (233...234))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (233...234) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: (234...235) = ")"
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (230...231) = "{"
+        │   │       │   │   └── closing_loc: (235...236) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RegularExpressionNode (location: (238...241))
+        │   │           ├── opening_loc: (238...239) = "/"
+        │   │           ├── content_loc: (239...240) = "x"
+        │   │           ├── closing_loc: (240...241) = "/"
+        │   │           ├── unescaped: "x"
+        │   │           └── flags: 
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (242...248))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (242...244) = "do"
+        │   │   └── closing_loc: (245...248) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (250...272))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (250...251) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (252...265))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (252...259))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (252...253) = "b"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block:
+            │       │   │   @ BlockNode (location: (253...259))
+            │       │   │   ├── locals: []
+            │       │   │   ├── parameters: ∅
+            │       │   │   ├── body:
+            │       │   │   │   @ StatementsNode (location: (254...258))
+            │       │   │   │   └── body: (length: 1)
+            │       │   │   │       └── @ CallNode (location: (254...258))
+            │       │   │   │           ├── receiver: ∅
+            │       │   │   │           ├── call_operator_loc: ∅
+            │       │   │   │           ├── message_loc: (254...255) = "c"
+            │       │   │   │           ├── opening_loc: (255...256) = "("
+            │       │   │   │           ├── arguments:
+            │       │   │   │           │   @ ArgumentsNode (location: (256...257))
+            │       │   │   │           │   └── arguments: (length: 1)
+            │       │   │   │           │       └── @ CallNode (location: (256...257))
+            │       │   │   │           │           ├── receiver: ∅
+            │       │   │   │           │           ├── call_operator_loc: ∅
+            │       │   │   │           │           ├── message_loc: (256...257) = "d"
+            │       │   │   │           │           ├── opening_loc: ∅
+            │       │   │   │           │           ├── arguments: ∅
+            │       │   │   │           │           ├── closing_loc: ∅
+            │       │   │   │           │           ├── block: ∅
+            │       │   │   │           │           ├── flags: variable_call
+            │       │   │   │           │           └── name: "d"
+            │       │   │   │           ├── closing_loc: (257...258) = ")"
+            │       │   │   │           ├── block: ∅
+            │       │   │   │           ├── flags: 
+            │       │   │   │           └── name: "c"
+            │       │   │   ├── opening_loc: (253...254) = "{"
+            │       │   │   └── closing_loc: (258...259) = "}"
+            │       │   ├── flags: 
+            │       │   └── name: "b"
+            │       └── @ RegularExpressionNode (location: (261...265))
+            │           ├── opening_loc: (261...262) = "/"
+            │           ├── content_loc: (262...263) = "x"
+            │           ├── closing_loc: (263...265) = "/m"
+            │           ├── unescaped: "x"
+            │           └── flags: multi_line
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (266...272))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (266...268) = "do"
+            │   └── closing_loc: (269...272) = "end"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_11873_a.txt b/test/yarp/snapshots/whitequark/ruby_bug_11873_a.txt
index 5cdffe39b1..6acf930302 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_11873_a.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_11873_a.txt
@@ -1,1025 +1,1157 @@
-ProgramNode(0...444)(
-  [],
-  StatementsNode(0...444)(
-    [CallNode(0...18)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...11)(
-         [CallNode(2...8)(
-            nil,
-            nil,
-            (2...3),
-            (3...4),
-            ArgumentsNode(4...7)(
-              [CallNode(4...7)(
-                 nil,
-                 nil,
-                 (4...5),
-                 nil,
-                 ArgumentsNode(6...7)(
-                   [CallNode(6...7)(
-                      nil,
-                      nil,
-                      (6...7),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (7...8),
-            nil,
-            0,
-            "b"
-          ),
-          IntegerNode(10...11)()]
-       ),
-       nil,
-       BlockNode(12...18)([], nil, nil, (12...14), (15...18)),
-       0,
-       "a"
-     ),
-     CallNode(20...40)(
-       nil,
-       nil,
-       (20...21),
-       nil,
-       ArgumentsNode(22...33)(
-         [CallNode(22...28)(
-            nil,
-            nil,
-            (22...23),
-            (23...24),
-            ArgumentsNode(24...27)(
-              [CallNode(24...27)(
-                 nil,
-                 nil,
-                 (24...25),
-                 nil,
-                 ArgumentsNode(26...27)(
-                   [CallNode(26...27)(
-                      nil,
-                      nil,
-                      (26...27),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (27...28),
-            nil,
-            0,
-            "b"
-          ),
-          FloatNode(30...33)()]
-       ),
-       nil,
-       BlockNode(34...40)([], nil, nil, (34...36), (37...40)),
-       0,
-       "a"
-     ),
-     CallNode(42...63)(
-       nil,
-       nil,
-       (42...43),
-       nil,
-       ArgumentsNode(44...56)(
-         [CallNode(44...50)(
-            nil,
-            nil,
-            (44...45),
-            (45...46),
-            ArgumentsNode(46...49)(
-              [CallNode(46...49)(
-                 nil,
-                 nil,
-                 (46...47),
-                 nil,
-                 ArgumentsNode(48...49)(
-                   [CallNode(48...49)(
-                      nil,
-                      nil,
-                      (48...49),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (49...50),
-            nil,
-            0,
-            "b"
-          ),
-          ImaginaryNode(52...56)(FloatNode(52...55)())]
-       ),
-       nil,
-       BlockNode(57...63)([], nil, nil, (57...59), (60...63)),
-       0,
-       "a"
-     ),
-     CallNode(65...86)(
-       nil,
-       nil,
-       (65...66),
-       nil,
-       ArgumentsNode(67...79)(
-         [CallNode(67...73)(
-            nil,
-            nil,
-            (67...68),
-            (68...69),
-            ArgumentsNode(69...72)(
-              [CallNode(69...72)(
-                 nil,
-                 nil,
-                 (69...70),
-                 nil,
-                 ArgumentsNode(71...72)(
-                   [CallNode(71...72)(
-                      nil,
-                      nil,
-                      (71...72),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (72...73),
-            nil,
-            0,
-            "b"
-          ),
-          RationalNode(75...79)(FloatNode(75...78)())]
-       ),
-       nil,
-       BlockNode(80...86)([], nil, nil, (80...82), (83...86)),
-       0,
-       "a"
-     ),
-     CallNode(88...107)(
-       nil,
-       nil,
-       (88...89),
-       nil,
-       ArgumentsNode(90...100)(
-         [CallNode(90...96)(
-            nil,
-            nil,
-            (90...91),
-            (91...92),
-            ArgumentsNode(92...95)(
-              [CallNode(92...95)(
-                 nil,
-                 nil,
-                 (92...93),
-                 nil,
-                 ArgumentsNode(94...95)(
-                   [CallNode(94...95)(
-                      nil,
-                      nil,
-                      (94...95),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (95...96),
-            nil,
-            0,
-            "b"
-          ),
-          SymbolNode(98...100)((98...99), (99...100), nil, "e")]
-       ),
-       nil,
-       BlockNode(101...107)([], nil, nil, (101...103), (104...107)),
-       0,
-       "a"
-     ),
-     CallNode(109...128)(
-       nil,
-       nil,
-       (109...110),
-       nil,
-       ArgumentsNode(111...121)(
-         [CallNode(111...118)(
-            nil,
-            nil,
-            (111...112),
-            (112...113),
-            ArgumentsNode(113...117)(
-              [CallNode(113...117)(
-                 nil,
-                 nil,
-                 (113...114),
-                 (114...115),
-                 ArgumentsNode(115...116)(
-                   [CallNode(115...116)(
-                      nil,
-                      nil,
-                      (115...116),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 (116...117),
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (117...118),
-            nil,
-            0,
-            "b"
-          ),
-          IntegerNode(120...121)()]
-       ),
-       nil,
-       BlockNode(122...128)([], nil, nil, (122...124), (125...128)),
-       0,
-       "a"
-     ),
-     CallNode(130...151)(
-       nil,
-       nil,
-       (130...131),
-       nil,
-       ArgumentsNode(132...144)(
-         [CallNode(132...139)(
-            nil,
-            nil,
-            (132...133),
-            (133...134),
-            ArgumentsNode(134...138)(
-              [CallNode(134...138)(
-                 nil,
-                 nil,
-                 (134...135),
-                 (135...136),
-                 ArgumentsNode(136...137)(
-                   [CallNode(136...137)(
-                      nil,
-                      nil,
-                      (136...137),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 (137...138),
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (138...139),
-            nil,
-            0,
-            "b"
-          ),
-          FloatNode(141...144)()]
-       ),
-       nil,
-       BlockNode(145...151)([], nil, nil, (145...147), (148...151)),
-       0,
-       "a"
-     ),
-     CallNode(153...175)(
-       nil,
-       nil,
-       (153...154),
-       nil,
-       ArgumentsNode(155...168)(
-         [CallNode(155...162)(
-            nil,
-            nil,
-            (155...156),
-            (156...157),
-            ArgumentsNode(157...161)(
-              [CallNode(157...161)(
-                 nil,
-                 nil,
-                 (157...158),
-                 (158...159),
-                 ArgumentsNode(159...160)(
-                   [CallNode(159...160)(
-                      nil,
-                      nil,
-                      (159...160),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 (160...161),
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (161...162),
-            nil,
-            0,
-            "b"
-          ),
-          ImaginaryNode(164...168)(FloatNode(164...167)())]
-       ),
-       nil,
-       BlockNode(169...175)([], nil, nil, (169...171), (172...175)),
-       0,
-       "a"
-     ),
-     CallNode(177...199)(
-       nil,
-       nil,
-       (177...178),
-       nil,
-       ArgumentsNode(179...192)(
-         [CallNode(179...186)(
-            nil,
-            nil,
-            (179...180),
-            (180...181),
-            ArgumentsNode(181...185)(
-              [CallNode(181...185)(
-                 nil,
-                 nil,
-                 (181...182),
-                 (182...183),
-                 ArgumentsNode(183...184)(
-                   [CallNode(183...184)(
-                      nil,
-                      nil,
-                      (183...184),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 (184...185),
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (185...186),
-            nil,
-            0,
-            "b"
-          ),
-          RationalNode(188...192)(FloatNode(188...191)())]
-       ),
-       nil,
-       BlockNode(193...199)([], nil, nil, (193...195), (196...199)),
-       0,
-       "a"
-     ),
-     CallNode(201...221)(
-       nil,
-       nil,
-       (201...202),
-       nil,
-       ArgumentsNode(203...214)(
-         [CallNode(203...210)(
-            nil,
-            nil,
-            (203...204),
-            (204...205),
-            ArgumentsNode(205...209)(
-              [CallNode(205...209)(
-                 nil,
-                 nil,
-                 (205...206),
-                 (206...207),
-                 ArgumentsNode(207...208)(
-                   [CallNode(207...208)(
-                      nil,
-                      nil,
-                      (207...208),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "d"
-                    )]
-                 ),
-                 (208...209),
-                 nil,
-                 0,
-                 "c"
-               )]
-            ),
-            (209...210),
-            nil,
-            0,
-            "b"
-          ),
-          SymbolNode(212...214)((212...213), (213...214), nil, "e")]
-       ),
-       nil,
-       BlockNode(215...221)([], nil, nil, (215...217), (218...221)),
-       0,
-       "a"
-     ),
-     CallNode(223...241)(
-       nil,
-       nil,
-       (223...224),
-       nil,
-       ArgumentsNode(225...234)(
-         [CallNode(225...231)(
-            nil,
-            nil,
-            (225...226),
-            nil,
-            nil,
-            nil,
-            BlockNode(226...231)(
-              [],
-              nil,
-              StatementsNode(227...230)(
-                [CallNode(227...230)(
-                   nil,
-                   nil,
-                   (227...228),
-                   nil,
-                   ArgumentsNode(229...230)(
-                     [CallNode(229...230)(
-                        nil,
-                        nil,
-                        (229...230),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (226...227),
-              (230...231)
-            ),
-            0,
-            "b"
-          ),
-          IntegerNode(233...234)()]
-       ),
-       nil,
-       BlockNode(235...241)([], nil, nil, (235...237), (238...241)),
-       0,
-       "a"
-     ),
-     CallNode(243...263)(
-       nil,
-       nil,
-       (243...244),
-       nil,
-       ArgumentsNode(245...256)(
-         [CallNode(245...251)(
-            nil,
-            nil,
-            (245...246),
-            nil,
-            nil,
-            nil,
-            BlockNode(246...251)(
-              [],
-              nil,
-              StatementsNode(247...250)(
-                [CallNode(247...250)(
-                   nil,
-                   nil,
-                   (247...248),
-                   nil,
-                   ArgumentsNode(249...250)(
-                     [CallNode(249...250)(
-                        nil,
-                        nil,
-                        (249...250),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (246...247),
-              (250...251)
-            ),
-            0,
-            "b"
-          ),
-          FloatNode(253...256)()]
-       ),
-       nil,
-       BlockNode(257...263)([], nil, nil, (257...259), (260...263)),
-       0,
-       "a"
-     ),
-     CallNode(265...286)(
-       nil,
-       nil,
-       (265...266),
-       nil,
-       ArgumentsNode(267...279)(
-         [CallNode(267...273)(
-            nil,
-            nil,
-            (267...268),
-            nil,
-            nil,
-            nil,
-            BlockNode(268...273)(
-              [],
-              nil,
-              StatementsNode(269...272)(
-                [CallNode(269...272)(
-                   nil,
-                   nil,
-                   (269...270),
-                   nil,
-                   ArgumentsNode(271...272)(
-                     [CallNode(271...272)(
-                        nil,
-                        nil,
-                        (271...272),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (268...269),
-              (272...273)
-            ),
-            0,
-            "b"
-          ),
-          ImaginaryNode(275...279)(FloatNode(275...278)())]
-       ),
-       nil,
-       BlockNode(280...286)([], nil, nil, (280...282), (283...286)),
-       0,
-       "a"
-     ),
-     CallNode(288...309)(
-       nil,
-       nil,
-       (288...289),
-       nil,
-       ArgumentsNode(290...302)(
-         [CallNode(290...296)(
-            nil,
-            nil,
-            (290...291),
-            nil,
-            nil,
-            nil,
-            BlockNode(291...296)(
-              [],
-              nil,
-              StatementsNode(292...295)(
-                [CallNode(292...295)(
-                   nil,
-                   nil,
-                   (292...293),
-                   nil,
-                   ArgumentsNode(294...295)(
-                     [CallNode(294...295)(
-                        nil,
-                        nil,
-                        (294...295),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (291...292),
-              (295...296)
-            ),
-            0,
-            "b"
-          ),
-          RationalNode(298...302)(FloatNode(298...301)())]
-       ),
-       nil,
-       BlockNode(303...309)([], nil, nil, (303...305), (306...309)),
-       0,
-       "a"
-     ),
-     CallNode(311...330)(
-       nil,
-       nil,
-       (311...312),
-       nil,
-       ArgumentsNode(313...323)(
-         [CallNode(313...319)(
-            nil,
-            nil,
-            (313...314),
-            nil,
-            nil,
-            nil,
-            BlockNode(314...319)(
-              [],
-              nil,
-              StatementsNode(315...318)(
-                [CallNode(315...318)(
-                   nil,
-                   nil,
-                   (315...316),
-                   nil,
-                   ArgumentsNode(317...318)(
-                     [CallNode(317...318)(
-                        nil,
-                        nil,
-                        (317...318),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (314...315),
-              (318...319)
-            ),
-            0,
-            "b"
-          ),
-          SymbolNode(321...323)((321...322), (322...323), nil, "e")]
-       ),
-       nil,
-       BlockNode(324...330)([], nil, nil, (324...326), (327...330)),
-       0,
-       "a"
-     ),
-     CallNode(332...351)(
-       nil,
-       nil,
-       (332...333),
-       nil,
-       ArgumentsNode(334...344)(
-         [CallNode(334...341)(
-            nil,
-            nil,
-            (334...335),
-            nil,
-            nil,
-            nil,
-            BlockNode(335...341)(
-              [],
-              nil,
-              StatementsNode(336...340)(
-                [CallNode(336...340)(
-                   nil,
-                   nil,
-                   (336...337),
-                   (337...338),
-                   ArgumentsNode(338...339)(
-                     [CallNode(338...339)(
-                        nil,
-                        nil,
-                        (338...339),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   (339...340),
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (335...336),
-              (340...341)
-            ),
-            0,
-            "b"
-          ),
-          IntegerNode(343...344)()]
-       ),
-       nil,
-       BlockNode(345...351)([], nil, nil, (345...347), (348...351)),
-       0,
-       "a"
-     ),
-     CallNode(353...374)(
-       nil,
-       nil,
-       (353...354),
-       nil,
-       ArgumentsNode(355...367)(
-         [CallNode(355...362)(
-            nil,
-            nil,
-            (355...356),
-            nil,
-            nil,
-            nil,
-            BlockNode(356...362)(
-              [],
-              nil,
-              StatementsNode(357...361)(
-                [CallNode(357...361)(
-                   nil,
-                   nil,
-                   (357...358),
-                   (358...359),
-                   ArgumentsNode(359...360)(
-                     [CallNode(359...360)(
-                        nil,
-                        nil,
-                        (359...360),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   (360...361),
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (356...357),
-              (361...362)
-            ),
-            0,
-            "b"
-          ),
-          FloatNode(364...367)()]
-       ),
-       nil,
-       BlockNode(368...374)([], nil, nil, (368...370), (371...374)),
-       0,
-       "a"
-     ),
-     CallNode(376...398)(
-       nil,
-       nil,
-       (376...377),
-       nil,
-       ArgumentsNode(378...391)(
-         [CallNode(378...385)(
-            nil,
-            nil,
-            (378...379),
-            nil,
-            nil,
-            nil,
-            BlockNode(379...385)(
-              [],
-              nil,
-              StatementsNode(380...384)(
-                [CallNode(380...384)(
-                   nil,
-                   nil,
-                   (380...381),
-                   (381...382),
-                   ArgumentsNode(382...383)(
-                     [CallNode(382...383)(
-                        nil,
-                        nil,
-                        (382...383),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   (383...384),
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (379...380),
-              (384...385)
-            ),
-            0,
-            "b"
-          ),
-          ImaginaryNode(387...391)(FloatNode(387...390)())]
-       ),
-       nil,
-       BlockNode(392...398)([], nil, nil, (392...394), (395...398)),
-       0,
-       "a"
-     ),
-     CallNode(400...422)(
-       nil,
-       nil,
-       (400...401),
-       nil,
-       ArgumentsNode(402...415)(
-         [CallNode(402...409)(
-            nil,
-            nil,
-            (402...403),
-            nil,
-            nil,
-            nil,
-            BlockNode(403...409)(
-              [],
-              nil,
-              StatementsNode(404...408)(
-                [CallNode(404...408)(
-                   nil,
-                   nil,
-                   (404...405),
-                   (405...406),
-                   ArgumentsNode(406...407)(
-                     [CallNode(406...407)(
-                        nil,
-                        nil,
-                        (406...407),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   (407...408),
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (403...404),
-              (408...409)
-            ),
-            0,
-            "b"
-          ),
-          RationalNode(411...415)(FloatNode(411...414)())]
-       ),
-       nil,
-       BlockNode(416...422)([], nil, nil, (416...418), (419...422)),
-       0,
-       "a"
-     ),
-     CallNode(424...444)(
-       nil,
-       nil,
-       (424...425),
-       nil,
-       ArgumentsNode(426...437)(
-         [CallNode(426...433)(
-            nil,
-            nil,
-            (426...427),
-            nil,
-            nil,
-            nil,
-            BlockNode(427...433)(
-              [],
-              nil,
-              StatementsNode(428...432)(
-                [CallNode(428...432)(
-                   nil,
-                   nil,
-                   (428...429),
-                   (429...430),
-                   ArgumentsNode(430...431)(
-                     [CallNode(430...431)(
-                        nil,
-                        nil,
-                        (430...431),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "d"
-                      )]
-                   ),
-                   (431...432),
-                   nil,
-                   0,
-                   "c"
-                 )]
-              ),
-              (427...428),
-              (432...433)
-            ),
-            0,
-            "b"
-          ),
-          SymbolNode(435...437)((435...436), (436...437), nil, "e")]
-       ),
-       nil,
-       BlockNode(438...444)([], nil, nil, (438...440), (441...444)),
-       0,
-       "a"
-     )]
-  )
-)
+@ ProgramNode (location: (0...444))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...444))
+    └── body: (length: 20)
+        ├── @ CallNode (location: (0...18))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...11))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (2...8))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (2...3) = "b"
+        │   │       │   ├── opening_loc: (3...4) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (4...7))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (4...7))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (4...5) = "c"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (6...7))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (6...7))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (6...7) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (7...8) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ IntegerNode (location: (10...11))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (12...18))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (12...14) = "do"
+        │   │   └── closing_loc: (15...18) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (20...40))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (20...21) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (22...33))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (22...28))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (22...23) = "b"
+        │   │       │   ├── opening_loc: (23...24) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (24...27))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (24...27))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (24...25) = "c"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (26...27))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (26...27))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (26...27) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (27...28) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ FloatNode (location: (30...33))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (34...40))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (34...36) = "do"
+        │   │   └── closing_loc: (37...40) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (42...63))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (42...43) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (44...56))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (44...50))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (44...45) = "b"
+        │   │       │   ├── opening_loc: (45...46) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (46...49))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (46...49))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (46...47) = "c"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (48...49))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (48...49))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (48...49) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (49...50) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ ImaginaryNode (location: (52...56))
+        │   │           └── numeric:
+        │   │               @ FloatNode (location: (52...55))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (57...63))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (57...59) = "do"
+        │   │   └── closing_loc: (60...63) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (65...86))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (65...66) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (67...79))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (67...73))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (67...68) = "b"
+        │   │       │   ├── opening_loc: (68...69) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (69...72))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (69...72))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (69...70) = "c"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (71...72))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (71...72))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (71...72) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (72...73) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RationalNode (location: (75...79))
+        │   │           └── numeric:
+        │   │               @ FloatNode (location: (75...78))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (80...86))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (80...82) = "do"
+        │   │   └── closing_loc: (83...86) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (88...107))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (88...89) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (90...100))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (90...96))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (90...91) = "b"
+        │   │       │   ├── opening_loc: (91...92) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (92...95))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (92...95))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (92...93) = "c"
+        │   │       │   │           ├── opening_loc: ∅
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (94...95))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (94...95))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (94...95) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: ∅
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (95...96) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ SymbolNode (location: (98...100))
+        │   │           ├── opening_loc: (98...99) = ":"
+        │   │           ├── value_loc: (99...100) = "e"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "e"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (101...107))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (101...103) = "do"
+        │   │   └── closing_loc: (104...107) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (109...128))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (109...110) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (111...121))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (111...118))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (111...112) = "b"
+        │   │       │   ├── opening_loc: (112...113) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (113...117))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (113...117))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (113...114) = "c"
+        │   │       │   │           ├── opening_loc: (114...115) = "("
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (115...116))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (115...116))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (115...116) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: (116...117) = ")"
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (117...118) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ IntegerNode (location: (120...121))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (122...128))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (122...124) = "do"
+        │   │   └── closing_loc: (125...128) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (130...151))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (130...131) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (132...144))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (132...139))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (132...133) = "b"
+        │   │       │   ├── opening_loc: (133...134) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (134...138))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (134...138))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (134...135) = "c"
+        │   │       │   │           ├── opening_loc: (135...136) = "("
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (136...137))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (136...137))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (136...137) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: (137...138) = ")"
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (138...139) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ FloatNode (location: (141...144))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (145...151))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (145...147) = "do"
+        │   │   └── closing_loc: (148...151) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (153...175))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (153...154) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (155...168))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (155...162))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (155...156) = "b"
+        │   │       │   ├── opening_loc: (156...157) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (157...161))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (157...161))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (157...158) = "c"
+        │   │       │   │           ├── opening_loc: (158...159) = "("
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (159...160))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (159...160))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (159...160) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: (160...161) = ")"
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (161...162) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ ImaginaryNode (location: (164...168))
+        │   │           └── numeric:
+        │   │               @ FloatNode (location: (164...167))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (169...175))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (169...171) = "do"
+        │   │   └── closing_loc: (172...175) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (177...199))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (177...178) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (179...192))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (179...186))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (179...180) = "b"
+        │   │       │   ├── opening_loc: (180...181) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (181...185))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (181...185))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (181...182) = "c"
+        │   │       │   │           ├── opening_loc: (182...183) = "("
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (183...184))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (183...184))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (183...184) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: (184...185) = ")"
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (185...186) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RationalNode (location: (188...192))
+        │   │           └── numeric:
+        │   │               @ FloatNode (location: (188...191))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (193...199))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (193...195) = "do"
+        │   │   └── closing_loc: (196...199) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (201...221))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (201...202) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (203...214))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (203...210))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (203...204) = "b"
+        │   │       │   ├── opening_loc: (204...205) = "("
+        │   │       │   ├── arguments:
+        │   │       │   │   @ ArgumentsNode (location: (205...209))
+        │   │       │   │   └── arguments: (length: 1)
+        │   │       │   │       └── @ CallNode (location: (205...209))
+        │   │       │   │           ├── receiver: ∅
+        │   │       │   │           ├── call_operator_loc: ∅
+        │   │       │   │           ├── message_loc: (205...206) = "c"
+        │   │       │   │           ├── opening_loc: (206...207) = "("
+        │   │       │   │           ├── arguments:
+        │   │       │   │           │   @ ArgumentsNode (location: (207...208))
+        │   │       │   │           │   └── arguments: (length: 1)
+        │   │       │   │           │       └── @ CallNode (location: (207...208))
+        │   │       │   │           │           ├── receiver: ∅
+        │   │       │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │           │           ├── message_loc: (207...208) = "d"
+        │   │       │   │           │           ├── opening_loc: ∅
+        │   │       │   │           │           ├── arguments: ∅
+        │   │       │   │           │           ├── closing_loc: ∅
+        │   │       │   │           │           ├── block: ∅
+        │   │       │   │           │           ├── flags: variable_call
+        │   │       │   │           │           └── name: "d"
+        │   │       │   │           ├── closing_loc: (208...209) = ")"
+        │   │       │   │           ├── block: ∅
+        │   │       │   │           ├── flags: 
+        │   │       │   │           └── name: "c"
+        │   │       │   ├── closing_loc: (209...210) = ")"
+        │   │       │   ├── block: ∅
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ SymbolNode (location: (212...214))
+        │   │           ├── opening_loc: (212...213) = ":"
+        │   │           ├── value_loc: (213...214) = "e"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "e"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (215...221))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (215...217) = "do"
+        │   │   └── closing_loc: (218...221) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (223...241))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (223...224) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (225...234))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (225...231))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (225...226) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (226...231))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (227...230))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (227...230))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (227...228) = "c"
+        │   │       │   │   │           ├── opening_loc: ∅
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (229...230))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (229...230))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (229...230) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: ∅
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (226...227) = "{"
+        │   │       │   │   └── closing_loc: (230...231) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ IntegerNode (location: (233...234))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (235...241))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (235...237) = "do"
+        │   │   └── closing_loc: (238...241) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (243...263))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (243...244) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (245...256))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (245...251))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (245...246) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (246...251))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (247...250))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (247...250))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (247...248) = "c"
+        │   │       │   │   │           ├── opening_loc: ∅
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (249...250))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (249...250))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (249...250) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: ∅
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (246...247) = "{"
+        │   │       │   │   └── closing_loc: (250...251) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ FloatNode (location: (253...256))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (257...263))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (257...259) = "do"
+        │   │   └── closing_loc: (260...263) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (265...286))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (265...266) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (267...279))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (267...273))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (267...268) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (268...273))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (269...272))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (269...272))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (269...270) = "c"
+        │   │       │   │   │           ├── opening_loc: ∅
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (271...272))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (271...272))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (271...272) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: ∅
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (268...269) = "{"
+        │   │       │   │   └── closing_loc: (272...273) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ ImaginaryNode (location: (275...279))
+        │   │           └── numeric:
+        │   │               @ FloatNode (location: (275...278))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (280...286))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (280...282) = "do"
+        │   │   └── closing_loc: (283...286) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (288...309))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (288...289) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (290...302))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (290...296))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (290...291) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (291...296))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (292...295))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (292...295))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (292...293) = "c"
+        │   │       │   │   │           ├── opening_loc: ∅
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (294...295))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (294...295))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (294...295) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: ∅
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (291...292) = "{"
+        │   │       │   │   └── closing_loc: (295...296) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RationalNode (location: (298...302))
+        │   │           └── numeric:
+        │   │               @ FloatNode (location: (298...301))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (303...309))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (303...305) = "do"
+        │   │   └── closing_loc: (306...309) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (311...330))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (311...312) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (313...323))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (313...319))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (313...314) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (314...319))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (315...318))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (315...318))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (315...316) = "c"
+        │   │       │   │   │           ├── opening_loc: ∅
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (317...318))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (317...318))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (317...318) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: ∅
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (314...315) = "{"
+        │   │       │   │   └── closing_loc: (318...319) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ SymbolNode (location: (321...323))
+        │   │           ├── opening_loc: (321...322) = ":"
+        │   │           ├── value_loc: (322...323) = "e"
+        │   │           ├── closing_loc: ∅
+        │   │           └── unescaped: "e"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (324...330))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (324...326) = "do"
+        │   │   └── closing_loc: (327...330) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (332...351))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (332...333) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (334...344))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (334...341))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (334...335) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (335...341))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (336...340))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (336...340))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (336...337) = "c"
+        │   │       │   │   │           ├── opening_loc: (337...338) = "("
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (338...339))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (338...339))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (338...339) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: (339...340) = ")"
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (335...336) = "{"
+        │   │       │   │   └── closing_loc: (340...341) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ IntegerNode (location: (343...344))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (345...351))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (345...347) = "do"
+        │   │   └── closing_loc: (348...351) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (353...374))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (353...354) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (355...367))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (355...362))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (355...356) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (356...362))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (357...361))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (357...361))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (357...358) = "c"
+        │   │       │   │   │           ├── opening_loc: (358...359) = "("
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (359...360))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (359...360))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (359...360) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: (360...361) = ")"
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (356...357) = "{"
+        │   │       │   │   └── closing_loc: (361...362) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ FloatNode (location: (364...367))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (368...374))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (368...370) = "do"
+        │   │   └── closing_loc: (371...374) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (376...398))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (376...377) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (378...391))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (378...385))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (378...379) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (379...385))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (380...384))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (380...384))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (380...381) = "c"
+        │   │       │   │   │           ├── opening_loc: (381...382) = "("
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (382...383))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (382...383))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (382...383) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: (383...384) = ")"
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (379...380) = "{"
+        │   │       │   │   └── closing_loc: (384...385) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ ImaginaryNode (location: (387...391))
+        │   │           └── numeric:
+        │   │               @ FloatNode (location: (387...390))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (392...398))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (392...394) = "do"
+        │   │   └── closing_loc: (395...398) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        ├── @ CallNode (location: (400...422))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (400...401) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (402...415))
+        │   │   └── arguments: (length: 2)
+        │   │       ├── @ CallNode (location: (402...409))
+        │   │       │   ├── receiver: ∅
+        │   │       │   ├── call_operator_loc: ∅
+        │   │       │   ├── message_loc: (402...403) = "b"
+        │   │       │   ├── opening_loc: ∅
+        │   │       │   ├── arguments: ∅
+        │   │       │   ├── closing_loc: ∅
+        │   │       │   ├── block:
+        │   │       │   │   @ BlockNode (location: (403...409))
+        │   │       │   │   ├── locals: []
+        │   │       │   │   ├── parameters: ∅
+        │   │       │   │   ├── body:
+        │   │       │   │   │   @ StatementsNode (location: (404...408))
+        │   │       │   │   │   └── body: (length: 1)
+        │   │       │   │   │       └── @ CallNode (location: (404...408))
+        │   │       │   │   │           ├── receiver: ∅
+        │   │       │   │   │           ├── call_operator_loc: ∅
+        │   │       │   │   │           ├── message_loc: (404...405) = "c"
+        │   │       │   │   │           ├── opening_loc: (405...406) = "("
+        │   │       │   │   │           ├── arguments:
+        │   │       │   │   │           │   @ ArgumentsNode (location: (406...407))
+        │   │       │   │   │           │   └── arguments: (length: 1)
+        │   │       │   │   │           │       └── @ CallNode (location: (406...407))
+        │   │       │   │   │           │           ├── receiver: ∅
+        │   │       │   │   │           │           ├── call_operator_loc: ∅
+        │   │       │   │   │           │           ├── message_loc: (406...407) = "d"
+        │   │       │   │   │           │           ├── opening_loc: ∅
+        │   │       │   │   │           │           ├── arguments: ∅
+        │   │       │   │   │           │           ├── closing_loc: ∅
+        │   │       │   │   │           │           ├── block: ∅
+        │   │       │   │   │           │           ├── flags: variable_call
+        │   │       │   │   │           │           └── name: "d"
+        │   │       │   │   │           ├── closing_loc: (407...408) = ")"
+        │   │       │   │   │           ├── block: ∅
+        │   │       │   │   │           ├── flags: 
+        │   │       │   │   │           └── name: "c"
+        │   │       │   │   ├── opening_loc: (403...404) = "{"
+        │   │       │   │   └── closing_loc: (408...409) = "}"
+        │   │       │   ├── flags: 
+        │   │       │   └── name: "b"
+        │   │       └── @ RationalNode (location: (411...415))
+        │   │           └── numeric:
+        │   │               @ FloatNode (location: (411...414))
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (416...422))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (416...418) = "do"
+        │   │   └── closing_loc: (419...422) = "end"
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ CallNode (location: (424...444))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (424...425) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (426...437))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (426...433))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (426...427) = "b"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block:
+            │       │   │   @ BlockNode (location: (427...433))
+            │       │   │   ├── locals: []
+            │       │   │   ├── parameters: ∅
+            │       │   │   ├── body:
+            │       │   │   │   @ StatementsNode (location: (428...432))
+            │       │   │   │   └── body: (length: 1)
+            │       │   │   │       └── @ CallNode (location: (428...432))
+            │       │   │   │           ├── receiver: ∅
+            │       │   │   │           ├── call_operator_loc: ∅
+            │       │   │   │           ├── message_loc: (428...429) = "c"
+            │       │   │   │           ├── opening_loc: (429...430) = "("
+            │       │   │   │           ├── arguments:
+            │       │   │   │           │   @ ArgumentsNode (location: (430...431))
+            │       │   │   │           │   └── arguments: (length: 1)
+            │       │   │   │           │       └── @ CallNode (location: (430...431))
+            │       │   │   │           │           ├── receiver: ∅
+            │       │   │   │           │           ├── call_operator_loc: ∅
+            │       │   │   │           │           ├── message_loc: (430...431) = "d"
+            │       │   │   │           │           ├── opening_loc: ∅
+            │       │   │   │           │           ├── arguments: ∅
+            │       │   │   │           │           ├── closing_loc: ∅
+            │       │   │   │           │           ├── block: ∅
+            │       │   │   │           │           ├── flags: variable_call
+            │       │   │   │           │           └── name: "d"
+            │       │   │   │           ├── closing_loc: (431...432) = ")"
+            │       │   │   │           ├── block: ∅
+            │       │   │   │           ├── flags: 
+            │       │   │   │           └── name: "c"
+            │       │   │   ├── opening_loc: (427...428) = "{"
+            │       │   │   └── closing_loc: (432...433) = "}"
+            │       │   ├── flags: 
+            │       │   └── name: "b"
+            │       └── @ SymbolNode (location: (435...437))
+            │           ├── opening_loc: (435...436) = ":"
+            │           ├── value_loc: (436...437) = "e"
+            │           ├── closing_loc: ∅
+            │           └── unescaped: "e"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (438...444))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (438...440) = "do"
+            │   └── closing_loc: (441...444) = "end"
+            ├── flags: 
+            └── name: "a"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_11873_b.txt b/test/yarp/snapshots/whitequark/ruby_bug_11873_b.txt
index f1a840a892..b3d200eb89 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_11873_b.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_11873_b.txt
@@ -1,82 +1,95 @@
-ProgramNode(0...25)(
-  [],
-  StatementsNode(0...25)(
-    [CallNode(0...25)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...18)(
-         [CallNode(2...13)(
-            nil,
-            nil,
-            (2...3),
-            nil,
-            nil,
-            nil,
-            BlockNode(3...13)(
-              [],
-              nil,
-              StatementsNode(4...12)(
-                [CallNode(4...8)(
-                   nil,
-                   nil,
-                   (4...5),
-                   (5...6),
-                   ArgumentsNode(6...7)(
-                     [CallNode(6...7)(
-                        nil,
-                        nil,
-                        (6...7),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "p"
-                      )]
-                   ),
-                   (7...8),
-                   nil,
-                   0,
-                   "p"
-                 ),
-                 CallNode(9...12)(
-                   nil,
-                   nil,
-                   (9...10),
-                   nil,
-                   ArgumentsNode(11...12)(
-                     [CallNode(11...12)(
-                        nil,
-                        nil,
-                        (11...12),
-                        nil,
-                        nil,
-                        nil,
-                        nil,
-                        2,
-                        "p"
-                      )]
-                   ),
-                   nil,
-                   nil,
-                   0,
-                   "p"
-                 )]
-              ),
-              (3...4),
-              (12...13)
-            ),
-            0,
-            "p"
-          ),
-          CallNode(15...18)(nil, nil, (15...18), nil, nil, nil, nil, 2, "tap")]
-       ),
-       nil,
-       BlockNode(19...25)([], nil, nil, (19...21), (22...25)),
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...25))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...25))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...25))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...18))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (2...13))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (2...3) = "p"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block:
+            │       │   │   @ BlockNode (location: (3...13))
+            │       │   │   ├── locals: []
+            │       │   │   ├── parameters: ∅
+            │       │   │   ├── body:
+            │       │   │   │   @ StatementsNode (location: (4...12))
+            │       │   │   │   └── body: (length: 2)
+            │       │   │   │       ├── @ CallNode (location: (4...8))
+            │       │   │   │       │   ├── receiver: ∅
+            │       │   │   │       │   ├── call_operator_loc: ∅
+            │       │   │   │       │   ├── message_loc: (4...5) = "p"
+            │       │   │   │       │   ├── opening_loc: (5...6) = "("
+            │       │   │   │       │   ├── arguments:
+            │       │   │   │       │   │   @ ArgumentsNode (location: (6...7))
+            │       │   │   │       │   │   └── arguments: (length: 1)
+            │       │   │   │       │   │       └── @ CallNode (location: (6...7))
+            │       │   │   │       │   │           ├── receiver: ∅
+            │       │   │   │       │   │           ├── call_operator_loc: ∅
+            │       │   │   │       │   │           ├── message_loc: (6...7) = "p"
+            │       │   │   │       │   │           ├── opening_loc: ∅
+            │       │   │   │       │   │           ├── arguments: ∅
+            │       │   │   │       │   │           ├── closing_loc: ∅
+            │       │   │   │       │   │           ├── block: ∅
+            │       │   │   │       │   │           ├── flags: variable_call
+            │       │   │   │       │   │           └── name: "p"
+            │       │   │   │       │   ├── closing_loc: (7...8) = ")"
+            │       │   │   │       │   ├── block: ∅
+            │       │   │   │       │   ├── flags: 
+            │       │   │   │       │   └── name: "p"
+            │       │   │   │       └── @ CallNode (location: (9...12))
+            │       │   │   │           ├── receiver: ∅
+            │       │   │   │           ├── call_operator_loc: ∅
+            │       │   │   │           ├── message_loc: (9...10) = "p"
+            │       │   │   │           ├── opening_loc: ∅
+            │       │   │   │           ├── arguments:
+            │       │   │   │           │   @ ArgumentsNode (location: (11...12))
+            │       │   │   │           │   └── arguments: (length: 1)
+            │       │   │   │           │       └── @ CallNode (location: (11...12))
+            │       │   │   │           │           ├── receiver: ∅
+            │       │   │   │           │           ├── call_operator_loc: ∅
+            │       │   │   │           │           ├── message_loc: (11...12) = "p"
+            │       │   │   │           │           ├── opening_loc: ∅
+            │       │   │   │           │           ├── arguments: ∅
+            │       │   │   │           │           ├── closing_loc: ∅
+            │       │   │   │           │           ├── block: ∅
+            │       │   │   │           │           ├── flags: variable_call
+            │       │   │   │           │           └── name: "p"
+            │       │   │   │           ├── closing_loc: ∅
+            │       │   │   │           ├── block: ∅
+            │       │   │   │           ├── flags: 
+            │       │   │   │           └── name: "p"
+            │       │   │   ├── opening_loc: (3...4) = "{"
+            │       │   │   └── closing_loc: (12...13) = "}"
+            │       │   ├── flags: 
+            │       │   └── name: "p"
+            │       └── @ CallNode (location: (15...18))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (15...18) = "tap"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "tap"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (19...25))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (19...21) = "do"
+            │   └── closing_loc: (22...25) = "end"
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_11989.txt b/test/yarp/snapshots/whitequark/ruby_bug_11989.txt
index 847bc83fac..4ef8466777 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_11989.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_11989.txt
@@ -1,22 +1,26 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...8)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...8)(
-         [InterpolatedStringNode(2...8)(
-            (2...8),
-            [StringNode(9...19)(nil, (9...19), nil, "x\n" + "   y\n")],
-            (19...21)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...8))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...8))
+            │   └── arguments: (length: 1)
+            │       └── @ InterpolatedStringNode (location: (2...8))
+            │           ├── opening_loc: (2...8) = "<<~\"E\""
+            │           ├── parts: (length: 1)
+            │           │   └── @ StringNode (location: (9...19))
+            │           │       ├── opening_loc: ∅
+            │           │       ├── content_loc: (9...19) = "  x\\n   y\n"
+            │           │       ├── closing_loc: ∅
+            │           │       └── unescaped: "x\n   y\n"
+            │           └── closing_loc: (19...21) = "E\n"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_11990.txt b/test/yarp/snapshots/whitequark/ruby_bug_11990.txt
index 379407bffb..13e89f8caa 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_11990.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_11990.txt
@@ -1,25 +1,34 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...12)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...12)(
-         [StringConcatNode(2...12)(
-            InterpolatedStringNode(2...6)(
-              (2...6),
-              [StringNode(13...17)(nil, (13...17), nil, "x\n")],
-              (17...19)
-            ),
-            StringNode(7...12)((7...8), (8...11), (11...12), "  y")
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "p"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...12))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "p"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...12))
+            │   └── arguments: (length: 1)
+            │       └── @ StringConcatNode (location: (2...12))
+            │           ├── left:
+            │           │   @ InterpolatedStringNode (location: (2...6))
+            │           │   ├── opening_loc: (2...6) = "<<~E"
+            │           │   ├── parts: (length: 1)
+            │           │   │   └── @ StringNode (location: (13...17))
+            │           │   │       ├── opening_loc: ∅
+            │           │   │       ├── content_loc: (13...17) = "  x\n"
+            │           │   │       ├── closing_loc: ∅
+            │           │   │       └── unescaped: "x\n"
+            │           │   └── closing_loc: (17...19) = "E\n"
+            │           └── right:
+            │               @ StringNode (location: (7...12))
+            │               ├── opening_loc: (7...8) = "\""
+            │               ├── content_loc: (8...11) = "  y"
+            │               ├── closing_loc: (11...12) = "\""
+            │               └── unescaped: "  y"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "p"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_12073.txt b/test/yarp/snapshots/whitequark/ruby_bug_12073.txt
index 29ac50831d..8de2a87bef 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_12073.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_12073.txt
@@ -1,72 +1,86 @@
-ProgramNode(0...49)(
-  [:a],
-  StatementsNode(0...49)(
-    [LocalVariableWriteNode(0...5)(
-       :a,
-       0,
-       (0...1),
-       IntegerNode(4...5)(),
-       (2...3)
-     ),
-     CallNode(7...13)(
-       nil,
-       nil,
-       (7...8),
-       nil,
-       ArgumentsNode(9...13)(
-         [KeywordHashNode(9...13)(
-            [AssocNode(9...13)(
-               SymbolNode(9...11)(nil, (9...10), (10...11), "b"),
-               IntegerNode(12...13)(),
-               nil
-             )]
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "a"
-     ),
-     DefNode(15...49)(
-       :foo,
-       (19...22),
-       nil,
-       ParametersNode(23...28)(
-         [RequiredParameterNode(23...28)(:raise)],
-         [],
-         [],
-         nil,
-         [],
-         nil,
-         nil
-       ),
-       StatementsNode(30...44)(
-         [CallNode(30...44)(
-            nil,
-            nil,
-            (30...35),
-            nil,
-            ArgumentsNode(36...44)(
-              [ConstantPathNode(36...40)(
-                 ConstantReadNode(36...37)(:A),
-                 ConstantReadNode(39...40)(:B),
-                 (37...39)
-               ),
-               StringNode(42...44)((42...43), (43...43), (43...44), "")]
-            ),
-            nil,
-            nil,
-            0,
-            "raise"
-          )]
-       ),
-       [:raise],
-       (15...18),
-       nil,
-       nil,
-       nil,
-       nil,
-       (46...49)
-     )]
-  )
-)
+@ ProgramNode (location: (0...49))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...49))
+    └── body: (length: 3)
+        ├── @ LocalVariableWriteNode (location: (0...5))
+        │   ├── name: :a
+        │   ├── depth: 0
+        │   ├── name_loc: (0...1) = "a"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (4...5))
+        │   └── operator_loc: (2...3) = "="
+        ├── @ CallNode (location: (7...13))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (7...8) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (9...13))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ KeywordHashNode (location: (9...13))
+        │   │           └── elements: (length: 1)
+        │   │               └── @ AssocNode (location: (9...13))
+        │   │                   ├── key:
+        │   │                   │   @ SymbolNode (location: (9...11))
+        │   │                   │   ├── opening_loc: ∅
+        │   │                   │   ├── value_loc: (9...10) = "b"
+        │   │                   │   ├── closing_loc: (10...11) = ":"
+        │   │                   │   └── unescaped: "b"
+        │   │                   ├── value:
+        │   │                   │   @ IntegerNode (location: (12...13))
+        │   │                   └── operator_loc: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a"
+        └── @ DefNode (location: (15...49))
+            ├── name: :foo
+            ├── name_loc: (19...22) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (23...28))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (23...28))
+            │   │       └── name: :raise
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (30...44))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (30...44))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (30...35) = "raise"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (36...44))
+            │           │   └── arguments: (length: 2)
+            │           │       ├── @ ConstantPathNode (location: (36...40))
+            │           │       │   ├── parent:
+            │           │       │   │   @ ConstantReadNode (location: (36...37))
+            │           │       │   │   └── name: :A
+            │           │       │   ├── child:
+            │           │       │   │   @ ConstantReadNode (location: (39...40))
+            │           │       │   │   └── name: :B
+            │           │       │   └── delimiter_loc: (37...39) = "::"
+            │           │       └── @ StringNode (location: (42...44))
+            │           │           ├── opening_loc: (42...43) = "'"
+            │           │           ├── content_loc: (43...43) = ""
+            │           │           ├── closing_loc: (43...44) = "'"
+            │           │           └── unescaped: ""
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "raise"
+            ├── locals: [:raise]
+            ├── def_keyword_loc: (15...18) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (46...49) = "end"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_12402.txt b/test/yarp/snapshots/whitequark/ruby_bug_12402.txt
index 2f7562fd20..8b79f1a883 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_12402.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_12402.txt
@@ -1,529 +1,569 @@
-ProgramNode(0...437)(
-  [:foo],
-  StatementsNode(0...437)(
-    [LocalVariableOperatorWriteNode(0...27)(
-       (0...3),
-       (4...6),
-       CallNode(7...27)(
-         nil,
-         nil,
-         (7...12),
-         nil,
-         ArgumentsNode(13...27)(
-           [RescueModifierNode(13...27)(
-              CallNode(13...16)(
-                nil,
-                nil,
-                (13...16),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (17...23),
-              NilNode(24...27)()
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "raise"
-       ),
-       :foo,
-       :+,
-       0
-     ),
-     LocalVariableOperatorWriteNode(29...57)(
-       (29...32),
-       (33...35),
-       RescueModifierNode(36...57)(
-         CallNode(36...46)(
-           nil,
-           nil,
-           (36...41),
-           (41...42),
-           ArgumentsNode(42...45)(
-             [CallNode(42...45)(
-                nil,
-                nil,
-                (42...45),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           (45...46),
-           nil,
-           0,
-           "raise"
-         ),
-         (47...53),
-         NilNode(54...57)()
-       ),
-       :foo,
-       :+,
-       0
-     ),
-     LocalVariableWriteNode(59...85)(
-       :foo,
-       0,
-       (59...62),
-       CallNode(65...85)(
-         nil,
-         nil,
-         (65...70),
-         nil,
-         ArgumentsNode(71...85)(
-           [RescueModifierNode(71...85)(
-              CallNode(71...74)(
-                nil,
-                nil,
-                (71...74),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (75...81),
-              NilNode(82...85)()
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "raise"
-       ),
-       (63...64)
-     ),
-     LocalVariableWriteNode(87...114)(
-       :foo,
-       0,
-       (87...90),
-       RescueModifierNode(93...114)(
-         CallNode(93...103)(
-           nil,
-           nil,
-           (93...98),
-           (98...99),
-           ArgumentsNode(99...102)(
-             [CallNode(99...102)(
-                nil,
-                nil,
-                (99...102),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           (102...103),
-           nil,
-           0,
-           "raise"
-         ),
-         (104...110),
-         NilNode(111...114)()
-       ),
-       (91...92)
-     ),
-     CallOperatorWriteNode(116...145)(
-       LocalVariableReadNode(116...119)(:foo, 0),
-       (119...120),
-       (120...121),
-       nil,
-       nil,
-       nil,
-       0,
-       "C",
-       "C=",
-       :+,
-       (122...124),
-       CallNode(125...145)(
-         nil,
-         nil,
-         (125...130),
-         nil,
-         ArgumentsNode(131...145)(
-           [RescueModifierNode(131...145)(
-              CallNode(131...134)(
-                nil,
-                nil,
-                (131...134),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (135...141),
-              NilNode(142...145)()
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "raise"
-       )
-     ),
-     CallOperatorWriteNode(147...177)(
-       LocalVariableReadNode(147...150)(:foo, 0),
-       (150...151),
-       (151...152),
-       nil,
-       nil,
-       nil,
-       0,
-       "C",
-       "C=",
-       :+,
-       (153...155),
-       RescueModifierNode(156...177)(
-         CallNode(156...166)(
-           nil,
-           nil,
-           (156...161),
-           (161...162),
-           ArgumentsNode(162...165)(
-             [CallNode(162...165)(
-                nil,
-                nil,
-                (162...165),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           (165...166),
-           nil,
-           0,
-           "raise"
-         ),
-         (167...173),
-         NilNode(174...177)()
-       )
-     ),
-     CallOperatorWriteNode(179...208)(
-       LocalVariableReadNode(179...182)(:foo, 0),
-       (182...183),
-       (183...184),
-       nil,
-       nil,
-       nil,
-       0,
-       "m",
-       "m=",
-       :+,
-       (185...187),
-       CallNode(188...208)(
-         nil,
-         nil,
-         (188...193),
-         nil,
-         ArgumentsNode(194...208)(
-           [RescueModifierNode(194...208)(
-              CallNode(194...197)(
-                nil,
-                nil,
-                (194...197),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (198...204),
-              NilNode(205...208)()
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "raise"
-       )
-     ),
-     CallOperatorWriteNode(210...240)(
-       LocalVariableReadNode(210...213)(:foo, 0),
-       (213...214),
-       (214...215),
-       nil,
-       nil,
-       nil,
-       0,
-       "m",
-       "m=",
-       :+,
-       (216...218),
-       RescueModifierNode(219...240)(
-         CallNode(219...229)(
-           nil,
-           nil,
-           (219...224),
-           (224...225),
-           ArgumentsNode(225...228)(
-             [CallNode(225...228)(
-                nil,
-                nil,
-                (225...228),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           (228...229),
-           nil,
-           0,
-           "raise"
-         ),
-         (230...236),
-         NilNode(237...240)()
-       )
-     ),
-     ConstantPathOrWriteNode(242...273)(
-       ConstantPathNode(242...248)(
-         LocalVariableReadNode(242...245)(:foo, 0),
-         ConstantReadNode(247...248)(:C),
-         (245...247)
-       ),
-       (249...252),
-       CallNode(253...273)(
-         nil,
-         nil,
-         (253...258),
-         nil,
-         ArgumentsNode(259...273)(
-           [RescueModifierNode(259...273)(
-              CallNode(259...262)(
-                nil,
-                nil,
-                (259...262),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (263...269),
-              NilNode(270...273)()
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "raise"
-       )
-     ),
-     ConstantPathOrWriteNode(275...307)(
-       ConstantPathNode(275...281)(
-         LocalVariableReadNode(275...278)(:foo, 0),
-         ConstantReadNode(280...281)(:C),
-         (278...280)
-       ),
-       (282...285),
-       RescueModifierNode(286...307)(
-         CallNode(286...296)(
-           nil,
-           nil,
-           (286...291),
-           (291...292),
-           ArgumentsNode(292...295)(
-             [CallNode(292...295)(
-                nil,
-                nil,
-                (292...295),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           (295...296),
-           nil,
-           0,
-           "raise"
-         ),
-         (297...303),
-         NilNode(304...307)()
-       )
-     ),
-     CallOperatorWriteNode(309...339)(
-       LocalVariableReadNode(309...312)(:foo, 0),
-       (312...314),
-       (314...315),
-       nil,
-       nil,
-       nil,
-       0,
-       "m",
-       "m=",
-       :+,
-       (316...318),
-       CallNode(319...339)(
-         nil,
-         nil,
-         (319...324),
-         nil,
-         ArgumentsNode(325...339)(
-           [RescueModifierNode(325...339)(
-              CallNode(325...328)(
-                nil,
-                nil,
-                (325...328),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (329...335),
-              NilNode(336...339)()
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "raise"
-       )
-     ),
-     CallOperatorWriteNode(341...372)(
-       LocalVariableReadNode(341...344)(:foo, 0),
-       (344...346),
-       (346...347),
-       nil,
-       nil,
-       nil,
-       0,
-       "m",
-       "m=",
-       :+,
-       (348...350),
-       RescueModifierNode(351...372)(
-         CallNode(351...361)(
-           nil,
-           nil,
-           (351...356),
-           (356...357),
-           ArgumentsNode(357...360)(
-             [CallNode(357...360)(
-                nil,
-                nil,
-                (357...360),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           (360...361),
-           nil,
-           0,
-           "raise"
-         ),
-         (362...368),
-         NilNode(369...372)()
-       )
-     ),
-     CallOperatorWriteNode(374...404)(
-       LocalVariableReadNode(374...377)(:foo, 0),
-       nil,
-       (377...380),
-       (377...378),
-       ArgumentsNode(378...379)([IntegerNode(378...379)()]),
-       (379...380),
-       0,
-       "[]",
-       "[]=",
-       :+,
-       (381...383),
-       CallNode(384...404)(
-         nil,
-         nil,
-         (384...389),
-         nil,
-         ArgumentsNode(390...404)(
-           [RescueModifierNode(390...404)(
-              CallNode(390...393)(
-                nil,
-                nil,
-                (390...393),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              ),
-              (394...400),
-              NilNode(401...404)()
-            )]
-         ),
-         nil,
-         nil,
-         0,
-         "raise"
-       )
-     ),
-     CallOperatorWriteNode(406...437)(
-       LocalVariableReadNode(406...409)(:foo, 0),
-       nil,
-       (409...412),
-       (409...410),
-       ArgumentsNode(410...411)([IntegerNode(410...411)()]),
-       (411...412),
-       0,
-       "[]",
-       "[]=",
-       :+,
-       (413...415),
-       RescueModifierNode(416...437)(
-         CallNode(416...426)(
-           nil,
-           nil,
-           (416...421),
-           (421...422),
-           ArgumentsNode(422...425)(
-             [CallNode(422...425)(
-                nil,
-                nil,
-                (422...425),
-                nil,
-                nil,
-                nil,
-                nil,
-                2,
-                "bar"
-              )]
-           ),
-           (425...426),
-           nil,
-           0,
-           "raise"
-         ),
-         (427...433),
-         NilNode(434...437)()
-       )
-     )]
-  )
-)
+@ ProgramNode (location: (0...437))
+├── locals: [:foo]
+└── statements:
+    @ StatementsNode (location: (0...437))
+    └── body: (length: 14)
+        ├── @ LocalVariableOperatorWriteNode (location: (0...27))
+        │   ├── name_loc: (0...3) = "foo"
+        │   ├── operator_loc: (4...6) = "+="
+        │   ├── value:
+        │   │   @ CallNode (location: (7...27))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (7...12) = "raise"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (13...27))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ RescueModifierNode (location: (13...27))
+        │   │   │           ├── expression:
+        │   │   │           │   @ CallNode (location: (13...16))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (13...16) = "bar"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "bar"
+        │   │   │           ├── keyword_loc: (17...23) = "rescue"
+        │   │   │           └── rescue_expression:
+        │   │   │               @ NilNode (location: (24...27))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "raise"
+        │   ├── name: :foo
+        │   ├── operator: :+
+        │   └── depth: 0
+        ├── @ LocalVariableOperatorWriteNode (location: (29...57))
+        │   ├── name_loc: (29...32) = "foo"
+        │   ├── operator_loc: (33...35) = "+="
+        │   ├── value:
+        │   │   @ RescueModifierNode (location: (36...57))
+        │   │   ├── expression:
+        │   │   │   @ CallNode (location: (36...46))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (36...41) = "raise"
+        │   │   │   ├── opening_loc: (41...42) = "("
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (42...45))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (42...45))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (42...45) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   ├── closing_loc: (45...46) = ")"
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "raise"
+        │   │   ├── keyword_loc: (47...53) = "rescue"
+        │   │   └── rescue_expression:
+        │   │       @ NilNode (location: (54...57))
+        │   ├── name: :foo
+        │   ├── operator: :+
+        │   └── depth: 0
+        ├── @ LocalVariableWriteNode (location: (59...85))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (59...62) = "foo"
+        │   ├── value:
+        │   │   @ CallNode (location: (65...85))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (65...70) = "raise"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (71...85))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ RescueModifierNode (location: (71...85))
+        │   │   │           ├── expression:
+        │   │   │           │   @ CallNode (location: (71...74))
+        │   │   │           │   ├── receiver: ∅
+        │   │   │           │   ├── call_operator_loc: ∅
+        │   │   │           │   ├── message_loc: (71...74) = "bar"
+        │   │   │           │   ├── opening_loc: ∅
+        │   │   │           │   ├── arguments: ∅
+        │   │   │           │   ├── closing_loc: ∅
+        │   │   │           │   ├── block: ∅
+        │   │   │           │   ├── flags: variable_call
+        │   │   │           │   └── name: "bar"
+        │   │   │           ├── keyword_loc: (75...81) = "rescue"
+        │   │   │           └── rescue_expression:
+        │   │   │               @ NilNode (location: (82...85))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "raise"
+        │   └── operator_loc: (63...64) = "="
+        ├── @ LocalVariableWriteNode (location: (87...114))
+        │   ├── name: :foo
+        │   ├── depth: 0
+        │   ├── name_loc: (87...90) = "foo"
+        │   ├── value:
+        │   │   @ RescueModifierNode (location: (93...114))
+        │   │   ├── expression:
+        │   │   │   @ CallNode (location: (93...103))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (93...98) = "raise"
+        │   │   │   ├── opening_loc: (98...99) = "("
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (99...102))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (99...102))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (99...102) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   ├── closing_loc: (102...103) = ")"
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "raise"
+        │   │   ├── keyword_loc: (104...110) = "rescue"
+        │   │   └── rescue_expression:
+        │   │       @ NilNode (location: (111...114))
+        │   └── operator_loc: (91...92) = "="
+        ├── @ CallOperatorWriteNode (location: (116...145))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (116...119))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (119...120) = "."
+        │   ├── message_loc: (120...121) = "C"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "C"
+        │   ├── write_name: "C="
+        │   ├── operator: :+
+        │   ├── operator_loc: (122...124) = "+="
+        │   └── value:
+        │       @ CallNode (location: (125...145))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (125...130) = "raise"
+        │       ├── opening_loc: ∅
+        │       ├── arguments:
+        │       │   @ ArgumentsNode (location: (131...145))
+        │       │   └── arguments: (length: 1)
+        │       │       └── @ RescueModifierNode (location: (131...145))
+        │       │           ├── expression:
+        │       │           │   @ CallNode (location: (131...134))
+        │       │           │   ├── receiver: ∅
+        │       │           │   ├── call_operator_loc: ∅
+        │       │           │   ├── message_loc: (131...134) = "bar"
+        │       │           │   ├── opening_loc: ∅
+        │       │           │   ├── arguments: ∅
+        │       │           │   ├── closing_loc: ∅
+        │       │           │   ├── block: ∅
+        │       │           │   ├── flags: variable_call
+        │       │           │   └── name: "bar"
+        │       │           ├── keyword_loc: (135...141) = "rescue"
+        │       │           └── rescue_expression:
+        │       │               @ NilNode (location: (142...145))
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: 
+        │       └── name: "raise"
+        ├── @ CallOperatorWriteNode (location: (147...177))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (147...150))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (150...151) = "."
+        │   ├── message_loc: (151...152) = "C"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "C"
+        │   ├── write_name: "C="
+        │   ├── operator: :+
+        │   ├── operator_loc: (153...155) = "+="
+        │   └── value:
+        │       @ RescueModifierNode (location: (156...177))
+        │       ├── expression:
+        │       │   @ CallNode (location: (156...166))
+        │       │   ├── receiver: ∅
+        │       │   ├── call_operator_loc: ∅
+        │       │   ├── message_loc: (156...161) = "raise"
+        │       │   ├── opening_loc: (161...162) = "("
+        │       │   ├── arguments:
+        │       │   │   @ ArgumentsNode (location: (162...165))
+        │       │   │   └── arguments: (length: 1)
+        │       │   │       └── @ CallNode (location: (162...165))
+        │       │   │           ├── receiver: ∅
+        │       │   │           ├── call_operator_loc: ∅
+        │       │   │           ├── message_loc: (162...165) = "bar"
+        │       │   │           ├── opening_loc: ∅
+        │       │   │           ├── arguments: ∅
+        │       │   │           ├── closing_loc: ∅
+        │       │   │           ├── block: ∅
+        │       │   │           ├── flags: variable_call
+        │       │   │           └── name: "bar"
+        │       │   ├── closing_loc: (165...166) = ")"
+        │       │   ├── block: ∅
+        │       │   ├── flags: 
+        │       │   └── name: "raise"
+        │       ├── keyword_loc: (167...173) = "rescue"
+        │       └── rescue_expression:
+        │           @ NilNode (location: (174...177))
+        ├── @ CallOperatorWriteNode (location: (179...208))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (179...182))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (182...183) = "."
+        │   ├── message_loc: (183...184) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "m"
+        │   ├── write_name: "m="
+        │   ├── operator: :+
+        │   ├── operator_loc: (185...187) = "+="
+        │   └── value:
+        │       @ CallNode (location: (188...208))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (188...193) = "raise"
+        │       ├── opening_loc: ∅
+        │       ├── arguments:
+        │       │   @ ArgumentsNode (location: (194...208))
+        │       │   └── arguments: (length: 1)
+        │       │       └── @ RescueModifierNode (location: (194...208))
+        │       │           ├── expression:
+        │       │           │   @ CallNode (location: (194...197))
+        │       │           │   ├── receiver: ∅
+        │       │           │   ├── call_operator_loc: ∅
+        │       │           │   ├── message_loc: (194...197) = "bar"
+        │       │           │   ├── opening_loc: ∅
+        │       │           │   ├── arguments: ∅
+        │       │           │   ├── closing_loc: ∅
+        │       │           │   ├── block: ∅
+        │       │           │   ├── flags: variable_call
+        │       │           │   └── name: "bar"
+        │       │           ├── keyword_loc: (198...204) = "rescue"
+        │       │           └── rescue_expression:
+        │       │               @ NilNode (location: (205...208))
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: 
+        │       └── name: "raise"
+        ├── @ CallOperatorWriteNode (location: (210...240))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (210...213))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (213...214) = "."
+        │   ├── message_loc: (214...215) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "m"
+        │   ├── write_name: "m="
+        │   ├── operator: :+
+        │   ├── operator_loc: (216...218) = "+="
+        │   └── value:
+        │       @ RescueModifierNode (location: (219...240))
+        │       ├── expression:
+        │       │   @ CallNode (location: (219...229))
+        │       │   ├── receiver: ∅
+        │       │   ├── call_operator_loc: ∅
+        │       │   ├── message_loc: (219...224) = "raise"
+        │       │   ├── opening_loc: (224...225) = "("
+        │       │   ├── arguments:
+        │       │   │   @ ArgumentsNode (location: (225...228))
+        │       │   │   └── arguments: (length: 1)
+        │       │   │       └── @ CallNode (location: (225...228))
+        │       │   │           ├── receiver: ∅
+        │       │   │           ├── call_operator_loc: ∅
+        │       │   │           ├── message_loc: (225...228) = "bar"
+        │       │   │           ├── opening_loc: ∅
+        │       │   │           ├── arguments: ∅
+        │       │   │           ├── closing_loc: ∅
+        │       │   │           ├── block: ∅
+        │       │   │           ├── flags: variable_call
+        │       │   │           └── name: "bar"
+        │       │   ├── closing_loc: (228...229) = ")"
+        │       │   ├── block: ∅
+        │       │   ├── flags: 
+        │       │   └── name: "raise"
+        │       ├── keyword_loc: (230...236) = "rescue"
+        │       └── rescue_expression:
+        │           @ NilNode (location: (237...240))
+        ├── @ ConstantPathOrWriteNode (location: (242...273))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (242...248))
+        │   │   ├── parent:
+        │   │   │   @ LocalVariableReadNode (location: (242...245))
+        │   │   │   ├── name: :foo
+        │   │   │   └── depth: 0
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (247...248))
+        │   │   │   └── name: :C
+        │   │   └── delimiter_loc: (245...247) = "::"
+        │   ├── operator_loc: (249...252) = "||="
+        │   └── value:
+        │       @ CallNode (location: (253...273))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (253...258) = "raise"
+        │       ├── opening_loc: ∅
+        │       ├── arguments:
+        │       │   @ ArgumentsNode (location: (259...273))
+        │       │   └── arguments: (length: 1)
+        │       │       └── @ RescueModifierNode (location: (259...273))
+        │       │           ├── expression:
+        │       │           │   @ CallNode (location: (259...262))
+        │       │           │   ├── receiver: ∅
+        │       │           │   ├── call_operator_loc: ∅
+        │       │           │   ├── message_loc: (259...262) = "bar"
+        │       │           │   ├── opening_loc: ∅
+        │       │           │   ├── arguments: ∅
+        │       │           │   ├── closing_loc: ∅
+        │       │           │   ├── block: ∅
+        │       │           │   ├── flags: variable_call
+        │       │           │   └── name: "bar"
+        │       │           ├── keyword_loc: (263...269) = "rescue"
+        │       │           └── rescue_expression:
+        │       │               @ NilNode (location: (270...273))
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: 
+        │       └── name: "raise"
+        ├── @ ConstantPathOrWriteNode (location: (275...307))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (275...281))
+        │   │   ├── parent:
+        │   │   │   @ LocalVariableReadNode (location: (275...278))
+        │   │   │   ├── name: :foo
+        │   │   │   └── depth: 0
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (280...281))
+        │   │   │   └── name: :C
+        │   │   └── delimiter_loc: (278...280) = "::"
+        │   ├── operator_loc: (282...285) = "||="
+        │   └── value:
+        │       @ RescueModifierNode (location: (286...307))
+        │       ├── expression:
+        │       │   @ CallNode (location: (286...296))
+        │       │   ├── receiver: ∅
+        │       │   ├── call_operator_loc: ∅
+        │       │   ├── message_loc: (286...291) = "raise"
+        │       │   ├── opening_loc: (291...292) = "("
+        │       │   ├── arguments:
+        │       │   │   @ ArgumentsNode (location: (292...295))
+        │       │   │   └── arguments: (length: 1)
+        │       │   │       └── @ CallNode (location: (292...295))
+        │       │   │           ├── receiver: ∅
+        │       │   │           ├── call_operator_loc: ∅
+        │       │   │           ├── message_loc: (292...295) = "bar"
+        │       │   │           ├── opening_loc: ∅
+        │       │   │           ├── arguments: ∅
+        │       │   │           ├── closing_loc: ∅
+        │       │   │           ├── block: ∅
+        │       │   │           ├── flags: variable_call
+        │       │   │           └── name: "bar"
+        │       │   ├── closing_loc: (295...296) = ")"
+        │       │   ├── block: ∅
+        │       │   ├── flags: 
+        │       │   └── name: "raise"
+        │       ├── keyword_loc: (297...303) = "rescue"
+        │       └── rescue_expression:
+        │           @ NilNode (location: (304...307))
+        ├── @ CallOperatorWriteNode (location: (309...339))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (309...312))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (312...314) = "::"
+        │   ├── message_loc: (314...315) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "m"
+        │   ├── write_name: "m="
+        │   ├── operator: :+
+        │   ├── operator_loc: (316...318) = "+="
+        │   └── value:
+        │       @ CallNode (location: (319...339))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (319...324) = "raise"
+        │       ├── opening_loc: ∅
+        │       ├── arguments:
+        │       │   @ ArgumentsNode (location: (325...339))
+        │       │   └── arguments: (length: 1)
+        │       │       └── @ RescueModifierNode (location: (325...339))
+        │       │           ├── expression:
+        │       │           │   @ CallNode (location: (325...328))
+        │       │           │   ├── receiver: ∅
+        │       │           │   ├── call_operator_loc: ∅
+        │       │           │   ├── message_loc: (325...328) = "bar"
+        │       │           │   ├── opening_loc: ∅
+        │       │           │   ├── arguments: ∅
+        │       │           │   ├── closing_loc: ∅
+        │       │           │   ├── block: ∅
+        │       │           │   ├── flags: variable_call
+        │       │           │   └── name: "bar"
+        │       │           ├── keyword_loc: (329...335) = "rescue"
+        │       │           └── rescue_expression:
+        │       │               @ NilNode (location: (336...339))
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: 
+        │       └── name: "raise"
+        ├── @ CallOperatorWriteNode (location: (341...372))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (341...344))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: (344...346) = "::"
+        │   ├── message_loc: (346...347) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── flags: 
+        │   ├── read_name: "m"
+        │   ├── write_name: "m="
+        │   ├── operator: :+
+        │   ├── operator_loc: (348...350) = "+="
+        │   └── value:
+        │       @ RescueModifierNode (location: (351...372))
+        │       ├── expression:
+        │       │   @ CallNode (location: (351...361))
+        │       │   ├── receiver: ∅
+        │       │   ├── call_operator_loc: ∅
+        │       │   ├── message_loc: (351...356) = "raise"
+        │       │   ├── opening_loc: (356...357) = "("
+        │       │   ├── arguments:
+        │       │   │   @ ArgumentsNode (location: (357...360))
+        │       │   │   └── arguments: (length: 1)
+        │       │   │       └── @ CallNode (location: (357...360))
+        │       │   │           ├── receiver: ∅
+        │       │   │           ├── call_operator_loc: ∅
+        │       │   │           ├── message_loc: (357...360) = "bar"
+        │       │   │           ├── opening_loc: ∅
+        │       │   │           ├── arguments: ∅
+        │       │   │           ├── closing_loc: ∅
+        │       │   │           ├── block: ∅
+        │       │   │           ├── flags: variable_call
+        │       │   │           └── name: "bar"
+        │       │   ├── closing_loc: (360...361) = ")"
+        │       │   ├── block: ∅
+        │       │   ├── flags: 
+        │       │   └── name: "raise"
+        │       ├── keyword_loc: (362...368) = "rescue"
+        │       └── rescue_expression:
+        │           @ NilNode (location: (369...372))
+        ├── @ CallOperatorWriteNode (location: (374...404))
+        │   ├── receiver:
+        │   │   @ LocalVariableReadNode (location: (374...377))
+        │   │   ├── name: :foo
+        │   │   └── depth: 0
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (377...380) = "[0]"
+        │   ├── opening_loc: (377...378) = "["
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (378...379))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (378...379))
+        │   ├── closing_loc: (379...380) = "]"
+        │   ├── flags: 
+        │   ├── read_name: "[]"
+        │   ├── write_name: "[]="
+        │   ├── operator: :+
+        │   ├── operator_loc: (381...383) = "+="
+        │   └── value:
+        │       @ CallNode (location: (384...404))
+        │       ├── receiver: ∅
+        │       ├── call_operator_loc: ∅
+        │       ├── message_loc: (384...389) = "raise"
+        │       ├── opening_loc: ∅
+        │       ├── arguments:
+        │       │   @ ArgumentsNode (location: (390...404))
+        │       │   └── arguments: (length: 1)
+        │       │       └── @ RescueModifierNode (location: (390...404))
+        │       │           ├── expression:
+        │       │           │   @ CallNode (location: (390...393))
+        │       │           │   ├── receiver: ∅
+        │       │           │   ├── call_operator_loc: ∅
+        │       │           │   ├── message_loc: (390...393) = "bar"
+        │       │           │   ├── opening_loc: ∅
+        │       │           │   ├── arguments: ∅
+        │       │           │   ├── closing_loc: ∅
+        │       │           │   ├── block: ∅
+        │       │           │   ├── flags: variable_call
+        │       │           │   └── name: "bar"
+        │       │           ├── keyword_loc: (394...400) = "rescue"
+        │       │           └── rescue_expression:
+        │       │               @ NilNode (location: (401...404))
+        │       ├── closing_loc: ∅
+        │       ├── block: ∅
+        │       ├── flags: 
+        │       └── name: "raise"
+        └── @ CallOperatorWriteNode (location: (406...437))
+            ├── receiver:
+            │   @ LocalVariableReadNode (location: (406...409))
+            │   ├── name: :foo
+            │   └── depth: 0
+            ├── call_operator_loc: ∅
+            ├── message_loc: (409...412) = "[0]"
+            ├── opening_loc: (409...410) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (410...411))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (410...411))
+            ├── closing_loc: (411...412) = "]"
+            ├── flags: 
+            ├── read_name: "[]"
+            ├── write_name: "[]="
+            ├── operator: :+
+            ├── operator_loc: (413...415) = "+="
+            └── value:
+                @ RescueModifierNode (location: (416...437))
+                ├── expression:
+                │   @ CallNode (location: (416...426))
+                │   ├── receiver: ∅
+                │   ├── call_operator_loc: ∅
+                │   ├── message_loc: (416...421) = "raise"
+                │   ├── opening_loc: (421...422) = "("
+                │   ├── arguments:
+                │   │   @ ArgumentsNode (location: (422...425))
+                │   │   └── arguments: (length: 1)
+                │   │       └── @ CallNode (location: (422...425))
+                │   │           ├── receiver: ∅
+                │   │           ├── call_operator_loc: ∅
+                │   │           ├── message_loc: (422...425) = "bar"
+                │   │           ├── opening_loc: ∅
+                │   │           ├── arguments: ∅
+                │   │           ├── closing_loc: ∅
+                │   │           ├── block: ∅
+                │   │           ├── flags: variable_call
+                │   │           └── name: "bar"
+                │   ├── closing_loc: (425...426) = ")"
+                │   ├── block: ∅
+                │   ├── flags: 
+                │   └── name: "raise"
+                ├── keyword_loc: (427...433) = "rescue"
+                └── rescue_expression:
+                    @ NilNode (location: (434...437))
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_12669.txt b/test/yarp/snapshots/whitequark/ruby_bug_12669.txt
index 689a3d9a77..01cff7933d 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_12669.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_12669.txt
@@ -1,109 +1,125 @@
-ProgramNode(0...74)(
-  [:a, :b],
-  StatementsNode(0...74)(
-    [LocalVariableOperatorWriteNode(0...18)(
-       (0...1),
-       (2...4),
-       LocalVariableOperatorWriteNode(5...18)(
-         (5...6),
-         (7...9),
-         CallNode(10...18)(
-           nil,
-           nil,
-           (10...15),
-           nil,
-           ArgumentsNode(16...18)(
-             [SymbolNode(16...18)((16...17), (17...18), nil, "x")]
-           ),
-           nil,
-           nil,
-           0,
-           "raise"
-         ),
-         :b,
-         :+,
-         0
-       ),
-       :a,
-       :+,
-       0
-     ),
-     LocalVariableOperatorWriteNode(20...37)(
-       (20...21),
-       (22...24),
-       LocalVariableWriteNode(25...37)(
-         :b,
-         0,
-         (25...26),
-         CallNode(29...37)(
-           nil,
-           nil,
-           (29...34),
-           nil,
-           ArgumentsNode(35...37)(
-             [SymbolNode(35...37)((35...36), (36...37), nil, "x")]
-           ),
-           nil,
-           nil,
-           0,
-           "raise"
-         ),
-         (27...28)
-       ),
-       :a,
-       :+,
-       0
-     ),
-     LocalVariableWriteNode(39...56)(
-       :a,
-       0,
-       (39...40),
-       LocalVariableOperatorWriteNode(43...56)(
-         (43...44),
-         (45...47),
-         CallNode(48...56)(
-           nil,
-           nil,
-           (48...53),
-           nil,
-           ArgumentsNode(54...56)(
-             [SymbolNode(54...56)((54...55), (55...56), nil, "x")]
-           ),
-           nil,
-           nil,
-           0,
-           "raise"
-         ),
-         :b,
-         :+,
-         0
-       ),
-       (41...42)
-     ),
-     LocalVariableWriteNode(58...74)(
-       :a,
-       0,
-       (58...59),
-       LocalVariableWriteNode(62...74)(
-         :b,
-         0,
-         (62...63),
-         CallNode(66...74)(
-           nil,
-           nil,
-           (66...71),
-           nil,
-           ArgumentsNode(72...74)(
-             [SymbolNode(72...74)((72...73), (73...74), nil, "x")]
-           ),
-           nil,
-           nil,
-           0,
-           "raise"
-         ),
-         (64...65)
-       ),
-       (60...61)
-     )]
-  )
-)
+@ ProgramNode (location: (0...74))
+├── locals: [:a, :b]
+└── statements:
+    @ StatementsNode (location: (0...74))
+    └── body: (length: 4)
+        ├── @ LocalVariableOperatorWriteNode (location: (0...18))
+        │   ├── name_loc: (0...1) = "a"
+        │   ├── operator_loc: (2...4) = "+="
+        │   ├── value:
+        │   │   @ LocalVariableOperatorWriteNode (location: (5...18))
+        │   │   ├── name_loc: (5...6) = "b"
+        │   │   ├── operator_loc: (7...9) = "+="
+        │   │   ├── value:
+        │   │   │   @ CallNode (location: (10...18))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (10...15) = "raise"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (16...18))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ SymbolNode (location: (16...18))
+        │   │   │   │           ├── opening_loc: (16...17) = ":"
+        │   │   │   │           ├── value_loc: (17...18) = "x"
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           └── unescaped: "x"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "raise"
+        │   │   ├── name: :b
+        │   │   ├── operator: :+
+        │   │   └── depth: 0
+        │   ├── name: :a
+        │   ├── operator: :+
+        │   └── depth: 0
+        ├── @ LocalVariableOperatorWriteNode (location: (20...37))
+        │   ├── name_loc: (20...21) = "a"
+        │   ├── operator_loc: (22...24) = "+="
+        │   ├── value:
+        │   │   @ LocalVariableWriteNode (location: (25...37))
+        │   │   ├── name: :b
+        │   │   ├── depth: 0
+        │   │   ├── name_loc: (25...26) = "b"
+        │   │   ├── value:
+        │   │   │   @ CallNode (location: (29...37))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (29...34) = "raise"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (35...37))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ SymbolNode (location: (35...37))
+        │   │   │   │           ├── opening_loc: (35...36) = ":"
+        │   │   │   │           ├── value_loc: (36...37) = "x"
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           └── unescaped: "x"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "raise"
+        │   │   └── operator_loc: (27...28) = "="
+        │   ├── name: :a
+        │   ├── operator: :+
+        │   └── depth: 0
+        ├── @ LocalVariableWriteNode (location: (39...56))
+        │   ├── name: :a
+        │   ├── depth: 0
+        │   ├── name_loc: (39...40) = "a"
+        │   ├── value:
+        │   │   @ LocalVariableOperatorWriteNode (location: (43...56))
+        │   │   ├── name_loc: (43...44) = "b"
+        │   │   ├── operator_loc: (45...47) = "+="
+        │   │   ├── value:
+        │   │   │   @ CallNode (location: (48...56))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (48...53) = "raise"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments:
+        │   │   │   │   @ ArgumentsNode (location: (54...56))
+        │   │   │   │   └── arguments: (length: 1)
+        │   │   │   │       └── @ SymbolNode (location: (54...56))
+        │   │   │   │           ├── opening_loc: (54...55) = ":"
+        │   │   │   │           ├── value_loc: (55...56) = "x"
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           └── unescaped: "x"
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: 
+        │   │   │   └── name: "raise"
+        │   │   ├── name: :b
+        │   │   ├── operator: :+
+        │   │   └── depth: 0
+        │   └── operator_loc: (41...42) = "="
+        └── @ LocalVariableWriteNode (location: (58...74))
+            ├── name: :a
+            ├── depth: 0
+            ├── name_loc: (58...59) = "a"
+            ├── value:
+            │   @ LocalVariableWriteNode (location: (62...74))
+            │   ├── name: :b
+            │   ├── depth: 0
+            │   ├── name_loc: (62...63) = "b"
+            │   ├── value:
+            │   │   @ CallNode (location: (66...74))
+            │   │   ├── receiver: ∅
+            │   │   ├── call_operator_loc: ∅
+            │   │   ├── message_loc: (66...71) = "raise"
+            │   │   ├── opening_loc: ∅
+            │   │   ├── arguments:
+            │   │   │   @ ArgumentsNode (location: (72...74))
+            │   │   │   └── arguments: (length: 1)
+            │   │   │       └── @ SymbolNode (location: (72...74))
+            │   │   │           ├── opening_loc: (72...73) = ":"
+            │   │   │           ├── value_loc: (73...74) = "x"
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           └── unescaped: "x"
+            │   │   ├── closing_loc: ∅
+            │   │   ├── block: ∅
+            │   │   ├── flags: 
+            │   │   └── name: "raise"
+            │   └── operator_loc: (64...65) = "="
+            └── operator_loc: (60...61) = "="
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_12686.txt b/test/yarp/snapshots/whitequark/ruby_bug_12686.txt
index f0ae6d1074..c6daf187b9 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_12686.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_12686.txt
@@ -1,38 +1,38 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...16)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...16)(
-         [ParenthesesNode(2...16)(
-            StatementsNode(3...15)(
-              [RescueModifierNode(3...15)(
-                 CallNode(3...4)(
-                   nil,
-                   nil,
-                   (3...4),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "g"
-                 ),
-                 (5...11),
-                 NilNode(12...15)()
-               )]
-            ),
-            (2...3),
-            (15...16)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "f"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...16))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...1) = "f"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (2...16))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (2...16))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (3...15))
+            │           │   └── body: (length: 1)
+            │           │       └── @ RescueModifierNode (location: (3...15))
+            │           │           ├── expression:
+            │           │           │   @ CallNode (location: (3...4))
+            │           │           │   ├── receiver: ∅
+            │           │           │   ├── call_operator_loc: ∅
+            │           │           │   ├── message_loc: (3...4) = "g"
+            │           │           │   ├── opening_loc: ∅
+            │           │           │   ├── arguments: ∅
+            │           │           │   ├── closing_loc: ∅
+            │           │           │   ├── block: ∅
+            │           │           │   ├── flags: variable_call
+            │           │           │   └── name: "g"
+            │           │           ├── keyword_loc: (5...11) = "rescue"
+            │           │           └── rescue_expression:
+            │           │               @ NilNode (location: (12...15))
+            │           ├── opening_loc: (2...3) = "("
+            │           └── closing_loc: (15...16) = ")"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "f"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_13547.txt b/test/yarp/snapshots/whitequark/ruby_bug_13547.txt
index c0e5ccd927..519811f79f 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_13547.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_13547.txt
@@ -1,16 +1,31 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       CallNode(0...4)(nil, nil, (0...4), nil, nil, nil, nil, 2, "meth"),
-       nil,
-       (4...6),
-       (4...5),
-       nil,
-       (5...6),
-       BlockNode(7...9)([], nil, nil, (7...8), (8...9)),
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver:
+            │   @ CallNode (location: (0...4))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...4) = "meth"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "meth"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (4...6) = "[]"
+            ├── opening_loc: (4...5) = "["
+            ├── arguments: ∅
+            ├── closing_loc: (5...6) = "]"
+            ├── block:
+            │   @ BlockNode (location: (7...9))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (7...8) = "{"
+            │   └── closing_loc: (8...9) = "}"
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_14690.txt b/test/yarp/snapshots/whitequark/ruby_bug_14690.txt
index 743cf8b7b6..1798a4c37c 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_14690.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_14690.txt
@@ -1,46 +1,57 @@
-ProgramNode(0...23)(
-  [],
-  StatementsNode(0...23)(
-    [CallNode(0...23)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...6)([ParenthesesNode(4...6)(nil, (4...5), (5...6))]),
-       nil,
-       BlockNode(7...23)(
-         [],
-         nil,
-         StatementsNode(9...21)(
-           [CallNode(9...21)(
-              nil,
-              nil,
-              (9...10),
-              (10...11),
-              ArgumentsNode(11...12)(
-                [CallNode(11...12)(
-                   nil,
-                   nil,
-                   (11...12),
-                   nil,
-                   nil,
-                   nil,
-                   nil,
-                   2,
-                   "a"
-                 )]
-              ),
-              (12...13),
-              BlockNode(14...21)([], nil, nil, (14...16), (18...21)),
-              0,
-              "m"
-            )]
-         ),
-         (7...8),
-         (22...23)
-       ),
-       0,
-       "let"
-     )]
-  )
-)
+@ ProgramNode (location: (0...23))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...23))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...23))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "let"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...6))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (4...6))
+            │           ├── body: ∅
+            │           ├── opening_loc: (4...5) = "("
+            │           └── closing_loc: (5...6) = ")"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (7...23))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body:
+            │   │   @ StatementsNode (location: (9...21))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (9...21))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (9...10) = "m"
+            │   │           ├── opening_loc: (10...11) = "("
+            │   │           ├── arguments:
+            │   │           │   @ ArgumentsNode (location: (11...12))
+            │   │           │   └── arguments: (length: 1)
+            │   │           │       └── @ CallNode (location: (11...12))
+            │   │           │           ├── receiver: ∅
+            │   │           │           ├── call_operator_loc: ∅
+            │   │           │           ├── message_loc: (11...12) = "a"
+            │   │           │           ├── opening_loc: ∅
+            │   │           │           ├── arguments: ∅
+            │   │           │           ├── closing_loc: ∅
+            │   │           │           ├── block: ∅
+            │   │           │           ├── flags: variable_call
+            │   │           │           └── name: "a"
+            │   │           ├── closing_loc: (12...13) = ")"
+            │   │           ├── block:
+            │   │           │   @ BlockNode (location: (14...21))
+            │   │           │   ├── locals: []
+            │   │           │   ├── parameters: ∅
+            │   │           │   ├── body: ∅
+            │   │           │   ├── opening_loc: (14...16) = "do"
+            │   │           │   └── closing_loc: (18...21) = "end"
+            │   │           ├── flags: 
+            │   │           └── name: "m"
+            │   ├── opening_loc: (7...8) = "{"
+            │   └── closing_loc: (22...23) = "}"
+            ├── flags: 
+            └── name: "let"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_15789.txt b/test/yarp/snapshots/whitequark/ruby_bug_15789.txt
index 9066a4032b..96fa33e48f 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_15789.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_15789.txt
@@ -1,118 +1,126 @@
-ProgramNode(0...41)(
-  [],
-  StatementsNode(0...41)(
-    [CallNode(0...20)(
-       nil,
-       nil,
-       (0...1),
-       nil,
-       ArgumentsNode(2...20)(
-         [LambdaNode(2...20)(
-            [:a],
-            (2...4),
-            (17...18),
-            (19...20),
-            BlockParametersNode(4...16)(
-              ParametersNode(5...15)(
-                [],
-                [OptionalParameterNode(5...15)(
-                   :a,
-                   (5...6),
-                   (7...8),
-                   LambdaNode(9...15)(
-                     [],
-                     (9...11),
-                     (11...12),
-                     (14...15),
-                     nil,
-                     StatementsNode(12...14)(
-                       [CallNode(12...14)(
-                          nil,
-                          nil,
-                          (12...14),
-                          nil,
-                          nil,
-                          nil,
-                          nil,
-                          2,
-                          "_1"
-                        )]
-                     )
-                   )
-                 )],
-                [],
-                nil,
-                [],
-                nil,
-                nil
-              ),
-              [],
-              (4...5),
-              (15...16)
-            ),
-            StatementsNode(18...19)([LocalVariableReadNode(18...19)(:a, 0)])
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "m"
-     ),
-     CallNode(22...41)(
-       nil,
-       nil,
-       (22...23),
-       nil,
-       ArgumentsNode(24...41)(
-         [LambdaNode(24...41)(
-            [:a],
-            (24...26),
-            (38...39),
-            (40...41),
-            BlockParametersNode(26...37)(
-              ParametersNode(27...36)(
-                [],
-                [],
-                [],
-                nil,
-                [KeywordParameterNode(27...36)(
-                   :a,
-                   (27...29),
-                   LambdaNode(30...36)(
-                     [],
-                     (30...32),
-                     (32...33),
-                     (35...36),
-                     nil,
-                     StatementsNode(33...35)(
-                       [CallNode(33...35)(
-                          nil,
-                          nil,
-                          (33...35),
-                          nil,
-                          nil,
-                          nil,
-                          nil,
-                          2,
-                          "_1"
-                        )]
-                     )
-                   )
-                 )],
-                nil,
-                nil
-              ),
-              [],
-              (26...27),
-              (36...37)
-            ),
-            StatementsNode(39...40)([LocalVariableReadNode(39...40)(:a, 0)])
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "m"
-     )]
-  )
-)
+@ ProgramNode (location: (0...41))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...41))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...20))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "m"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (2...20))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ LambdaNode (location: (2...20))
+        │   │           ├── locals: [:a]
+        │   │           ├── operator_loc: (2...4) = "->"
+        │   │           ├── opening_loc: (17...18) = "{"
+        │   │           ├── closing_loc: (19...20) = "}"
+        │   │           ├── parameters:
+        │   │           │   @ BlockParametersNode (location: (4...16))
+        │   │           │   ├── parameters:
+        │   │           │   │   @ ParametersNode (location: (5...15))
+        │   │           │   │   ├── requireds: (length: 0)
+        │   │           │   │   ├── optionals: (length: 1)
+        │   │           │   │   │   └── @ OptionalParameterNode (location: (5...15))
+        │   │           │   │   │       ├── name: :a
+        │   │           │   │   │       ├── name_loc: (5...6) = "a"
+        │   │           │   │   │       ├── operator_loc: (7...8) = "="
+        │   │           │   │   │       └── value:
+        │   │           │   │   │           @ LambdaNode (location: (9...15))
+        │   │           │   │   │           ├── locals: []
+        │   │           │   │   │           ├── operator_loc: (9...11) = "->"
+        │   │           │   │   │           ├── opening_loc: (11...12) = "{"
+        │   │           │   │   │           ├── closing_loc: (14...15) = "}"
+        │   │           │   │   │           ├── parameters: ∅
+        │   │           │   │   │           └── body:
+        │   │           │   │   │               @ StatementsNode (location: (12...14))
+        │   │           │   │   │               └── body: (length: 1)
+        │   │           │   │   │                   └── @ CallNode (location: (12...14))
+        │   │           │   │   │                       ├── receiver: ∅
+        │   │           │   │   │                       ├── call_operator_loc: ∅
+        │   │           │   │   │                       ├── message_loc: (12...14) = "_1"
+        │   │           │   │   │                       ├── opening_loc: ∅
+        │   │           │   │   │                       ├── arguments: ∅
+        │   │           │   │   │                       ├── closing_loc: ∅
+        │   │           │   │   │                       ├── block: ∅
+        │   │           │   │   │                       ├── flags: variable_call
+        │   │           │   │   │                       └── name: "_1"
+        │   │           │   │   ├── posts: (length: 0)
+        │   │           │   │   ├── rest: ∅
+        │   │           │   │   ├── keywords: (length: 0)
+        │   │           │   │   ├── keyword_rest: ∅
+        │   │           │   │   └── block: ∅
+        │   │           │   ├── locals: (length: 0)
+        │   │           │   ├── opening_loc: (4...5) = "("
+        │   │           │   └── closing_loc: (15...16) = ")"
+        │   │           └── body:
+        │   │               @ StatementsNode (location: (18...19))
+        │   │               └── body: (length: 1)
+        │   │                   └── @ LocalVariableReadNode (location: (18...19))
+        │   │                       ├── name: :a
+        │   │                       └── depth: 0
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "m"
+        └── @ CallNode (location: (22...41))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (22...23) = "m"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (24...41))
+            │   └── arguments: (length: 1)
+            │       └── @ LambdaNode (location: (24...41))
+            │           ├── locals: [:a]
+            │           ├── operator_loc: (24...26) = "->"
+            │           ├── opening_loc: (38...39) = "{"
+            │           ├── closing_loc: (40...41) = "}"
+            │           ├── parameters:
+            │           │   @ BlockParametersNode (location: (26...37))
+            │           │   ├── parameters:
+            │           │   │   @ ParametersNode (location: (27...36))
+            │           │   │   ├── requireds: (length: 0)
+            │           │   │   ├── optionals: (length: 0)
+            │           │   │   ├── posts: (length: 0)
+            │           │   │   ├── rest: ∅
+            │           │   │   ├── keywords: (length: 1)
+            │           │   │   │   └── @ KeywordParameterNode (location: (27...36))
+            │           │   │   │       ├── name: :a
+            │           │   │   │       ├── name_loc: (27...29) = "a:"
+            │           │   │   │       └── value:
+            │           │   │   │           @ LambdaNode (location: (30...36))
+            │           │   │   │           ├── locals: []
+            │           │   │   │           ├── operator_loc: (30...32) = "->"
+            │           │   │   │           ├── opening_loc: (32...33) = "{"
+            │           │   │   │           ├── closing_loc: (35...36) = "}"
+            │           │   │   │           ├── parameters: ∅
+            │           │   │   │           └── body:
+            │           │   │   │               @ StatementsNode (location: (33...35))
+            │           │   │   │               └── body: (length: 1)
+            │           │   │   │                   └── @ CallNode (location: (33...35))
+            │           │   │   │                       ├── receiver: ∅
+            │           │   │   │                       ├── call_operator_loc: ∅
+            │           │   │   │                       ├── message_loc: (33...35) = "_1"
+            │           │   │   │                       ├── opening_loc: ∅
+            │           │   │   │                       ├── arguments: ∅
+            │           │   │   │                       ├── closing_loc: ∅
+            │           │   │   │                       ├── block: ∅
+            │           │   │   │                       ├── flags: variable_call
+            │           │   │   │                       └── name: "_1"
+            │           │   │   ├── keyword_rest: ∅
+            │           │   │   └── block: ∅
+            │           │   ├── locals: (length: 0)
+            │           │   ├── opening_loc: (26...27) = "("
+            │           │   └── closing_loc: (36...37) = ")"
+            │           └── body:
+            │               @ StatementsNode (location: (39...40))
+            │               └── body: (length: 1)
+            │                   └── @ LocalVariableReadNode (location: (39...40))
+            │                       ├── name: :a
+            │                       └── depth: 0
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "m"
diff --git a/test/yarp/snapshots/whitequark/ruby_bug_9669.txt b/test/yarp/snapshots/whitequark/ruby_bug_9669.txt
index c79fad9941..4e72978696 100644
--- a/test/yarp/snapshots/whitequark/ruby_bug_9669.txt
+++ b/test/yarp/snapshots/whitequark/ruby_bug_9669.txt
@@ -1,42 +1,55 @@
-ProgramNode(0...33)(
-  [:o],
-  StatementsNode(0...33)(
-    [DefNode(0...19)(
-       :a,
-       (4...5),
-       nil,
-       ParametersNode(6...8)(
-         [],
-         [],
-         [],
-         nil,
-         [KeywordParameterNode(6...8)(:b, (6...8), nil)],
-         nil,
-         nil
-       ),
-       StatementsNode(9...15)([ReturnNode(9...15)((9...15), nil)]),
-       [:b],
-       (0...3),
-       nil,
-       nil,
-       nil,
-       nil,
-       (16...19)
-     ),
-     LocalVariableWriteNode(21...33)(
-       :o,
-       0,
-       (21...22),
-       HashNode(25...33)(
-         (25...26),
-         [AssocNode(27...31)(
-            SymbolNode(27...29)(nil, (27...28), (28...29), "a"),
-            IntegerNode(30...31)(),
-            nil
-          )],
-         (32...33)
-       ),
-       (23...24)
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: [:o]
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 2)
+        ├── @ DefNode (location: (0...19))
+        │   ├── name: :a
+        │   ├── name_loc: (4...5) = "a"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (6...8))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── posts: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── keywords: (length: 1)
+        │   │   │   └── @ KeywordParameterNode (location: (6...8))
+        │   │   │       ├── name: :b
+        │   │   │       ├── name_loc: (6...8) = "b:"
+        │   │   │       └── value: ∅
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body:
+        │   │   @ StatementsNode (location: (9...15))
+        │   │   └── body: (length: 1)
+        │   │       └── @ ReturnNode (location: (9...15))
+        │   │           ├── keyword_loc: (9...15) = "return"
+        │   │           └── arguments: ∅
+        │   ├── locals: [:b]
+        │   ├── def_keyword_loc: (0...3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: ∅
+        │   ├── rparen_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (16...19) = "end"
+        └── @ LocalVariableWriteNode (location: (21...33))
+            ├── name: :o
+            ├── depth: 0
+            ├── name_loc: (21...22) = "o"
+            ├── value:
+            │   @ HashNode (location: (25...33))
+            │   ├── opening_loc: (25...26) = "{"
+            │   ├── elements: (length: 1)
+            │   │   └── @ AssocNode (location: (27...31))
+            │   │       ├── key:
+            │   │       │   @ SymbolNode (location: (27...29))
+            │   │       │   ├── opening_loc: ∅
+            │   │       │   ├── value_loc: (27...28) = "a"
+            │   │       │   ├── closing_loc: (28...29) = ":"
+            │   │       │   └── unescaped: "a"
+            │   │       ├── value:
+            │   │       │   @ IntegerNode (location: (30...31))
+            │   │       └── operator_loc: ∅
+            │   └── closing_loc: (32...33) = "}"
+            └── operator_loc: (23...24) = "="
diff --git a/test/yarp/snapshots/whitequark/sclass.txt b/test/yarp/snapshots/whitequark/sclass.txt
index a8beb303eb..2b763a0353 100644
--- a/test/yarp/snapshots/whitequark/sclass.txt
+++ b/test/yarp/snapshots/whitequark/sclass.txt
@@ -1,13 +1,25 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [SingletonClassNode(0...22)(
-       [],
-       (0...5),
-       (6...8),
-       CallNode(9...12)(nil, nil, (9...12), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(14...17)([NilNode(14...17)()]),
-       (19...22)
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 1)
+        └── @ SingletonClassNode (location: (0...22))
+            ├── locals: []
+            ├── class_keyword_loc: (0...5) = "class"
+            ├── operator_loc: (6...8) = "<<"
+            ├── expression:
+            │   @ CallNode (location: (9...12))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (9...12) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── body:
+            │   @ StatementsNode (location: (14...17))
+            │   └── body: (length: 1)
+            │       └── @ NilNode (location: (14...17))
+            └── end_keyword_loc: (19...22) = "end"
diff --git a/test/yarp/snapshots/whitequark/self.txt b/test/yarp/snapshots/whitequark/self.txt
index 0002d6ee6d..671273750e 100644
--- a/test/yarp/snapshots/whitequark/self.txt
+++ b/test/yarp/snapshots/whitequark/self.txt
@@ -1 +1,6 @@
-ProgramNode(0...4)([], StatementsNode(0...4)([SelfNode(0...4)()]))
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ SelfNode (location: (0...4))
diff --git a/test/yarp/snapshots/whitequark/send_attr_asgn.txt b/test/yarp/snapshots/whitequark/send_attr_asgn.txt
index b4b3d57064..0d901d8b65 100644
--- a/test/yarp/snapshots/whitequark/send_attr_asgn.txt
+++ b/test/yarp/snapshots/whitequark/send_attr_asgn.txt
@@ -1,47 +1,95 @@
-ProgramNode(0...44)(
-  [],
-  StatementsNode(0...44)(
-    [CallNode(0...9)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       (4...5),
-       nil,
-       ArgumentsNode(8...9)([IntegerNode(8...9)()]),
-       nil,
-       nil,
-       0,
-       "A="
-     ),
-     CallNode(11...20)(
-       CallNode(11...14)(nil, nil, (11...14), nil, nil, nil, nil, 2, "foo"),
-       (14...15),
-       (15...16),
-       nil,
-       ArgumentsNode(19...20)([IntegerNode(19...20)()]),
-       nil,
-       nil,
-       0,
-       "a="
-     ),
-     ConstantPathWriteNode(22...32)(
-       ConstantPathNode(22...28)(
-         CallNode(22...25)(nil, nil, (22...25), nil, nil, nil, nil, 2, "foo"),
-         ConstantReadNode(27...28)(:A),
-         (25...27)
-       ),
-       (29...30),
-       IntegerNode(31...32)()
-     ),
-     CallNode(34...44)(
-       CallNode(34...37)(nil, nil, (34...37), nil, nil, nil, nil, 2, "foo"),
-       (37...39),
-       (39...40),
-       nil,
-       ArgumentsNode(43...44)([IntegerNode(43...44)()]),
-       nil,
-       nil,
-       0,
-       "a="
-     )]
-  )
-)
+@ ProgramNode (location: (0...44))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...44))
+    └── body: (length: 4)
+        ├── @ CallNode (location: (0...9))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: (4...5) = "A"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (8...9))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (8...9))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "A="
+        ├── @ CallNode (location: (11...20))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (11...14))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (11...14) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (14...15) = "."
+        │   ├── message_loc: (15...16) = "a"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (19...20))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (19...20))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "a="
+        ├── @ ConstantPathWriteNode (location: (22...32))
+        │   ├── target:
+        │   │   @ ConstantPathNode (location: (22...28))
+        │   │   ├── parent:
+        │   │   │   @ CallNode (location: (22...25))
+        │   │   │   ├── receiver: ∅
+        │   │   │   ├── call_operator_loc: ∅
+        │   │   │   ├── message_loc: (22...25) = "foo"
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── arguments: ∅
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   ├── block: ∅
+        │   │   │   ├── flags: variable_call
+        │   │   │   └── name: "foo"
+        │   │   ├── child:
+        │   │   │   @ ConstantReadNode (location: (27...28))
+        │   │   │   └── name: :A
+        │   │   └── delimiter_loc: (25...27) = "::"
+        │   ├── operator_loc: (29...30) = "="
+        │   └── value:
+        │       @ IntegerNode (location: (31...32))
+        └── @ CallNode (location: (34...44))
+            ├── receiver:
+            │   @ CallNode (location: (34...37))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (34...37) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: (37...39) = "::"
+            ├── message_loc: (39...40) = "a"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (43...44))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (43...44))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "a="
diff --git a/test/yarp/snapshots/whitequark/send_attr_asgn_conditional.txt b/test/yarp/snapshots/whitequark/send_attr_asgn_conditional.txt
index a48f189f41..d6dc44e783 100644
--- a/test/yarp/snapshots/whitequark/send_attr_asgn_conditional.txt
+++ b/test/yarp/snapshots/whitequark/send_attr_asgn_conditional.txt
@@ -1,16 +1,28 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...8)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       ArgumentsNode(7...8)([IntegerNode(7...8)()]),
-       nil,
-       nil,
-       1,
-       "b="
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...8))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (7...8))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (7...8))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "b="
diff --git a/test/yarp/snapshots/whitequark/send_binary_op.txt b/test/yarp/snapshots/whitequark/send_binary_op.txt
index aadcb1fcb9..966b64eff1 100644
--- a/test/yarp/snapshots/whitequark/send_binary_op.txt
+++ b/test/yarp/snapshots/whitequark/send_binary_op.txt
@@ -1,336 +1,488 @@
-ProgramNode(0...200)(
-  [],
-  StatementsNode(0...200)(
-    [CallNode(0...8)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (4...6),
-       nil,
-       ArgumentsNode(7...8)([IntegerNode(7...8)()]),
-       nil,
-       nil,
-       0,
-       "!="
-     ),
-     CallNode(10...18)(
-       CallNode(10...13)(nil, nil, (10...13), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (14...16),
-       nil,
-       ArgumentsNode(17...18)([IntegerNode(17...18)()]),
-       nil,
-       nil,
-       0,
-       "!~"
-     ),
-     CallNode(20...27)(
-       CallNode(20...23)(nil, nil, (20...23), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (24...25),
-       nil,
-       ArgumentsNode(26...27)([IntegerNode(26...27)()]),
-       nil,
-       nil,
-       0,
-       "%"
-     ),
-     CallNode(29...36)(
-       CallNode(29...32)(nil, nil, (29...32), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (33...34),
-       nil,
-       ArgumentsNode(35...36)([IntegerNode(35...36)()]),
-       nil,
-       nil,
-       0,
-       "&"
-     ),
-     CallNode(38...45)(
-       CallNode(38...41)(nil, nil, (38...41), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (42...43),
-       nil,
-       ArgumentsNode(44...45)([IntegerNode(44...45)()]),
-       nil,
-       nil,
-       0,
-       "*"
-     ),
-     CallNode(47...55)(
-       CallNode(47...50)(nil, nil, (47...50), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (51...53),
-       nil,
-       ArgumentsNode(54...55)([IntegerNode(54...55)()]),
-       nil,
-       nil,
-       0,
-       "**"
-     ),
-     CallNode(57...64)(
-       CallNode(57...60)(nil, nil, (57...60), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (61...62),
-       nil,
-       ArgumentsNode(63...64)([IntegerNode(63...64)()]),
-       nil,
-       nil,
-       0,
-       "+"
-     ),
-     CallNode(66...73)(
-       CallNode(66...69)(nil, nil, (66...69), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (70...71),
-       nil,
-       ArgumentsNode(72...73)([IntegerNode(72...73)()]),
-       nil,
-       nil,
-       0,
-       "-"
-     ),
-     CallNode(75...82)(
-       CallNode(75...78)(nil, nil, (75...78), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (79...80),
-       nil,
-       ArgumentsNode(81...82)([IntegerNode(81...82)()]),
-       nil,
-       nil,
-       0,
-       "/"
-     ),
-     CallNode(84...91)(
-       CallNode(84...87)(nil, nil, (84...87), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (88...89),
-       nil,
-       ArgumentsNode(90...91)([IntegerNode(90...91)()]),
-       nil,
-       nil,
-       0,
-       "<"
-     ),
-     CallNode(93...101)(
-       CallNode(93...96)(nil, nil, (93...96), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (97...99),
-       nil,
-       ArgumentsNode(100...101)([IntegerNode(100...101)()]),
-       nil,
-       nil,
-       0,
-       "<<"
-     ),
-     CallNode(103...111)(
-       CallNode(103...106)(
-         nil,
-         nil,
-         (103...106),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (107...109),
-       nil,
-       ArgumentsNode(110...111)([IntegerNode(110...111)()]),
-       nil,
-       nil,
-       0,
-       "<="
-     ),
-     CallNode(113...122)(
-       CallNode(113...116)(
-         nil,
-         nil,
-         (113...116),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (117...120),
-       nil,
-       ArgumentsNode(121...122)([IntegerNode(121...122)()]),
-       nil,
-       nil,
-       0,
-       "<=>"
-     ),
-     CallNode(124...132)(
-       CallNode(124...127)(
-         nil,
-         nil,
-         (124...127),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (128...130),
-       nil,
-       ArgumentsNode(131...132)([IntegerNode(131...132)()]),
-       nil,
-       nil,
-       0,
-       "=="
-     ),
-     CallNode(134...143)(
-       CallNode(134...137)(
-         nil,
-         nil,
-         (134...137),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (138...141),
-       nil,
-       ArgumentsNode(142...143)([IntegerNode(142...143)()]),
-       nil,
-       nil,
-       0,
-       "==="
-     ),
-     CallNode(145...153)(
-       CallNode(145...148)(
-         nil,
-         nil,
-         (145...148),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (149...151),
-       nil,
-       ArgumentsNode(152...153)([IntegerNode(152...153)()]),
-       nil,
-       nil,
-       0,
-       "=~"
-     ),
-     CallNode(155...162)(
-       CallNode(155...158)(
-         nil,
-         nil,
-         (155...158),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (159...160),
-       nil,
-       ArgumentsNode(161...162)([IntegerNode(161...162)()]),
-       nil,
-       nil,
-       0,
-       ">"
-     ),
-     CallNode(164...172)(
-       CallNode(164...167)(
-         nil,
-         nil,
-         (164...167),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (168...170),
-       nil,
-       ArgumentsNode(171...172)([IntegerNode(171...172)()]),
-       nil,
-       nil,
-       0,
-       ">="
-     ),
-     CallNode(174...182)(
-       CallNode(174...177)(
-         nil,
-         nil,
-         (174...177),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (178...180),
-       nil,
-       ArgumentsNode(181...182)([IntegerNode(181...182)()]),
-       nil,
-       nil,
-       0,
-       ">>"
-     ),
-     CallNode(184...191)(
-       CallNode(184...187)(
-         nil,
-         nil,
-         (184...187),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (188...189),
-       nil,
-       ArgumentsNode(190...191)([IntegerNode(190...191)()]),
-       nil,
-       nil,
-       0,
-       "^"
-     ),
-     CallNode(193...200)(
-       CallNode(193...196)(
-         nil,
-         nil,
-         (193...196),
-         nil,
-         nil,
-         nil,
-         nil,
-         2,
-         "foo"
-       ),
-       nil,
-       (197...198),
-       nil,
-       ArgumentsNode(199...200)([IntegerNode(199...200)()]),
-       nil,
-       nil,
-       0,
-       "|"
-     )]
-  )
-)
+@ ProgramNode (location: (0...200))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...200))
+    └── body: (length: 21)
+        ├── @ CallNode (location: (0...8))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (4...6) = "!="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (7...8))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (7...8))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!="
+        ├── @ CallNode (location: (10...18))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (10...13))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (10...13) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (14...16) = "!~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (17...18))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (17...18))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "!~"
+        ├── @ CallNode (location: (20...27))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (20...23))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (20...23) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (24...25) = "%"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (26...27))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (26...27))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "%"
+        ├── @ CallNode (location: (29...36))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (29...32))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (29...32) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (33...34) = "&"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (35...36))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (35...36))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "&"
+        ├── @ CallNode (location: (38...45))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (38...41))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (38...41) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (42...43) = "*"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (44...45))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (44...45))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "*"
+        ├── @ CallNode (location: (47...55))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (47...50))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (47...50) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (51...53) = "**"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (54...55))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (54...55))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "**"
+        ├── @ CallNode (location: (57...64))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (57...60))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (57...60) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (61...62) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (63...64))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (63...64))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+"
+        ├── @ CallNode (location: (66...73))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (66...69))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (66...69) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (70...71) = "-"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (72...73))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (72...73))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "-"
+        ├── @ CallNode (location: (75...82))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (75...78))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (75...78) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (79...80) = "/"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (81...82))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (81...82))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "/"
+        ├── @ CallNode (location: (84...91))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (84...87))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (84...87) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (88...89) = "<"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (90...91))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (90...91))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<"
+        ├── @ CallNode (location: (93...101))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (93...96))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (93...96) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (97...99) = "<<"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (100...101))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (100...101))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<<"
+        ├── @ CallNode (location: (103...111))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (103...106))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (103...106) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (107...109) = "<="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (110...111))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (110...111))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<="
+        ├── @ CallNode (location: (113...122))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (113...116))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (113...116) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (117...120) = "<=>"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (121...122))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (121...122))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "<=>"
+        ├── @ CallNode (location: (124...132))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (124...127))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (124...127) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (128...130) = "=="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (131...132))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (131...132))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=="
+        ├── @ CallNode (location: (134...143))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (134...137))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (134...137) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (138...141) = "==="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (142...143))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (142...143))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "==="
+        ├── @ CallNode (location: (145...153))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (145...148))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (145...148) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (149...151) = "=~"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (152...153))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (152...153))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "=~"
+        ├── @ CallNode (location: (155...162))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (155...158))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (155...158) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (159...160) = ">"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (161...162))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (161...162))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: ">"
+        ├── @ CallNode (location: (164...172))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (164...167))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (164...167) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (168...170) = ">="
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (171...172))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (171...172))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: ">="
+        ├── @ CallNode (location: (174...182))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (174...177))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (174...177) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (178...180) = ">>"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (181...182))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (181...182))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: ">>"
+        ├── @ CallNode (location: (184...191))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (184...187))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (184...187) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (188...189) = "^"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (190...191))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (190...191))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "^"
+        └── @ CallNode (location: (193...200))
+            ├── receiver:
+            │   @ CallNode (location: (193...196))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (193...196) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (197...198) = "|"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (199...200))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (199...200))
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "|"
diff --git a/test/yarp/snapshots/whitequark/send_block_chain_cmd.txt b/test/yarp/snapshots/whitequark/send_block_chain_cmd.txt
index c9d9a36628..2ff68883c1 100644
--- a/test/yarp/snapshots/whitequark/send_block_chain_cmd.txt
+++ b/test/yarp/snapshots/whitequark/send_block_chain_cmd.txt
@@ -1,194 +1,298 @@
-ProgramNode(0...173)(
-  [],
-  StatementsNode(0...173)(
-    [CallNode(0...21)(
-       CallNode(0...13)(
-         nil,
-         nil,
-         (0...4),
-         nil,
-         ArgumentsNode(5...6)([IntegerNode(5...6)()]),
-         nil,
-         BlockNode(7...13)([], nil, nil, (7...9), (10...13)),
-         0,
-         "meth"
-       ),
-       (13...14),
-       (14...17),
-       nil,
-       ArgumentsNode(18...21)(
-         [CallNode(18...21)(nil, nil, (18...21), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(23...51)(
-       CallNode(23...36)(
-         nil,
-         nil,
-         (23...27),
-         nil,
-         ArgumentsNode(28...29)([IntegerNode(28...29)()]),
-         nil,
-         BlockNode(30...36)([], nil, nil, (30...32), (33...36)),
-         0,
-         "meth"
-       ),
-       (36...37),
-       (37...40),
-       nil,
-       ArgumentsNode(41...44)(
-         [CallNode(41...44)(nil, nil, (41...44), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       BlockNode(45...51)([], nil, nil, (45...47), (48...51)),
-       0,
-       "fun"
-     ),
-     CallNode(53...73)(
-       CallNode(53...66)(
-         nil,
-         nil,
-         (53...57),
-         nil,
-         ArgumentsNode(58...59)([IntegerNode(58...59)()]),
-         nil,
-         BlockNode(60...66)([], nil, nil, (60...62), (63...66)),
-         0,
-         "meth"
-       ),
-       (66...67),
-       (67...70),
-       nil,
-       nil,
-       nil,
-       BlockNode(71...73)([], nil, nil, (71...72), (72...73)),
-       0,
-       "fun"
-     ),
-     CallNode(75...97)(
-       CallNode(75...88)(
-         nil,
-         nil,
-         (75...79),
-         nil,
-         ArgumentsNode(80...81)([IntegerNode(80...81)()]),
-         nil,
-         BlockNode(82...88)([], nil, nil, (82...84), (85...88)),
-         0,
-         "meth"
-       ),
-       (88...89),
-       (89...92),
-       (92...93),
-       ArgumentsNode(93...96)(
-         [CallNode(93...96)(nil, nil, (93...96), nil, nil, nil, nil, 2, "bar")]
-       ),
-       (96...97),
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(99...124)(
-       CallNode(99...112)(
-         nil,
-         nil,
-         (99...103),
-         nil,
-         ArgumentsNode(104...105)([IntegerNode(104...105)()]),
-         nil,
-         BlockNode(106...112)([], nil, nil, (106...108), (109...112)),
-         0,
-         "meth"
-       ),
-       (112...113),
-       (113...116),
-       (116...117),
-       ArgumentsNode(117...120)(
-         [CallNode(117...120)(
-            nil,
-            nil,
-            (117...120),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       (120...121),
-       BlockNode(122...124)([], nil, nil, (122...123), (123...124)),
-       0,
-       "fun"
-     ),
-     CallNode(126...148)(
-       CallNode(126...139)(
-         nil,
-         nil,
-         (126...130),
-         nil,
-         ArgumentsNode(131...132)([IntegerNode(131...132)()]),
-         nil,
-         BlockNode(133...139)([], nil, nil, (133...135), (136...139)),
-         0,
-         "meth"
-       ),
-       (139...141),
-       (141...144),
-       nil,
-       ArgumentsNode(145...148)(
-         [CallNode(145...148)(
-            nil,
-            nil,
-            (145...148),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(150...173)(
-       CallNode(150...163)(
-         nil,
-         nil,
-         (150...154),
-         nil,
-         ArgumentsNode(155...156)([IntegerNode(155...156)()]),
-         nil,
-         BlockNode(157...163)([], nil, nil, (157...159), (160...163)),
-         0,
-         "meth"
-       ),
-       (163...165),
-       (165...168),
-       (168...169),
-       ArgumentsNode(169...172)(
-         [CallNode(169...172)(
-            nil,
-            nil,
-            (169...172),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "bar"
-          )]
-       ),
-       (172...173),
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...173))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...173))
+    └── body: (length: 7)
+        ├── @ CallNode (location: (0...21))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...13))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...4) = "meth"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (5...6))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (5...6))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (7...13))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (7...9) = "do"
+        │   │   │   └── closing_loc: (10...13) = "end"
+        │   │   ├── flags: 
+        │   │   └── name: "meth"
+        │   ├── call_operator_loc: (13...14) = "."
+        │   ├── message_loc: (14...17) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (18...21))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (18...21))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (18...21) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (23...51))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (23...36))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (23...27) = "meth"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (28...29))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (28...29))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (30...36))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (30...32) = "do"
+        │   │   │   └── closing_loc: (33...36) = "end"
+        │   │   ├── flags: 
+        │   │   └── name: "meth"
+        │   ├── call_operator_loc: (36...37) = "."
+        │   ├── message_loc: (37...40) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (41...44))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (41...44))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (41...44) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (45...51))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (45...47) = "do"
+        │   │   └── closing_loc: (48...51) = "end"
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (53...73))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (53...66))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (53...57) = "meth"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (58...59))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (58...59))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (60...66))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (60...62) = "do"
+        │   │   │   └── closing_loc: (63...66) = "end"
+        │   │   ├── flags: 
+        │   │   └── name: "meth"
+        │   ├── call_operator_loc: (66...67) = "."
+        │   ├── message_loc: (67...70) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (71...73))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (71...72) = "{"
+        │   │   └── closing_loc: (72...73) = "}"
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (75...97))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (75...88))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (75...79) = "meth"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (80...81))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (80...81))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (82...88))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (82...84) = "do"
+        │   │   │   └── closing_loc: (85...88) = "end"
+        │   │   ├── flags: 
+        │   │   └── name: "meth"
+        │   ├── call_operator_loc: (88...89) = "."
+        │   ├── message_loc: (89...92) = "fun"
+        │   ├── opening_loc: (92...93) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (93...96))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (93...96))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (93...96) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: (96...97) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (99...124))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (99...112))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (99...103) = "meth"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (104...105))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (104...105))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (106...112))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (106...108) = "do"
+        │   │   │   └── closing_loc: (109...112) = "end"
+        │   │   ├── flags: 
+        │   │   └── name: "meth"
+        │   ├── call_operator_loc: (112...113) = "."
+        │   ├── message_loc: (113...116) = "fun"
+        │   ├── opening_loc: (116...117) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (117...120))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (117...120))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (117...120) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: (120...121) = ")"
+        │   ├── block:
+        │   │   @ BlockNode (location: (122...124))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (122...123) = "{"
+        │   │   └── closing_loc: (123...124) = "}"
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (126...148))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (126...139))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (126...130) = "meth"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (131...132))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (131...132))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block:
+        │   │   │   @ BlockNode (location: (133...139))
+        │   │   │   ├── locals: []
+        │   │   │   ├── parameters: ∅
+        │   │   │   ├── body: ∅
+        │   │   │   ├── opening_loc: (133...135) = "do"
+        │   │   │   └── closing_loc: (136...139) = "end"
+        │   │   ├── flags: 
+        │   │   └── name: "meth"
+        │   ├── call_operator_loc: (139...141) = "::"
+        │   ├── message_loc: (141...144) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (145...148))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (145...148))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (145...148) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        └── @ CallNode (location: (150...173))
+            ├── receiver:
+            │   @ CallNode (location: (150...163))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (150...154) = "meth"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (155...156))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ IntegerNode (location: (155...156))
+            │   ├── closing_loc: ∅
+            │   ├── block:
+            │   │   @ BlockNode (location: (157...163))
+            │   │   ├── locals: []
+            │   │   ├── parameters: ∅
+            │   │   ├── body: ∅
+            │   │   ├── opening_loc: (157...159) = "do"
+            │   │   └── closing_loc: (160...163) = "end"
+            │   ├── flags: 
+            │   └── name: "meth"
+            ├── call_operator_loc: (163...165) = "::"
+            ├── message_loc: (165...168) = "fun"
+            ├── opening_loc: (168...169) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (169...172))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (169...172))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (169...172) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── closing_loc: (172...173) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/send_block_conditional.txt b/test/yarp/snapshots/whitequark/send_block_conditional.txt
index 3ac7347f7a..7e8570168f 100644
--- a/test/yarp/snapshots/whitequark/send_block_conditional.txt
+++ b/test/yarp/snapshots/whitequark/send_block_conditional.txt
@@ -1,16 +1,31 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallNode(0...11)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...5),
-       (5...8),
-       nil,
-       nil,
-       nil,
-       BlockNode(9...11)([], nil, nil, (9...10), (10...11)),
-       1,
-       "bar"
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...11))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: (3...5) = "&."
+            ├── message_loc: (5...8) = "bar"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (9...11))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (9...10) = "{"
+            │   └── closing_loc: (10...11) = "}"
+            ├── flags: safe_navigation
+            └── name: "bar"
diff --git a/test/yarp/snapshots/whitequark/send_call.txt b/test/yarp/snapshots/whitequark/send_call.txt
index f96195145b..c9045e53b3 100644
--- a/test/yarp/snapshots/whitequark/send_call.txt
+++ b/test/yarp/snapshots/whitequark/send_call.txt
@@ -1,27 +1,51 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...7)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       nil,
-       (4...5),
-       ArgumentsNode(5...6)([IntegerNode(5...6)()]),
-       (6...7),
-       nil,
-       0,
-       "call"
-     ),
-     CallNode(9...17)(
-       CallNode(9...12)(nil, nil, (9...12), nil, nil, nil, nil, 2, "foo"),
-       (12...14),
-       nil,
-       (14...15),
-       ArgumentsNode(15...16)([IntegerNode(15...16)()]),
-       (16...17),
-       nil,
-       0,
-       "call"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 2)
+        ├── @ CallNode (location: (0...7))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: ∅
+        │   ├── opening_loc: (4...5) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (5...6))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (5...6))
+        │   ├── closing_loc: (6...7) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "call"
+        └── @ CallNode (location: (9...17))
+            ├── receiver:
+            │   @ CallNode (location: (9...12))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (9...12) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: (12...14) = "::"
+            ├── message_loc: ∅
+            ├── opening_loc: (14...15) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (15...16))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (15...16))
+            ├── closing_loc: (16...17) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "call"
diff --git a/test/yarp/snapshots/whitequark/send_conditional.txt b/test/yarp/snapshots/whitequark/send_conditional.txt
index d170db0f55..281a3e3df6 100644
--- a/test/yarp/snapshots/whitequark/send_conditional.txt
+++ b/test/yarp/snapshots/whitequark/send_conditional.txt
@@ -1,16 +1,25 @@
-ProgramNode(0...4)(
-  [],
-  StatementsNode(0...4)(
-    [CallNode(0...4)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       nil,
-       1,
-       "b"
-     )]
-  )
-)
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...4))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: safe_navigation
+            └── name: "b"
diff --git a/test/yarp/snapshots/whitequark/send_index.txt b/test/yarp/snapshots/whitequark/send_index.txt
index 75f8c0ff87..5ba94a8468 100644
--- a/test/yarp/snapshots/whitequark/send_index.txt
+++ b/test/yarp/snapshots/whitequark/send_index.txt
@@ -1,16 +1,29 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...9),
-       (3...4),
-       ArgumentsNode(4...8)([IntegerNode(4...5)(), IntegerNode(7...8)()]),
-       (8...9),
-       nil,
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...9) = "[1, 2]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...8))
+            │   └── arguments: (length: 2)
+            │       ├── @ IntegerNode (location: (4...5))
+            │       └── @ IntegerNode (location: (7...8))
+            ├── closing_loc: (8...9) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/whitequark/send_index_asgn.txt b/test/yarp/snapshots/whitequark/send_index_asgn.txt
index d38af8fb52..1fa55b1853 100644
--- a/test/yarp/snapshots/whitequark/send_index_asgn.txt
+++ b/test/yarp/snapshots/whitequark/send_index_asgn.txt
@@ -1,18 +1,30 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...9),
-       (3...4),
-       ArgumentsNode(4...13)(
-         [IntegerNode(4...5)(), IntegerNode(7...8)(), IntegerNode(12...13)()]
-       ),
-       (8...9),
-       nil,
-       0,
-       "[]="
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...9) = "[1, 2]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...13))
+            │   └── arguments: (length: 3)
+            │       ├── @ IntegerNode (location: (4...5))
+            │       ├── @ IntegerNode (location: (7...8))
+            │       └── @ IntegerNode (location: (12...13))
+            ├── closing_loc: (8...9) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]="
diff --git a/test/yarp/snapshots/whitequark/send_index_asgn_legacy.txt b/test/yarp/snapshots/whitequark/send_index_asgn_legacy.txt
index d38af8fb52..1fa55b1853 100644
--- a/test/yarp/snapshots/whitequark/send_index_asgn_legacy.txt
+++ b/test/yarp/snapshots/whitequark/send_index_asgn_legacy.txt
@@ -1,18 +1,30 @@
-ProgramNode(0...13)(
-  [],
-  StatementsNode(0...13)(
-    [CallNode(0...13)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...9),
-       (3...4),
-       ArgumentsNode(4...13)(
-         [IntegerNode(4...5)(), IntegerNode(7...8)(), IntegerNode(12...13)()]
-       ),
-       (8...9),
-       nil,
-       0,
-       "[]="
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...13))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...9) = "[1, 2]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...13))
+            │   └── arguments: (length: 3)
+            │       ├── @ IntegerNode (location: (4...5))
+            │       ├── @ IntegerNode (location: (7...8))
+            │       └── @ IntegerNode (location: (12...13))
+            ├── closing_loc: (8...9) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]="
diff --git a/test/yarp/snapshots/whitequark/send_index_cmd.txt b/test/yarp/snapshots/whitequark/send_index_cmd.txt
index 38c69392b3..c0d3eade6d 100644
--- a/test/yarp/snapshots/whitequark/send_index_cmd.txt
+++ b/test/yarp/snapshots/whitequark/send_index_cmd.txt
@@ -1,40 +1,49 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [CallNode(0...10)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...10),
-       (3...4),
-       ArgumentsNode(4...9)(
-         [CallNode(4...9)(
-            nil,
-            nil,
-            (4...5),
-            nil,
-            ArgumentsNode(6...9)(
-              [CallNode(6...9)(
-                 nil,
-                 nil,
-                 (6...9),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "bar"
-               )]
-            ),
-            nil,
-            nil,
-            0,
-            "m"
-          )]
-       ),
-       (9...10),
-       nil,
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...10))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...10) = "[m bar]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...9))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (4...9))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (4...5) = "m"
+            │           ├── opening_loc: ∅
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (6...9))
+            │           │   └── arguments: (length: 1)
+            │           │       └── @ CallNode (location: (6...9))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (6...9) = "bar"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "bar"
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "m"
+            ├── closing_loc: (9...10) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/whitequark/send_index_legacy.txt b/test/yarp/snapshots/whitequark/send_index_legacy.txt
index 75f8c0ff87..5ba94a8468 100644
--- a/test/yarp/snapshots/whitequark/send_index_legacy.txt
+++ b/test/yarp/snapshots/whitequark/send_index_legacy.txt
@@ -1,16 +1,29 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (3...9),
-       (3...4),
-       ArgumentsNode(4...8)([IntegerNode(4...5)(), IntegerNode(7...8)()]),
-       (8...9),
-       nil,
-       0,
-       "[]"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (3...9) = "[1, 2]"
+            ├── opening_loc: (3...4) = "["
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...8))
+            │   └── arguments: (length: 2)
+            │       ├── @ IntegerNode (location: (4...5))
+            │       └── @ IntegerNode (location: (7...8))
+            ├── closing_loc: (8...9) = "]"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "[]"
diff --git a/test/yarp/snapshots/whitequark/send_lambda.txt b/test/yarp/snapshots/whitequark/send_lambda.txt
index 52d1fb26a5..1607682c8e 100644
--- a/test/yarp/snapshots/whitequark/send_lambda.txt
+++ b/test/yarp/snapshots/whitequark/send_lambda.txt
@@ -1,28 +1,43 @@
-ProgramNode(0...26)(
-  [],
-  StatementsNode(0...26)(
-    [LambdaNode(0...8)(
-       [:*],
-       (0...2),
-       (5...6),
-       (7...8),
-       BlockParametersNode(3...4)(
-         ParametersNode(3...4)(
-           [],
-           [],
-           [],
-           RestParameterNode(3...4)(nil, nil, (3...4)),
-           [],
-           nil,
-           nil
-         ),
-         [],
-         nil,
-         nil
-       ),
-       nil
-     ),
-     LambdaNode(10...19)([], (10...12), (13...15), (16...19), nil, nil),
-     LambdaNode(21...26)([], (21...23), (23...24), (25...26), nil, nil)]
-  )
-)
+@ ProgramNode (location: (0...26))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...26))
+    └── body: (length: 3)
+        ├── @ LambdaNode (location: (0...8))
+        │   ├── locals: [:*]
+        │   ├── operator_loc: (0...2) = "->"
+        │   ├── opening_loc: (5...6) = "{"
+        │   ├── closing_loc: (7...8) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (3...4))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (3...4))
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest:
+        │   │   │   │   @ RestParameterNode (location: (3...4))
+        │   │   │   │   ├── name: nil
+        │   │   │   │   ├── name_loc: ∅
+        │   │   │   │   └── operator_loc: (3...4) = "*"
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── body: ∅
+        ├── @ LambdaNode (location: (10...19))
+        │   ├── locals: []
+        │   ├── operator_loc: (10...12) = "->"
+        │   ├── opening_loc: (13...15) = "do"
+        │   ├── closing_loc: (16...19) = "end"
+        │   ├── parameters: ∅
+        │   └── body: ∅
+        └── @ LambdaNode (location: (21...26))
+            ├── locals: []
+            ├── operator_loc: (21...23) = "->"
+            ├── opening_loc: (23...24) = "{"
+            ├── closing_loc: (25...26) = "}"
+            ├── parameters: ∅
+            └── body: ∅
diff --git a/test/yarp/snapshots/whitequark/send_lambda_args.txt b/test/yarp/snapshots/whitequark/send_lambda_args.txt
index ae41cfa463..affbd7d543 100644
--- a/test/yarp/snapshots/whitequark/send_lambda_args.txt
+++ b/test/yarp/snapshots/whitequark/send_lambda_args.txt
@@ -1,47 +1,49 @@
-ProgramNode(0...21)(
-  [],
-  StatementsNode(0...21)(
-    [LambdaNode(0...10)(
-       [:a],
-       (0...2),
-       (7...8),
-       (9...10),
-       BlockParametersNode(3...6)(
-         ParametersNode(4...5)(
-           [RequiredParameterNode(4...5)(:a)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (3...4),
-         (5...6)
-       ),
-       nil
-     ),
-     LambdaNode(12...21)(
-       [:a],
-       (12...14),
-       (18...19),
-       (20...21),
-       BlockParametersNode(14...17)(
-         ParametersNode(15...16)(
-           [RequiredParameterNode(15...16)(:a)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [],
-         (14...15),
-         (16...17)
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...21))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...21))
+    └── body: (length: 2)
+        ├── @ LambdaNode (location: (0...10))
+        │   ├── locals: [:a]
+        │   ├── operator_loc: (0...2) = "->"
+        │   ├── opening_loc: (7...8) = "{"
+        │   ├── closing_loc: (9...10) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (3...6))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (4...5))
+        │   │   │   ├── requireds: (length: 1)
+        │   │   │   │   └── @ RequiredParameterNode (location: (4...5))
+        │   │   │   │       └── name: :a
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 0)
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: (3...4) = "("
+        │   │   └── closing_loc: (5...6) = ")"
+        │   └── body: ∅
+        └── @ LambdaNode (location: (12...21))
+            ├── locals: [:a]
+            ├── operator_loc: (12...14) = "->"
+            ├── opening_loc: (18...19) = "{"
+            ├── closing_loc: (20...21) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (14...17))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (15...16))
+            │   │   ├── requireds: (length: 1)
+            │   │   │   └── @ RequiredParameterNode (location: (15...16))
+            │   │   │       └── name: :a
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 0)
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: (14...15) = "("
+            │   └── closing_loc: (16...17) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/whitequark/send_lambda_args_noparen.txt b/test/yarp/snapshots/whitequark/send_lambda_args_noparen.txt
index 57f5c2ead2..4883f66806 100644
--- a/test/yarp/snapshots/whitequark/send_lambda_args_noparen.txt
+++ b/test/yarp/snapshots/whitequark/send_lambda_args_noparen.txt
@@ -1,47 +1,54 @@
-ProgramNode(0...22)(
-  [],
-  StatementsNode(0...22)(
-    [LambdaNode(0...11)(
-       [:a],
-       (0...2),
-       (8...9),
-       (10...11),
-       BlockParametersNode(3...7)(
-         ParametersNode(3...7)(
-           [],
-           [],
-           [],
-           nil,
-           [KeywordParameterNode(3...7)(:a, (3...5), IntegerNode(6...7)())],
-           nil,
-           nil
-         ),
-         [],
-         nil,
-         nil
-       ),
-       nil
-     ),
-     LambdaNode(13...22)(
-       [:a],
-       (13...15),
-       (19...20),
-       (21...22),
-       BlockParametersNode(16...18)(
-         ParametersNode(16...18)(
-           [],
-           [],
-           [],
-           nil,
-           [KeywordParameterNode(16...18)(:a, (16...18), nil)],
-           nil,
-           nil
-         ),
-         [],
-         nil,
-         nil
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...22))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...22))
+    └── body: (length: 2)
+        ├── @ LambdaNode (location: (0...11))
+        │   ├── locals: [:a]
+        │   ├── operator_loc: (0...2) = "->"
+        │   ├── opening_loc: (8...9) = "{"
+        │   ├── closing_loc: (10...11) = "}"
+        │   ├── parameters:
+        │   │   @ BlockParametersNode (location: (3...7))
+        │   │   ├── parameters:
+        │   │   │   @ ParametersNode (location: (3...7))
+        │   │   │   ├── requireds: (length: 0)
+        │   │   │   ├── optionals: (length: 0)
+        │   │   │   ├── posts: (length: 0)
+        │   │   │   ├── rest: ∅
+        │   │   │   ├── keywords: (length: 1)
+        │   │   │   │   └── @ KeywordParameterNode (location: (3...7))
+        │   │   │   │       ├── name: :a
+        │   │   │   │       ├── name_loc: (3...5) = "a:"
+        │   │   │   │       └── value:
+        │   │   │   │           @ IntegerNode (location: (6...7))
+        │   │   │   ├── keyword_rest: ∅
+        │   │   │   └── block: ∅
+        │   │   ├── locals: (length: 0)
+        │   │   ├── opening_loc: ∅
+        │   │   └── closing_loc: ∅
+        │   └── body: ∅
+        └── @ LambdaNode (location: (13...22))
+            ├── locals: [:a]
+            ├── operator_loc: (13...15) = "->"
+            ├── opening_loc: (19...20) = "{"
+            ├── closing_loc: (21...22) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (16...18))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (16...18))
+            │   │   ├── requireds: (length: 0)
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 1)
+            │   │   │   └── @ KeywordParameterNode (location: (16...18))
+            │   │   │       ├── name: :a
+            │   │   │       ├── name_loc: (16...18) = "a:"
+            │   │   │       └── value: ∅
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 0)
+            │   ├── opening_loc: ∅
+            │   └── closing_loc: ∅
+            └── body: ∅
diff --git a/test/yarp/snapshots/whitequark/send_lambda_args_shadow.txt b/test/yarp/snapshots/whitequark/send_lambda_args_shadow.txt
index cee0016fa7..c28c58c4ab 100644
--- a/test/yarp/snapshots/whitequark/send_lambda_args_shadow.txt
+++ b/test/yarp/snapshots/whitequark/send_lambda_args_shadow.txt
@@ -1,27 +1,31 @@
-ProgramNode(0...19)(
-  [],
-  StatementsNode(0...19)(
-    [LambdaNode(0...19)(
-       [:a, :foo, :bar],
-       (0...2),
-       (16...17),
-       (18...19),
-       BlockParametersNode(2...15)(
-         ParametersNode(3...4)(
-           [RequiredParameterNode(3...4)(:a)],
-           [],
-           [],
-           nil,
-           [],
-           nil,
-           nil
-         ),
-         [BlockLocalVariableNode(6...9)(:foo),
-          BlockLocalVariableNode(11...14)(:bar)],
-         (2...3),
-         (14...15)
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...19))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...19))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...19))
+            ├── locals: [:a, :foo, :bar]
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (16...17) = "{"
+            ├── closing_loc: (18...19) = "}"
+            ├── parameters:
+            │   @ BlockParametersNode (location: (2...15))
+            │   ├── parameters:
+            │   │   @ ParametersNode (location: (3...4))
+            │   │   ├── requireds: (length: 1)
+            │   │   │   └── @ RequiredParameterNode (location: (3...4))
+            │   │   │       └── name: :a
+            │   │   ├── optionals: (length: 0)
+            │   │   ├── posts: (length: 0)
+            │   │   ├── rest: ∅
+            │   │   ├── keywords: (length: 0)
+            │   │   ├── keyword_rest: ∅
+            │   │   └── block: ∅
+            │   ├── locals: (length: 2)
+            │   │   ├── @ BlockLocalVariableNode (location: (6...9))
+            │   │   │   └── name: :foo
+            │   │   └── @ BlockLocalVariableNode (location: (11...14))
+            │   │       └── name: :bar
+            │   ├── opening_loc: (2...3) = "("
+            │   └── closing_loc: (14...15) = ")"
+            └── body: ∅
diff --git a/test/yarp/snapshots/whitequark/send_lambda_legacy.txt b/test/yarp/snapshots/whitequark/send_lambda_legacy.txt
index 57b827cb7e..61a2b77f4e 100644
--- a/test/yarp/snapshots/whitequark/send_lambda_legacy.txt
+++ b/test/yarp/snapshots/whitequark/send_lambda_legacy.txt
@@ -1,6 +1,12 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)(
-    [LambdaNode(0...5)([], (0...2), (2...3), (4...5), nil, nil)]
-  )
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ LambdaNode (location: (0...5))
+            ├── locals: []
+            ├── operator_loc: (0...2) = "->"
+            ├── opening_loc: (2...3) = "{"
+            ├── closing_loc: (4...5) = "}"
+            ├── parameters: ∅
+            └── body: ∅
diff --git a/test/yarp/snapshots/whitequark/send_op_asgn_conditional.txt b/test/yarp/snapshots/whitequark/send_op_asgn_conditional.txt
index 767a6e7b22..13ce9d0ea2 100644
--- a/test/yarp/snapshots/whitequark/send_op_asgn_conditional.txt
+++ b/test/yarp/snapshots/whitequark/send_op_asgn_conditional.txt
@@ -1,18 +1,28 @@
-ProgramNode(0...10)(
-  [],
-  StatementsNode(0...10)(
-    [CallAndWriteNode(0...10)(
-       CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
-       (1...3),
-       (3...4),
-       nil,
-       nil,
-       nil,
-       1,
-       "b",
-       "b=",
-       (5...8),
-       IntegerNode(9...10)()
-     )]
-  )
-)
+@ ProgramNode (location: (0...10))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...10))
+    └── body: (length: 1)
+        └── @ CallAndWriteNode (location: (0...10))
+            ├── receiver:
+            │   @ CallNode (location: (0...1))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...1) = "a"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "a"
+            ├── call_operator_loc: (1...3) = "&."
+            ├── message_loc: (3...4) = "b"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── flags: safe_navigation
+            ├── read_name: "b"
+            ├── write_name: "b="
+            ├── operator_loc: (5...8) = "&&="
+            └── value:
+                @ IntegerNode (location: (9...10))
diff --git a/test/yarp/snapshots/whitequark/send_plain.txt b/test/yarp/snapshots/whitequark/send_plain.txt
index 2272355126..00af7a0915 100644
--- a/test/yarp/snapshots/whitequark/send_plain.txt
+++ b/test/yarp/snapshots/whitequark/send_plain.txt
@@ -1,38 +1,65 @@
-ProgramNode(0...29)(
-  [],
-  StatementsNode(0...29)(
-    [CallNode(0...7)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       (4...7),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(9...19)(
-       CallNode(9...12)(nil, nil, (9...12), nil, nil, nil, nil, 2, "foo"),
-       (12...14),
-       (14...17),
-       (17...18),
-       nil,
-       (18...19),
-       nil,
-       0,
-       "Fun"
-     ),
-     CallNode(21...29)(
-       CallNode(21...24)(nil, nil, (21...24), nil, nil, nil, nil, 2, "foo"),
-       (24...26),
-       (26...29),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...29))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...29))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...7))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: (4...7) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (9...19))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (9...12))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (9...12) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (12...14) = "::"
+        │   ├── message_loc: (14...17) = "Fun"
+        │   ├── opening_loc: (17...18) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (18...19) = ")"
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Fun"
+        └── @ CallNode (location: (21...29))
+            ├── receiver:
+            │   @ CallNode (location: (21...24))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (21...24) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: (24...26) = "::"
+            ├── message_loc: (26...29) = "fun"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/send_plain_cmd.txt b/test/yarp/snapshots/whitequark/send_plain_cmd.txt
index 4fc9fcb730..d2b17c26e6 100644
--- a/test/yarp/snapshots/whitequark/send_plain_cmd.txt
+++ b/test/yarp/snapshots/whitequark/send_plain_cmd.txt
@@ -1,44 +1,101 @@
-ProgramNode(0...39)(
-  [],
-  StatementsNode(0...39)(
-    [CallNode(0...11)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       (4...7),
-       nil,
-       ArgumentsNode(8...11)(
-         [CallNode(8...11)(nil, nil, (8...11), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "fun"
-     ),
-     CallNode(13...25)(
-       CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo"),
-       (16...18),
-       (18...21),
-       nil,
-       ArgumentsNode(22...25)(
-         [CallNode(22...25)(nil, nil, (22...25), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "Fun"
-     ),
-     CallNode(27...39)(
-       CallNode(27...30)(nil, nil, (27...30), nil, nil, nil, nil, 2, "foo"),
-       (30...32),
-       (32...35),
-       nil,
-       ArgumentsNode(36...39)(
-         [CallNode(36...39)(nil, nil, (36...39), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...39))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...39))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...11))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: (4...7) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (8...11))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (8...11))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (8...11) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (13...25))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (13...16))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (13...16) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (16...18) = "::"
+        │   ├── message_loc: (18...21) = "Fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (22...25))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (22...25))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (22...25) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "Fun"
+        └── @ CallNode (location: (27...39))
+            ├── receiver:
+            │   @ CallNode (location: (27...30))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (27...30) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: (30...32) = "::"
+            ├── message_loc: (32...35) = "fun"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (36...39))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (36...39))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (36...39) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/send_self.txt b/test/yarp/snapshots/whitequark/send_self.txt
index 6f24c1ba89..5c1cc10db9 100644
--- a/test/yarp/snapshots/whitequark/send_self.txt
+++ b/test/yarp/snapshots/whitequark/send_self.txt
@@ -1,18 +1,38 @@
-ProgramNode(0...17)(
-  [],
-  StatementsNode(0...17)(
-    [CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "fun"),
-     CallNode(5...9)(nil, nil, (5...9), nil, nil, nil, nil, 0, "fun!"),
-     CallNode(11...17)(
-       nil,
-       nil,
-       (11...14),
-       (14...15),
-       ArgumentsNode(15...16)([IntegerNode(15...16)()]),
-       (16...17),
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...17))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...17))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...3))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: variable_call
+        │   └── name: "fun"
+        ├── @ CallNode (location: (5...9))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (5...9) = "fun!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "fun!"
+        └── @ CallNode (location: (11...17))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (11...14) = "fun"
+            ├── opening_loc: (14...15) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (15...16))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (15...16))
+            ├── closing_loc: (16...17) = ")"
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/send_self_block.txt b/test/yarp/snapshots/whitequark/send_self_block.txt
index 1ae9968e74..12bdf1d019 100644
--- a/test/yarp/snapshots/whitequark/send_self_block.txt
+++ b/test/yarp/snapshots/whitequark/send_self_block.txt
@@ -1,49 +1,72 @@
-ProgramNode(0...42)(
-  [],
-  StatementsNode(0...42)(
-    [CallNode(0...10)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       nil,
-       nil,
-       BlockNode(4...10)([], nil, nil, (4...6), (7...10)),
-       0,
-       "fun"
-     ),
-     CallNode(12...19)(
-       nil,
-       nil,
-       (12...15),
-       nil,
-       nil,
-       nil,
-       BlockNode(16...19)([], nil, nil, (16...17), (18...19)),
-       0,
-       "fun"
-     ),
-     CallNode(21...30)(
-       nil,
-       nil,
-       (21...24),
-       (24...25),
-       nil,
-       (25...26),
-       BlockNode(27...30)([], nil, nil, (27...28), (29...30)),
-       0,
-       "fun"
-     ),
-     CallNode(32...42)(
-       nil,
-       nil,
-       (32...35),
-       (35...36),
-       ArgumentsNode(36...37)([IntegerNode(36...37)()]),
-       (37...38),
-       BlockNode(39...42)([], nil, nil, (39...40), (41...42)),
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...42))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...42))
+    └── body: (length: 4)
+        ├── @ CallNode (location: (0...10))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...3) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (4...10))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (4...6) = "do"
+        │   │   └── closing_loc: (7...10) = "end"
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (12...19))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (12...15) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (16...19))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (16...17) = "{"
+        │   │   └── closing_loc: (18...19) = "}"
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (21...30))
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (21...24) = "fun"
+        │   ├── opening_loc: (24...25) = "("
+        │   ├── arguments: ∅
+        │   ├── closing_loc: (25...26) = ")"
+        │   ├── block:
+        │   │   @ BlockNode (location: (27...30))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (27...28) = "{"
+        │   │   └── closing_loc: (29...30) = "}"
+        │   ├── flags: 
+        │   └── name: "fun"
+        └── @ CallNode (location: (32...42))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (32...35) = "fun"
+            ├── opening_loc: (35...36) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (36...37))
+            │   └── arguments: (length: 1)
+            │       └── @ IntegerNode (location: (36...37))
+            ├── closing_loc: (37...38) = ")"
+            ├── block:
+            │   @ BlockNode (location: (39...42))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (39...40) = "{"
+            │   └── closing_loc: (41...42) = "}"
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/send_unary_op.txt b/test/yarp/snapshots/whitequark/send_unary_op.txt
index 6906d49ae0..5996b1ed2d 100644
--- a/test/yarp/snapshots/whitequark/send_unary_op.txt
+++ b/test/yarp/snapshots/whitequark/send_unary_op.txt
@@ -1,38 +1,65 @@
-ProgramNode(0...16)(
-  [],
-  StatementsNode(0...16)(
-    [CallNode(0...4)(
-       CallNode(1...4)(nil, nil, (1...4), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (0...1),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "+@"
-     ),
-     CallNode(6...10)(
-       CallNode(7...10)(nil, nil, (7...10), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (6...7),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "-@"
-     ),
-     CallNode(12...16)(
-       CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo"),
-       nil,
-       (12...13),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "~"
-     )]
-  )
-)
+@ ProgramNode (location: (0...16))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...16))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...4))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (1...4))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (1...4) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (0...1) = "+"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "+@"
+        ├── @ CallNode (location: (6...10))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (7...10))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (7...10) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (6...7) = "-"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "-@"
+        └── @ CallNode (location: (12...16))
+            ├── receiver:
+            │   @ CallNode (location: (13...16))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (13...16) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (12...13) = "~"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "~"
diff --git a/test/yarp/snapshots/whitequark/slash_newline_in_heredocs.txt b/test/yarp/snapshots/whitequark/slash_newline_in_heredocs.txt
index 7485f4c8bd..150325e628 100644
--- a/test/yarp/snapshots/whitequark/slash_newline_in_heredocs.txt
+++ b/test/yarp/snapshots/whitequark/slash_newline_in_heredocs.txt
@@ -1,15 +1,23 @@
-ProgramNode(0...33)(
-  [],
-  StatementsNode(0...33)(
-    [InterpolatedStringNode(0...4)(
-       (0...4),
-       [StringNode(5...25)(nil, (5...25), nil, "    1     2\n" + "    3\n")],
-       (25...27)
-     ),
-     InterpolatedStringNode(29...33)(
-       (29...33),
-       [StringNode(34...54)(nil, (34...54), nil, "1 2\n" + "3\n")],
-       (54...56)
-     )]
-  )
-)
+@ ProgramNode (location: (0...33))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...33))
+    └── body: (length: 2)
+        ├── @ InterpolatedStringNode (location: (0...4))
+        │   ├── opening_loc: (0...4) = "<<-E"
+        │   ├── parts: (length: 1)
+        │   │   └── @ StringNode (location: (5...25))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (5...25) = "    1 \\\n    2\n    3\n"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: "    1     2\n    3\n"
+        │   └── closing_loc: (25...27) = "E\n"
+        └── @ InterpolatedStringNode (location: (29...33))
+            ├── opening_loc: (29...33) = "<<~E"
+            ├── parts: (length: 1)
+            │   └── @ StringNode (location: (34...54))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (34...54) = "    1 \\\n    2\n    3\n"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "1 2\n3\n"
+            └── closing_loc: (54...56) = "E\n"
diff --git a/test/yarp/snapshots/whitequark/space_args_arg.txt b/test/yarp/snapshots/whitequark/space_args_arg.txt
index d1dfcc4f65..a8a321065d 100644
--- a/test/yarp/snapshots/whitequark/space_args_arg.txt
+++ b/test/yarp/snapshots/whitequark/space_args_arg.txt
@@ -1,22 +1,24 @@
-ProgramNode(0...7)(
-  [],
-  StatementsNode(0...7)(
-    [CallNode(0...7)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...7)(
-         [ParenthesesNode(4...7)(
-            StatementsNode(5...6)([IntegerNode(5...6)()]),
-            (4...5),
-            (6...7)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...7))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "fun"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...7))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (4...7))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (5...6))
+            │           │   └── body: (length: 1)
+            │           │       └── @ IntegerNode (location: (5...6))
+            │           ├── opening_loc: (4...5) = "("
+            │           └── closing_loc: (6...7) = ")"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/space_args_arg_block.txt b/test/yarp/snapshots/whitequark/space_args_arg_block.txt
index d17aae90cd..ca28f30c03 100644
--- a/test/yarp/snapshots/whitequark/space_args_arg_block.txt
+++ b/test/yarp/snapshots/whitequark/space_args_arg_block.txt
@@ -1,56 +1,100 @@
-ProgramNode(0...43)(
-  [],
-  StatementsNode(0...43)(
-    [CallNode(0...14)(
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       (3...4),
-       (4...7),
-       nil,
-       ArgumentsNode(8...11)(
-         [ParenthesesNode(8...11)(
-            StatementsNode(9...10)([IntegerNode(9...10)()]),
-            (8...9),
-            (10...11)
-          )]
-       ),
-       nil,
-       BlockNode(12...14)([], nil, nil, (12...13), (13...14)),
-       0,
-       "fun"
-     ),
-     CallNode(16...31)(
-       CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "foo"),
-       (19...21),
-       (21...24),
-       nil,
-       ArgumentsNode(25...28)(
-         [ParenthesesNode(25...28)(
-            StatementsNode(26...27)([IntegerNode(26...27)()]),
-            (25...26),
-            (27...28)
-          )]
-       ),
-       nil,
-       BlockNode(29...31)([], nil, nil, (29...30), (30...31)),
-       0,
-       "fun"
-     ),
-     CallNode(33...43)(
-       nil,
-       nil,
-       (33...36),
-       nil,
-       ArgumentsNode(37...40)(
-         [ParenthesesNode(37...40)(
-            StatementsNode(38...39)([IntegerNode(38...39)()]),
-            (37...38),
-            (39...40)
-          )]
-       ),
-       nil,
-       BlockNode(41...43)([], nil, nil, (41...42), (42...43)),
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...43))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...43))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...14))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (0...3))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (0...3) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (3...4) = "."
+        │   ├── message_loc: (4...7) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (8...11))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (8...11))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (9...10))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (9...10))
+        │   │           ├── opening_loc: (8...9) = "("
+        │   │           └── closing_loc: (10...11) = ")"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (12...14))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (12...13) = "{"
+        │   │   └── closing_loc: (13...14) = "}"
+        │   ├── flags: 
+        │   └── name: "fun"
+        ├── @ CallNode (location: (16...31))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (16...19))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (16...19) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── call_operator_loc: (19...21) = "::"
+        │   ├── message_loc: (21...24) = "fun"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (25...28))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ ParenthesesNode (location: (25...28))
+        │   │           ├── body:
+        │   │           │   @ StatementsNode (location: (26...27))
+        │   │           │   └── body: (length: 1)
+        │   │           │       └── @ IntegerNode (location: (26...27))
+        │   │           ├── opening_loc: (25...26) = "("
+        │   │           └── closing_loc: (27...28) = ")"
+        │   ├── closing_loc: ∅
+        │   ├── block:
+        │   │   @ BlockNode (location: (29...31))
+        │   │   ├── locals: []
+        │   │   ├── parameters: ∅
+        │   │   ├── body: ∅
+        │   │   ├── opening_loc: (29...30) = "{"
+        │   │   └── closing_loc: (30...31) = "}"
+        │   ├── flags: 
+        │   └── name: "fun"
+        └── @ CallNode (location: (33...43))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (33...36) = "fun"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (37...40))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (37...40))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (38...39))
+            │           │   └── body: (length: 1)
+            │           │       └── @ IntegerNode (location: (38...39))
+            │           ├── opening_loc: (37...38) = "("
+            │           └── closing_loc: (39...40) = ")"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (41...43))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (41...42) = "{"
+            │   └── closing_loc: (42...43) = "}"
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/space_args_arg_call.txt b/test/yarp/snapshots/whitequark/space_args_arg_call.txt
index 01bc1dbde3..2c276e7f9b 100644
--- a/test/yarp/snapshots/whitequark/space_args_arg_call.txt
+++ b/test/yarp/snapshots/whitequark/space_args_arg_call.txt
@@ -1,32 +1,34 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [CallNode(0...12)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...12)(
-         [CallNode(4...12)(
-            ParenthesesNode(4...7)(
-              StatementsNode(5...6)([IntegerNode(5...6)()]),
-              (4...5),
-              (6...7)
-            ),
-            (7...8),
-            (8...12),
-            nil,
-            nil,
-            nil,
-            nil,
-            0,
-            "to_i"
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...12))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "fun"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...12))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (4...12))
+            │           ├── receiver:
+            │           │   @ ParenthesesNode (location: (4...7))
+            │           │   ├── body:
+            │           │   │   @ StatementsNode (location: (5...6))
+            │           │   │   └── body: (length: 1)
+            │           │   │       └── @ IntegerNode (location: (5...6))
+            │           │   ├── opening_loc: (4...5) = "("
+            │           │   └── closing_loc: (6...7) = ")"
+            │           ├── call_operator_loc: (7...8) = "."
+            │           ├── message_loc: (8...12) = "to_i"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "to_i"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/space_args_arg_newline.txt b/test/yarp/snapshots/whitequark/space_args_arg_newline.txt
index 36e321ad7c..d149baaa84 100644
--- a/test/yarp/snapshots/whitequark/space_args_arg_newline.txt
+++ b/test/yarp/snapshots/whitequark/space_args_arg_newline.txt
@@ -1,22 +1,24 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [CallNode(0...8)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...8)(
-         [ParenthesesNode(4...8)(
-            StatementsNode(5...6)([IntegerNode(5...6)()]),
-            (4...5),
-            (7...8)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...8))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "fun"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...8))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (4...8))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (5...6))
+            │           │   └── body: (length: 1)
+            │           │       └── @ IntegerNode (location: (5...6))
+            │           ├── opening_loc: (4...5) = "("
+            │           └── closing_loc: (7...8) = ")"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/space_args_block.txt b/test/yarp/snapshots/whitequark/space_args_block.txt
index 7895ad2606..d795262c1a 100644
--- a/test/yarp/snapshots/whitequark/space_args_block.txt
+++ b/test/yarp/snapshots/whitequark/space_args_block.txt
@@ -1,16 +1,27 @@
-ProgramNode(0...9)(
-  [],
-  StatementsNode(0...9)(
-    [CallNode(0...9)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...6)([ParenthesesNode(4...6)(nil, (4...5), (5...6))]),
-       nil,
-       BlockNode(7...9)([], nil, nil, (7...8), (8...9)),
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...9))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...9))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...9))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "fun"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...6))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (4...6))
+            │           ├── body: ∅
+            │           ├── opening_loc: (4...5) = "("
+            │           └── closing_loc: (5...6) = ")"
+            ├── closing_loc: ∅
+            ├── block:
+            │   @ BlockNode (location: (7...9))
+            │   ├── locals: []
+            │   ├── parameters: ∅
+            │   ├── body: ∅
+            │   ├── opening_loc: (7...8) = "{"
+            │   └── closing_loc: (8...9) = "}"
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/space_args_cmd.txt b/test/yarp/snapshots/whitequark/space_args_cmd.txt
index 84493c09a9..c932dc36b3 100644
--- a/test/yarp/snapshots/whitequark/space_args_cmd.txt
+++ b/test/yarp/snapshots/whitequark/space_args_cmd.txt
@@ -1,46 +1,45 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [CallNode(0...11)(
-       nil,
-       nil,
-       (0...3),
-       nil,
-       ArgumentsNode(4...11)(
-         [ParenthesesNode(4...11)(
-            StatementsNode(5...10)(
-              [CallNode(5...10)(
-                 nil,
-                 nil,
-                 (5...6),
-                 nil,
-                 ArgumentsNode(7...10)(
-                   [CallNode(7...10)(
-                      nil,
-                      nil,
-                      (7...10),
-                      nil,
-                      nil,
-                      nil,
-                      nil,
-                      2,
-                      "bar"
-                    )]
-                 ),
-                 nil,
-                 nil,
-                 0,
-                 "f"
-               )]
-            ),
-            (4...5),
-            (10...11)
-          )]
-       ),
-       nil,
-       nil,
-       0,
-       "fun"
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ CallNode (location: (0...11))
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── message_loc: (0...3) = "fun"
+            ├── opening_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (4...11))
+            │   └── arguments: (length: 1)
+            │       └── @ ParenthesesNode (location: (4...11))
+            │           ├── body:
+            │           │   @ StatementsNode (location: (5...10))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (5...10))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (5...6) = "f"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments:
+            │           │           │   @ ArgumentsNode (location: (7...10))
+            │           │           │   └── arguments: (length: 1)
+            │           │           │       └── @ CallNode (location: (7...10))
+            │           │           │           ├── receiver: ∅
+            │           │           │           ├── call_operator_loc: ∅
+            │           │           │           ├── message_loc: (7...10) = "bar"
+            │           │           │           ├── opening_loc: ∅
+            │           │           │           ├── arguments: ∅
+            │           │           │           ├── closing_loc: ∅
+            │           │           │           ├── block: ∅
+            │           │           │           ├── flags: variable_call
+            │           │           │           └── name: "bar"
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: 
+            │           │           └── name: "f"
+            │           ├── opening_loc: (4...5) = "("
+            │           └── closing_loc: (10...11) = ")"
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "fun"
diff --git a/test/yarp/snapshots/whitequark/string___FILE__.txt b/test/yarp/snapshots/whitequark/string___FILE__.txt
index 83e601222d..ff1ade75d9 100644
--- a/test/yarp/snapshots/whitequark/string___FILE__.txt
+++ b/test/yarp/snapshots/whitequark/string___FILE__.txt
@@ -1,6 +1,7 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [SourceFileNode(0...8)("whitequark/string___FILE__.txt")]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ SourceFileNode (location: (0...8))
+            └── filepath: "whitequark/string___FILE__.txt"
diff --git a/test/yarp/snapshots/whitequark/string_concat.txt b/test/yarp/snapshots/whitequark/string_concat.txt
index a51362805e..9b9e519448 100644
--- a/test/yarp/snapshots/whitequark/string_concat.txt
+++ b/test/yarp/snapshots/whitequark/string_concat.txt
@@ -1,17 +1,27 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [StringConcatNode(0...14)(
-       InterpolatedStringNode(0...8)(
-         (0...1),
-         [StringNode(1...4)(nil, (1...4), nil, "foo"),
-          EmbeddedVariableNode(4...7)(
-            (4...5),
-            InstanceVariableReadNode(5...7)(:@a)
-          )],
-         (7...8)
-       ),
-       StringNode(9...14)((9...10), (10...13), (13...14), "bar")
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ StringConcatNode (location: (0...14))
+            ├── left:
+            │   @ InterpolatedStringNode (location: (0...8))
+            │   ├── opening_loc: (0...1) = "\""
+            │   ├── parts: (length: 2)
+            │   │   ├── @ StringNode (location: (1...4))
+            │   │   │   ├── opening_loc: ∅
+            │   │   │   ├── content_loc: (1...4) = "foo"
+            │   │   │   ├── closing_loc: ∅
+            │   │   │   └── unescaped: "foo"
+            │   │   └── @ EmbeddedVariableNode (location: (4...7))
+            │   │       ├── operator_loc: (4...5) = "#"
+            │   │       └── variable:
+            │   │           @ InstanceVariableReadNode (location: (5...7))
+            │   │           └── name: :@a
+            │   └── closing_loc: (7...8) = "\""
+            └── right:
+                @ StringNode (location: (9...14))
+                ├── opening_loc: (9...10) = "\""
+                ├── content_loc: (10...13) = "bar"
+                ├── closing_loc: (13...14) = "\""
+                └── unescaped: "bar"
diff --git a/test/yarp/snapshots/whitequark/string_dvar.txt b/test/yarp/snapshots/whitequark/string_dvar.txt
index 66cd00b5cb..a4522eb41d 100644
--- a/test/yarp/snapshots/whitequark/string_dvar.txt
+++ b/test/yarp/snapshots/whitequark/string_dvar.txt
@@ -1,23 +1,34 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [InterpolatedStringNode(0...14)(
-       (0...1),
-       [EmbeddedVariableNode(1...4)(
-          (1...2),
-          InstanceVariableReadNode(2...4)(:@a)
-        ),
-        StringNode(4...5)(nil, (4...5), nil, " "),
-        EmbeddedVariableNode(5...9)(
-          (5...6),
-          ClassVariableReadNode(6...9)(:@@a)
-        ),
-        StringNode(9...10)(nil, (9...10), nil, " "),
-        EmbeddedVariableNode(10...13)(
-          (10...11),
-          GlobalVariableReadNode(11...13)(:$a)
-        )],
-       (13...14)
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...14))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 5)
+            │   ├── @ EmbeddedVariableNode (location: (1...4))
+            │   │   ├── operator_loc: (1...2) = "#"
+            │   │   └── variable:
+            │   │       @ InstanceVariableReadNode (location: (2...4))
+            │   │       └── name: :@a
+            │   ├── @ StringNode (location: (4...5))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (4...5) = " "
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: " "
+            │   ├── @ EmbeddedVariableNode (location: (5...9))
+            │   │   ├── operator_loc: (5...6) = "#"
+            │   │   └── variable:
+            │   │       @ ClassVariableReadNode (location: (6...9))
+            │   │       └── name: :@@a
+            │   ├── @ StringNode (location: (9...10))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (9...10) = " "
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: " "
+            │   └── @ EmbeddedVariableNode (location: (10...13))
+            │       ├── operator_loc: (10...11) = "#"
+            │       └── variable:
+            │           @ GlobalVariableReadNode (location: (11...13))
+            │           └── name: :$a
+            └── closing_loc: (13...14) = "\""
diff --git a/test/yarp/snapshots/whitequark/string_interp.txt b/test/yarp/snapshots/whitequark/string_interp.txt
index cd41265c99..654d40b692 100644
--- a/test/yarp/snapshots/whitequark/string_interp.txt
+++ b/test/yarp/snapshots/whitequark/string_interp.txt
@@ -1,18 +1,35 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [InterpolatedStringNode(0...14)(
-       (0...1),
-       [StringNode(1...4)(nil, (1...4), nil, "foo"),
-        EmbeddedStatementsNode(4...10)(
-          (4...6),
-          StatementsNode(6...9)(
-            [CallNode(6...9)(nil, nil, (6...9), nil, nil, nil, nil, 2, "bar")]
-          ),
-          (9...10)
-        ),
-        StringNode(10...13)(nil, (10...13), nil, "baz")],
-       (13...14)
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ InterpolatedStringNode (location: (0...14))
+            ├── opening_loc: (0...1) = "\""
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (1...4))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (1...4) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   ├── @ EmbeddedStatementsNode (location: (4...10))
+            │   │   ├── opening_loc: (4...6) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (6...9))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (6...9))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (6...9) = "bar"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "bar"
+            │   │   └── closing_loc: (9...10) = "}"
+            │   └── @ StringNode (location: (10...13))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (10...13) = "baz"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "baz"
+            └── closing_loc: (13...14) = "\""
diff --git a/test/yarp/snapshots/whitequark/string_plain.txt b/test/yarp/snapshots/whitequark/string_plain.txt
index fe0822a568..106548bdf3 100644
--- a/test/yarp/snapshots/whitequark/string_plain.txt
+++ b/test/yarp/snapshots/whitequark/string_plain.txt
@@ -1,7 +1,15 @@
-ProgramNode(0...20)(
-  [],
-  StatementsNode(0...20)(
-    [StringNode(0...10)((0...3), (3...9), (9...10), "foobar"),
-     StringNode(12...20)((12...13), (13...19), (19...20), "foobar")]
-  )
-)
+@ ProgramNode (location: (0...20))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...20))
+    └── body: (length: 2)
+        ├── @ StringNode (location: (0...10))
+        │   ├── opening_loc: (0...3) = "%q("
+        │   ├── content_loc: (3...9) = "foobar"
+        │   ├── closing_loc: (9...10) = ")"
+        │   └── unescaped: "foobar"
+        └── @ StringNode (location: (12...20))
+            ├── opening_loc: (12...13) = "'"
+            ├── content_loc: (13...19) = "foobar"
+            ├── closing_loc: (19...20) = "'"
+            └── unescaped: "foobar"
diff --git a/test/yarp/snapshots/whitequark/super.txt b/test/yarp/snapshots/whitequark/super.txt
index 65eb72d5f5..e912a4f1e6 100644
--- a/test/yarp/snapshots/whitequark/super.txt
+++ b/test/yarp/snapshots/whitequark/super.txt
@@ -1,24 +1,47 @@
-ProgramNode(0...30)(
-  [],
-  StatementsNode(0...30)(
-    [SuperNode(0...9)(
-       (0...5),
-       nil,
-       ArgumentsNode(6...9)(
-         [CallNode(6...9)(nil, nil, (6...9), nil, nil, nil, nil, 2, "foo")]
-       ),
-       nil,
-       nil
-     ),
-     SuperNode(11...18)((11...16), (16...17), nil, (17...18), nil),
-     SuperNode(20...30)(
-       (20...25),
-       (25...26),
-       ArgumentsNode(26...29)(
-         [CallNode(26...29)(nil, nil, (26...29), nil, nil, nil, nil, 2, "foo")]
-       ),
-       (29...30),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...30))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...30))
+    └── body: (length: 3)
+        ├── @ SuperNode (location: (0...9))
+        │   ├── keyword_loc: (0...5) = "super"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (6...9))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (6...9))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (6...9) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "foo"
+        │   ├── rparen_loc: ∅
+        │   └── block: ∅
+        ├── @ SuperNode (location: (11...18))
+        │   ├── keyword_loc: (11...16) = "super"
+        │   ├── lparen_loc: (16...17) = "("
+        │   ├── arguments: ∅
+        │   ├── rparen_loc: (17...18) = ")"
+        │   └── block: ∅
+        └── @ SuperNode (location: (20...30))
+            ├── keyword_loc: (20...25) = "super"
+            ├── lparen_loc: (25...26) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (26...29))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (26...29))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (26...29) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "foo"
+            ├── rparen_loc: (29...30) = ")"
+            └── block: ∅
diff --git a/test/yarp/snapshots/whitequark/super_block.txt b/test/yarp/snapshots/whitequark/super_block.txt
index a26dad1b37..54e82b4b4e 100644
--- a/test/yarp/snapshots/whitequark/super_block.txt
+++ b/test/yarp/snapshots/whitequark/super_block.txt
@@ -1,18 +1,47 @@
-ProgramNode(0...35)(
-  [],
-  StatementsNode(0...35)(
-    [ForwardingSuperNode(0...12)(
-       BlockNode(6...12)([], nil, nil, (6...8), (9...12))
-     ),
-     SuperNode(14...35)(
-       (14...19),
-       nil,
-       ArgumentsNode(20...28)(
-         [CallNode(20...23)(nil, nil, (20...23), nil, nil, nil, nil, 2, "foo"),
-          CallNode(25...28)(nil, nil, (25...28), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       BlockNode(29...35)([], nil, nil, (29...31), (32...35))
-     )]
-  )
-)
+@ ProgramNode (location: (0...35))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...35))
+    └── body: (length: 2)
+        ├── @ ForwardingSuperNode (location: (0...12))
+        │   └── block:
+        │       @ BlockNode (location: (6...12))
+        │       ├── locals: []
+        │       ├── parameters: ∅
+        │       ├── body: ∅
+        │       ├── opening_loc: (6...8) = "do"
+        │       └── closing_loc: (9...12) = "end"
+        └── @ SuperNode (location: (14...35))
+            ├── keyword_loc: (14...19) = "super"
+            ├── lparen_loc: ∅
+            ├── arguments:
+            │   @ ArgumentsNode (location: (20...28))
+            │   └── arguments: (length: 2)
+            │       ├── @ CallNode (location: (20...23))
+            │       │   ├── receiver: ∅
+            │       │   ├── call_operator_loc: ∅
+            │       │   ├── message_loc: (20...23) = "foo"
+            │       │   ├── opening_loc: ∅
+            │       │   ├── arguments: ∅
+            │       │   ├── closing_loc: ∅
+            │       │   ├── block: ∅
+            │       │   ├── flags: variable_call
+            │       │   └── name: "foo"
+            │       └── @ CallNode (location: (25...28))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (25...28) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── rparen_loc: ∅
+            └── block:
+                @ BlockNode (location: (29...35))
+                ├── locals: []
+                ├── parameters: ∅
+                ├── body: ∅
+                ├── opening_loc: (29...31) = "do"
+                └── closing_loc: (32...35) = "end"
diff --git a/test/yarp/snapshots/whitequark/symbol_interp.txt b/test/yarp/snapshots/whitequark/symbol_interp.txt
index 5fd0375ae6..3786818f7b 100644
--- a/test/yarp/snapshots/whitequark/symbol_interp.txt
+++ b/test/yarp/snapshots/whitequark/symbol_interp.txt
@@ -1,28 +1,35 @@
-ProgramNode(0...15)(
-  [],
-  StatementsNode(0...15)(
-    [InterpolatedSymbolNode(0...15)(
-       (0...2),
-       [StringNode(2...5)(nil, (2...5), nil, "foo"),
-        EmbeddedStatementsNode(5...11)(
-          (5...7),
-          StatementsNode(7...10)(
-            [CallNode(7...10)(
-               nil,
-               nil,
-               (7...10),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          ),
-          (10...11)
-        ),
-        StringNode(11...14)(nil, (11...14), nil, "baz")],
-       (14...15)
-     )]
-  )
-)
+@ ProgramNode (location: (0...15))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...15))
+    └── body: (length: 1)
+        └── @ InterpolatedSymbolNode (location: (0...15))
+            ├── opening_loc: (0...2) = ":\""
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (2...5))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (2...5) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   ├── @ EmbeddedStatementsNode (location: (5...11))
+            │   │   ├── opening_loc: (5...7) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (7...10))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (7...10))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (7...10) = "bar"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "bar"
+            │   │   └── closing_loc: (10...11) = "}"
+            │   └── @ StringNode (location: (11...14))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (11...14) = "baz"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "baz"
+            └── closing_loc: (14...15) = "\""
diff --git a/test/yarp/snapshots/whitequark/symbol_plain.txt b/test/yarp/snapshots/whitequark/symbol_plain.txt
index 7cbac4e19d..8bc5045bef 100644
--- a/test/yarp/snapshots/whitequark/symbol_plain.txt
+++ b/test/yarp/snapshots/whitequark/symbol_plain.txt
@@ -1,7 +1,15 @@
-ProgramNode(0...12)(
-  [],
-  StatementsNode(0...12)(
-    [SymbolNode(0...6)((0...2), (2...5), (5...6), "foo"),
-     SymbolNode(8...12)((8...9), (9...12), nil, "foo")]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 2)
+        ├── @ SymbolNode (location: (0...6))
+        │   ├── opening_loc: (0...2) = ":'"
+        │   ├── value_loc: (2...5) = "foo"
+        │   ├── closing_loc: (5...6) = "'"
+        │   └── unescaped: "foo"
+        └── @ SymbolNode (location: (8...12))
+            ├── opening_loc: (8...9) = ":"
+            ├── value_loc: (9...12) = "foo"
+            ├── closing_loc: ∅
+            └── unescaped: "foo"
diff --git a/test/yarp/snapshots/whitequark/ternary.txt b/test/yarp/snapshots/whitequark/ternary.txt
index c975e93c7e..6d635c429c 100644
--- a/test/yarp/snapshots/whitequark/ternary.txt
+++ b/test/yarp/snapshots/whitequark/ternary.txt
@@ -1,16 +1,31 @@
-ProgramNode(0...11)(
-  [],
-  StatementsNode(0...11)(
-    [IfNode(0...11)(
-       nil,
-       CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(6...7)([IntegerNode(6...7)()]),
-       ElseNode(8...11)(
-         (8...9),
-         StatementsNode(10...11)([IntegerNode(10...11)()]),
-         nil
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...11))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...11))
+    └── body: (length: 1)
+        └── @ IfNode (location: (0...11))
+            ├── if_keyword_loc: ∅
+            ├── predicate:
+            │   @ CallNode (location: (0...3))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (0...3) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (6...7))
+            │   └── body: (length: 1)
+            │       └── @ IntegerNode (location: (6...7))
+            ├── consequent:
+            │   @ ElseNode (location: (8...11))
+            │   ├── else_keyword_loc: (8...9) = ":"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (10...11))
+            │   │   └── body: (length: 1)
+            │   │       └── @ IntegerNode (location: (10...11))
+            │   └── end_keyword_loc: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/ternary_ambiguous_symbol.txt b/test/yarp/snapshots/whitequark/ternary_ambiguous_symbol.txt
index e7e814c053..c5a1d06672 100644
--- a/test/yarp/snapshots/whitequark/ternary_ambiguous_symbol.txt
+++ b/test/yarp/snapshots/whitequark/ternary_ambiguous_symbol.txt
@@ -1,29 +1,47 @@
-ProgramNode(0...13)(
-  [:t],
-  StatementsNode(0...13)(
-    [LocalVariableWriteNode(0...3)(
-       :t,
-       0,
-       (0...1),
-       IntegerNode(2...3)(),
-       (1...2)
-     ),
-     IfNode(4...13)(
-       nil,
-       ParenthesesNode(4...9)(
-         StatementsNode(5...8)(
-           [CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "foo")]
-         ),
-         (4...5),
-         (8...9)
-       ),
-       StatementsNode(10...11)([LocalVariableReadNode(10...11)(:t, 0)]),
-       ElseNode(11...13)(
-         (11...12),
-         StatementsNode(12...13)([ConstantReadNode(12...13)(:T)]),
-         nil
-       ),
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...13))
+├── locals: [:t]
+└── statements:
+    @ StatementsNode (location: (0...13))
+    └── body: (length: 2)
+        ├── @ LocalVariableWriteNode (location: (0...3))
+        │   ├── name: :t
+        │   ├── depth: 0
+        │   ├── name_loc: (0...1) = "t"
+        │   ├── value:
+        │   │   @ IntegerNode (location: (2...3))
+        │   └── operator_loc: (1...2) = "="
+        └── @ IfNode (location: (4...13))
+            ├── if_keyword_loc: ∅
+            ├── predicate:
+            │   @ ParenthesesNode (location: (4...9))
+            │   ├── body:
+            │   │   @ StatementsNode (location: (5...8))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (5...8))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (5...8) = "foo"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "foo"
+            │   ├── opening_loc: (4...5) = "("
+            │   └── closing_loc: (8...9) = ")"
+            ├── statements:
+            │   @ StatementsNode (location: (10...11))
+            │   └── body: (length: 1)
+            │       └── @ LocalVariableReadNode (location: (10...11))
+            │           ├── name: :t
+            │           └── depth: 0
+            ├── consequent:
+            │   @ ElseNode (location: (11...13))
+            │   ├── else_keyword_loc: (11...12) = ":"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (12...13))
+            │   │   └── body: (length: 1)
+            │   │       └── @ ConstantReadNode (location: (12...13))
+            │   │           └── name: :T
+            │   └── end_keyword_loc: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/trailing_forward_arg.txt b/test/yarp/snapshots/whitequark/trailing_forward_arg.txt
index f250529610..dcc0303fb4 100644
--- a/test/yarp/snapshots/whitequark/trailing_forward_arg.txt
+++ b/test/yarp/snapshots/whitequark/trailing_forward_arg.txt
@@ -1,44 +1,50 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [DefNode(0...40)(
-       :foo,
-       (4...7),
-       nil,
-       ParametersNode(8...17)(
-         [RequiredParameterNode(8...9)(:a),
-          RequiredParameterNode(11...12)(:b)],
-         [],
-         [],
-         nil,
-         [],
-         ForwardingParameterNode(14...17)(),
-         nil
-       ),
-       StatementsNode(20...35)(
-         [CallNode(20...35)(
-            nil,
-            nil,
-            (20...23),
-            (23...24),
-            ArgumentsNode(24...34)(
-              [LocalVariableReadNode(24...25)(:a, 0),
-               IntegerNode(27...29)(),
-               ForwardingArgumentsNode(31...34)()]
-            ),
-            (34...35),
-            nil,
-            0,
-            "bar"
-          )]
-       ),
-       [:a, :b, :"..."],
-       (0...3),
-       nil,
-       (7...8),
-       (17...18),
-       nil,
-       (37...40)
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 1)
+        └── @ DefNode (location: (0...40))
+            ├── name: :foo
+            ├── name_loc: (4...7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (8...17))
+            │   ├── requireds: (length: 2)
+            │   │   ├── @ RequiredParameterNode (location: (8...9))
+            │   │   │   └── name: :a
+            │   │   └── @ RequiredParameterNode (location: (11...12))
+            │   │       └── name: :b
+            │   ├── optionals: (length: 0)
+            │   ├── posts: (length: 0)
+            │   ├── rest: ∅
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest:
+            │   │   @ ForwardingParameterNode (location: (14...17))
+            │   └── block: ∅
+            ├── body:
+            │   @ StatementsNode (location: (20...35))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (20...35))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (20...23) = "bar"
+            │           ├── opening_loc: (23...24) = "("
+            │           ├── arguments:
+            │           │   @ ArgumentsNode (location: (24...34))
+            │           │   └── arguments: (length: 3)
+            │           │       ├── @ LocalVariableReadNode (location: (24...25))
+            │           │       │   ├── name: :a
+            │           │       │   └── depth: 0
+            │           │       ├── @ IntegerNode (location: (27...29))
+            │           │       └── @ ForwardingArgumentsNode (location: (31...34))
+            │           ├── closing_loc: (34...35) = ")"
+            │           ├── block: ∅
+            │           ├── flags: 
+            │           └── name: "bar"
+            ├── locals: [:a, :b, :"..."]
+            ├── def_keyword_loc: (0...3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (7...8) = "("
+            ├── rparen_loc: (17...18) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (37...40) = "end"
diff --git a/test/yarp/snapshots/whitequark/true.txt b/test/yarp/snapshots/whitequark/true.txt
index 14b0c8cecc..48711e2d48 100644
--- a/test/yarp/snapshots/whitequark/true.txt
+++ b/test/yarp/snapshots/whitequark/true.txt
@@ -1 +1,6 @@
-ProgramNode(0...4)([], StatementsNode(0...4)([TrueNode(0...4)()]))
+@ ProgramNode (location: (0...4))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...4))
+    └── body: (length: 1)
+        └── @ TrueNode (location: (0...4))
diff --git a/test/yarp/snapshots/whitequark/unary_num_pow_precedence.txt b/test/yarp/snapshots/whitequark/unary_num_pow_precedence.txt
index 319b29b170..090e4c2ec1 100644
--- a/test/yarp/snapshots/whitequark/unary_num_pow_precedence.txt
+++ b/test/yarp/snapshots/whitequark/unary_num_pow_precedence.txt
@@ -1,58 +1,67 @@
-ProgramNode(0...32)(
-  [],
-  StatementsNode(0...32)(
-    [CallNode(0...10)(
-       FloatNode(0...4)(),
-       nil,
-       (5...7),
-       nil,
-       ArgumentsNode(8...10)([IntegerNode(8...10)()]),
-       nil,
-       nil,
-       0,
-       "**"
-     ),
-     CallNode(12...20)(
-       CallNode(13...20)(
-         IntegerNode(13...14)(),
-         nil,
-         (15...17),
-         nil,
-         ArgumentsNode(18...20)([IntegerNode(18...20)()]),
-         nil,
-         nil,
-         0,
-         "**"
-       ),
-       nil,
-       (12...13),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "-@"
-     ),
-     CallNode(22...32)(
-       CallNode(23...32)(
-         FloatNode(23...26)(),
-         nil,
-         (27...29),
-         nil,
-         ArgumentsNode(30...32)([IntegerNode(30...32)()]),
-         nil,
-         nil,
-         0,
-         "**"
-       ),
-       nil,
-       (22...23),
-       nil,
-       nil,
-       nil,
-       nil,
-       0,
-       "-@"
-     )]
-  )
-)
+@ ProgramNode (location: (0...32))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...32))
+    └── body: (length: 3)
+        ├── @ CallNode (location: (0...10))
+        │   ├── receiver:
+        │   │   @ FloatNode (location: (0...4))
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (5...7) = "**"
+        │   ├── opening_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (8...10))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (8...10))
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "**"
+        ├── @ CallNode (location: (12...20))
+        │   ├── receiver:
+        │   │   @ CallNode (location: (13...20))
+        │   │   ├── receiver:
+        │   │   │   @ IntegerNode (location: (13...14))
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (15...17) = "**"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments:
+        │   │   │   @ ArgumentsNode (location: (18...20))
+        │   │   │   └── arguments: (length: 1)
+        │   │   │       └── @ IntegerNode (location: (18...20))
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: 
+        │   │   └── name: "**"
+        │   ├── call_operator_loc: ∅
+        │   ├── message_loc: (12...13) = "-"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── block: ∅
+        │   ├── flags: 
+        │   └── name: "-@"
+        └── @ CallNode (location: (22...32))
+            ├── receiver:
+            │   @ CallNode (location: (23...32))
+            │   ├── receiver:
+            │   │   @ FloatNode (location: (23...26))
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (27...29) = "**"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (30...32))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ IntegerNode (location: (30...32))
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "**"
+            ├── call_operator_loc: ∅
+            ├── message_loc: (22...23) = "-"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── block: ∅
+            ├── flags: 
+            └── name: "-@"
diff --git a/test/yarp/snapshots/whitequark/undef.txt b/test/yarp/snapshots/whitequark/undef.txt
index eb253762b3..373936f520 100644
--- a/test/yarp/snapshots/whitequark/undef.txt
+++ b/test/yarp/snapshots/whitequark/undef.txt
@@ -1,20 +1,34 @@
-ProgramNode(0...27)(
-  [],
-  StatementsNode(0...27)(
-    [UndefNode(0...27)(
-       [SymbolNode(6...9)(nil, (6...9), nil, "foo"),
-        SymbolNode(11...15)((11...12), (12...15), nil, "bar"),
-        InterpolatedSymbolNode(17...27)(
-          (17...19),
-          [StringNode(19...22)(nil, (19...22), nil, "foo"),
-           EmbeddedStatementsNode(22...26)(
-             (22...24),
-             StatementsNode(24...25)([IntegerNode(24...25)()]),
-             (25...26)
-           )],
-          (26...27)
-        )],
-       (0...5)
-     )]
-  )
-)
+@ ProgramNode (location: (0...27))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...27))
+    └── body: (length: 1)
+        └── @ UndefNode (location: (0...27))
+            ├── names: (length: 3)
+            │   ├── @ SymbolNode (location: (6...9))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── value_loc: (6...9) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   ├── @ SymbolNode (location: (11...15))
+            │   │   ├── opening_loc: (11...12) = ":"
+            │   │   ├── value_loc: (12...15) = "bar"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "bar"
+            │   └── @ InterpolatedSymbolNode (location: (17...27))
+            │       ├── opening_loc: (17...19) = ":\""
+            │       ├── parts: (length: 2)
+            │       │   ├── @ StringNode (location: (19...22))
+            │       │   │   ├── opening_loc: ∅
+            │       │   │   ├── content_loc: (19...22) = "foo"
+            │       │   │   ├── closing_loc: ∅
+            │       │   │   └── unescaped: "foo"
+            │       │   └── @ EmbeddedStatementsNode (location: (22...26))
+            │       │       ├── opening_loc: (22...24) = "\#{"
+            │       │       ├── statements:
+            │       │       │   @ StatementsNode (location: (24...25))
+            │       │       │   └── body: (length: 1)
+            │       │       │       └── @ IntegerNode (location: (24...25))
+            │       │       └── closing_loc: (25...26) = "}"
+            │       └── closing_loc: (26...27) = "\""
+            └── keyword_loc: (0...5) = "undef"
diff --git a/test/yarp/snapshots/whitequark/unless.txt b/test/yarp/snapshots/whitequark/unless.txt
index 2c0a7aa062..f08bba46f8 100644
--- a/test/yarp/snapshots/whitequark/unless.txt
+++ b/test/yarp/snapshots/whitequark/unless.txt
@@ -1,23 +1,61 @@
-ProgramNode(0...46)(
-  [],
-  StatementsNode(0...46)(
-    [UnlessNode(0...24)(
-       (0...6),
-       CallNode(7...10)(nil, nil, (7...10), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(16...19)(
-         [CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       (21...24)
-     ),
-     UnlessNode(26...46)(
-       (26...32),
-       CallNode(33...36)(nil, nil, (33...36), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(38...41)(
-         [CallNode(38...41)(nil, nil, (38...41), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       (43...46)
-     )]
-  )
-)
+@ ProgramNode (location: (0...46))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...46))
+    └── body: (length: 2)
+        ├── @ UnlessNode (location: (0...24))
+        │   ├── keyword_loc: (0...6) = "unless"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (7...10))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (7...10) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (16...19))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (16...19))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (16...19) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── consequent: ∅
+        │   └── end_keyword_loc: (21...24) = "end"
+        └── @ UnlessNode (location: (26...46))
+            ├── keyword_loc: (26...32) = "unless"
+            ├── predicate:
+            │   @ CallNode (location: (33...36))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (33...36) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (38...41))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (38...41))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (38...41) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── consequent: ∅
+            └── end_keyword_loc: (43...46) = "end"
diff --git a/test/yarp/snapshots/whitequark/unless_else.txt b/test/yarp/snapshots/whitequark/unless_else.txt
index d08e1294e1..c087aae0c9 100644
--- a/test/yarp/snapshots/whitequark/unless_else.txt
+++ b/test/yarp/snapshots/whitequark/unless_else.txt
@@ -1,55 +1,93 @@
-ProgramNode(0...66)(
-  [],
-  StatementsNode(0...66)(
-    [UnlessNode(0...34)(
-       (0...6),
-       CallNode(7...10)(nil, nil, (7...10), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(16...19)(
-         [CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "bar")]
-       ),
-       ElseNode(21...34)(
-         (21...25),
-         StatementsNode(26...29)(
-           [CallNode(26...29)(
-              nil,
-              nil,
-              (26...29),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         (31...34)
-       ),
-       (31...34)
-     ),
-     UnlessNode(36...66)(
-       (36...42),
-       CallNode(43...46)(nil, nil, (43...46), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(48...51)(
-         [CallNode(48...51)(nil, nil, (48...51), nil, nil, nil, nil, 2, "bar")]
-       ),
-       ElseNode(53...66)(
-         (53...57),
-         StatementsNode(58...61)(
-           [CallNode(58...61)(
-              nil,
-              nil,
-              (58...61),
-              nil,
-              nil,
-              nil,
-              nil,
-              2,
-              "baz"
-            )]
-         ),
-         (63...66)
-       ),
-       (63...66)
-     )]
-  )
-)
+@ ProgramNode (location: (0...66))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...66))
+    └── body: (length: 2)
+        ├── @ UnlessNode (location: (0...34))
+        │   ├── keyword_loc: (0...6) = "unless"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (7...10))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (7...10) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (16...19))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (16...19))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (16...19) = "bar"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "bar"
+        │   ├── consequent:
+        │   │   @ ElseNode (location: (21...34))
+        │   │   ├── else_keyword_loc: (21...25) = "else"
+        │   │   ├── statements:
+        │   │   │   @ StatementsNode (location: (26...29))
+        │   │   │   └── body: (length: 1)
+        │   │   │       └── @ CallNode (location: (26...29))
+        │   │   │           ├── receiver: ∅
+        │   │   │           ├── call_operator_loc: ∅
+        │   │   │           ├── message_loc: (26...29) = "baz"
+        │   │   │           ├── opening_loc: ∅
+        │   │   │           ├── arguments: ∅
+        │   │   │           ├── closing_loc: ∅
+        │   │   │           ├── block: ∅
+        │   │   │           ├── flags: variable_call
+        │   │   │           └── name: "baz"
+        │   │   └── end_keyword_loc: (31...34) = "end"
+        │   └── end_keyword_loc: (31...34) = "end"
+        └── @ UnlessNode (location: (36...66))
+            ├── keyword_loc: (36...42) = "unless"
+            ├── predicate:
+            │   @ CallNode (location: (43...46))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (43...46) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (48...51))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (48...51))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (48...51) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── consequent:
+            │   @ ElseNode (location: (53...66))
+            │   ├── else_keyword_loc: (53...57) = "else"
+            │   ├── statements:
+            │   │   @ StatementsNode (location: (58...61))
+            │   │   └── body: (length: 1)
+            │   │       └── @ CallNode (location: (58...61))
+            │   │           ├── receiver: ∅
+            │   │           ├── call_operator_loc: ∅
+            │   │           ├── message_loc: (58...61) = "baz"
+            │   │           ├── opening_loc: ∅
+            │   │           ├── arguments: ∅
+            │   │           ├── closing_loc: ∅
+            │   │           ├── block: ∅
+            │   │           ├── flags: variable_call
+            │   │           └── name: "baz"
+            │   └── end_keyword_loc: (63...66) = "end"
+            └── end_keyword_loc: (63...66) = "end"
diff --git a/test/yarp/snapshots/whitequark/unless_mod.txt b/test/yarp/snapshots/whitequark/unless_mod.txt
index 8f2306aa6c..427a950c45 100644
--- a/test/yarp/snapshots/whitequark/unless_mod.txt
+++ b/test/yarp/snapshots/whitequark/unless_mod.txt
@@ -1,14 +1,33 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [UnlessNode(0...14)(
-       (4...10),
-       CallNode(11...14)(nil, nil, (11...14), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(0...3)(
-         [CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "bar")]
-       ),
-       nil,
-       nil
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ UnlessNode (location: (0...14))
+            ├── keyword_loc: (4...10) = "unless"
+            ├── predicate:
+            │   @ CallNode (location: (11...14))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (11...14) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (0...3))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (0...3))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (0...3) = "bar"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "bar"
+            ├── consequent: ∅
+            └── end_keyword_loc: ∅
diff --git a/test/yarp/snapshots/whitequark/until.txt b/test/yarp/snapshots/whitequark/until.txt
index 5a40a615bd..4b46825aee 100644
--- a/test/yarp/snapshots/whitequark/until.txt
+++ b/test/yarp/snapshots/whitequark/until.txt
@@ -1,43 +1,61 @@
-ProgramNode(0...42)(
-  [],
-  StatementsNode(0...42)(
-    [UntilNode(0...21)(
-       (0...5),
-       (18...21),
-       CallNode(6...9)(nil, nil, (6...9), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(13...17)(
-         [CallNode(13...17)(
-            nil,
-            nil,
-            (13...17),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "meth"
-          )]
-       ),
-       0
-     ),
-     UntilNode(23...42)(
-       (23...28),
-       (39...42),
-       CallNode(29...32)(nil, nil, (29...32), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(34...38)(
-         [CallNode(34...38)(
-            nil,
-            nil,
-            (34...38),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "meth"
-          )]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...42))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...42))
+    └── body: (length: 2)
+        ├── @ UntilNode (location: (0...21))
+        │   ├── keyword_loc: (0...5) = "until"
+        │   ├── closing_loc: (18...21) = "end"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (6...9))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (6...9) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (13...17))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (13...17))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (13...17) = "meth"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "meth"
+        │   └── flags: 
+        └── @ UntilNode (location: (23...42))
+            ├── keyword_loc: (23...28) = "until"
+            ├── closing_loc: (39...42) = "end"
+            ├── predicate:
+            │   @ CallNode (location: (29...32))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (29...32) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (34...38))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (34...38))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (34...38) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/until_mod.txt b/test/yarp/snapshots/whitequark/until_mod.txt
index ab5acaf4b3..5eb0f34fb9 100644
--- a/test/yarp/snapshots/whitequark/until_mod.txt
+++ b/test/yarp/snapshots/whitequark/until_mod.txt
@@ -1,14 +1,33 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [UntilNode(0...14)(
-       (5...10),
-       nil,
-       CallNode(11...14)(nil, nil, (11...14), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(0...4)(
-         [CallNode(0...4)(nil, nil, (0...4), nil, nil, nil, nil, 2, "meth")]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ UntilNode (location: (0...14))
+            ├── keyword_loc: (5...10) = "until"
+            ├── closing_loc: ∅
+            ├── predicate:
+            │   @ CallNode (location: (11...14))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (11...14) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (0...4))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (0...4))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (0...4) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/until_post.txt b/test/yarp/snapshots/whitequark/until_post.txt
index 87a0fa3a12..6750200540 100644
--- a/test/yarp/snapshots/whitequark/until_post.txt
+++ b/test/yarp/snapshots/whitequark/until_post.txt
@@ -1,33 +1,42 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [UntilNode(0...24)(
-       (15...20),
-       nil,
-       CallNode(21...24)(nil, nil, (21...24), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(0...14)(
-         [BeginNode(0...14)(
-            (0...5),
-            StatementsNode(6...10)(
-              [CallNode(6...10)(
-                 nil,
-                 nil,
-                 (6...10),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "meth"
-               )]
-            ),
-            nil,
-            nil,
-            nil,
-            (11...14)
-          )]
-       ),
-       1
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ UntilNode (location: (0...24))
+            ├── keyword_loc: (15...20) = "until"
+            ├── closing_loc: ∅
+            ├── predicate:
+            │   @ CallNode (location: (21...24))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (21...24) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (0...14))
+            │   └── body: (length: 1)
+            │       └── @ BeginNode (location: (0...14))
+            │           ├── begin_keyword_loc: (0...5) = "begin"
+            │           ├── statements:
+            │           │   @ StatementsNode (location: (6...10))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (6...10))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (6...10) = "meth"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "meth"
+            │           ├── rescue_clause: ∅
+            │           ├── else_clause: ∅
+            │           ├── ensure_clause: ∅
+            │           └── end_keyword_loc: (11...14) = "end"
+            └── flags: begin_modifier
diff --git a/test/yarp/snapshots/whitequark/var_and_asgn.txt b/test/yarp/snapshots/whitequark/var_and_asgn.txt
index a613761d87..565ceaa0f3 100644
--- a/test/yarp/snapshots/whitequark/var_and_asgn.txt
+++ b/test/yarp/snapshots/whitequark/var_and_asgn.txt
@@ -1,12 +1,12 @@
-ProgramNode(0...7)(
-  [:a],
-  StatementsNode(0...7)(
-    [LocalVariableAndWriteNode(0...7)(
-       (0...1),
-       (2...5),
-       IntegerNode(6...7)(),
-       :a,
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ LocalVariableAndWriteNode (location: (0...7))
+            ├── name_loc: (0...1) = "a"
+            ├── operator_loc: (2...5) = "&&="
+            ├── value:
+            │   @ IntegerNode (location: (6...7))
+            ├── name: :a
+            └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/var_op_asgn.txt b/test/yarp/snapshots/whitequark/var_op_asgn.txt
index 48abb4ebf6..efbad402d9 100644
--- a/test/yarp/snapshots/whitequark/var_op_asgn.txt
+++ b/test/yarp/snapshots/whitequark/var_op_asgn.txt
@@ -1,49 +1,49 @@
-ProgramNode(0...53)(
-  [:a],
-  StatementsNode(0...53)(
-    [ClassVariableOperatorWriteNode(0...11)(
-       :@@var,
-       (0...5),
-       (6...8),
-       IntegerNode(9...11)(),
-       :|
-     ),
-     InstanceVariableOperatorWriteNode(13...20)(
-       :@a,
-       (13...15),
-       (16...18),
-       IntegerNode(19...20)(),
-       :|
-     ),
-     LocalVariableOperatorWriteNode(22...28)(
-       (22...23),
-       (24...26),
-       IntegerNode(27...28)(),
-       :a,
-       :+,
-       0
-     ),
-     DefNode(30...53)(
-       :a,
-       (34...35),
-       nil,
-       nil,
-       StatementsNode(37...48)(
-         [ClassVariableOperatorWriteNode(37...48)(
-            :@@var,
-            (37...42),
-            (43...45),
-            IntegerNode(46...48)(),
-            :|
-          )]
-       ),
-       [],
-       (30...33),
-       nil,
-       nil,
-       nil,
-       nil,
-       (50...53)
-     )]
-  )
-)
+@ ProgramNode (location: (0...53))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...53))
+    └── body: (length: 4)
+        ├── @ ClassVariableOperatorWriteNode (location: (0...11))
+        │   ├── name: :@@var
+        │   ├── name_loc: (0...5) = "@@var"
+        │   ├── operator_loc: (6...8) = "|="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (9...11))
+        │   └── operator: :|
+        ├── @ InstanceVariableOperatorWriteNode (location: (13...20))
+        │   ├── name: :@a
+        │   ├── name_loc: (13...15) = "@a"
+        │   ├── operator_loc: (16...18) = "|="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (19...20))
+        │   └── operator: :|
+        ├── @ LocalVariableOperatorWriteNode (location: (22...28))
+        │   ├── name_loc: (22...23) = "a"
+        │   ├── operator_loc: (24...26) = "+="
+        │   ├── value:
+        │   │   @ IntegerNode (location: (27...28))
+        │   ├── name: :a
+        │   ├── operator: :+
+        │   └── depth: 0
+        └── @ DefNode (location: (30...53))
+            ├── name: :a
+            ├── name_loc: (34...35) = "a"
+            ├── receiver: ∅
+            ├── parameters: ∅
+            ├── body:
+            │   @ StatementsNode (location: (37...48))
+            │   └── body: (length: 1)
+            │       └── @ ClassVariableOperatorWriteNode (location: (37...48))
+            │           ├── name: :@@var
+            │           ├── name_loc: (37...42) = "@@var"
+            │           ├── operator_loc: (43...45) = "|="
+            │           ├── value:
+            │           │   @ IntegerNode (location: (46...48))
+            │           └── operator: :|
+            ├── locals: []
+            ├── def_keyword_loc: (30...33) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: ∅
+            ├── rparen_loc: ∅
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (50...53) = "end"
diff --git a/test/yarp/snapshots/whitequark/var_op_asgn_cmd.txt b/test/yarp/snapshots/whitequark/var_op_asgn_cmd.txt
index 21c1fb6e10..b7771e50f9 100644
--- a/test/yarp/snapshots/whitequark/var_op_asgn_cmd.txt
+++ b/test/yarp/snapshots/whitequark/var_op_asgn_cmd.txt
@@ -1,23 +1,27 @@
-ProgramNode(0...12)(
-  [:foo],
-  StatementsNode(0...12)(
-    [LocalVariableOperatorWriteNode(0...12)(
-       (0...3),
-       (4...6),
-       CallNode(7...12)(
-         nil,
-         nil,
-         (7...8),
-         nil,
-         ArgumentsNode(9...12)([LocalVariableReadNode(9...12)(:foo, 0)]),
-         nil,
-         nil,
-         0,
-         "m"
-       ),
-       :foo,
-       :+,
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...12))
+├── locals: [:foo]
+└── statements:
+    @ StatementsNode (location: (0...12))
+    └── body: (length: 1)
+        └── @ LocalVariableOperatorWriteNode (location: (0...12))
+            ├── name_loc: (0...3) = "foo"
+            ├── operator_loc: (4...6) = "+="
+            ├── value:
+            │   @ CallNode (location: (7...12))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (7...8) = "m"
+            │   ├── opening_loc: ∅
+            │   ├── arguments:
+            │   │   @ ArgumentsNode (location: (9...12))
+            │   │   └── arguments: (length: 1)
+            │   │       └── @ LocalVariableReadNode (location: (9...12))
+            │   │           ├── name: :foo
+            │   │           └── depth: 0
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: 
+            │   └── name: "m"
+            ├── name: :foo
+            ├── operator: :+
+            └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/var_or_asgn.txt b/test/yarp/snapshots/whitequark/var_or_asgn.txt
index 3fb56b7f4a..41793f1e21 100644
--- a/test/yarp/snapshots/whitequark/var_or_asgn.txt
+++ b/test/yarp/snapshots/whitequark/var_or_asgn.txt
@@ -1,12 +1,12 @@
-ProgramNode(0...7)(
-  [:a],
-  StatementsNode(0...7)(
-    [LocalVariableOrWriteNode(0...7)(
-       (0...1),
-       (2...5),
-       IntegerNode(6...7)(),
-       :a,
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...7))
+├── locals: [:a]
+└── statements:
+    @ StatementsNode (location: (0...7))
+    └── body: (length: 1)
+        └── @ LocalVariableOrWriteNode (location: (0...7))
+            ├── name_loc: (0...1) = "a"
+            ├── operator_loc: (2...5) = "||="
+            ├── value:
+            │   @ IntegerNode (location: (6...7))
+            ├── name: :a
+            └── depth: 0
diff --git a/test/yarp/snapshots/whitequark/when_multi.txt b/test/yarp/snapshots/whitequark/when_multi.txt
index 7a5c41f747..8cda6a88e1 100644
--- a/test/yarp/snapshots/whitequark/when_multi.txt
+++ b/test/yarp/snapshots/whitequark/when_multi.txt
@@ -1,29 +1,47 @@
-ProgramNode(0...37)(
-  [],
-  StatementsNode(0...37)(
-    [CaseNode(0...37)(
-       CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "foo"),
-       [WhenNode(10...32)(
-          (10...14),
-          [StringNode(15...20)((15...16), (16...19), (19...20), "bar"),
-           StringNode(22...27)((22...23), (23...26), (26...27), "baz")],
-          StatementsNode(29...32)(
-            [CallNode(29...32)(
-               nil,
-               nil,
-               (29...32),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          )
-        )],
-       nil,
-       (0...4),
-       (34...37)
-     )]
-  )
-)
+@ ProgramNode (location: (0...37))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...37))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...37))
+            ├── predicate:
+            │   @ CallNode (location: (5...8))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (5...8) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (10...32))
+            │       ├── keyword_loc: (10...14) = "when"
+            │       ├── conditions: (length: 2)
+            │       │   ├── @ StringNode (location: (15...20))
+            │       │   │   ├── opening_loc: (15...16) = "'"
+            │       │   │   ├── content_loc: (16...19) = "bar"
+            │       │   │   ├── closing_loc: (19...20) = "'"
+            │       │   │   └── unescaped: "bar"
+            │       │   └── @ StringNode (location: (22...27))
+            │       │       ├── opening_loc: (22...23) = "'"
+            │       │       ├── content_loc: (23...26) = "baz"
+            │       │       ├── closing_loc: (26...27) = "'"
+            │       │       └── unescaped: "baz"
+            │       └── statements:
+            │           @ StatementsNode (location: (29...32))
+            │           └── body: (length: 1)
+            │               └── @ CallNode (location: (29...32))
+            │                   ├── receiver: ∅
+            │                   ├── call_operator_loc: ∅
+            │                   ├── message_loc: (29...32) = "bar"
+            │                   ├── opening_loc: ∅
+            │                   ├── arguments: ∅
+            │                   ├── closing_loc: ∅
+            │                   ├── block: ∅
+            │                   ├── flags: variable_call
+            │                   └── name: "bar"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (34...37) = "end"
diff --git a/test/yarp/snapshots/whitequark/when_splat.txt b/test/yarp/snapshots/whitequark/when_splat.txt
index 88d2115eb4..215dc88845 100644
--- a/test/yarp/snapshots/whitequark/when_splat.txt
+++ b/test/yarp/snapshots/whitequark/when_splat.txt
@@ -1,60 +1,68 @@
-ProgramNode(0...43)(
-  [],
-  StatementsNode(0...43)(
-    [CaseNode(0...43)(
-       CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "foo"),
-       [WhenNode(10...27)(
-          (10...14),
-          [IntegerNode(15...16)(),
-           SplatNode(18...22)(
-             (18...19),
-             CallNode(19...22)(
-               nil,
-               nil,
-               (19...22),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "baz"
-             )
-           )],
-          StatementsNode(24...27)(
-            [CallNode(24...27)(
-               nil,
-               nil,
-               (24...27),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          )
-        ),
-        WhenNode(29...38)(
-          (29...33),
-          [SplatNode(34...38)(
-             (34...35),
-             CallNode(35...38)(
-               nil,
-               nil,
-               (35...38),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "foo"
-             )
-           )],
-          nil
-        )],
-       nil,
-       (0...4),
-       (40...43)
-     )]
-  )
-)
+@ ProgramNode (location: (0...43))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...43))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...43))
+            ├── predicate:
+            │   @ CallNode (location: (5...8))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (5...8) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── conditions: (length: 2)
+            │   ├── @ WhenNode (location: (10...27))
+            │   │   ├── keyword_loc: (10...14) = "when"
+            │   │   ├── conditions: (length: 2)
+            │   │   │   ├── @ IntegerNode (location: (15...16))
+            │   │   │   └── @ SplatNode (location: (18...22))
+            │   │   │       ├── operator_loc: (18...19) = "*"
+            │   │   │       └── expression:
+            │   │   │           @ CallNode (location: (19...22))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (19...22) = "baz"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "baz"
+            │   │   └── statements:
+            │   │       @ StatementsNode (location: (24...27))
+            │   │       └── body: (length: 1)
+            │   │           └── @ CallNode (location: (24...27))
+            │   │               ├── receiver: ∅
+            │   │               ├── call_operator_loc: ∅
+            │   │               ├── message_loc: (24...27) = "bar"
+            │   │               ├── opening_loc: ∅
+            │   │               ├── arguments: ∅
+            │   │               ├── closing_loc: ∅
+            │   │               ├── block: ∅
+            │   │               ├── flags: variable_call
+            │   │               └── name: "bar"
+            │   └── @ WhenNode (location: (29...38))
+            │       ├── keyword_loc: (29...33) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ SplatNode (location: (34...38))
+            │       │       ├── operator_loc: (34...35) = "*"
+            │       │       └── expression:
+            │       │           @ CallNode (location: (35...38))
+            │       │           ├── receiver: ∅
+            │       │           ├── call_operator_loc: ∅
+            │       │           ├── message_loc: (35...38) = "foo"
+            │       │           ├── opening_loc: ∅
+            │       │           ├── arguments: ∅
+            │       │           ├── closing_loc: ∅
+            │       │           ├── block: ∅
+            │       │           ├── flags: variable_call
+            │       │           └── name: "foo"
+            │       └── statements: ∅
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (40...43) = "end"
diff --git a/test/yarp/snapshots/whitequark/when_then.txt b/test/yarp/snapshots/whitequark/when_then.txt
index 8c08e6d8e5..7e2d6227b3 100644
--- a/test/yarp/snapshots/whitequark/when_then.txt
+++ b/test/yarp/snapshots/whitequark/when_then.txt
@@ -1,28 +1,42 @@
-ProgramNode(0...34)(
-  [],
-  StatementsNode(0...34)(
-    [CaseNode(0...34)(
-       CallNode(5...8)(nil, nil, (5...8), nil, nil, nil, nil, 2, "foo"),
-       [WhenNode(10...29)(
-          (10...14),
-          [StringNode(15...20)((15...16), (16...19), (19...20), "bar")],
-          StatementsNode(26...29)(
-            [CallNode(26...29)(
-               nil,
-               nil,
-               (26...29),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          )
-        )],
-       nil,
-       (0...4),
-       (31...34)
-     )]
-  )
-)
+@ ProgramNode (location: (0...34))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...34))
+    └── body: (length: 1)
+        └── @ CaseNode (location: (0...34))
+            ├── predicate:
+            │   @ CallNode (location: (5...8))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (5...8) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── conditions: (length: 1)
+            │   └── @ WhenNode (location: (10...29))
+            │       ├── keyword_loc: (10...14) = "when"
+            │       ├── conditions: (length: 1)
+            │       │   └── @ StringNode (location: (15...20))
+            │       │       ├── opening_loc: (15...16) = "'"
+            │       │       ├── content_loc: (16...19) = "bar"
+            │       │       ├── closing_loc: (19...20) = "'"
+            │       │       └── unescaped: "bar"
+            │       └── statements:
+            │           @ StatementsNode (location: (26...29))
+            │           └── body: (length: 1)
+            │               └── @ CallNode (location: (26...29))
+            │                   ├── receiver: ∅
+            │                   ├── call_operator_loc: ∅
+            │                   ├── message_loc: (26...29) = "bar"
+            │                   ├── opening_loc: ∅
+            │                   ├── arguments: ∅
+            │                   ├── closing_loc: ∅
+            │                   ├── block: ∅
+            │                   ├── flags: variable_call
+            │                   └── name: "bar"
+            ├── consequent: ∅
+            ├── case_keyword_loc: (0...4) = "case"
+            └── end_keyword_loc: (31...34) = "end"
diff --git a/test/yarp/snapshots/whitequark/while.txt b/test/yarp/snapshots/whitequark/while.txt
index 7529b6e1bc..9a853a127a 100644
--- a/test/yarp/snapshots/whitequark/while.txt
+++ b/test/yarp/snapshots/whitequark/while.txt
@@ -1,43 +1,61 @@
-ProgramNode(0...42)(
-  [],
-  StatementsNode(0...42)(
-    [WhileNode(0...21)(
-       (0...5),
-       (18...21),
-       CallNode(6...9)(nil, nil, (6...9), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(13...17)(
-         [CallNode(13...17)(
-            nil,
-            nil,
-            (13...17),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "meth"
-          )]
-       ),
-       0
-     ),
-     WhileNode(23...42)(
-       (23...28),
-       (39...42),
-       CallNode(29...32)(nil, nil, (29...32), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(34...38)(
-         [CallNode(34...38)(
-            nil,
-            nil,
-            (34...38),
-            nil,
-            nil,
-            nil,
-            nil,
-            2,
-            "meth"
-          )]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...42))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...42))
+    └── body: (length: 2)
+        ├── @ WhileNode (location: (0...21))
+        │   ├── keyword_loc: (0...5) = "while"
+        │   ├── closing_loc: (18...21) = "end"
+        │   ├── predicate:
+        │   │   @ CallNode (location: (6...9))
+        │   │   ├── receiver: ∅
+        │   │   ├── call_operator_loc: ∅
+        │   │   ├── message_loc: (6...9) = "foo"
+        │   │   ├── opening_loc: ∅
+        │   │   ├── arguments: ∅
+        │   │   ├── closing_loc: ∅
+        │   │   ├── block: ∅
+        │   │   ├── flags: variable_call
+        │   │   └── name: "foo"
+        │   ├── statements:
+        │   │   @ StatementsNode (location: (13...17))
+        │   │   └── body: (length: 1)
+        │   │       └── @ CallNode (location: (13...17))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (13...17) = "meth"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "meth"
+        │   └── flags: 
+        └── @ WhileNode (location: (23...42))
+            ├── keyword_loc: (23...28) = "while"
+            ├── closing_loc: (39...42) = "end"
+            ├── predicate:
+            │   @ CallNode (location: (29...32))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (29...32) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (34...38))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (34...38))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (34...38) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/while_mod.txt b/test/yarp/snapshots/whitequark/while_mod.txt
index 2f0ade7006..c8a592429e 100644
--- a/test/yarp/snapshots/whitequark/while_mod.txt
+++ b/test/yarp/snapshots/whitequark/while_mod.txt
@@ -1,14 +1,33 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [WhileNode(0...14)(
-       (5...10),
-       nil,
-       CallNode(11...14)(nil, nil, (11...14), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(0...4)(
-         [CallNode(0...4)(nil, nil, (0...4), nil, nil, nil, nil, 2, "meth")]
-       ),
-       0
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ WhileNode (location: (0...14))
+            ├── keyword_loc: (5...10) = "while"
+            ├── closing_loc: ∅
+            ├── predicate:
+            │   @ CallNode (location: (11...14))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (11...14) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (0...4))
+            │   └── body: (length: 1)
+            │       └── @ CallNode (location: (0...4))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (0...4) = "meth"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "meth"
+            └── flags: 
diff --git a/test/yarp/snapshots/whitequark/while_post.txt b/test/yarp/snapshots/whitequark/while_post.txt
index 1b2169107a..2ad5e8a84e 100644
--- a/test/yarp/snapshots/whitequark/while_post.txt
+++ b/test/yarp/snapshots/whitequark/while_post.txt
@@ -1,33 +1,42 @@
-ProgramNode(0...24)(
-  [],
-  StatementsNode(0...24)(
-    [WhileNode(0...24)(
-       (15...20),
-       nil,
-       CallNode(21...24)(nil, nil, (21...24), nil, nil, nil, nil, 2, "foo"),
-       StatementsNode(0...14)(
-         [BeginNode(0...14)(
-            (0...5),
-            StatementsNode(6...10)(
-              [CallNode(6...10)(
-                 nil,
-                 nil,
-                 (6...10),
-                 nil,
-                 nil,
-                 nil,
-                 nil,
-                 2,
-                 "meth"
-               )]
-            ),
-            nil,
-            nil,
-            nil,
-            (11...14)
-          )]
-       ),
-       1
-     )]
-  )
-)
+@ ProgramNode (location: (0...24))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...24))
+    └── body: (length: 1)
+        └── @ WhileNode (location: (0...24))
+            ├── keyword_loc: (15...20) = "while"
+            ├── closing_loc: ∅
+            ├── predicate:
+            │   @ CallNode (location: (21...24))
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── message_loc: (21...24) = "foo"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── block: ∅
+            │   ├── flags: variable_call
+            │   └── name: "foo"
+            ├── statements:
+            │   @ StatementsNode (location: (0...14))
+            │   └── body: (length: 1)
+            │       └── @ BeginNode (location: (0...14))
+            │           ├── begin_keyword_loc: (0...5) = "begin"
+            │           ├── statements:
+            │           │   @ StatementsNode (location: (6...10))
+            │           │   └── body: (length: 1)
+            │           │       └── @ CallNode (location: (6...10))
+            │           │           ├── receiver: ∅
+            │           │           ├── call_operator_loc: ∅
+            │           │           ├── message_loc: (6...10) = "meth"
+            │           │           ├── opening_loc: ∅
+            │           │           ├── arguments: ∅
+            │           │           ├── closing_loc: ∅
+            │           │           ├── block: ∅
+            │           │           ├── flags: variable_call
+            │           │           └── name: "meth"
+            │           ├── rescue_clause: ∅
+            │           ├── else_clause: ∅
+            │           ├── ensure_clause: ∅
+            │           └── end_keyword_loc: (11...14) = "end"
+            └── flags: begin_modifier
diff --git a/test/yarp/snapshots/whitequark/xstring_interp.txt b/test/yarp/snapshots/whitequark/xstring_interp.txt
index 39d4a12c98..5b70aaaa3e 100644
--- a/test/yarp/snapshots/whitequark/xstring_interp.txt
+++ b/test/yarp/snapshots/whitequark/xstring_interp.txt
@@ -1,18 +1,35 @@
-ProgramNode(0...14)(
-  [],
-  StatementsNode(0...14)(
-    [InterpolatedXStringNode(0...14)(
-       (0...1),
-       [StringNode(1...4)(nil, (1...4), nil, "foo"),
-        EmbeddedStatementsNode(4...10)(
-          (4...6),
-          StatementsNode(6...9)(
-            [CallNode(6...9)(nil, nil, (6...9), nil, nil, nil, nil, 2, "bar")]
-          ),
-          (9...10)
-        ),
-        StringNode(10...13)(nil, (10...13), nil, "baz")],
-       (13...14)
-     )]
-  )
-)
+@ ProgramNode (location: (0...14))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...14))
+    └── body: (length: 1)
+        └── @ InterpolatedXStringNode (location: (0...14))
+            ├── opening_loc: (0...1) = "`"
+            ├── parts: (length: 3)
+            │   ├── @ StringNode (location: (1...4))
+            │   │   ├── opening_loc: ∅
+            │   │   ├── content_loc: (1...4) = "foo"
+            │   │   ├── closing_loc: ∅
+            │   │   └── unescaped: "foo"
+            │   ├── @ EmbeddedStatementsNode (location: (4...10))
+            │   │   ├── opening_loc: (4...6) = "\#{"
+            │   │   ├── statements:
+            │   │   │   @ StatementsNode (location: (6...9))
+            │   │   │   └── body: (length: 1)
+            │   │   │       └── @ CallNode (location: (6...9))
+            │   │   │           ├── receiver: ∅
+            │   │   │           ├── call_operator_loc: ∅
+            │   │   │           ├── message_loc: (6...9) = "bar"
+            │   │   │           ├── opening_loc: ∅
+            │   │   │           ├── arguments: ∅
+            │   │   │           ├── closing_loc: ∅
+            │   │   │           ├── block: ∅
+            │   │   │           ├── flags: variable_call
+            │   │   │           └── name: "bar"
+            │   │   └── closing_loc: (9...10) = "}"
+            │   └── @ StringNode (location: (10...13))
+            │       ├── opening_loc: ∅
+            │       ├── content_loc: (10...13) = "baz"
+            │       ├── closing_loc: ∅
+            │       └── unescaped: "baz"
+            └── closing_loc: (13...14) = "`"
diff --git a/test/yarp/snapshots/whitequark/xstring_plain.txt b/test/yarp/snapshots/whitequark/xstring_plain.txt
index 61515d89d9..4e73240258 100644
--- a/test/yarp/snapshots/whitequark/xstring_plain.txt
+++ b/test/yarp/snapshots/whitequark/xstring_plain.txt
@@ -1,6 +1,10 @@
-ProgramNode(0...8)(
-  [],
-  StatementsNode(0...8)(
-    [XStringNode(0...8)((0...1), (1...7), (7...8), "foobar")]
-  )
-)
+@ ProgramNode (location: (0...8))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...8))
+    └── body: (length: 1)
+        └── @ XStringNode (location: (0...8))
+            ├── opening_loc: (0...1) = "`"
+            ├── content_loc: (1...7) = "foobar"
+            ├── closing_loc: (7...8) = "`"
+            └── unescaped: "foobar"
diff --git a/test/yarp/snapshots/whitequark/yield.txt b/test/yarp/snapshots/whitequark/yield.txt
index ae0c2140a3..0331729a8a 100644
--- a/test/yarp/snapshots/whitequark/yield.txt
+++ b/test/yarp/snapshots/whitequark/yield.txt
@@ -1,23 +1,49 @@
-ProgramNode(0...37)(
-  [],
-  StatementsNode(0...37)(
-    [YieldNode(0...5)((0...5), nil, nil, nil),
-     YieldNode(7...16)(
-       (7...12),
-       nil,
-       ArgumentsNode(13...16)(
-         [CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo")]
-       ),
-       nil
-     ),
-     YieldNode(18...25)((18...23), (23...24), nil, (24...25)),
-     YieldNode(27...37)(
-       (27...32),
-       (32...33),
-       ArgumentsNode(33...36)(
-         [CallNode(33...36)(nil, nil, (33...36), nil, nil, nil, nil, 2, "foo")]
-       ),
-       (36...37)
-     )]
-  )
-)
+@ ProgramNode (location: (0...37))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...37))
+    └── body: (length: 4)
+        ├── @ YieldNode (location: (0...5))
+        │   ├── keyword_loc: (0...5) = "yield"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments: ∅
+        │   └── rparen_loc: ∅
+        ├── @ YieldNode (location: (7...16))
+        │   ├── keyword_loc: (7...12) = "yield"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (13...16))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ CallNode (location: (13...16))
+        │   │           ├── receiver: ∅
+        │   │           ├── call_operator_loc: ∅
+        │   │           ├── message_loc: (13...16) = "foo"
+        │   │           ├── opening_loc: ∅
+        │   │           ├── arguments: ∅
+        │   │           ├── closing_loc: ∅
+        │   │           ├── block: ∅
+        │   │           ├── flags: variable_call
+        │   │           └── name: "foo"
+        │   └── rparen_loc: ∅
+        ├── @ YieldNode (location: (18...25))
+        │   ├── keyword_loc: (18...23) = "yield"
+        │   ├── lparen_loc: (23...24) = "("
+        │   ├── arguments: ∅
+        │   └── rparen_loc: (24...25) = ")"
+        └── @ YieldNode (location: (27...37))
+            ├── keyword_loc: (27...32) = "yield"
+            ├── lparen_loc: (32...33) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (33...36))
+            │   └── arguments: (length: 1)
+            │       └── @ CallNode (location: (33...36))
+            │           ├── receiver: ∅
+            │           ├── call_operator_loc: ∅
+            │           ├── message_loc: (33...36) = "foo"
+            │           ├── opening_loc: ∅
+            │           ├── arguments: ∅
+            │           ├── closing_loc: ∅
+            │           ├── block: ∅
+            │           ├── flags: variable_call
+            │           └── name: "foo"
+            └── rparen_loc: (36...37) = ")"
diff --git a/test/yarp/snapshots/whitequark/zsuper.txt b/test/yarp/snapshots/whitequark/zsuper.txt
index b9f92d0055..0055d2d590 100644
--- a/test/yarp/snapshots/whitequark/zsuper.txt
+++ b/test/yarp/snapshots/whitequark/zsuper.txt
@@ -1,4 +1,7 @@
-ProgramNode(0...5)(
-  [],
-  StatementsNode(0...5)([ForwardingSuperNode(0...5)(nil)])
-)
+@ ProgramNode (location: (0...5))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...5))
+    └── body: (length: 1)
+        └── @ ForwardingSuperNode (location: (0...5))
+            └── block: ∅
diff --git a/test/yarp/snapshots/xstring.txt b/test/yarp/snapshots/xstring.txt
index fe7d5de5a0..199f4586fa 100644
--- a/test/yarp/snapshots/xstring.txt
+++ b/test/yarp/snapshots/xstring.txt
@@ -1,31 +1,50 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [XStringNode(0...7)((0...3), (3...6), (6...7), "foo"),
-     InterpolatedXStringNode(9...25)(
-       (9...10),
-       [StringNode(10...14)(nil, (10...14), nil, "foo "),
-        EmbeddedStatementsNode(14...20)(
-          (14...16),
-          StatementsNode(16...19)(
-            [CallNode(16...19)(
-               nil,
-               nil,
-               (16...19),
-               nil,
-               nil,
-               nil,
-               nil,
-               2,
-               "bar"
-             )]
-          ),
-          (19...20)
-        ),
-        StringNode(20...24)(nil, (20...24), nil, " baz")],
-       (24...25)
-     ),
-     XStringNode(27...33)((27...28), (28...32), (32...33), "foo"),
-     XStringNode(35...40)((35...36), (36...39), (39...40), "foo")]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 4)
+        ├── @ XStringNode (location: (0...7))
+        │   ├── opening_loc: (0...3) = "%x["
+        │   ├── content_loc: (3...6) = "foo"
+        │   ├── closing_loc: (6...7) = "]"
+        │   └── unescaped: "foo"
+        ├── @ InterpolatedXStringNode (location: (9...25))
+        │   ├── opening_loc: (9...10) = "`"
+        │   ├── parts: (length: 3)
+        │   │   ├── @ StringNode (location: (10...14))
+        │   │   │   ├── opening_loc: ∅
+        │   │   │   ├── content_loc: (10...14) = "foo "
+        │   │   │   ├── closing_loc: ∅
+        │   │   │   └── unescaped: "foo "
+        │   │   ├── @ EmbeddedStatementsNode (location: (14...20))
+        │   │   │   ├── opening_loc: (14...16) = "\#{"
+        │   │   │   ├── statements:
+        │   │   │   │   @ StatementsNode (location: (16...19))
+        │   │   │   │   └── body: (length: 1)
+        │   │   │   │       └── @ CallNode (location: (16...19))
+        │   │   │   │           ├── receiver: ∅
+        │   │   │   │           ├── call_operator_loc: ∅
+        │   │   │   │           ├── message_loc: (16...19) = "bar"
+        │   │   │   │           ├── opening_loc: ∅
+        │   │   │   │           ├── arguments: ∅
+        │   │   │   │           ├── closing_loc: ∅
+        │   │   │   │           ├── block: ∅
+        │   │   │   │           ├── flags: variable_call
+        │   │   │   │           └── name: "bar"
+        │   │   │   └── closing_loc: (19...20) = "}"
+        │   │   └── @ StringNode (location: (20...24))
+        │   │       ├── opening_loc: ∅
+        │   │       ├── content_loc: (20...24) = " baz"
+        │   │       ├── closing_loc: ∅
+        │   │       └── unescaped: " baz"
+        │   └── closing_loc: (24...25) = "`"
+        ├── @ XStringNode (location: (27...33))
+        │   ├── opening_loc: (27...28) = "`"
+        │   ├── content_loc: (28...32) = "f\\oo"
+        │   ├── closing_loc: (32...33) = "`"
+        │   └── unescaped: "foo"
+        └── @ XStringNode (location: (35...40))
+            ├── opening_loc: (35...36) = "`"
+            ├── content_loc: (36...39) = "foo"
+            ├── closing_loc: (39...40) = "`"
+            └── unescaped: "foo"
diff --git a/test/yarp/snapshots/yield.txt b/test/yarp/snapshots/yield.txt
index 9dba03e7b7..eb200ca45b 100644
--- a/test/yarp/snapshots/yield.txt
+++ b/test/yarp/snapshots/yield.txt
@@ -1,23 +1,33 @@
-ProgramNode(0...40)(
-  [],
-  StatementsNode(0...40)(
-    [YieldNode(0...5)((0...5), nil, nil, nil),
-     YieldNode(7...14)((7...12), (12...13), nil, (13...14)),
-     YieldNode(16...24)(
-       (16...21),
-       (21...22),
-       ArgumentsNode(22...23)([IntegerNode(22...23)()]),
-       (23...24)
-     ),
-     YieldNode(26...40)(
-       (26...31),
-       (31...32),
-       ArgumentsNode(32...39)(
-         [IntegerNode(32...33)(),
-          IntegerNode(35...36)(),
-          IntegerNode(38...39)()]
-       ),
-       (39...40)
-     )]
-  )
-)
+@ ProgramNode (location: (0...40))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (0...40))
+    └── body: (length: 4)
+        ├── @ YieldNode (location: (0...5))
+        │   ├── keyword_loc: (0...5) = "yield"
+        │   ├── lparen_loc: ∅
+        │   ├── arguments: ∅
+        │   └── rparen_loc: ∅
+        ├── @ YieldNode (location: (7...14))
+        │   ├── keyword_loc: (7...12) = "yield"
+        │   ├── lparen_loc: (12...13) = "("
+        │   ├── arguments: ∅
+        │   └── rparen_loc: (13...14) = ")"
+        ├── @ YieldNode (location: (16...24))
+        │   ├── keyword_loc: (16...21) = "yield"
+        │   ├── lparen_loc: (21...22) = "("
+        │   ├── arguments:
+        │   │   @ ArgumentsNode (location: (22...23))
+        │   │   └── arguments: (length: 1)
+        │   │       └── @ IntegerNode (location: (22...23))
+        │   └── rparen_loc: (23...24) = ")"
+        └── @ YieldNode (location: (26...40))
+            ├── keyword_loc: (26...31) = "yield"
+            ├── lparen_loc: (31...32) = "("
+            ├── arguments:
+            │   @ ArgumentsNode (location: (32...39))
+            │   └── arguments: (length: 3)
+            │       ├── @ IntegerNode (location: (32...33))
+            │       ├── @ IntegerNode (location: (35...36))
+            │       └── @ IntegerNode (location: (38...39))
+            └── rparen_loc: (39...40) = ")"