Remove incorrectly committed snapshots

3 files changed, 0 insertions, 1256 deletions

diff --git a/test/prism/snapshots/it_indirect_writes.txt b/test/prism/snapshots/it_indirect_writes.txt
deleted file mode 100644
index 165aececc6..0000000000
--- a/test/prism/snapshots/it_indirect_writes.txt
+++ /dev/null
@@ -1,419 +0,0 @@
-@ ProgramNode (location: (1,0)-(23,24))
-├── flags: ∅
-├── locals: []
-└── statements:
-    @ StatementsNode (location: (1,0)-(23,24))
-    ├── flags: ∅
-    └── body: (length: 12)
-        ├── @ CallNode (location: (1,0)-(1,15))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (1,0)-(1,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (1,4)-(1,15))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (1,6)-(1,13))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 1)
-        │       │       └── @ LocalVariableOperatorWriteNode (location: (1,6)-(1,13))
-        │       │           ├── flags: newline
-        │       │           ├── name_loc: (1,6)-(1,8) = "it"
-        │       │           ├── binary_operator_loc: (1,9)-(1,11) = "+="
-        │       │           ├── value:
-        │       │           │   @ IntegerNode (location: (1,12)-(1,13))
-        │       │           │   ├── flags: static_literal, decimal
-        │       │           │   └── value: 1
-        │       │           ├── name: :it
-        │       │           ├── binary_operator: :+
-        │       │           └── depth: 0
-        │       ├── opening_loc: (1,4)-(1,5) = "{"
-        │       └── closing_loc: (1,14)-(1,15) = "}"
-        ├── @ CallNode (location: (3,0)-(3,16))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (3,0)-(3,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (3,4)-(3,16))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (3,6)-(3,14))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 1)
-        │       │       └── @ LocalVariableOrWriteNode (location: (3,6)-(3,14))
-        │       │           ├── flags: newline
-        │       │           ├── name_loc: (3,6)-(3,8) = "it"
-        │       │           ├── operator_loc: (3,9)-(3,12) = "||="
-        │       │           ├── value:
-        │       │           │   @ IntegerNode (location: (3,13)-(3,14))
-        │       │           │   ├── flags: static_literal, decimal
-        │       │           │   └── value: 1
-        │       │           ├── name: :it
-        │       │           └── depth: 0
-        │       ├── opening_loc: (3,4)-(3,5) = "{"
-        │       └── closing_loc: (3,15)-(3,16) = "}"
-        ├── @ CallNode (location: (5,0)-(5,16))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (5,0)-(5,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (5,4)-(5,16))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (5,6)-(5,14))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 1)
-        │       │       └── @ LocalVariableAndWriteNode (location: (5,6)-(5,14))
-        │       │           ├── flags: newline
-        │       │           ├── name_loc: (5,6)-(5,8) = "it"
-        │       │           ├── operator_loc: (5,9)-(5,12) = "&&="
-        │       │           ├── value:
-        │       │           │   @ IntegerNode (location: (5,13)-(5,14))
-        │       │           │   ├── flags: static_literal, decimal
-        │       │           │   └── value: 1
-        │       │           ├── name: :it
-        │       │           └── depth: 0
-        │       ├── opening_loc: (5,4)-(5,5) = "{"
-        │       └── closing_loc: (5,15)-(5,16) = "}"
-        ├── @ CallNode (location: (7,0)-(7,19))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (7,0)-(7,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (7,4)-(7,19))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters:
-        │       │   @ ItParametersNode (location: (7,4)-(7,19))
-        │       │   └── flags: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (7,6)-(7,17))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 2)
-        │       │       ├── @ ItLocalVariableReadNode (location: (7,6)-(7,8))
-        │       │       │   └── flags: newline
-        │       │       └── @ LocalVariableOperatorWriteNode (location: (7,10)-(7,17))
-        │       │           ├── flags: newline
-        │       │           ├── name_loc: (7,10)-(7,12) = "it"
-        │       │           ├── binary_operator_loc: (7,13)-(7,15) = "+="
-        │       │           ├── value:
-        │       │           │   @ IntegerNode (location: (7,16)-(7,17))
-        │       │           │   ├── flags: static_literal, decimal
-        │       │           │   └── value: 1
-        │       │           ├── name: :it
-        │       │           ├── binary_operator: :+
-        │       │           └── depth: 0
-        │       ├── opening_loc: (7,4)-(7,5) = "{"
-        │       └── closing_loc: (7,18)-(7,19) = "}"
-        ├── @ CallNode (location: (9,0)-(9,20))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (9,0)-(9,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (9,4)-(9,20))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters:
-        │       │   @ ItParametersNode (location: (9,4)-(9,20))
-        │       │   └── flags: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (9,6)-(9,18))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 2)
-        │       │       ├── @ ItLocalVariableReadNode (location: (9,6)-(9,8))
-        │       │       │   └── flags: newline
-        │       │       └── @ LocalVariableOrWriteNode (location: (9,10)-(9,18))
-        │       │           ├── flags: newline
-        │       │           ├── name_loc: (9,10)-(9,12) = "it"
-        │       │           ├── operator_loc: (9,13)-(9,16) = "||="
-        │       │           ├── value:
-        │       │           │   @ IntegerNode (location: (9,17)-(9,18))
-        │       │           │   ├── flags: static_literal, decimal
-        │       │           │   └── value: 1
-        │       │           ├── name: :it
-        │       │           └── depth: 0
-        │       ├── opening_loc: (9,4)-(9,5) = "{"
-        │       └── closing_loc: (9,19)-(9,20) = "}"
-        ├── @ CallNode (location: (11,0)-(11,20))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (11,0)-(11,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (11,4)-(11,20))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters:
-        │       │   @ ItParametersNode (location: (11,4)-(11,20))
-        │       │   └── flags: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (11,6)-(11,18))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 2)
-        │       │       ├── @ ItLocalVariableReadNode (location: (11,6)-(11,8))
-        │       │       │   └── flags: newline
-        │       │       └── @ LocalVariableAndWriteNode (location: (11,10)-(11,18))
-        │       │           ├── flags: newline
-        │       │           ├── name_loc: (11,10)-(11,12) = "it"
-        │       │           ├── operator_loc: (11,13)-(11,16) = "&&="
-        │       │           ├── value:
-        │       │           │   @ IntegerNode (location: (11,17)-(11,18))
-        │       │           │   ├── flags: static_literal, decimal
-        │       │           │   └── value: 1
-        │       │           ├── name: :it
-        │       │           └── depth: 0
-        │       ├── opening_loc: (11,4)-(11,5) = "{"
-        │       └── closing_loc: (11,19)-(11,20) = "}"
-        ├── @ CallNode (location: (13,0)-(13,19))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (13,0)-(13,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (13,4)-(13,19))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (13,6)-(13,17))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 2)
-        │       │       ├── @ LocalVariableOperatorWriteNode (location: (13,6)-(13,13))
-        │       │       │   ├── flags: newline
-        │       │       │   ├── name_loc: (13,6)-(13,8) = "it"
-        │       │       │   ├── binary_operator_loc: (13,9)-(13,11) = "+="
-        │       │       │   ├── value:
-        │       │       │   │   @ IntegerNode (location: (13,12)-(13,13))
-        │       │       │   │   ├── flags: static_literal, decimal
-        │       │       │   │   └── value: 1
-        │       │       │   ├── name: :it
-        │       │       │   ├── binary_operator: :+
-        │       │       │   └── depth: 0
-        │       │       └── @ LocalVariableReadNode (location: (13,15)-(13,17))
-        │       │           ├── flags: newline
-        │       │           ├── name: :it
-        │       │           └── depth: 0
-        │       ├── opening_loc: (13,4)-(13,5) = "{"
-        │       └── closing_loc: (13,18)-(13,19) = "}"
-        ├── @ CallNode (location: (15,0)-(15,20))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (15,0)-(15,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (15,4)-(15,20))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (15,6)-(15,18))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 2)
-        │       │       ├── @ LocalVariableOrWriteNode (location: (15,6)-(15,14))
-        │       │       │   ├── flags: newline
-        │       │       │   ├── name_loc: (15,6)-(15,8) = "it"
-        │       │       │   ├── operator_loc: (15,9)-(15,12) = "||="
-        │       │       │   ├── value:
-        │       │       │   │   @ IntegerNode (location: (15,13)-(15,14))
-        │       │       │   │   ├── flags: static_literal, decimal
-        │       │       │   │   └── value: 1
-        │       │       │   ├── name: :it
-        │       │       │   └── depth: 0
-        │       │       └── @ LocalVariableReadNode (location: (15,16)-(15,18))
-        │       │           ├── flags: newline
-        │       │           ├── name: :it
-        │       │           └── depth: 0
-        │       ├── opening_loc: (15,4)-(15,5) = "{"
-        │       └── closing_loc: (15,19)-(15,20) = "}"
-        ├── @ CallNode (location: (17,0)-(17,20))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (17,0)-(17,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (17,4)-(17,20))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (17,6)-(17,18))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 2)
-        │       │       ├── @ LocalVariableAndWriteNode (location: (17,6)-(17,14))
-        │       │       │   ├── flags: newline
-        │       │       │   ├── name_loc: (17,6)-(17,8) = "it"
-        │       │       │   ├── operator_loc: (17,9)-(17,12) = "&&="
-        │       │       │   ├── value:
-        │       │       │   │   @ IntegerNode (location: (17,13)-(17,14))
-        │       │       │   │   ├── flags: static_literal, decimal
-        │       │       │   │   └── value: 1
-        │       │       │   ├── name: :it
-        │       │       │   └── depth: 0
-        │       │       └── @ LocalVariableReadNode (location: (17,16)-(17,18))
-        │       │           ├── flags: newline
-        │       │           ├── name: :it
-        │       │           └── depth: 0
-        │       ├── opening_loc: (17,4)-(17,5) = "{"
-        │       └── closing_loc: (17,19)-(17,20) = "}"
-        ├── @ CallNode (location: (19,0)-(19,23))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (19,0)-(19,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (19,4)-(19,23))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters:
-        │       │   @ ItParametersNode (location: (19,4)-(19,23))
-        │       │   └── flags: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (19,6)-(19,21))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 3)
-        │       │       ├── @ ItLocalVariableReadNode (location: (19,6)-(19,8))
-        │       │       │   └── flags: newline
-        │       │       ├── @ LocalVariableOperatorWriteNode (location: (19,10)-(19,17))
-        │       │       │   ├── flags: newline
-        │       │       │   ├── name_loc: (19,10)-(19,12) = "it"
-        │       │       │   ├── binary_operator_loc: (19,13)-(19,15) = "+="
-        │       │       │   ├── value:
-        │       │       │   │   @ IntegerNode (location: (19,16)-(19,17))
-        │       │       │   │   ├── flags: static_literal, decimal
-        │       │       │   │   └── value: 1
-        │       │       │   ├── name: :it
-        │       │       │   ├── binary_operator: :+
-        │       │       │   └── depth: 0
-        │       │       └── @ LocalVariableReadNode (location: (19,19)-(19,21))
-        │       │           ├── flags: newline
-        │       │           ├── name: :it
-        │       │           └── depth: 0
-        │       ├── opening_loc: (19,4)-(19,5) = "{"
-        │       └── closing_loc: (19,22)-(19,23) = "}"
-        ├── @ CallNode (location: (21,0)-(21,24))
-        │   ├── flags: newline, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :tap
-        │   ├── message_loc: (21,0)-(21,3) = "tap"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   └── block:
-        │       @ BlockNode (location: (21,4)-(21,24))
-        │       ├── flags: ∅
-        │       ├── locals: [:it]
-        │       ├── parameters:
-        │       │   @ ItParametersNode (location: (21,4)-(21,24))
-        │       │   └── flags: ∅
-        │       ├── body:
-        │       │   @ StatementsNode (location: (21,6)-(21,22))
-        │       │   ├── flags: ∅
-        │       │   └── body: (length: 3)
-        │       │       ├── @ ItLocalVariableReadNode (location: (21,6)-(21,8))
-        │       │       │   └── flags: newline
-        │       │       ├── @ LocalVariableOrWriteNode (location: (21,10)-(21,18))
-        │       │       │   ├── flags: newline
-        │       │       │   ├── name_loc: (21,10)-(21,12) = "it"
-        │       │       │   ├── operator_loc: (21,13)-(21,16) = "||="
-        │       │       │   ├── value:
-        │       │       │   │   @ IntegerNode (location: (21,17)-(21,18))
-        │       │       │   │   ├── flags: static_literal, decimal
-        │       │       │   │   └── value: 1
-        │       │       │   ├── name: :it
-        │       │       │   └── depth: 0
-        │       │       └── @ LocalVariableReadNode (location: (21,20)-(21,22))
-        │       │           ├── flags: newline
-        │       │           ├── name: :it
-        │       │           └── depth: 0
-        │       ├── opening_loc: (21,4)-(21,5) = "{"
-        │       └── closing_loc: (21,23)-(21,24) = "}"
-        └── @ CallNode (location: (23,0)-(23,24))
-            ├── flags: newline, ignore_visibility
-            ├── receiver: ∅
-            ├── call_operator_loc: ∅
-            ├── name: :tap
-            ├── message_loc: (23,0)-(23,3) = "tap"
-            ├── opening_loc: ∅
-            ├── arguments: ∅
-            ├── closing_loc: ∅
-            └── block:
-                @ BlockNode (location: (23,4)-(23,24))
-                ├── flags: ∅
-                ├── locals: [:it]
-                ├── parameters:
-                │   @ ItParametersNode (location: (23,4)-(23,24))
-                │   └── flags: ∅
-                ├── body:
-                │   @ StatementsNode (location: (23,6)-(23,22))
-                │   ├── flags: ∅
-                │   └── body: (length: 3)
-                │       ├── @ ItLocalVariableReadNode (location: (23,6)-(23,8))
-                │       │   └── flags: newline
-                │       ├── @ LocalVariableAndWriteNode (location: (23,10)-(23,18))
-                │       │   ├── flags: newline
-                │       │   ├── name_loc: (23,10)-(23,12) = "it"
-                │       │   ├── operator_loc: (23,13)-(23,16) = "&&="
-                │       │   ├── value:
-                │       │   │   @ IntegerNode (location: (23,17)-(23,18))
-                │       │   │   ├── flags: static_literal, decimal
-                │       │   │   └── value: 1
-                │       │   ├── name: :it
-                │       │   └── depth: 0
-                │       └── @ LocalVariableReadNode (location: (23,20)-(23,22))
-                │           ├── flags: newline
-                │           ├── name: :it
-                │           └── depth: 0
-                ├── opening_loc: (23,4)-(23,5) = "{"
-                └── closing_loc: (23,23)-(23,24) = "}"
diff --git a/test/prism/snapshots/rescue_modifier.txt b/test/prism/snapshots/rescue_modifier.txt
deleted file mode 100644
index 0a27a3bb49..0000000000
--- a/test/prism/snapshots/rescue_modifier.txt
+++ /dev/null
@@ -1,230 +0,0 @@
-@ ProgramNode (location: (1,0)-(7,23))
-├── flags: ∅
-├── locals: [:a]
-└── statements:
-    @ StatementsNode (location: (1,0)-(7,23))
-    ├── flags: ∅
-    └── body: (length: 4)
-        ├── @ IfNode (location: (1,0)-(1,15))
-        │   ├── flags: newline
-        │   ├── if_keyword_loc: (1,11)-(1,13) = "if"
-        │   ├── predicate:
-        │   │   @ CallNode (location: (1,14)-(1,15))
-        │   │   ├── flags: variable_call, ignore_visibility
-        │   │   ├── receiver: ∅
-        │   │   ├── call_operator_loc: ∅
-        │   │   ├── name: :c
-        │   │   ├── message_loc: (1,14)-(1,15) = "c"
-        │   │   ├── opening_loc: ∅
-        │   │   ├── arguments: ∅
-        │   │   ├── closing_loc: ∅
-        │   │   └── block: ∅
-        │   ├── then_keyword_loc: ∅
-        │   ├── statements:
-        │   │   @ StatementsNode (location: (1,0)-(1,10))
-        │   │   ├── flags: ∅
-        │   │   └── body: (length: 1)
-        │   │       └── @ RescueModifierNode (location: (1,0)-(1,10))
-        │   │           ├── flags: newline
-        │   │           ├── expression:
-        │   │           │   @ CallNode (location: (1,0)-(1,1))
-        │   │           │   ├── flags: variable_call, ignore_visibility
-        │   │           │   ├── receiver: ∅
-        │   │           │   ├── call_operator_loc: ∅
-        │   │           │   ├── name: :a
-        │   │           │   ├── message_loc: (1,0)-(1,1) = "a"
-        │   │           │   ├── opening_loc: ∅
-        │   │           │   ├── arguments: ∅
-        │   │           │   ├── closing_loc: ∅
-        │   │           │   └── block: ∅
-        │   │           ├── keyword_loc: (1,2)-(1,8) = "rescue"
-        │   │           └── rescue_expression:
-        │   │               @ CallNode (location: (1,9)-(1,10))
-        │   │               ├── flags: variable_call, ignore_visibility
-        │   │               ├── receiver: ∅
-        │   │               ├── call_operator_loc: ∅
-        │   │               ├── name: :b
-        │   │               ├── message_loc: (1,9)-(1,10) = "b"
-        │   │               ├── opening_loc: ∅
-        │   │               ├── arguments: ∅
-        │   │               ├── closing_loc: ∅
-        │   │               └── block: ∅
-        │   ├── subsequent: ∅
-        │   └── end_keyword_loc: ∅
-        ├── @ IfNode (location: (3,0)-(3,19))
-        │   ├── flags: newline
-        │   ├── if_keyword_loc: (3,15)-(3,17) = "if"
-        │   ├── predicate:
-        │   │   @ CallNode (location: (3,18)-(3,19))
-        │   │   ├── flags: variable_call, ignore_visibility
-        │   │   ├── receiver: ∅
-        │   │   ├── call_operator_loc: ∅
-        │   │   ├── name: :d
-        │   │   ├── message_loc: (3,18)-(3,19) = "d"
-        │   │   ├── opening_loc: ∅
-        │   │   ├── arguments: ∅
-        │   │   ├── closing_loc: ∅
-        │   │   └── block: ∅
-        │   ├── then_keyword_loc: ∅
-        │   ├── statements:
-        │   │   @ StatementsNode (location: (3,0)-(3,14))
-        │   │   ├── flags: ∅
-        │   │   └── body: (length: 1)
-        │   │       └── @ LocalVariableWriteNode (location: (3,0)-(3,14))
-        │   │           ├── flags: newline
-        │   │           ├── name: :a
-        │   │           ├── depth: 0
-        │   │           ├── name_loc: (3,0)-(3,1) = "a"
-        │   │           ├── value:
-        │   │           │   @ RescueModifierNode (location: (3,4)-(3,14))
-        │   │           │   ├── flags: ∅
-        │   │           │   ├── expression:
-        │   │           │   │   @ CallNode (location: (3,4)-(3,5))
-        │   │           │   │   ├── flags: variable_call, ignore_visibility
-        │   │           │   │   ├── receiver: ∅
-        │   │           │   │   ├── call_operator_loc: ∅
-        │   │           │   │   ├── name: :b
-        │   │           │   │   ├── message_loc: (3,4)-(3,5) = "b"
-        │   │           │   │   ├── opening_loc: ∅
-        │   │           │   │   ├── arguments: ∅
-        │   │           │   │   ├── closing_loc: ∅
-        │   │           │   │   └── block: ∅
-        │   │           │   ├── keyword_loc: (3,6)-(3,12) = "rescue"
-        │   │           │   └── rescue_expression:
-        │   │           │       @ CallNode (location: (3,13)-(3,14))
-        │   │           │       ├── flags: variable_call, ignore_visibility
-        │   │           │       ├── receiver: ∅
-        │   │           │       ├── call_operator_loc: ∅
-        │   │           │       ├── name: :c
-        │   │           │       ├── message_loc: (3,13)-(3,14) = "c"
-        │   │           │       ├── opening_loc: ∅
-        │   │           │       ├── arguments: ∅
-        │   │           │       ├── closing_loc: ∅
-        │   │           │       └── block: ∅
-        │   │           └── operator_loc: (3,2)-(3,3) = "="
-        │   ├── subsequent: ∅
-        │   └── end_keyword_loc: ∅
-        ├── @ IfNode (location: (5,0)-(5,20))
-        │   ├── flags: newline
-        │   ├── if_keyword_loc: (5,16)-(5,18) = "if"
-        │   ├── predicate:
-        │   │   @ CallNode (location: (5,19)-(5,20))
-        │   │   ├── flags: variable_call, ignore_visibility
-        │   │   ├── receiver: ∅
-        │   │   ├── call_operator_loc: ∅
-        │   │   ├── name: :d
-        │   │   ├── message_loc: (5,19)-(5,20) = "d"
-        │   │   ├── opening_loc: ∅
-        │   │   ├── arguments: ∅
-        │   │   ├── closing_loc: ∅
-        │   │   └── block: ∅
-        │   ├── then_keyword_loc: ∅
-        │   ├── statements:
-        │   │   @ StatementsNode (location: (5,0)-(5,15))
-        │   │   ├── flags: ∅
-        │   │   └── body: (length: 1)
-        │   │       └── @ MultiWriteNode (location: (5,0)-(5,15))
-        │   │           ├── flags: newline
-        │   │           ├── lefts: (length: 1)
-        │   │           │   └── @ LocalVariableTargetNode (location: (5,0)-(5,1))
-        │   │           │       ├── flags: ∅
-        │   │           │       ├── name: :a
-        │   │           │       └── depth: 0
-        │   │           ├── rest:
-        │   │           │   @ ImplicitRestNode (location: (5,1)-(5,2))
-        │   │           │   └── flags: ∅
-        │   │           ├── rights: (length: 0)
-        │   │           ├── lparen_loc: ∅
-        │   │           ├── rparen_loc: ∅
-        │   │           ├── operator_loc: (5,3)-(5,4) = "="
-        │   │           └── value:
-        │   │               @ RescueModifierNode (location: (5,5)-(5,15))
-        │   │               ├── flags: ∅
-        │   │               ├── expression:
-        │   │               │   @ CallNode (location: (5,5)-(5,6))
-        │   │               │   ├── flags: variable_call, ignore_visibility
-        │   │               │   ├── receiver: ∅
-        │   │               │   ├── call_operator_loc: ∅
-        │   │               │   ├── name: :b
-        │   │               │   ├── message_loc: (5,5)-(5,6) = "b"
-        │   │               │   ├── opening_loc: ∅
-        │   │               │   ├── arguments: ∅
-        │   │               │   ├── closing_loc: ∅
-        │   │               │   └── block: ∅
-        │   │               ├── keyword_loc: (5,7)-(5,13) = "rescue"
-        │   │               └── rescue_expression:
-        │   │                   @ CallNode (location: (5,14)-(5,15))
-        │   │                   ├── flags: variable_call, ignore_visibility
-        │   │                   ├── receiver: ∅
-        │   │                   ├── call_operator_loc: ∅
-        │   │                   ├── name: :c
-        │   │                   ├── message_loc: (5,14)-(5,15) = "c"
-        │   │                   ├── opening_loc: ∅
-        │   │                   ├── arguments: ∅
-        │   │                   ├── closing_loc: ∅
-        │   │                   └── block: ∅
-        │   ├── subsequent: ∅
-        │   └── end_keyword_loc: ∅
-        └── @ IfNode (location: (7,0)-(7,23))
-            ├── flags: newline
-            ├── if_keyword_loc: (7,19)-(7,21) = "if"
-            ├── predicate:
-            │   @ CallNode (location: (7,22)-(7,23))
-            │   ├── flags: variable_call, ignore_visibility
-            │   ├── receiver: ∅
-            │   ├── call_operator_loc: ∅
-            │   ├── name: :d
-            │   ├── message_loc: (7,22)-(7,23) = "d"
-            │   ├── opening_loc: ∅
-            │   ├── arguments: ∅
-            │   ├── closing_loc: ∅
-            │   └── block: ∅
-            ├── then_keyword_loc: ∅
-            ├── statements:
-            │   @ StatementsNode (location: (7,0)-(7,18))
-            │   ├── flags: ∅
-            │   └── body: (length: 1)
-            │       └── @ DefNode (location: (7,0)-(7,18))
-            │           ├── flags: newline
-            │           ├── name: :a
-            │           ├── name_loc: (7,4)-(7,5) = "a"
-            │           ├── receiver: ∅
-            │           ├── parameters: ∅
-            │           ├── body:
-            │           │   @ StatementsNode (location: (7,8)-(7,18))
-            │           │   ├── flags: ∅
-            │           │   └── body: (length: 1)
-            │           │       └── @ RescueModifierNode (location: (7,8)-(7,18))
-            │           │           ├── flags: ∅
-            │           │           ├── expression:
-            │           │           │   @ CallNode (location: (7,8)-(7,9))
-            │           │           │   ├── flags: variable_call, ignore_visibility
-            │           │           │   ├── receiver: ∅
-            │           │           │   ├── call_operator_loc: ∅
-            │           │           │   ├── name: :b
-            │           │           │   ├── message_loc: (7,8)-(7,9) = "b"
-            │           │           │   ├── opening_loc: ∅
-            │           │           │   ├── arguments: ∅
-            │           │           │   ├── closing_loc: ∅
-            │           │           │   └── block: ∅
-            │           │           ├── keyword_loc: (7,10)-(7,16) = "rescue"
-            │           │           └── rescue_expression:
-            │           │               @ CallNode (location: (7,17)-(7,18))
-            │           │               ├── flags: variable_call, ignore_visibility
-            │           │               ├── receiver: ∅
-            │           │               ├── call_operator_loc: ∅
-            │           │               ├── name: :c
-            │           │               ├── message_loc: (7,17)-(7,18) = "c"
-            │           │               ├── opening_loc: ∅
-            │           │               ├── arguments: ∅
-            │           │               ├── closing_loc: ∅
-            │           │               └── block: ∅
-            │           ├── locals: []
-            │           ├── def_keyword_loc: (7,0)-(7,3) = "def"
-            │           ├── operator_loc: ∅
-            │           ├── lparen_loc: ∅
-            │           ├── rparen_loc: ∅
-            │           ├── equal_loc: (7,6)-(7,7) = "="
-            │           └── end_keyword_loc: ∅
-            ├── subsequent: ∅
-            └── end_keyword_loc: ∅
diff --git a/test/prism/snapshots/strings.txt b/test/prism/snapshots/strings.txt
deleted file mode 100644
index 0e281ba152..0000000000
--- a/test/prism/snapshots/strings.txt
+++ /dev/null
@@ -1,607 +0,0 @@
-@ ProgramNode (location: (1,0)-(119,15))
-├── flags: ∅
-├── locals: []
-└── statements:
-    @ StatementsNode (location: (1,0)-(119,15))
-    ├── flags: ∅
-    └── body: (length: 54)
-        ├── @ StringNode (location: (1,0)-(1,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (1,0)-(1,2) = "%%"
-        │   ├── content_loc: (1,2)-(1,5) = "abc"
-        │   ├── closing_loc: (1,5)-(1,6) = "%"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (3,0)-(3,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (3,0)-(3,2) = "%^"
-        │   ├── content_loc: (3,2)-(3,5) = "abc"
-        │   ├── closing_loc: (3,5)-(3,6) = "^"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (5,0)-(5,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (5,0)-(5,2) = "%&"
-        │   ├── content_loc: (5,2)-(5,5) = "abc"
-        │   ├── closing_loc: (5,5)-(5,6) = "&"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (7,0)-(7,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (7,0)-(7,2) = "%*"
-        │   ├── content_loc: (7,2)-(7,5) = "abc"
-        │   ├── closing_loc: (7,5)-(7,6) = "*"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (9,0)-(9,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (9,0)-(9,2) = "%_"
-        │   ├── content_loc: (9,2)-(9,5) = "abc"
-        │   ├── closing_loc: (9,5)-(9,6) = "_"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (11,0)-(11,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (11,0)-(11,2) = "%+"
-        │   ├── content_loc: (11,2)-(11,5) = "abc"
-        │   ├── closing_loc: (11,5)-(11,6) = "+"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (13,0)-(13,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (13,0)-(13,2) = "%-"
-        │   ├── content_loc: (13,2)-(13,5) = "abc"
-        │   ├── closing_loc: (13,5)-(13,6) = "-"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (15,0)-(15,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (15,0)-(15,2) = "%:"
-        │   ├── content_loc: (15,2)-(15,5) = "abc"
-        │   ├── closing_loc: (15,5)-(15,6) = ":"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (17,0)-(17,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (17,0)-(17,2) = "%;"
-        │   ├── content_loc: (17,2)-(17,5) = "abc"
-        │   ├── closing_loc: (17,5)-(17,6) = ";"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (19,0)-(19,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (19,0)-(19,2) = "%'"
-        │   ├── content_loc: (19,2)-(19,5) = "abc"
-        │   ├── closing_loc: (19,5)-(19,6) = "'"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (21,0)-(21,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (21,0)-(21,2) = "%~"
-        │   ├── content_loc: (21,2)-(21,5) = "abc"
-        │   ├── closing_loc: (21,5)-(21,6) = "~"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (23,0)-(23,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (23,0)-(23,2) = "%?"
-        │   ├── content_loc: (23,2)-(23,5) = "abc"
-        │   ├── closing_loc: (23,5)-(23,6) = "?"
-        │   └── unescaped: "abc"
-        ├── @ ArrayNode (location: (25,0)-(25,8))
-        │   ├── flags: newline, static_literal
-        │   ├── elements: (length: 0)
-        │   ├── opening_loc: (25,0)-(25,3) = "%w{"
-        │   └── closing_loc: (25,7)-(25,8) = "}"
-        ├── @ StringNode (location: (27,0)-(27,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (27,0)-(27,2) = "%/"
-        │   ├── content_loc: (27,2)-(27,5) = "abc"
-        │   ├── closing_loc: (27,5)-(27,6) = "/"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (29,0)-(29,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (29,0)-(29,2) = "%`"
-        │   ├── content_loc: (29,2)-(29,5) = "abc"
-        │   ├── closing_loc: (29,5)-(29,6) = "`"
-        │   └── unescaped: "abc"
-        ├── @ InterpolatedStringNode (location: (31,0)-(31,8))
-        │   ├── flags: newline
-        │   ├── opening_loc: (31,0)-(31,1) = "\""
-        │   ├── parts: (length: 1)
-        │   │   └── @ EmbeddedVariableNode (location: (31,1)-(31,7))
-        │   │       ├── flags: ∅
-        │   │       ├── operator_loc: (31,1)-(31,2) = "#"
-        │   │       └── variable:
-        │   │           @ ClassVariableReadNode (location: (31,2)-(31,7))
-        │   │           ├── flags: ∅
-        │   │           └── name: :@@foo
-        │   └── closing_loc: (31,7)-(31,8) = "\""
-        ├── @ StringNode (location: (33,0)-(33,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (33,0)-(33,2) = "%\\"
-        │   ├── content_loc: (33,2)-(33,5) = "abc"
-        │   ├── closing_loc: (33,5)-(33,6) = "\\"
-        │   └── unescaped: "abc"
-        ├── @ InterpolatedStringNode (location: (35,0)-(35,17))
-        │   ├── flags: newline
-        │   ├── opening_loc: (35,0)-(35,2) = "%{"
-        │   ├── parts: (length: 3)
-        │   │   ├── @ StringNode (location: (35,2)-(35,6))
-        │   │   │   ├── flags: static_literal, frozen
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (35,2)-(35,6) = "aaa "
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "aaa "
-        │   │   ├── @ EmbeddedStatementsNode (location: (35,6)-(35,12))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: (35,6)-(35,8) = "\#{"
-        │   │   │   ├── statements:
-        │   │   │   │   @ StatementsNode (location: (35,8)-(35,11))
-        │   │   │   │   ├── flags: ∅
-        │   │   │   │   └── body: (length: 1)
-        │   │   │   │       └── @ CallNode (location: (35,8)-(35,11))
-        │   │   │   │           ├── flags: variable_call, ignore_visibility
-        │   │   │   │           ├── receiver: ∅
-        │   │   │   │           ├── call_operator_loc: ∅
-        │   │   │   │           ├── name: :bbb
-        │   │   │   │           ├── message_loc: (35,8)-(35,11) = "bbb"
-        │   │   │   │           ├── opening_loc: ∅
-        │   │   │   │           ├── arguments: ∅
-        │   │   │   │           ├── closing_loc: ∅
-        │   │   │   │           └── block: ∅
-        │   │   │   └── closing_loc: (35,11)-(35,12) = "}"
-        │   │   └── @ StringNode (location: (35,12)-(35,16))
-        │   │       ├── flags: static_literal, frozen
-        │   │       ├── opening_loc: ∅
-        │   │       ├── content_loc: (35,12)-(35,16) = " ccc"
-        │   │       ├── closing_loc: ∅
-        │   │       └── unescaped: " ccc"
-        │   └── closing_loc: (35,16)-(35,17) = "}"
-        ├── @ StringNode (location: (37,0)-(37,8))
-        │   ├── flags: newline
-        │   ├── opening_loc: (37,0)-(37,2) = "%["
-        │   ├── content_loc: (37,2)-(37,7) = "foo[]"
-        │   ├── closing_loc: (37,7)-(37,8) = "]"
-        │   └── unescaped: "foo[]"
-        ├── @ CallNode (location: (39,0)-(41,5))
-        │   ├── flags: newline
-        │   ├── receiver:
-        │   │   @ StringNode (location: (39,0)-(39,5))
-        │   │   ├── flags: ∅
-        │   │   ├── opening_loc: (39,0)-(39,1) = "\""
-        │   │   ├── content_loc: (39,1)-(39,4) = "foo"
-        │   │   ├── closing_loc: (39,4)-(39,5) = "\""
-        │   │   └── unescaped: "foo"
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :+
-        │   ├── message_loc: (39,6)-(39,7) = "+"
-        │   ├── opening_loc: ∅
-        │   ├── arguments:
-        │   │   @ ArgumentsNode (location: (41,0)-(41,5))
-        │   │   ├── flags: ∅
-        │   │   └── arguments: (length: 1)
-        │   │       └── @ StringNode (location: (41,0)-(41,5))
-        │   │           ├── flags: ∅
-        │   │           ├── opening_loc: (41,0)-(41,1) = "\""
-        │   │           ├── content_loc: (41,1)-(41,4) = "bar"
-        │   │           ├── closing_loc: (41,4)-(41,5) = "\""
-        │   │           └── unescaped: "bar"
-        │   ├── closing_loc: ∅
-        │   └── block: ∅
-        ├── @ StringNode (location: (43,0)-(46,1))
-        │   ├── flags: newline
-        │   ├── opening_loc: (43,0)-(43,1) = "\""
-        │   ├── content_loc: (43,1)-(46,0) = "\nfoo\\\nb\\nar\n"
-        │   ├── closing_loc: (46,0)-(46,1) = "\""
-        │   └── unescaped: "\nfoob\nar\n"
-        ├── @ StringNode (location: (48,0)-(48,7))
-        │   ├── flags: newline
-        │   ├── opening_loc: (48,0)-(48,3) = "%q{"
-        │   ├── content_loc: (48,3)-(48,6) = "abc"
-        │   ├── closing_loc: (48,6)-(48,7) = "}"
-        │   └── unescaped: "abc"
-        ├── @ SymbolNode (location: (50,0)-(50,7))
-        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
-        │   ├── opening_loc: (50,0)-(50,3) = "%s["
-        │   ├── value_loc: (50,3)-(50,6) = "abc"
-        │   ├── closing_loc: (50,6)-(50,7) = "]"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (52,0)-(52,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (52,0)-(52,2) = "%{"
-        │   ├── content_loc: (52,2)-(52,5) = "abc"
-        │   ├── closing_loc: (52,5)-(52,6) = "}"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (54,0)-(54,2))
-        │   ├── flags: newline
-        │   ├── opening_loc: (54,0)-(54,1) = "'"
-        │   ├── content_loc: (54,1)-(54,1) = ""
-        │   ├── closing_loc: (54,1)-(54,2) = "'"
-        │   └── unescaped: ""
-        ├── @ StringNode (location: (56,0)-(56,5))
-        │   ├── flags: newline
-        │   ├── opening_loc: (56,0)-(56,1) = "\""
-        │   ├── content_loc: (56,1)-(56,4) = "abc"
-        │   ├── closing_loc: (56,4)-(56,5) = "\""
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (58,0)-(58,7))
-        │   ├── flags: newline
-        │   ├── opening_loc: (58,0)-(58,1) = "\""
-        │   ├── content_loc: (58,1)-(58,6) = "\#@---"
-        │   ├── closing_loc: (58,6)-(58,7) = "\""
-        │   └── unescaped: "\#@---"
-        ├── @ InterpolatedStringNode (location: (60,0)-(60,16))
-        │   ├── flags: newline
-        │   ├── opening_loc: (60,0)-(60,1) = "\""
-        │   ├── parts: (length: 3)
-        │   │   ├── @ StringNode (location: (60,1)-(60,5))
-        │   │   │   ├── flags: static_literal, frozen
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (60,1)-(60,5) = "aaa "
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "aaa "
-        │   │   ├── @ EmbeddedStatementsNode (location: (60,5)-(60,11))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: (60,5)-(60,7) = "\#{"
-        │   │   │   ├── statements:
-        │   │   │   │   @ StatementsNode (location: (60,7)-(60,10))
-        │   │   │   │   ├── flags: ∅
-        │   │   │   │   └── body: (length: 1)
-        │   │   │   │       └── @ CallNode (location: (60,7)-(60,10))
-        │   │   │   │           ├── flags: variable_call, ignore_visibility
-        │   │   │   │           ├── receiver: ∅
-        │   │   │   │           ├── call_operator_loc: ∅
-        │   │   │   │           ├── name: :bbb
-        │   │   │   │           ├── message_loc: (60,7)-(60,10) = "bbb"
-        │   │   │   │           ├── opening_loc: ∅
-        │   │   │   │           ├── arguments: ∅
-        │   │   │   │           ├── closing_loc: ∅
-        │   │   │   │           └── block: ∅
-        │   │   │   └── closing_loc: (60,10)-(60,11) = "}"
-        │   │   └── @ StringNode (location: (60,11)-(60,15))
-        │   │       ├── flags: static_literal, frozen
-        │   │       ├── opening_loc: ∅
-        │   │       ├── content_loc: (60,11)-(60,15) = " ccc"
-        │   │       ├── closing_loc: ∅
-        │   │       └── unescaped: " ccc"
-        │   └── closing_loc: (60,15)-(60,16) = "\""
-        ├── @ StringNode (location: (62,0)-(62,5))
-        │   ├── flags: newline
-        │   ├── opening_loc: (62,0)-(62,1) = "'"
-        │   ├── content_loc: (62,1)-(62,4) = "abc"
-        │   ├── closing_loc: (62,4)-(62,5) = "'"
-        │   └── unescaped: "abc"
-        ├── @ ArrayNode (location: (64,0)-(64,9))
-        │   ├── flags: newline
-        │   ├── elements: (length: 3)
-        │   │   ├── @ StringNode (location: (64,3)-(64,4))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (64,3)-(64,4) = "a"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "a"
-        │   │   ├── @ StringNode (location: (64,5)-(64,6))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (64,5)-(64,6) = "b"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "b"
-        │   │   └── @ StringNode (location: (64,7)-(64,8))
-        │   │       ├── flags: ∅
-        │   │       ├── opening_loc: ∅
-        │   │       ├── content_loc: (64,7)-(64,8) = "c"
-        │   │       ├── closing_loc: ∅
-        │   │       └── unescaped: "c"
-        │   ├── opening_loc: (64,0)-(64,3) = "%w["
-        │   └── closing_loc: (64,8)-(64,9) = "]"
-        ├── @ ArrayNode (location: (66,0)-(66,17))
-        │   ├── flags: newline
-        │   ├── elements: (length: 3)
-        │   │   ├── @ StringNode (location: (66,3)-(66,6))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (66,3)-(66,6) = "a[]"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "a[]"
-        │   │   ├── @ StringNode (location: (66,7)-(66,12))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (66,7)-(66,12) = "b[[]]"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "b[[]]"
-        │   │   └── @ StringNode (location: (66,13)-(66,16))
-        │   │       ├── flags: ∅
-        │   │       ├── opening_loc: ∅
-        │   │       ├── content_loc: (66,13)-(66,16) = "c[]"
-        │   │       ├── closing_loc: ∅
-        │   │       └── unescaped: "c[]"
-        │   ├── opening_loc: (66,0)-(66,3) = "%w["
-        │   └── closing_loc: (66,16)-(66,17) = "]"
-        ├── @ ArrayNode (location: (68,0)-(68,18))
-        │   ├── flags: newline
-        │   ├── elements: (length: 2)
-        │   │   ├── @ StringNode (location: (68,3)-(68,11))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (68,3)-(68,11) = "foo\\ bar"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "foo bar"
-        │   │   └── @ StringNode (location: (68,12)-(68,17))
-        │   │       ├── flags: ∅
-        │   │       ├── opening_loc: ∅
-        │   │       ├── content_loc: (68,12)-(68,17) = "\\\#{1}"
-        │   │       ├── closing_loc: ∅
-        │   │       └── unescaped: "\\\#{1}"
-        │   ├── opening_loc: (68,0)-(68,3) = "%w["
-        │   └── closing_loc: (68,17)-(68,18) = "]"
-        ├── @ ArrayNode (location: (70,0)-(70,16))
-        │   ├── flags: newline
-        │   ├── elements: (length: 2)
-        │   │   ├── @ StringNode (location: (70,3)-(70,11))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (70,3)-(70,11) = "foo\\ bar"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "foo bar"
-        │   │   └── @ StringNode (location: (70,12)-(70,15))
-        │   │       ├── flags: ∅
-        │   │       ├── opening_loc: ∅
-        │   │       ├── content_loc: (70,12)-(70,15) = "baz"
-        │   │       ├── closing_loc: ∅
-        │   │       └── unescaped: "baz"
-        │   ├── opening_loc: (70,0)-(70,3) = "%w["
-        │   └── closing_loc: (70,15)-(70,16) = "]"
-        ├── @ ArrayNode (location: (72,0)-(72,14))
-        │   ├── flags: newline
-        │   ├── elements: (length: 3)
-        │   │   ├── @ StringNode (location: (72,3)-(72,4))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (72,3)-(72,4) = "a"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "a"
-        │   │   ├── @ InterpolatedStringNode (location: (72,5)-(72,11))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── parts: (length: 3)
-        │   │   │   │   ├── @ StringNode (location: (72,5)-(72,6))
-        │   │   │   │   │   ├── flags: static_literal, frozen
-        │   │   │   │   │   ├── opening_loc: ∅
-        │   │   │   │   │   ├── content_loc: (72,5)-(72,6) = "b"
-        │   │   │   │   │   ├── closing_loc: ∅
-        │   │   │   │   │   └── unescaped: "b"
-        │   │   │   │   ├── @ EmbeddedStatementsNode (location: (72,6)-(72,10))
-        │   │   │   │   │   ├── flags: ∅
-        │   │   │   │   │   ├── opening_loc: (72,6)-(72,8) = "\#{"
-        │   │   │   │   │   ├── statements:
-        │   │   │   │   │   │   @ StatementsNode (location: (72,8)-(72,9))
-        │   │   │   │   │   │   ├── flags: ∅
-        │   │   │   │   │   │   └── body: (length: 1)
-        │   │   │   │   │   │       └── @ CallNode (location: (72,8)-(72,9))
-        │   │   │   │   │   │           ├── flags: variable_call, ignore_visibility
-        │   │   │   │   │   │           ├── receiver: ∅
-        │   │   │   │   │   │           ├── call_operator_loc: ∅
-        │   │   │   │   │   │           ├── name: :c
-        │   │   │   │   │   │           ├── message_loc: (72,8)-(72,9) = "c"
-        │   │   │   │   │   │           ├── opening_loc: ∅
-        │   │   │   │   │   │           ├── arguments: ∅
-        │   │   │   │   │   │           ├── closing_loc: ∅
-        │   │   │   │   │   │           └── block: ∅
-        │   │   │   │   │   └── closing_loc: (72,9)-(72,10) = "}"
-        │   │   │   │   └── @ StringNode (location: (72,10)-(72,11))
-        │   │   │   │       ├── flags: static_literal, frozen
-        │   │   │   │       ├── opening_loc: ∅
-        │   │   │   │       ├── content_loc: (72,10)-(72,11) = "d"
-        │   │   │   │       ├── closing_loc: ∅
-        │   │   │   │       └── unescaped: "d"
-        │   │   │   └── closing_loc: ∅
-        │   │   └── @ StringNode (location: (72,12)-(72,13))
-        │   │       ├── flags: ∅
-        │   │       ├── opening_loc: ∅
-        │   │       ├── content_loc: (72,12)-(72,13) = "e"
-        │   │       ├── closing_loc: ∅
-        │   │       └── unescaped: "e"
-        │   ├── opening_loc: (72,0)-(72,3) = "%W["
-        │   └── closing_loc: (72,13)-(72,14) = "]"
-        ├── @ ArrayNode (location: (74,0)-(74,9))
-        │   ├── flags: newline
-        │   ├── elements: (length: 3)
-        │   │   ├── @ StringNode (location: (74,3)-(74,4))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (74,3)-(74,4) = "a"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "a"
-        │   │   ├── @ StringNode (location: (74,5)-(74,6))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (74,5)-(74,6) = "b"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "b"
-        │   │   └── @ StringNode (location: (74,7)-(74,8))
-        │   │       ├── flags: ∅
-        │   │       ├── opening_loc: ∅
-        │   │       ├── content_loc: (74,7)-(74,8) = "c"
-        │   │       ├── closing_loc: ∅
-        │   │       └── unescaped: "c"
-        │   ├── opening_loc: (74,0)-(74,3) = "%W["
-        │   └── closing_loc: (74,8)-(74,9) = "]"
-        ├── @ ArrayNode (location: (76,0)-(80,1))
-        │   ├── flags: newline
-        │   ├── elements: (length: 3)
-        │   │   ├── @ StringNode (location: (77,2)-(77,3))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (77,2)-(77,3) = "a"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "a"
-        │   │   ├── @ StringNode (location: (78,2)-(78,3))
-        │   │   │   ├── flags: ∅
-        │   │   │   ├── opening_loc: ∅
-        │   │   │   ├── content_loc: (78,2)-(78,3) = "b"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "b"
-        │   │   └── @ StringNode (location: (79,2)-(79,3))
-        │   │       ├── flags: ∅
-        │   │       ├── opening_loc: ∅
-        │   │       ├── content_loc: (79,2)-(79,3) = "c"
-        │   │       ├── closing_loc: ∅
-        │   │       └── unescaped: "c"
-        │   ├── opening_loc: (76,0)-(76,3) = "%w["
-        │   └── closing_loc: (80,0)-(80,1) = "]"
-        ├── @ StringNode (location: (82,0)-(82,15))
-        │   ├── flags: newline
-        │   ├── opening_loc: (82,0)-(82,1) = "'"
-        │   ├── content_loc: (82,1)-(82,14) = "\\' foo \\' bar"
-        │   ├── closing_loc: (82,14)-(82,15) = "'"
-        │   └── unescaped: "' foo ' bar"
-        ├── @ StringNode (location: (84,0)-(84,15))
-        │   ├── flags: newline
-        │   ├── opening_loc: (84,0)-(84,1) = "'"
-        │   ├── content_loc: (84,1)-(84,14) = "\\\\ foo \\\\ bar"
-        │   ├── closing_loc: (84,14)-(84,15) = "'"
-        │   └── unescaped: "\\ foo \\ bar"
-        ├── @ StringNode (location: (86,0)-(89,1))
-        │   ├── flags: newline
-        │   ├── opening_loc: (86,0)-(86,1) = "'"
-        │   ├── content_loc: (86,1)-(89,0) = "foo\\\nbar\\\\\nbaz\n"
-        │   ├── closing_loc: (89,0)-(89,1) = "'"
-        │   └── unescaped: "foo\\\nbar\\\nbaz\n"
-        ├── @ InterpolatedStringNode (location: (91,0)-(91,7))
-        │   ├── flags: newline
-        │   ├── opening_loc: (91,0)-(91,1) = "\""
-        │   ├── parts: (length: 1)
-        │   │   └── @ EmbeddedVariableNode (location: (91,1)-(91,6))
-        │   │       ├── flags: ∅
-        │   │       ├── operator_loc: (91,1)-(91,2) = "#"
-        │   │       └── variable:
-        │   │           @ GlobalVariableReadNode (location: (91,2)-(91,6))
-        │   │           ├── flags: ∅
-        │   │           └── name: :$foo
-        │   └── closing_loc: (91,6)-(91,7) = "\""
-        ├── @ InterpolatedStringNode (location: (93,0)-(93,7))
-        │   ├── flags: newline
-        │   ├── opening_loc: (93,0)-(93,1) = "\""
-        │   ├── parts: (length: 1)
-        │   │   └── @ EmbeddedVariableNode (location: (93,1)-(93,6))
-        │   │       ├── flags: ∅
-        │   │       ├── operator_loc: (93,1)-(93,2) = "#"
-        │   │       └── variable:
-        │   │           @ InstanceVariableReadNode (location: (93,2)-(93,6))
-        │   │           ├── flags: ∅
-        │   │           └── name: :@foo
-        │   └── closing_loc: (93,6)-(93,7) = "\""
-        ├── @ StringNode (location: (95,0)-(95,15))
-        │   ├── flags: newline
-        │   ├── opening_loc: (95,0)-(95,1) = "\""
-        │   ├── content_loc: (95,1)-(95,14) = "\\x7 \\x23 \\x61"
-        │   ├── closing_loc: (95,14)-(95,15) = "\""
-        │   └── unescaped: "\a # a"
-        ├── @ StringNode (location: (97,0)-(97,13))
-        │   ├── flags: newline
-        │   ├── opening_loc: (97,0)-(97,1) = "\""
-        │   ├── content_loc: (97,1)-(97,12) = "\\7 \\43 \\141"
-        │   ├── closing_loc: (97,12)-(97,13) = "\""
-        │   └── unescaped: "\a # a"
-        ├── @ StringNode (location: (99,0)-(99,17))
-        │   ├── flags: newline, forced_utf8_encoding
-        │   ├── opening_loc: (99,0)-(99,1) = "\""
-        │   ├── content_loc: (99,1)-(99,16) = "ち\\xE3\\x81\\xFF"
-        │   ├── closing_loc: (99,16)-(99,17) = "\""
-        │   └── unescaped: "ち\xE3\x81\xFF"
-        ├── @ StringNode (location: (101,0)-(101,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (101,0)-(101,2) = "%["
-        │   ├── content_loc: (101,2)-(101,5) = "abc"
-        │   ├── closing_loc: (101,5)-(101,6) = "]"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (103,0)-(103,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (103,0)-(103,2) = "%("
-        │   ├── content_loc: (103,2)-(103,5) = "abc"
-        │   ├── closing_loc: (103,5)-(103,6) = ")"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (105,0)-(105,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (105,0)-(105,2) = "%@"
-        │   ├── content_loc: (105,2)-(105,5) = "abc"
-        │   ├── closing_loc: (105,5)-(105,6) = "@"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (107,0)-(107,6))
-        │   ├── flags: newline
-        │   ├── opening_loc: (107,0)-(107,2) = "%$"
-        │   ├── content_loc: (107,2)-(107,5) = "abc"
-        │   ├── closing_loc: (107,5)-(107,6) = "$"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (109,0)-(109,2))
-        │   ├── flags: newline
-        │   ├── opening_loc: (109,0)-(109,1) = "?"
-        │   ├── content_loc: (109,1)-(109,2) = "a"
-        │   ├── closing_loc: ∅
-        │   └── unescaped: "a"
-        ├── @ InterpolatedStringNode (location: (111,0)-(111,6))
-        │   ├── flags: newline, static_literal
-        │   ├── opening_loc: ∅
-        │   ├── parts: (length: 2)
-        │   │   ├── @ StringNode (location: (111,0)-(111,2))
-        │   │   │   ├── flags: static_literal, frozen
-        │   │   │   ├── opening_loc: (111,0)-(111,1) = "?"
-        │   │   │   ├── content_loc: (111,1)-(111,2) = "a"
-        │   │   │   ├── closing_loc: ∅
-        │   │   │   └── unescaped: "a"
-        │   │   └── @ StringNode (location: (111,3)-(111,6))
-        │   │       ├── flags: static_literal, frozen
-        │   │       ├── opening_loc: (111,3)-(111,4) = "\""
-        │   │       ├── content_loc: (111,4)-(111,5) = "a"
-        │   │       ├── closing_loc: (111,5)-(111,6) = "\""
-        │   │       └── unescaped: "a"
-        │   └── closing_loc: ∅
-        ├── @ StringNode (location: (113,0)-(113,7))
-        │   ├── flags: newline
-        │   ├── opening_loc: (113,0)-(113,3) = "%Q{"
-        │   ├── content_loc: (113,3)-(113,6) = "abc"
-        │   ├── closing_loc: (113,6)-(113,7) = "}"
-        │   └── unescaped: "abc"
-        ├── @ StringNode (location: (115,0)-(115,5))
-        │   ├── flags: newline
-        │   ├── opening_loc: (115,0)-(115,2) = "%^"
-        │   ├── content_loc: (115,2)-(115,4) = "\#$"
-        │   ├── closing_loc: (115,4)-(115,5) = "^"
-        │   └── unescaped: "\#$"
-        ├── @ StringNode (location: (117,0)-(117,4))
-        │   ├── flags: newline
-        │   ├── opening_loc: (117,0)-(117,2) = "%@"
-        │   ├── content_loc: (117,2)-(117,3) = "#"
-        │   ├── closing_loc: (117,3)-(117,4) = "@"
-        │   └── unescaped: "#"
-        └── @ InterpolatedStringNode (location: (119,0)-(119,15))
-            ├── flags: newline
-            ├── opening_loc: (119,0)-(119,1) = "\""
-            ├── parts: (length: 2)
-            │   ├── @ EmbeddedStatementsNode (location: (119,1)-(119,12))
-            │   │   ├── flags: ∅
-            │   │   ├── opening_loc: (119,1)-(119,3) = "\#{"
-            │   │   ├── statements:
-            │   │   │   @ StatementsNode (location: (119,3)-(119,11))
-            │   │   │   ├── flags: ∅
-            │   │   │   └── body: (length: 1)
-            │   │   │       └── @ InterpolatedStringNode (location: (119,3)-(119,11))
-            │   │   │           ├── flags: ∅
-            │   │   │           ├── opening_loc: (119,3)-(119,4) = "\""
-            │   │   │           ├── parts: (length: 2)
-            │   │   │           │   ├── @ EmbeddedStatementsNode (location: (119,4)-(119,8))
-            │   │   │           │   │   ├── flags: ∅
-            │   │   │           │   │   ├── opening_loc: (119,4)-(119,6) = "\#{"
-            │   │   │           │   │   ├── statements:
-            │   │   │           │   │   │   @ StatementsNode (location: (119,6)-(119,7))
-            │   │   │           │   │   │   ├── flags: ∅
-            │   │   │           │   │   │   └── body: (length: 1)
-            │   │   │           │   │   │       └── @ ConstantReadNode (location: (119,6)-(119,7))
-            │   │   │           │   │   │           ├── flags: ∅
-            │   │   │           │   │   │           └── name: :B
-            │   │   │           │   │   └── closing_loc: (119,7)-(119,8) = "}"
-            │   │   │           │   └── @ StringNode (location: (119,8)-(119,10))
-            │   │   │           │       ├── flags: static_literal, frozen
-            │   │   │           │       ├── opening_loc: ∅
-            │   │   │           │       ├── content_loc: (119,8)-(119,10) = " C"
-            │   │   │           │       ├── closing_loc: ∅
-            │   │   │           │       └── unescaped: " C"
-            │   │   │           └── closing_loc: (119,10)-(119,11) = "\""
-            │   │   └── closing_loc: (119,11)-(119,12) = "}"
-            │   └── @ StringNode (location: (119,12)-(119,14))
-            │       ├── flags: static_literal, frozen
-            │       ├── opening_loc: ∅
-            │       ├── content_loc: (119,12)-(119,14) = " D"
-            │       ├── closing_loc: ∅
-            │       └── unescaped: " D"
-            └── closing_loc: (119,14)-(119,15) = "\""