path: root/test/prism/snapshots/patterns.txt

@ ProgramNode (location: (1,0)-(217,5))
├── locals: [:bar, :baz, :qux, :b, :a, :foo, :x]
└── statements:
    @ StatementsNode (location: (1,0)-(217,5))
    └── body: (length: 180)
        ├── @ MatchRequiredNode (location: (1,0)-(1,10))
        │   ├── value:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ LocalVariableTargetNode (location: (1,7)-(1,10))
        │   │   ├── name: :bar
        │   │   └── depth: 0
        │   └── operator_loc: (1,4)-(1,6) = "=>"
        ├── @ MatchRequiredNode (location: (2,0)-(2,8))
        │   ├── value:
        │   │   @ CallNode (location: (2,0)-(2,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (2,0)-(2,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ IntegerNode (location: (2,7)-(2,8))
        │   │   ├── flags: decimal
        │   │   └── value: 1
        │   └── operator_loc: (2,4)-(2,6) = "=>"
        ├── @ MatchRequiredNode (location: (3,0)-(3,10))
        │   ├── value:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FloatNode (location: (3,7)-(3,10))
        │   │   └── value: 1.0
        │   └── operator_loc: (3,4)-(3,6) = "=>"
        ├── @ MatchRequiredNode (location: (4,0)-(4,9))
        │   ├── value:
        │   │   @ CallNode (location: (4,0)-(4,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (4,0)-(4,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ImaginaryNode (location: (4,7)-(4,9))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (4,7)-(4,8))
        │   │       ├── flags: decimal
        │   │       └── value: 1
        │   └── operator_loc: (4,4)-(4,6) = "=>"
        ├── @ MatchRequiredNode (location: (5,0)-(5,9))
        │   ├── value:
        │   │   @ CallNode (location: (5,0)-(5,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,0)-(5,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RationalNode (location: (5,7)-(5,9))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (5,7)-(5,8))
        │   │       ├── flags: decimal
        │   │       └── value: 1
        │   └── operator_loc: (5,4)-(5,6) = "=>"
        ├── @ MatchRequiredNode (location: (6,0)-(6,11))
        │   ├── value:
        │   │   @ CallNode (location: (6,0)-(6,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (6,0)-(6,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (6,7)-(6,11))
        │   │   ├── flags: forced_us_ascii_encoding
        │   │   ├── opening_loc: (6,7)-(6,8) = ":"
        │   │   ├── value_loc: (6,8)-(6,11) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (6,4)-(6,6) = "=>"
        ├── @ MatchRequiredNode (location: (7,0)-(7,14))
        │   ├── value:
        │   │   @ CallNode (location: (7,0)-(7,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (7,0)-(7,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (7,7)-(7,14))
        │   │   ├── flags: forced_us_ascii_encoding
        │   │   ├── opening_loc: (7,7)-(7,10) = "%s["
        │   │   ├── value_loc: (7,10)-(7,13) = "foo"
        │   │   ├── closing_loc: (7,13)-(7,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (7,4)-(7,6) = "=>"
        ├── @ MatchRequiredNode (location: (8,0)-(8,13))
        │   ├── value:
        │   │   @ CallNode (location: (8,0)-(8,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (8,0)-(8,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (8,7)-(8,13))
        │   │   ├── flags: forced_us_ascii_encoding
        │   │   ├── opening_loc: (8,7)-(8,9) = ":\""
        │   │   ├── value_loc: (8,9)-(8,12) = "foo"
        │   │   ├── closing_loc: (8,12)-(8,13) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (8,4)-(8,6) = "=>"
        ├── @ MatchRequiredNode (location: (9,0)-(9,12))
        │   ├── value:
        │   │   @ CallNode (location: (9,0)-(9,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RegularExpressionNode (location: (9,7)-(9,12))
        │   │   ├── flags: forced_us_ascii_encoding
        │   │   ├── opening_loc: (9,7)-(9,8) = "/"
        │   │   ├── content_loc: (9,8)-(9,11) = "foo"
        │   │   ├── closing_loc: (9,11)-(9,12) = "/"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (9,4)-(9,6) = "=>"
        ├── @ MatchRequiredNode (location: (10,0)-(10,12))
        │   ├── value:
        │   │   @ CallNode (location: (10,0)-(10,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (10,0)-(10,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ XStringNode (location: (10,7)-(10,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (10,7)-(10,8) = "`"
        │   │   ├── content_loc: (10,8)-(10,11) = "foo"
        │   │   ├── closing_loc: (10,11)-(10,12) = "`"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (10,4)-(10,6) = "=>"
        ├── @ MatchRequiredNode (location: (11,0)-(11,14))
        │   ├── value:
        │   │   @ CallNode (location: (11,0)-(11,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (11,0)-(11,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ XStringNode (location: (11,7)-(11,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (11,7)-(11,10) = "%x["
        │   │   ├── content_loc: (11,10)-(11,13) = "foo"
        │   │   ├── closing_loc: (11,13)-(11,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (11,4)-(11,6) = "=>"
        ├── @ MatchRequiredNode (location: (12,0)-(12,14))
        │   ├── value:
        │   │   @ CallNode (location: (12,0)-(12,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (12,0)-(12,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (12,7)-(12,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (12,10)-(12,13))
        │   │   │       ├── flags: forced_us_ascii_encoding
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (12,10)-(12,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (12,7)-(12,10) = "%i["
        │   │   └── closing_loc: (12,13)-(12,14) = "]"
        │   └── operator_loc: (12,4)-(12,6) = "=>"
        ├── @ MatchRequiredNode (location: (13,0)-(13,14))
        │   ├── value:
        │   │   @ CallNode (location: (13,0)-(13,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (13,0)-(13,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (13,7)-(13,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (13,10)-(13,13))
        │   │   │       ├── flags: forced_us_ascii_encoding
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (13,10)-(13,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (13,7)-(13,10) = "%I["
        │   │   └── closing_loc: (13,13)-(13,14) = "]"
        │   └── operator_loc: (13,4)-(13,6) = "=>"
        ├── @ MatchRequiredNode (location: (14,0)-(14,14))
        │   ├── value:
        │   │   @ CallNode (location: (14,0)-(14,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (14,0)-(14,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (14,7)-(14,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (14,10)-(14,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (14,10)-(14,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (14,7)-(14,10) = "%w["
        │   │   └── closing_loc: (14,13)-(14,14) = "]"
        │   └── operator_loc: (14,4)-(14,6) = "=>"
        ├── @ MatchRequiredNode (location: (15,0)-(15,14))
        │   ├── value:
        │   │   @ CallNode (location: (15,0)-(15,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (15,0)-(15,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (15,7)-(15,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (15,10)-(15,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (15,10)-(15,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (15,7)-(15,10) = "%W["
        │   │   └── closing_loc: (15,13)-(15,14) = "]"
        │   └── operator_loc: (15,4)-(15,6) = "=>"
        ├── @ MatchRequiredNode (location: (16,0)-(16,14))
        │   ├── value:
        │   │   @ CallNode (location: (16,0)-(16,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (16,0)-(16,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (16,7)-(16,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (16,7)-(16,10) = "%q["
        │   │   ├── content_loc: (16,10)-(16,13) = "foo"
        │   │   ├── closing_loc: (16,13)-(16,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (16,4)-(16,6) = "=>"
        ├── @ MatchRequiredNode (location: (17,0)-(17,14))
        │   ├── value:
        │   │   @ CallNode (location: (17,0)-(17,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (17,7)-(17,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (17,7)-(17,10) = "%Q["
        │   │   ├── content_loc: (17,10)-(17,13) = "foo"
        │   │   ├── closing_loc: (17,13)-(17,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (17,4)-(17,6) = "=>"
        ├── @ MatchRequiredNode (location: (18,0)-(18,12))
        │   ├── value:
        │   │   @ CallNode (location: (18,0)-(18,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (18,0)-(18,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (18,7)-(18,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (18,7)-(18,8) = "\""
        │   │   ├── content_loc: (18,8)-(18,11) = "foo"
        │   │   ├── closing_loc: (18,11)-(18,12) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (18,4)-(18,6) = "=>"
        ├── @ MatchRequiredNode (location: (19,0)-(19,10))
        │   ├── value:
        │   │   @ CallNode (location: (19,0)-(19,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (19,0)-(19,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ NilNode (location: (19,7)-(19,10))
        │   └── operator_loc: (19,4)-(19,6) = "=>"
        ├── @ MatchRequiredNode (location: (20,0)-(20,11))
        │   ├── value:
        │   │   @ CallNode (location: (20,0)-(20,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (20,0)-(20,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SelfNode (location: (20,7)-(20,11))
        │   └── operator_loc: (20,4)-(20,6) = "=>"
        ├── @ MatchRequiredNode (location: (21,0)-(21,11))
        │   ├── value:
        │   │   @ CallNode (location: (21,0)-(21,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (21,0)-(21,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ TrueNode (location: (21,7)-(21,11))
        │   └── operator_loc: (21,4)-(21,6) = "=>"
        ├── @ MatchRequiredNode (location: (22,0)-(22,12))
        │   ├── value:
        │   │   @ CallNode (location: (22,0)-(22,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (22,0)-(22,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FalseNode (location: (22,7)-(22,12))
        │   └── operator_loc: (22,4)-(22,6) = "=>"
        ├── @ MatchRequiredNode (location: (23,0)-(23,15))
        │   ├── value:
        │   │   @ CallNode (location: (23,0)-(23,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (23,0)-(23,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceFileNode (location: (23,7)-(23,15))
        │   │   ├── flags: ∅
        │   │   └── filepath: "patterns.txt"
        │   └── operator_loc: (23,4)-(23,6) = "=>"
        ├── @ MatchRequiredNode (location: (24,0)-(24,15))
        │   ├── value:
        │   │   @ CallNode (location: (24,0)-(24,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (24,0)-(24,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceLineNode (location: (24,7)-(24,15))
        │   └── operator_loc: (24,4)-(24,6) = "=>"
        ├── @ MatchRequiredNode (location: (25,0)-(25,19))
        │   ├── value:
        │   │   @ CallNode (location: (25,0)-(25,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (25,0)-(25,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceEncodingNode (location: (25,7)-(25,19))
        │   └── operator_loc: (25,4)-(25,6) = "=>"
        ├── @ MatchRequiredNode (location: (26,0)-(26,17))
        │   ├── value:
        │   │   @ CallNode (location: (26,0)-(26,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (26,0)-(26,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ LambdaNode (location: (26,7)-(26,17))
        │   │   ├── locals: []
        │   │   ├── operator_loc: (26,7)-(26,9) = "->"
        │   │   ├── opening_loc: (26,10)-(26,11) = "{"
        │   │   ├── closing_loc: (26,16)-(26,17) = "}"
        │   │   ├── parameters: ∅
        │   │   └── body:
        │   │       @ StatementsNode (location: (26,12)-(26,15))
        │   │       └── body: (length: 1)
        │   │           └── @ LocalVariableReadNode (location: (26,12)-(26,15))
        │   │               ├── name: :bar
        │   │               └── depth: 1
        │   └── operator_loc: (26,4)-(26,6) = "=>"
        ├── @ MatchRequiredNode (location: (28,0)-(28,13))
        │   ├── value:
        │   │   @ CallNode (location: (28,0)-(28,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (28,0)-(28,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (28,7)-(28,13))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (28,7)-(28,8))
        │   │   │   ├── flags: decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (28,12)-(28,13))
        │   │   │   ├── flags: decimal
        │   │   │   └── value: 1
        │   │   └── operator_loc: (28,9)-(28,11) = ".."
        │   └── operator_loc: (28,4)-(28,6) = "=>"
        ├── @ MatchRequiredNode (location: (29,0)-(29,17))
        │   ├── value:
        │   │   @ CallNode (location: (29,0)-(29,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (29,0)-(29,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (29,7)-(29,17))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ FloatNode (location: (29,7)-(29,10))
        │   │   │   └── value: 1.0
        │   │   ├── right:
        │   │   │   @ FloatNode (location: (29,14)-(29,17))
        │   │   │   └── value: 1.0
        │   │   └── operator_loc: (29,11)-(29,13) = ".."
        │   └── operator_loc: (29,4)-(29,6) = "=>"
        ├── @ MatchRequiredNode (location: (30,0)-(30,15))
        │   ├── value:
        │   │   @ CallNode (location: (30,0)-(30,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (30,0)-(30,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (30,7)-(30,15))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ImaginaryNode (location: (30,7)-(30,9))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (30,7)-(30,8))
        │   │   │       ├── flags: decimal
        │   │   │       └── value: 1
        │   │   ├── right:
        │   │   │   @ ImaginaryNode (location: (30,13)-(30,15))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (30,13)-(30,14))
        │   │   │       ├── flags: decimal
        │   │   │       └── value: 1
        │   │   └── operator_loc: (30,10)-(30,12) = ".."
        │   └── operator_loc: (30,4)-(30,6) = "=>"
        ├── @ MatchRequiredNode (location: (31,0)-(31,15))
        │   ├── value:
        │   │   @ CallNode (location: (31,0)-(31,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (31,0)-(31,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (31,7)-(31,15))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ RationalNode (location: (31,7)-(31,9))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (31,7)-(31,8))
        │   │   │       ├── flags: decimal
        │   │   │       └── value: 1
        │   │   ├── right:
        │   │   │   @ RationalNode (location: (31,13)-(31,15))
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (31,13)-(31,14))
        │   │   │       ├── flags: decimal
        │   │   │       └── value: 1
        │   │   └── operator_loc: (31,10)-(31,12) = ".."
        │   └── operator_loc: (31,4)-(31,6) = "=>"
        ├── @ MatchRequiredNode (location: (32,0)-(32,19))
        │   ├── value:
        │   │   @ CallNode (location: (32,0)-(32,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (32,0)-(32,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (32,7)-(32,19))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (32,7)-(32,11))
        │   │   │   ├── flags: forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (32,7)-(32,8) = ":"
        │   │   │   ├── value_loc: (32,8)-(32,11) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (32,15)-(32,19))
        │   │   │   ├── flags: forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (32,15)-(32,16) = ":"
        │   │   │   ├── value_loc: (32,16)-(32,19) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (32,12)-(32,14) = ".."
        │   └── operator_loc: (32,4)-(32,6) = "=>"
        ├── @ MatchRequiredNode (location: (33,0)-(33,25))
        │   ├── value:
        │   │   @ CallNode (location: (33,0)-(33,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (33,0)-(33,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (33,7)-(33,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (33,7)-(33,14))
        │   │   │   ├── flags: forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (33,7)-(33,10) = "%s["
        │   │   │   ├── value_loc: (33,10)-(33,13) = "foo"
        │   │   │   ├── closing_loc: (33,13)-(33,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (33,18)-(33,25))
        │   │   │   ├── flags: forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (33,18)-(33,21) = "%s["
        │   │   │   ├── value_loc: (33,21)-(33,24) = "foo"
        │   │   │   ├── closing_loc: (33,24)-(33,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (33,15)-(33,17) = ".."
        │   └── operator_loc: (33,4)-(33,6) = "=>"
        ├── @ MatchRequiredNode (location: (34,0)-(34,23))
        │   ├── value:
        │   │   @ CallNode (location: (34,0)-(34,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (34,0)-(34,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (34,7)-(34,23))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (34,7)-(34,13))
        │   │   │   ├── flags: forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (34,7)-(34,9) = ":\""
        │   │   │   ├── value_loc: (34,9)-(34,12) = "foo"
        │   │   │   ├── closing_loc: (34,12)-(34,13) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (34,17)-(34,23))
        │   │   │   ├── flags: forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (34,17)-(34,19) = ":\""
        │   │   │   ├── value_loc: (34,19)-(34,22) = "foo"
        │   │   │   ├── closing_loc: (34,22)-(34,23) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (34,14)-(34,16) = ".."
        │   └── operator_loc: (34,4)-(34,6) = "=>"
        ├── @ MatchRequiredNode (location: (35,0)-(35,21))
        │   ├── value:
        │   │   @ CallNode (location: (35,0)-(35,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (35,0)-(35,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (35,7)-(35,21))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ RegularExpressionNode (location: (35,7)-(35,12))
        │   │   │   ├── flags: forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (35,7)-(35,8) = "/"
        │   │   │   ├── content_loc: (35,8)-(35,11) = "foo"
        │   │   │   ├── closing_loc: (35,11)-(35,12) = "/"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ RegularExpressionNode (location: (35,16)-(35,21))
        │   │   │   ├── flags: forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (35,16)-(35,17) = "/"
        │   │   │   ├── content_loc: (35,17)-(35,20) = "foo"
        │   │   │   ├── closing_loc: (35,20)-(35,21) = "/"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (35,13)-(35,15) = ".."
        │   └── operator_loc: (35,4)-(35,6) = "=>"
        ├── @ MatchRequiredNode (location: (36,0)-(36,21))
        │   ├── value:
        │   │   @ CallNode (location: (36,0)-(36,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (36,0)-(36,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (36,7)-(36,21))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ XStringNode (location: (36,7)-(36,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (36,7)-(36,8) = "`"
        │   │   │   ├── content_loc: (36,8)-(36,11) = "foo"
        │   │   │   ├── closing_loc: (36,11)-(36,12) = "`"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ XStringNode (location: (36,16)-(36,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (36,16)-(36,17) = "`"
        │   │   │   ├── content_loc: (36,17)-(36,20) = "foo"
        │   │   │   ├── closing_loc: (36,20)-(36,21) = "`"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (36,13)-(36,15) = ".."
        │   └── operator_loc: (36,4)-(36,6) = "=>"
        ├── @ MatchRequiredNode (location: (37,0)-(37,25))
        │   ├── value:
        │   │   @ CallNode (location: (37,0)-(37,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (37,0)-(37,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (37,7)-(37,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ XStringNode (location: (37,7)-(37,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (37,7)-(37,10) = "%x["
        │   │   │   ├── content_loc: (37,10)-(37,13) = "foo"
        │   │   │   ├── closing_loc: (37,13)-(37,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ XStringNode (location: (37,18)-(37,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (37,18)-(37,21) = "%x["
        │   │   │   ├── content_loc: (37,21)-(37,24) = "foo"
        │   │   │   ├── closing_loc: (37,24)-(37,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (37,15)-(37,17) = ".."
        │   └── operator_loc: (37,4)-(37,6) = "=>"
        ├── @ MatchRequiredNode (location: (38,0)-(38,25))
        │   ├── value:
        │   │   @ CallNode (location: (38,0)-(38,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (38,0)-(38,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (38,7)-(38,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (38,7)-(38,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (38,10)-(38,13))
        │   │   │   │       ├── flags: forced_us_ascii_encoding
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (38,10)-(38,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (38,7)-(38,10) = "%i["
        │   │   │   └── closing_loc: (38,13)-(38,14) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (38,18)-(38,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (38,21)-(38,24))
        │   │   │   │       ├── flags: forced_us_ascii_encoding
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (38,21)-(38,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (38,18)-(38,21) = "%i["
        │   │   │   └── closing_loc: (38,24)-(38,25) = "]"
        │   │   └── operator_loc: (38,15)-(38,17) = ".."
        │   └── operator_loc: (38,4)-(38,6) = "=>"
        ├── @ MatchRequiredNode (location: (39,0)-(39,25))
        │   ├── value:
        │   │   @ CallNode (location: (39,0)-(39,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (39,0)-(39,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (39,7)-(39,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (39,7)-(39,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (39,10)-(39,13))
        │   │   │   │       ├── flags: forced_us_ascii_encoding
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (39,10)-(39,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (39,7)-(39,10) = "%I["
        │   │   │   └── closing_loc: (39,13)-(39,14) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (39,18)-(39,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (39,21)-(39,24))
        │   │   │   │       ├── flags: forced_us_ascii_encoding
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (39,21)-(39,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (39,18)-(39,21) = "%I["
        │   │   │   └── closing_loc: (39,24)-(39,25) = "]"
        │   │   └── operator_loc: (39,15)-(39,17) = ".."
        │   └── operator_loc: (39,4)-(39,6) = "=>"
        ├── @ MatchRequiredNode (location: (40,0)-(40,25))
        │   ├── value:
        │   │   @ CallNode (location: (40,0)-(40,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (40,0)-(40,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (40,7)-(40,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (40,7)-(40,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (40,10)-(40,13))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (40,10)-(40,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (40,7)-(40,10) = "%w["
        │   │   │   └── closing_loc: (40,13)-(40,14) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (40,18)-(40,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (40,21)-(40,24))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (40,21)-(40,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (40,18)-(40,21) = "%w["
        │   │   │   └── closing_loc: (40,24)-(40,25) = "]"
        │   │   └── operator_loc: (40,15)-(40,17) = ".."
        │   └── operator_loc: (40,4)-(40,6) = "=>"
        ├── @ MatchRequiredNode (location: (41,0)-(41,25))
        │   ├── value:
        │   │   @ CallNode (location: (41,0)-(41,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (41,0)-(41,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (41,7)-(41,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (41,7)-(41,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (41,10)-(41,13))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (41,10)-(41,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (41,7)-(41,10) = "%W["
        │   │   │   └── closing_loc: (41,13)-(41,14) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (41,18)-(41,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (41,21)-(41,24))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (41,21)-(41,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (41,18)-(41,21) = "%W["
        │   │   │   └── closing_loc: (41,24)-(41,25) = "]"
        │   │   └── operator_loc: (41,15)-(41,17) = ".."
        │   └── operator_loc: (41,4)-(41,6) = "=>"
        ├── @ MatchRequiredNode (location: (42,0)-(42,25))
        │   ├── value:
        │   │   @ CallNode (location: (42,0)-(42,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (42,0)-(42,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (42,7)-(42,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ StringNode (location: (42,7)-(42,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (42,7)-(42,10) = "%q["
        │   │   │   ├── content_loc: (42,10)-(42,13) = "foo"
        │   │   │   ├── closing_loc: (42,13)-(42,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (42,18)-(42,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (42,18)-(42,21) = "%q["
        │   │   │   ├── content_loc: (42,21)-(42,24) = "foo"
        │   │   │   ├── closing_loc: (42,24)-(42,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (42,15)-(42,17) = ".."
        │   └── operator_loc: (42,4)-(42,6) = "=>"
        ├── @ MatchRequiredNode (location: (43,0)-(43,25))
        │   ├── value:
        │   │   @ CallNode (location: (43,0)-(43,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (43,0)-(43,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (43,7)-(43,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ StringNode (location: (43,7)-(43,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (43,7)-(43,10) = "%Q["
        │   │   │   ├── content_loc: (43,10)-(43,13) = "foo"
        │   │   │   ├── closing_loc: (43,13)-(43,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (43,18)-(43,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (43,18)-(43,21) = "%Q["
        │   │   │   ├── content_loc: (43,21)-(43,24) = "foo"
        │   │   │   ├── closing_loc: (43,24)-(43,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (43,15)-(43,17) = ".."
        │   └── operator_loc: (43,4)-(43,6) = "=>"
        ├── @ MatchRequiredNode (location: (44,0)-(44,21))
        │   ├── value:
        │   │   @ CallNode (location: (44,0)-(44,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (44,0)-(44,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (44,7)-(44,21))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ StringNode (location: (44,7)-(44,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (44,7)-(44,8) = "\""
        │   │   │   ├── content_loc: (44,8)-(44,11) = "foo"
        │   │   │   ├── closing_loc: (44,11)-(44,12) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (44,16)-(44,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (44,16)-(44,17) = "\""
        │   │   │   ├── content_loc: (44,17)-(44,20) = "foo"
        │   │   │   ├── closing_loc: (44,20)-(44,21) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (44,13)-(44,15) = ".."
        │   └── operator_loc: (44,4)-(44,6) = "=>"
        ├── @ MatchRequiredNode (location: (45,0)-(45,17))
        │   ├── value:
        │   │   @ CallNode (location: (45,0)-(45,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (45,0)-(45,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (45,7)-(45,17))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ NilNode (location: (45,7)-(45,10))
        │   │   ├── right:
        │   │   │   @ NilNode (location: (45,14)-(45,17))
        │   │   └── operator_loc: (45,11)-(45,13) = ".."
        │   └── operator_loc: (45,4)-(45,6) = "=>"
        ├── @ MatchRequiredNode (location: (46,0)-(46,19))
        │   ├── value:
        │   │   @ CallNode (location: (46,0)-(46,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (46,0)-(46,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (46,7)-(46,19))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SelfNode (location: (46,7)-(46,11))
        │   │   ├── right:
        │   │   │   @ SelfNode (location: (46,15)-(46,19))
        │   │   └── operator_loc: (46,12)-(46,14) = ".."
        │   └── operator_loc: (46,4)-(46,6) = "=>"
        ├── @ MatchRequiredNode (location: (47,0)-(47,19))
        │   ├── value:
        │   │   @ CallNode (location: (47,0)-(47,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (47,0)-(47,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (47,7)-(47,19))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ TrueNode (location: (47,7)-(47,11))
        │   │   ├── right:
        │   │   │   @ TrueNode (location: (47,15)-(47,19))
        │   │   └── operator_loc: (47,12)-(47,14) = ".."
        │   └── operator_loc: (47,4)-(47,6) = "=>"
        ├── @ MatchRequiredNode (location: (48,0)-(48,21))
        │   ├── value:
        │   │   @ CallNode (location: (48,0)-(48,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (48,0)-(48,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (48,7)-(48,21))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ FalseNode (location: (48,7)-(48,12))
        │   │   ├── right:
        │   │   │   @ FalseNode (location: (48,16)-(48,21))
        │   │   └── operator_loc: (48,13)-(48,15) = ".."
        │   └── operator_loc: (48,4)-(48,6) = "=>"
        ├── @ MatchRequiredNode (location: (49,0)-(49,27))
        │   ├── value:
        │   │   @ CallNode (location: (49,0)-(49,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (49,0)-(49,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (49,7)-(49,27))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SourceFileNode (location: (49,7)-(49,15))
        │   │   │   ├── flags: ∅
        │   │   │   └── filepath: "patterns.txt"
        │   │   ├── right:
        │   │   │   @ SourceFileNode (location: (49,19)-(49,27))
        │   │   │   ├── flags: ∅
        │   │   │   └── filepath: "patterns.txt"
        │   │   └── operator_loc: (49,16)-(49,18) = ".."
        │   └── operator_loc: (49,4)-(49,6) = "=>"
        ├── @ MatchRequiredNode (location: (50,0)-(50,27))
        │   ├── value:
        │   │   @ CallNode (location: (50,0)-(50,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (50,0)-(50,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (50,7)-(50,27))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SourceLineNode (location: (50,7)-(50,15))
        │   │   ├── right:
        │   │   │   @ SourceLineNode (location: (50,19)-(50,27))
        │   │   └── operator_loc: (50,16)-(50,18) = ".."
        │   └── operator_loc: (50,4)-(50,6) = "=>"
        ├── @ MatchRequiredNode (location: (51,0)-(51,35))
        │   ├── value:
        │   │   @ CallNode (location: (51,0)-(51,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (51,0)-(51,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (51,7)-(51,35))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SourceEncodingNode (location: (51,7)-(51,19))
        │   │   ├── right:
        │   │   │   @ SourceEncodingNode (location: (51,23)-(51,35))
        │   │   └── operator_loc: (51,20)-(51,22) = ".."
        │   └── operator_loc: (51,4)-(51,6) = "=>"
        ├── @ MatchRequiredNode (location: (52,0)-(52,31))
        │   ├── value:
        │   │   @ CallNode (location: (52,0)-(52,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (52,0)-(52,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (52,7)-(52,31))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ LambdaNode (location: (52,7)-(52,17))
        │   │   │   ├── locals: []
        │   │   │   ├── operator_loc: (52,7)-(52,9) = "->"
        │   │   │   ├── opening_loc: (52,10)-(52,11) = "{"
        │   │   │   ├── closing_loc: (52,16)-(52,17) = "}"
        │   │   │   ├── parameters: ∅
        │   │   │   └── body:
        │   │   │       @ StatementsNode (location: (52,12)-(52,15))
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ LocalVariableReadNode (location: (52,12)-(52,15))
        │   │   │               ├── name: :bar
        │   │   │               └── depth: 1
        │   │   ├── right:
        │   │   │   @ LambdaNode (location: (52,21)-(52,31))
        │   │   │   ├── locals: []
        │   │   │   ├── operator_loc: (52,21)-(52,23) = "->"
        │   │   │   ├── opening_loc: (52,24)-(52,25) = "{"
        │   │   │   ├── closing_loc: (52,30)-(52,31) = "}"
        │   │   │   ├── parameters: ∅
        │   │   │   └── body:
        │   │   │       @ StatementsNode (location: (52,26)-(52,29))
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ LocalVariableReadNode (location: (52,26)-(52,29))
        │   │   │               ├── name: :bar
        │   │   │               └── depth: 1
        │   │   └── operator_loc: (52,18)-(52,20) = ".."
        │   └── operator_loc: (52,4)-(52,6) = "=>"
        ├── @ LocalVariableWriteNode (location: (54,0)-(54,7))
        │   ├── name: :bar
        │   ├── depth: 0
        │   ├── name_loc: (54,0)-(54,3) = "bar"
        │   ├── value:
        │   │   @ IntegerNode (location: (54,6)-(54,7))
        │   │   ├── flags: decimal
        │   │   └── value: 1
        │   └── operator_loc: (54,4)-(54,5) = "="
        ├── @ MatchRequiredNode (location: (54,9)-(54,20))
        │   ├── value:
        │   │   @ CallNode (location: (54,9)-(54,12))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (54,9)-(54,12) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (54,16)-(54,20))
        │   │   ├── variable:
        │   │   │   @ LocalVariableReadNode (location: (54,17)-(54,20))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (54,16)-(54,17) = "^"
        │   └── operator_loc: (54,13)-(54,15) = "=>"
        ├── @ MatchRequiredNode (location: (55,0)-(55,12))
        │   ├── value:
        │   │   @ CallNode (location: (55,0)-(55,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (55,0)-(55,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (55,7)-(55,12))
        │   │   ├── variable:
        │   │   │   @ InstanceVariableReadNode (location: (55,8)-(55,12))
        │   │   │   └── name: :@bar
        │   │   └── operator_loc: (55,7)-(55,8) = "^"
        │   └── operator_loc: (55,4)-(55,6) = "=>"
        ├── @ MatchRequiredNode (location: (56,0)-(56,13))
        │   ├── value:
        │   │   @ CallNode (location: (56,0)-(56,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (56,0)-(56,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (56,7)-(56,13))
        │   │   ├── variable:
        │   │   │   @ ClassVariableReadNode (location: (56,8)-(56,13))
        │   │   │   └── name: :@@bar
        │   │   └── operator_loc: (56,7)-(56,8) = "^"
        │   └── operator_loc: (56,4)-(56,6) = "=>"
        ├── @ MatchRequiredNode (location: (57,0)-(57,12))
        │   ├── value:
        │   │   @ CallNode (location: (57,0)-(57,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (57,0)-(57,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (57,7)-(57,12))
        │   │   ├── variable:
        │   │   │   @ GlobalVariableReadNode (location: (57,8)-(57,12))
        │   │   │   └── name: :$bar
        │   │   └── operator_loc: (57,7)-(57,8) = "^"
        │   └── operator_loc: (57,4)-(57,6) = "=>"
        ├── @ MatchRequiredNode (location: (59,0)-(59,11))
        │   ├── value:
        │   │   @ CallNode (location: (59,0)-(59,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (59,0)-(59,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (59,7)-(59,11))
        │   │   ├── expression:
        │   │   │   @ IntegerNode (location: (59,9)-(59,10))
        │   │   │   ├── flags: decimal
        │   │   │   └── value: 1
        │   │   ├── operator_loc: (59,7)-(59,8) = "^"
        │   │   ├── lparen_loc: (59,8)-(59,9) = "("
        │   │   └── rparen_loc: (59,10)-(59,11) = ")"
        │   └── operator_loc: (59,4)-(59,6) = "=>"
        ├── @ MatchRequiredNode (location: (60,0)-(60,13))
        │   ├── value:
        │   │   @ CallNode (location: (60,0)-(60,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (60,0)-(60,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (60,7)-(60,13))
        │   │   ├── expression:
        │   │   │   @ NilNode (location: (60,9)-(60,12))
        │   │   ├── operator_loc: (60,7)-(60,8) = "^"
        │   │   ├── lparen_loc: (60,8)-(60,9) = "("
        │   │   └── rparen_loc: (60,12)-(60,13) = ")"
        │   └── operator_loc: (60,4)-(60,6) = "=>"
        ├── @ MatchRequiredNode (location: (61,0)-(61,23))
        │   ├── value:
        │   │   @ CallNode (location: (61,0)-(61,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (61,0)-(61,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (61,7)-(61,23))
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (61,9)-(61,22))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ StringNode (location: (61,9)-(61,14))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (61,9)-(61,10) = "\""
        │   │   │   │   ├── content_loc: (61,10)-(61,13) = "bar"
        │   │   │   │   ├── closing_loc: (61,13)-(61,14) = "\""
        │   │   │   │   └── unescaped: "bar"
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :+
        │   │   │   ├── message_loc: (61,15)-(61,16) = "+"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (61,17)-(61,22))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ StringNode (location: (61,17)-(61,22))
        │   │   │   │           ├── flags: ∅
        │   │   │   │           ├── opening_loc: (61,17)-(61,18) = "\""
        │   │   │   │           ├── content_loc: (61,18)-(61,21) = "baz"
        │   │   │   │           ├── closing_loc: (61,21)-(61,22) = "\""
        │   │   │   │           └── unescaped: "baz"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── operator_loc: (61,7)-(61,8) = "^"
        │   │   ├── lparen_loc: (61,8)-(61,9) = "("
        │   │   └── rparen_loc: (61,22)-(61,23) = ")"
        │   └── operator_loc: (61,4)-(61,6) = "=>"
        ├── @ MatchRequiredNode (location: (63,0)-(63,10))
        │   ├── value:
        │   │   @ CallNode (location: (63,0)-(63,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (63,0)-(63,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ConstantReadNode (location: (63,7)-(63,10))
        │   │   └── name: :Foo
        │   └── operator_loc: (63,4)-(63,6) = "=>"
        ├── @ MatchRequiredNode (location: (64,0)-(64,20))
        │   ├── value:
        │   │   @ CallNode (location: (64,0)-(64,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (64,0)-(64,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (64,7)-(64,20))
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (64,7)-(64,15))
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantReadNode (location: (64,7)-(64,10))
        │   │   │   │   └── name: :Foo
        │   │   │   ├── child:
        │   │   │   │   @ ConstantReadNode (location: (64,12)-(64,15))
        │   │   │   │   └── name: :Bar
        │   │   │   └── delimiter_loc: (64,10)-(64,12) = "::"
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (64,17)-(64,20))
        │   │   │   └── name: :Baz
        │   │   └── delimiter_loc: (64,15)-(64,17) = "::"
        │   └── operator_loc: (64,4)-(64,6) = "=>"
        ├── @ MatchRequiredNode (location: (65,0)-(65,12))
        │   ├── value:
        │   │   @ CallNode (location: (65,0)-(65,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (65,0)-(65,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (65,7)-(65,12))
        │   │   ├── parent: ∅
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (65,9)-(65,12))
        │   │   │   └── name: :Foo
        │   │   └── delimiter_loc: (65,7)-(65,9) = "::"
        │   └── operator_loc: (65,4)-(65,6) = "=>"
        ├── @ MatchRequiredNode (location: (66,0)-(66,22))
        │   ├── value:
        │   │   @ CallNode (location: (66,0)-(66,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (66,0)-(66,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (66,7)-(66,22))
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (66,7)-(66,17))
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantPathNode (location: (66,7)-(66,12))
        │   │   │   │   ├── parent: ∅
        │   │   │   │   ├── child:
        │   │   │   │   │   @ ConstantReadNode (location: (66,9)-(66,12))
        │   │   │   │   │   └── name: :Foo
        │   │   │   │   └── delimiter_loc: (66,7)-(66,9) = "::"
        │   │   │   ├── child:
        │   │   │   │   @ ConstantReadNode (location: (66,14)-(66,17))
        │   │   │   │   └── name: :Bar
        │   │   │   └── delimiter_loc: (66,12)-(66,14) = "::"
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (66,19)-(66,22))
        │   │   │   └── name: :Baz
        │   │   └── delimiter_loc: (66,17)-(66,19) = "::"
        │   └── operator_loc: (66,4)-(66,6) = "=>"
        ├── @ MatchRequiredNode (location: (68,0)-(68,12))
        │   ├── value:
        │   │   @ CallNode (location: (68,0)-(68,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (68,0)-(68,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (68,7)-(68,12))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (68,7)-(68,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (68,10)-(68,11) = "("
        │   │   └── closing_loc: (68,11)-(68,12) = ")"
        │   └── operator_loc: (68,4)-(68,6) = "=>"
        ├── @ MatchRequiredNode (location: (69,0)-(69,13))
        │   ├── value:
        │   │   @ CallNode (location: (69,0)-(69,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (69,0)-(69,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (69,7)-(69,13))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (69,7)-(69,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ IntegerNode (location: (69,11)-(69,12))
        │   │   │       ├── flags: decimal
        │   │   │       └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (69,10)-(69,11) = "("
        │   │   └── closing_loc: (69,12)-(69,13) = ")"
        │   └── operator_loc: (69,4)-(69,6) = "=>"
        ├── @ MatchRequiredNode (location: (70,0)-(70,19))
        │   ├── value:
        │   │   @ CallNode (location: (70,0)-(70,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (70,0)-(70,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (70,7)-(70,19))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (70,7)-(70,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ IntegerNode (location: (70,11)-(70,12))
        │   │   │   │   ├── flags: decimal
        │   │   │   │   └── value: 1
        │   │   │   ├── @ IntegerNode (location: (70,14)-(70,15))
        │   │   │   │   ├── flags: decimal
        │   │   │   │   └── value: 2
        │   │   │   └── @ IntegerNode (location: (70,17)-(70,18))
        │   │   │       ├── flags: decimal
        │   │   │       └── value: 3
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (70,10)-(70,11) = "("
        │   │   └── closing_loc: (70,18)-(70,19) = ")"
        │   └── operator_loc: (70,4)-(70,6) = "=>"
        ├── @ MatchRequiredNode (location: (71,0)-(71,15))
        │   ├── value:
        │   │   @ CallNode (location: (71,0)-(71,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (71,0)-(71,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (71,7)-(71,15))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (71,7)-(71,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (71,11)-(71,14))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (71,10)-(71,11) = "("
        │   │   └── closing_loc: (71,14)-(71,15) = ")"
        │   └── operator_loc: (71,4)-(71,6) = "=>"
        ├── @ MatchRequiredNode (location: (72,0)-(72,21))
        │   ├── value:
        │   │   @ CallNode (location: (72,0)-(72,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (72,0)-(72,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (72,7)-(72,21))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (72,7)-(72,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (72,11)-(72,15))
        │   │   │   ├── operator_loc: (72,11)-(72,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (72,12)-(72,15))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (72,17)-(72,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (72,10)-(72,11) = "("
        │   │   └── closing_loc: (72,20)-(72,21) = ")"
        │   └── operator_loc: (72,4)-(72,6) = "=>"
        ├── @ MatchRequiredNode (location: (73,0)-(73,21))
        │   ├── value:
        │   │   @ CallNode (location: (73,0)-(73,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (73,0)-(73,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (73,7)-(73,21))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (73,7)-(73,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (73,11)-(73,14))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (73,16)-(73,20))
        │   │   │   ├── operator_loc: (73,16)-(73,17) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (73,17)-(73,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (73,10)-(73,11) = "("
        │   │   └── closing_loc: (73,20)-(73,21) = ")"
        │   └── operator_loc: (73,4)-(73,6) = "=>"
        ├── @ MatchRequiredNode (location: (74,0)-(74,27))
        │   ├── value:
        │   │   @ CallNode (location: (74,0)-(74,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (74,0)-(74,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (74,7)-(74,27))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (74,7)-(74,10))
        │   │   │   └── name: :Foo
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (74,11)-(74,15))
        │   │   │   ├── operator_loc: (74,11)-(74,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (74,12)-(74,15))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (74,17)-(74,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (74,22)-(74,26))
        │   │   │   ├── operator_loc: (74,22)-(74,23) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (74,23)-(74,26))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (74,10)-(74,11) = "("
        │   │   └── closing_loc: (74,26)-(74,27) = ")"
        │   └── operator_loc: (74,4)-(74,6) = "=>"
        ├── @ MatchRequiredNode (location: (76,0)-(76,12))
        │   ├── value:
        │   │   @ CallNode (location: (76,0)-(76,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (76,0)-(76,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (76,7)-(76,12))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (76,7)-(76,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (76,10)-(76,11) = "["
        │   │   └── closing_loc: (76,11)-(76,12) = "]"
        │   └── operator_loc: (76,4)-(76,6) = "=>"
        ├── @ MatchRequiredNode (location: (77,0)-(77,13))
        │   ├── value:
        │   │   @ CallNode (location: (77,0)-(77,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (77,0)-(77,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (77,7)-(77,13))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (77,7)-(77,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ IntegerNode (location: (77,11)-(77,12))
        │   │   │       ├── flags: decimal
        │   │   │       └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (77,10)-(77,11) = "["
        │   │   └── closing_loc: (77,12)-(77,13) = "]"
        │   └── operator_loc: (77,4)-(77,6) = "=>"
        ├── @ MatchRequiredNode (location: (78,0)-(78,19))
        │   ├── value:
        │   │   @ CallNode (location: (78,0)-(78,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (78,0)-(78,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (78,7)-(78,19))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (78,7)-(78,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ IntegerNode (location: (78,11)-(78,12))
        │   │   │   │   ├── flags: decimal
        │   │   │   │   └── value: 1
        │   │   │   ├── @ IntegerNode (location: (78,14)-(78,15))
        │   │   │   │   ├── flags: decimal
        │   │   │   │   └── value: 2
        │   │   │   └── @ IntegerNode (location: (78,17)-(78,18))
        │   │   │       ├── flags: decimal
        │   │   │       └── value: 3
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (78,10)-(78,11) = "["
        │   │   └── closing_loc: (78,18)-(78,19) = "]"
        │   └── operator_loc: (78,4)-(78,6) = "=>"
        ├── @ MatchRequiredNode (location: (79,0)-(79,17))
        │   ├── value:
        │   │   @ CallNode (location: (79,0)-(79,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (79,0)-(79,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (79,7)-(79,17))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (79,7)-(79,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ ArrayPatternNode (location: (79,11)-(79,16))
        │   │   │       ├── constant:
        │   │   │       │   @ ConstantReadNode (location: (79,11)-(79,14))
        │   │   │       │   └── name: :Foo
        │   │   │       ├── requireds: (length: 0)
        │   │   │       ├── rest: ∅
        │   │   │       ├── posts: (length: 0)
        │   │   │       ├── opening_loc: (79,14)-(79,15) = "["
        │   │   │       └── closing_loc: (79,15)-(79,16) = "]"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (79,10)-(79,11) = "["
        │   │   └── closing_loc: (79,16)-(79,17) = "]"
        │   └── operator_loc: (79,4)-(79,6) = "=>"
        ├── @ MatchRequiredNode (location: (80,0)-(80,15))
        │   ├── value:
        │   │   @ CallNode (location: (80,0)-(80,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (80,0)-(80,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (80,7)-(80,15))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (80,7)-(80,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (80,11)-(80,14))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (80,10)-(80,11) = "["
        │   │   └── closing_loc: (80,14)-(80,15) = "]"
        │   └── operator_loc: (80,4)-(80,6) = "=>"
        ├── @ MatchRequiredNode (location: (81,0)-(81,21))
        │   ├── value:
        │   │   @ CallNode (location: (81,0)-(81,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (81,0)-(81,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (81,7)-(81,21))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (81,7)-(81,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (81,11)-(81,15))
        │   │   │   ├── operator_loc: (81,11)-(81,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (81,12)-(81,15))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (81,17)-(81,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (81,10)-(81,11) = "["
        │   │   └── closing_loc: (81,20)-(81,21) = "]"
        │   └── operator_loc: (81,4)-(81,6) = "=>"
        ├── @ MatchRequiredNode (location: (82,0)-(82,21))
        │   ├── value:
        │   │   @ CallNode (location: (82,0)-(82,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (82,0)-(82,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (82,7)-(82,21))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (82,7)-(82,10))
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (82,11)-(82,14))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (82,16)-(82,20))
        │   │   │   ├── operator_loc: (82,16)-(82,17) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (82,17)-(82,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (82,10)-(82,11) = "["
        │   │   └── closing_loc: (82,20)-(82,21) = "]"
        │   └── operator_loc: (82,4)-(82,6) = "=>"
        ├── @ MatchRequiredNode (location: (83,0)-(83,27))
        │   ├── value:
        │   │   @ CallNode (location: (83,0)-(83,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (83,0)-(83,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (83,7)-(83,27))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (83,7)-(83,10))
        │   │   │   └── name: :Foo
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (83,11)-(83,15))
        │   │   │   ├── operator_loc: (83,11)-(83,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (83,12)-(83,15))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (83,17)-(83,20))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (83,22)-(83,26))
        │   │   │   ├── operator_loc: (83,22)-(83,23) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (83,23)-(83,26))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (83,10)-(83,11) = "["
        │   │   └── closing_loc: (83,26)-(83,27) = "]"
        │   └── operator_loc: (83,4)-(83,6) = "=>"
        ├── @ MatchRequiredNode (location: (85,0)-(85,11))
        │   ├── value:
        │   │   @ CallNode (location: (85,0)-(85,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (85,0)-(85,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (85,7)-(85,11))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (85,7)-(85,11))
        │   │   │   ├── operator_loc: (85,7)-(85,8) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (85,8)-(85,11))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (85,4)-(85,6) = "=>"
        ├── @ MatchRequiredNode (location: (86,0)-(86,21))
        │   ├── value:
        │   │   @ CallNode (location: (86,0)-(86,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (86,0)-(86,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (86,7)-(86,21))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (86,7)-(86,11))
        │   │   │   ├── operator_loc: (86,7)-(86,8) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (86,8)-(86,11))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (86,13)-(86,16))
        │   │   │   │   ├── name: :baz
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (86,18)-(86,21))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (86,4)-(86,6) = "=>"
        ├── @ MatchRequiredNode (location: (87,0)-(87,21))
        │   ├── value:
        │   │   @ CallNode (location: (87,0)-(87,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (87,0)-(87,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (87,7)-(87,21))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (87,7)-(87,10))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (87,12)-(87,16))
        │   │   │   ├── operator_loc: (87,12)-(87,13) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (87,13)-(87,16))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (87,18)-(87,21))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (87,4)-(87,6) = "=>"
        ├── @ MatchRequiredNode (location: (88,0)-(88,21))
        │   ├── value:
        │   │   @ CallNode (location: (88,0)-(88,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (88,0)-(88,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (88,7)-(88,21))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (88,7)-(88,10))
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (88,12)-(88,15))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (88,17)-(88,21))
        │   │   │   ├── operator_loc: (88,17)-(88,18) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (88,18)-(88,21))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (88,4)-(88,6) = "=>"
        ├── @ MatchRequiredNode (location: (89,0)-(89,22))
        │   ├── value:
        │   │   @ CallNode (location: (89,0)-(89,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (89,0)-(89,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (89,7)-(89,22))
        │   │   ├── constant: ∅
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (89,7)-(89,11))
        │   │   │   ├── operator_loc: (89,7)-(89,8) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (89,8)-(89,11))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (89,13)-(89,16))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (89,18)-(89,22))
        │   │   │   ├── operator_loc: (89,18)-(89,19) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (89,19)-(89,22))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (89,4)-(89,6) = "=>"
        ├── @ MatchRequiredNode (location: (91,0)-(91,11))
        │   ├── value:
        │   │   @ CallNode (location: (91,0)-(91,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (91,0)-(91,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (91,7)-(91,11))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (91,7)-(91,10))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ ImplicitRestNode (location: (91,10)-(91,11))
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (91,4)-(91,6) = "=>"
        ├── @ MatchRequiredNode (location: (95,0)-(95,9))
        │   ├── value:
        │   │   @ CallNode (location: (95,0)-(95,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (95,0)-(95,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (95,7)-(95,9))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (95,7)-(95,8) = "["
        │   │   └── closing_loc: (95,8)-(95,9) = "]"
        │   └── operator_loc: (95,4)-(95,6) = "=>"
        ├── @ MatchRequiredNode (location: (96,0)-(96,17))
        │   ├── value:
        │   │   @ CallNode (location: (96,0)-(96,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (96,0)-(96,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (96,7)-(96,17))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ ArrayPatternNode (location: (96,8)-(96,16))
        │   │   │       ├── constant: ∅
        │   │   │       ├── requireds: (length: 1)
        │   │   │       │   └── @ ArrayPatternNode (location: (96,9)-(96,15))
        │   │   │       │       ├── constant: ∅
        │   │   │       │       ├── requireds: (length: 1)
        │   │   │       │       │   └── @ ArrayPatternNode (location: (96,10)-(96,14))
        │   │   │       │       │       ├── constant: ∅
        │   │   │       │       │       ├── requireds: (length: 1)
        │   │   │       │       │       │   └── @ ArrayPatternNode (location: (96,11)-(96,13))
        │   │   │       │       │       │       ├── constant: ∅
        │   │   │       │       │       │       ├── requireds: (length: 0)
        │   │   │       │       │       │       ├── rest: ∅
        │   │   │       │       │       │       ├── posts: (length: 0)
        │   │   │       │       │       │       ├── opening_loc: (96,11)-(96,12) = "["
        │   │   │       │       │       │       └── closing_loc: (96,12)-(96,13) = "]"
        │   │   │       │       │       ├── rest: ∅
        │   │   │       │       │       ├── posts: (length: 0)
        │   │   │       │       │       ├── opening_loc: (96,10)-(96,11) = "["
        │   │   │       │       │       └── closing_loc: (96,13)-(96,14) = "]"
        │   │   │       │       ├── rest: ∅
        │   │   │       │       ├── posts: (length: 0)
        │   │   │       │       ├── opening_loc: (96,9)-(96,10) = "["
        │   │   │       │       └── closing_loc: (96,14)-(96,15) = "]"
        │   │   │       ├── rest: ∅
        │   │   │       ├── posts: (length: 0)
        │   │   │       ├── opening_loc: (96,8)-(96,9) = "["
        │   │   │       └── closing_loc: (96,15)-(96,16) = "]"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (96,7)-(96,8) = "["
        │   │   └── closing_loc: (96,16)-(96,17) = "]"
        │   └── operator_loc: (96,4)-(96,6) = "=>"
        ├── @ MatchRequiredNode (location: (98,0)-(98,13))
        │   ├── value:
        │   │   @ CallNode (location: (98,0)-(98,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (98,0)-(98,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (98,7)-(98,13))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (98,8)-(98,12))
        │   │   │   ├── operator_loc: (98,8)-(98,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (98,9)-(98,12))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (98,7)-(98,8) = "["
        │   │   └── closing_loc: (98,12)-(98,13) = "]"
        │   └── operator_loc: (98,4)-(98,6) = "=>"
        ├── @ MatchRequiredNode (location: (99,0)-(99,23))
        │   ├── value:
        │   │   @ CallNode (location: (99,0)-(99,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (99,0)-(99,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (99,7)-(99,23))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (99,8)-(99,12))
        │   │   │   ├── operator_loc: (99,8)-(99,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (99,9)-(99,12))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (99,14)-(99,17))
        │   │   │   │   ├── name: :baz
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (99,19)-(99,22))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (99,7)-(99,8) = "["
        │   │   └── closing_loc: (99,22)-(99,23) = "]"
        │   └── operator_loc: (99,4)-(99,6) = "=>"
        ├── @ MatchRequiredNode (location: (100,0)-(100,23))
        │   ├── value:
        │   │   @ CallNode (location: (100,0)-(100,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (100,0)-(100,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (100,7)-(100,23))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (100,8)-(100,11))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (100,13)-(100,17))
        │   │   │   ├── operator_loc: (100,13)-(100,14) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (100,14)-(100,17))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (100,19)-(100,22))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (100,7)-(100,8) = "["
        │   │   └── closing_loc: (100,22)-(100,23) = "]"
        │   └── operator_loc: (100,4)-(100,6) = "=>"
        ├── @ MatchRequiredNode (location: (101,0)-(101,23))
        │   ├── value:
        │   │   @ CallNode (location: (101,0)-(101,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (101,0)-(101,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (101,7)-(101,23))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (101,8)-(101,11))
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (101,13)-(101,16))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (101,18)-(101,22))
        │   │   │   ├── operator_loc: (101,18)-(101,19) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (101,19)-(101,22))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (101,7)-(101,8) = "["
        │   │   └── closing_loc: (101,22)-(101,23) = "]"
        │   └── operator_loc: (101,4)-(101,6) = "=>"
        ├── @ MatchRequiredNode (location: (102,0)-(102,24))
        │   ├── value:
        │   │   @ CallNode (location: (102,0)-(102,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (102,0)-(102,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (102,7)-(102,24))
        │   │   ├── constant: ∅
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (102,8)-(102,12))
        │   │   │   ├── operator_loc: (102,8)-(102,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (102,9)-(102,12))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (102,14)-(102,17))
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (102,19)-(102,23))
        │   │   │   ├── operator_loc: (102,19)-(102,20) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (102,20)-(102,23))
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (102,7)-(102,8) = "["
        │   │   └── closing_loc: (102,23)-(102,24) = "]"
        │   └── operator_loc: (102,4)-(102,6) = "=>"
        ├── @ MatchPredicateNode (location: (104,0)-(104,10))
        │   ├── value:
        │   │   @ CallNode (location: (104,0)-(104,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (104,0)-(104,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ LocalVariableTargetNode (location: (104,7)-(104,10))
        │   │   ├── name: :bar
        │   │   └── depth: 0
        │   └── operator_loc: (104,4)-(104,6) = "in"
        ├── @ MatchPredicateNode (location: (105,0)-(105,8))
        │   ├── value:
        │   │   @ CallNode (location: (105,0)-(105,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (105,0)-(105,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ IntegerNode (location: (105,7)-(105,8))
        │   │   ├── flags: decimal
        │   │   └── value: 1
        │   └── operator_loc: (105,4)-(105,6) = "in"
        ├── @ MatchPredicateNode (location: (106,0)-(106,10))
        │   ├── value:
        │   │   @ CallNode (location: (106,0)-(106,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (106,0)-(106,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FloatNode (location: (106,7)-(106,10))
        │   │   └── value: 1.0
        │   └── operator_loc: (106,4)-(106,6) = "in"
        ├── @ MatchPredicateNode (location: (107,0)-(107,9))
        │   ├── value:
        │   │   @ CallNode (location: (107,0)-(107,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (107,0)-(107,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ImaginaryNode (location: (107,7)-(107,9))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (107,7)-(107,8))
        │   │       ├── flags: decimal
        │   │       └── value: 1
        │   └── operator_loc: (107,4)-(107,6) = "in"
        ├── @ MatchPredicateNode (location: (108,0)-(108,9))
        │   ├── value:
        │   │   @ CallNode (location: (108,0)-(108,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (108,0)-(108,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RationalNode (location: (108,7)-(108,9))
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (108,7)-(108,8))
        │   │       ├── flags: decimal
        │   │       └── value: 1
        │   └── operator_loc: (108,4)-(108,6) = "in"
        ├── @ MatchPredicateNode (location: (109,0)-(109,11))
        │   ├── value:
        │   │   @ CallNode (location: (109,0)-(109,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (109,0)-(109,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (109,7)-(109,11))
        │   │   ├── flags: forced_us_ascii_encoding
        │   │   ├── opening_loc: (109,7)-(109,8) = ":"
        │   │   ├── value_loc: (109,8)-(109,11) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (109,4)-(109,6) = "in"
        ├── @ MatchPredicateNode (location: (110,0)-(110,14))
        │   ├── value:
        │   │   @ CallNode (location: (110,0)-(110,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (110,0)-(110,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (110,7)-(110,14))
        │   │   ├── flags: forced_us_ascii_encoding
        │   │   ├── opening_loc: (110,7)-(110,10) = "%s["
        │   │   ├── value_loc: (110,10)-(110,13) = "foo"
        │   │   ├── closing_loc: (110,13)-(110,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (110,4)-(110,6) = "in"
        ├── @ MatchPredicateNode (location: (111,0)-(111,13))
        │   ├── value:
        │   │   @ CallNode (location: (111,0)-(111,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (111,0)-(111,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (111,7)-(111,13))
        │   │   ├── flags: forced_us_ascii_encoding
        │   │   ├── opening_loc: (111,7)-(111,9) = ":\""
        │   │   ├── value_loc: (111,9)-(111,12) = "foo"
        │   │   ├── closing_loc: (111,12)-(111,13) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (111,4)-(111,6) = "in"
        ├── @ MatchPredicateNode (location: (112,0)-(112,12))
        │   ├── value:
        │   │   @ CallNode (location: (112,0)-(112,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (112,0)-(112,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RegularExpressionNode (location: (112,7)-(112,12))
        │   │   ├── flags: forced_us_ascii_encoding
        │   │   ├── opening_loc: (112,7)-(112,8) = "/"
        │   │   ├── content_loc: (112,8)-(112,11) = "foo"
        │   │   ├── closing_loc: (112,11)-(112,12) = "/"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (112,4)-(112,6) = "in"
        ├── @ MatchPredicateNode (location: (113,0)-(113,12))
        │   ├── value:
        │   │   @ CallNode (location: (113,0)-(113,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (113,0)-(113,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ XStringNode (location: (113,7)-(113,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (113,7)-(113,8) = "`"
        │   │   ├── content_loc: (113,8)-(113,11) = "foo"
        │   │   ├── closing_loc: (113,11)-(113,12) = "`"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (113,4)-(113,6) = "in"
        ├── @ MatchPredicateNode (location: (114,0)-(114,14))
        │   ├── value:
        │   │   @ CallNode (location: (114,0)-(114,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (114,0)-(114,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ XStringNode (location: (114,7)-(114,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (114,7)-(114,10) = "%x["
        │   │   ├── content_loc: (114,10)-(114,13) = "foo"
        │   │   ├── closing_loc: (114,13)-(114,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (114,4)-(114,6) = "in"
        ├── @ MatchPredicateNode (location: (115,0)-(115,14))
        │   ├── value:
        │   │   @ CallNode (location: (115,0)-(115,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (115,0)-(115,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (115,7)-(115,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (115,10)-(115,13))
        │   │   │       ├── flags: forced_us_ascii_encoding
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (115,10)-(115,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (115,7)-(115,10) = "%i["
        │   │   └── closing_loc: (115,13)-(115,14) = "]"
        │   └── operator_loc: (115,4)-(115,6) = "in"
        ├── @ MatchPredicateNode (location: (116,0)-(116,14))
        │   ├── value:
        │   │   @ CallNode (location: (116,0)-(116,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (116,0)-(116,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (116,7)-(116,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (116,10)-(116,13))
        │   │   │       ├── flags: forced_us_ascii_encoding
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (116,10)-(116,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (116,7)-(116,10) = "%I["
        │   │   └── closing_loc: (116,13)-(116,14) = "]"
        │   └── operator_loc: (116,4)-(116,6) = "in"
        ├── @ MatchPredicateNode (location: (117,0)-(117,14))
        │   ├── value:
        │   │   @ CallNode (location: (117,0)-(117,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (117,0)-(117,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (117,7)-(117,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (117,10)-(117,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (117,10)-(117,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (117,7)-(117,10) = "%w["
        │   │   └── closing_loc: (117,13)-(117,14) = "]"
        │   └── operator_loc: (117,4)-(117,6) = "in"
        ├── @ MatchPredicateNode (location: (118,0)-(118,14))
        │   ├── value:
        │   │   @ CallNode (location: (118,0)-(118,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (118,0)-(118,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (118,7)-(118,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (118,10)-(118,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (118,10)-(118,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (118,7)-(118,10) = "%W["
        │   │   └── closing_loc: (118,13)-(118,14) = "]"
        │   └── operator_loc: (118,4)-(118,6) = "in"
        ├── @ MatchPredicateNode (location: (119,0)-(119,14))
        │   ├── value:
        │   │   @ CallNode (location: (119,0)-(119,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (119,0)-(119,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (119,7)-(119,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (119,7)-(119,10) = "%q["
        │   │   ├── content_loc: (119,10)-(119,13) = "foo"
        │   │   ├── closing_loc: (119,13)-(119,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (119,4)-(119,6) = "in"
        ├── @ MatchPredicateNode (location: (120,0)-(120,14))
        │   ├── value:
        │   │   @ CallNode (location: (120,0)-(120,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (120,0)-(120,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (120,7)-(120,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (120,7)-(120,10) = "%Q["
        │   │   ├── content_loc: (120,10)-(120,13) = "foo"
        │   │   ├── closing_loc: (120,13)-(120,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (120,4)-(120,6) = "in"
        ├── @ MatchPredicateNode (location: (121,0)-(121,12))
        │   ├── value:
        │   │   @ CallNode (location: (121,0)-(121,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (121,0)-(121,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (121,7)-(121,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (121,7)-(121,8) = "\""
        │   │   ├── content_loc: (121,8)-(121,11) = "foo"
        │   │   ├── closing_loc: (121,11)-(121,12) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (121,4)-(121,6) = "in"
        ├── @ MatchPredicateNode (location: (122,0)-(122,10))
        │   ├── value:
        │   │   @ CallNode (location: (122,0)-(122,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (122,0)-(122,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ NilNode (location: (122,7)-(122,10))
        │   └── operator_loc: (122,4)-(122,6) = "in"
        ├── @ MatchPredicateNode (location: (123,0)-(123,11))
        │   ├── value:
        │   │   @ CallNode (location: (123,0)-(123,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (123,0)-(123,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SelfNode (location: (123,7)-(123,11))
        │   └── operator_loc: (123,4)-(123,6) = "in"
        ├── @ MatchPredicateNode (location: (124,0)-(124,11))
        │   ├── value:
        │   │   @ CallNode (location: (124,0)-(124,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (124,0)-(124,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ TrueNode (location: (124,7)-(124,11))
        │   └── operator_loc: (124,4)-(124,6) = "in"
        ├── @ MatchPredicateNode (location: (125,0)-(125,12))
        │   ├── value:
        │   │   @ CallNode (location: (125,0)-(125,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (125,0)-(125,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FalseNode (location: (125,7)-(125,12))
        │   └── operator_loc: (125,4)-(125,6) = "in"
        ├── @ MatchPredicateNode (location: (126,0)-(126,15))
        │   ├── value:
        │   │   @ CallNode (location: (126,0)-(126,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (126,0)-(126,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceFileNode (location: (126,7)-(126,15))
        │   │   ├── flags: ∅
        │   │   └── filepath: "patterns.txt"
        │   └── operator_loc: (126,4)-(126,6) = "in"
        ├── @ MatchPredicateNode (location: (127,0)-(127,15))
        │   ├── value:
        │   │   @ CallNode (location: (127,0)-(127,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (127,0)-(127,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceLineNode (location: (127,7)-(127,15))
        │   └── operator_loc: (127,4)-(127,6) = "in"
        ├── @ MatchPredicateNode (location: (128,0)-(128,19))
        │   ├── value:
        │   │   @ CallNode (location: (128,0)-(128,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (128,0)-(128,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceEncodingNode (location: (128,7)-(128,19))
        │   └── operator_loc: (128,4)-(128,6) = "in"
        ├── @ MatchPredicateNode (location: (129,0)-(129,17))
        │   ├── value:
        │   │   @ CallNode (location: (129,0)-(129,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (129,0)-(129,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ LambdaNode (location: (129,7)-(129,17))
        │   │   ├── locals: []
        │   │   ├── operator_loc: (129,7)-(129,9) = "->"
        │   │   ├── opening_loc: (129,10)-(129,11) = "{"
        │   │   ├── closing_loc: (129,16)-(129,17) = "}"
        │   │   ├── parameters: ∅
        │   │   └── body:
        │   │       @ StatementsNode (location: (129,12)-(129,15))
        │   │       └── body: (length: 1)
        │   │           └── @ LocalVariableReadNode (location: (129,12)-(129,15))
        │   │               ├── name: :bar
        │   │               └── depth: 1
        │   └── operator_loc: (129,4)-(129,6) = "in"
        ├── @ MatchPredicateNode (location: (131,0)-(131,11))
        │   ├── value:
        │   │   @ CallNode (location: (131,0)-(131,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (131,0)-(131,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (131,7)-(131,11))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (131,7)-(131,10))
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ ImplicitRestNode (location: (131,10)-(131,11))
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (131,4)-(131,6) = "in"
        ├── @ CaseMatchNode (location: (135,0)-(135,25))
        │   ├── predicate:
        │   │   @ CallNode (location: (135,5)-(135,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (135,5)-(135,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (135,10)-(135,21))
        │   │       ├── pattern:
        │   │       │   @ LocalVariableTargetNode (location: (135,13)-(135,16))
        │   │       │   ├── name: :bar
        │   │       │   └── depth: 0
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (135,10)-(135,12) = "in"
        │   │       └── then_loc: (135,17)-(135,21) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (135,0)-(135,4) = "case"
        │   └── end_keyword_loc: (135,22)-(135,25) = "end"
        ├── @ CaseMatchNode (location: (136,0)-(136,23))
        │   ├── predicate:
        │   │   @ CallNode (location: (136,5)-(136,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (136,5)-(136,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (136,10)-(136,19))
        │   │       ├── pattern:
        │   │       │   @ IntegerNode (location: (136,13)-(136,14))
        │   │       │   ├── flags: decimal
        │   │       │   └── value: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (136,10)-(136,12) = "in"
        │   │       └── then_loc: (136,15)-(136,19) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (136,0)-(136,4) = "case"
        │   └── end_keyword_loc: (136,20)-(136,23) = "end"
        ├── @ CaseMatchNode (location: (137,0)-(137,25))
        │   ├── predicate:
        │   │   @ CallNode (location: (137,5)-(137,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (137,5)-(137,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (137,10)-(137,21))
        │   │       ├── pattern:
        │   │       │   @ FloatNode (location: (137,13)-(137,16))
        │   │       │   └── value: 1.0
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (137,10)-(137,12) = "in"
        │   │       └── then_loc: (137,17)-(137,21) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (137,0)-(137,4) = "case"
        │   └── end_keyword_loc: (137,22)-(137,25) = "end"
        ├── @ CaseMatchNode (location: (138,0)-(138,24))
        │   ├── predicate:
        │   │   @ CallNode (location: (138,5)-(138,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (138,5)-(138,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (138,10)-(138,20))
        │   │       ├── pattern:
        │   │       │   @ ImaginaryNode (location: (138,13)-(138,15))
        │   │       │   └── numeric:
        │   │       │       @ IntegerNode (location: (138,13)-(138,14))
        │   │       │       ├── flags: decimal
        │   │       │       └── value: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (138,10)-(138,12) = "in"
        │   │       └── then_loc: (138,16)-(138,20) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (138,0)-(138,4) = "case"
        │   └── end_keyword_loc: (138,21)-(138,24) = "end"
        ├── @ CaseMatchNode (location: (139,0)-(139,24))
        │   ├── predicate:
        │   │   @ CallNode (location: (139,5)-(139,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (139,5)-(139,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (139,10)-(139,20))
        │   │       ├── pattern:
        │   │       │   @ RationalNode (location: (139,13)-(139,15))
        │   │       │   └── numeric:
        │   │       │       @ IntegerNode (location: (139,13)-(139,14))
        │   │       │       ├── flags: decimal
        │   │       │       └── value: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (139,10)-(139,12) = "in"
        │   │       └── then_loc: (139,16)-(139,20) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (139,0)-(139,4) = "case"
        │   └── end_keyword_loc: (139,21)-(139,24) = "end"
        ├── @ CaseMatchNode (location: (140,0)-(140,26))
        │   ├── predicate:
        │   │   @ CallNode (location: (140,5)-(140,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (140,5)-(140,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (140,10)-(140,22))
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (140,13)-(140,17))
        │   │       │   ├── flags: forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (140,13)-(140,14) = ":"
        │   │       │   ├── value_loc: (140,14)-(140,17) = "foo"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (140,10)-(140,12) = "in"
        │   │       └── then_loc: (140,18)-(140,22) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (140,0)-(140,4) = "case"
        │   └── end_keyword_loc: (140,23)-(140,26) = "end"
        ├── @ CaseMatchNode (location: (141,0)-(141,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (141,5)-(141,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (141,5)-(141,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (141,10)-(141,25))
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (141,13)-(141,20))
        │   │       │   ├── flags: forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (141,13)-(141,16) = "%s["
        │   │       │   ├── value_loc: (141,16)-(141,19) = "foo"
        │   │       │   ├── closing_loc: (141,19)-(141,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (141,10)-(141,12) = "in"
        │   │       └── then_loc: (141,21)-(141,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (141,0)-(141,4) = "case"
        │   └── end_keyword_loc: (141,26)-(141,29) = "end"
        ├── @ CaseMatchNode (location: (142,0)-(142,28))
        │   ├── predicate:
        │   │   @ CallNode (location: (142,5)-(142,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (142,5)-(142,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (142,10)-(142,24))
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (142,13)-(142,19))
        │   │       │   ├── flags: forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (142,13)-(142,15) = ":\""
        │   │       │   ├── value_loc: (142,15)-(142,18) = "foo"
        │   │       │   ├── closing_loc: (142,18)-(142,19) = "\""
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (142,10)-(142,12) = "in"
        │   │       └── then_loc: (142,20)-(142,24) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (142,0)-(142,4) = "case"
        │   └── end_keyword_loc: (142,25)-(142,28) = "end"
        ├── @ CaseMatchNode (location: (143,0)-(143,27))
        │   ├── predicate:
        │   │   @ CallNode (location: (143,5)-(143,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (143,5)-(143,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (143,10)-(143,23))
        │   │       ├── pattern:
        │   │       │   @ RegularExpressionNode (location: (143,13)-(143,18))
        │   │       │   ├── flags: forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (143,13)-(143,14) = "/"
        │   │       │   ├── content_loc: (143,14)-(143,17) = "foo"
        │   │       │   ├── closing_loc: (143,17)-(143,18) = "/"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (143,10)-(143,12) = "in"
        │   │       └── then_loc: (143,19)-(143,23) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (143,0)-(143,4) = "case"
        │   └── end_keyword_loc: (143,24)-(143,27) = "end"
        ├── @ CaseMatchNode (location: (144,0)-(144,27))
        │   ├── predicate:
        │   │   @ CallNode (location: (144,5)-(144,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (144,5)-(144,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (144,10)-(144,23))
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (144,13)-(144,18))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (144,13)-(144,14) = "`"
        │   │       │   ├── content_loc: (144,14)-(144,17) = "foo"
        │   │       │   ├── closing_loc: (144,17)-(144,18) = "`"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (144,10)-(144,12) = "in"
        │   │       └── then_loc: (144,19)-(144,23) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (144,0)-(144,4) = "case"
        │   └── end_keyword_loc: (144,24)-(144,27) = "end"
        ├── @ CaseMatchNode (location: (145,0)-(145,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (145,5)-(145,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (145,5)-(145,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (145,10)-(145,25))
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (145,13)-(145,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (145,13)-(145,16) = "%x["
        │   │       │   ├── content_loc: (145,16)-(145,19) = "foo"
        │   │       │   ├── closing_loc: (145,19)-(145,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (145,10)-(145,12) = "in"
        │   │       └── then_loc: (145,21)-(145,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (145,0)-(145,4) = "case"
        │   └── end_keyword_loc: (145,26)-(145,29) = "end"
        ├── @ CaseMatchNode (location: (146,0)-(146,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (146,5)-(146,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (146,5)-(146,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (146,10)-(146,25))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (146,13)-(146,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (146,16)-(146,19))
        │   │       │   │       ├── flags: forced_us_ascii_encoding
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (146,16)-(146,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (146,13)-(146,16) = "%i["
        │   │       │   └── closing_loc: (146,19)-(146,20) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (146,10)-(146,12) = "in"
        │   │       └── then_loc: (146,21)-(146,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (146,0)-(146,4) = "case"
        │   └── end_keyword_loc: (146,26)-(146,29) = "end"
        ├── @ CaseMatchNode (location: (147,0)-(147,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (147,5)-(147,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (147,5)-(147,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (147,10)-(147,25))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (147,13)-(147,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (147,16)-(147,19))
        │   │       │   │       ├── flags: forced_us_ascii_encoding
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (147,16)-(147,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (147,13)-(147,16) = "%I["
        │   │       │   └── closing_loc: (147,19)-(147,20) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (147,10)-(147,12) = "in"
        │   │       └── then_loc: (147,21)-(147,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (147,0)-(147,4) = "case"
        │   └── end_keyword_loc: (147,26)-(147,29) = "end"
        ├── @ CaseMatchNode (location: (148,0)-(148,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (148,5)-(148,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (148,5)-(148,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (148,10)-(148,25))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (148,13)-(148,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ StringNode (location: (148,16)-(148,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (148,16)-(148,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (148,13)-(148,16) = "%w["
        │   │       │   └── closing_loc: (148,19)-(148,20) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (148,10)-(148,12) = "in"
        │   │       └── then_loc: (148,21)-(148,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (148,0)-(148,4) = "case"
        │   └── end_keyword_loc: (148,26)-(148,29) = "end"
        ├── @ CaseMatchNode (location: (149,0)-(149,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (149,5)-(149,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (149,5)-(149,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (149,10)-(149,25))
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (149,13)-(149,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ StringNode (location: (149,16)-(149,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (149,16)-(149,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (149,13)-(149,16) = "%W["
        │   │       │   └── closing_loc: (149,19)-(149,20) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (149,10)-(149,12) = "in"
        │   │       └── then_loc: (149,21)-(149,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (149,0)-(149,4) = "case"
        │   └── end_keyword_loc: (149,26)-(149,29) = "end"
        ├── @ CaseMatchNode (location: (150,0)-(150,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (150,5)-(150,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (150,5)-(150,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (150,10)-(150,25))
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (150,13)-(150,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (150,13)-(150,16) = "%q["
        │   │       │   ├── content_loc: (150,16)-(150,19) = "foo"
        │   │       │   ├── closing_loc: (150,19)-(150,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (150,10)-(150,12) = "in"
        │   │       └── then_loc: (150,21)-(150,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (150,0)-(150,4) = "case"
        │   └── end_keyword_loc: (150,26)-(150,29) = "end"
        ├── @ CaseMatchNode (location: (151,0)-(151,29))
        │   ├── predicate:
        │   │   @ CallNode (location: (151,5)-(151,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (151,5)-(151,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (151,10)-(151,25))
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (151,13)-(151,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (151,13)-(151,16) = "%Q["
        │   │       │   ├── content_loc: (151,16)-(151,19) = "foo"
        │   │       │   ├── closing_loc: (151,19)-(151,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (151,10)-(151,12) = "in"
        │   │       └── then_loc: (151,21)-(151,25) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (151,0)-(151,4) = "case"
        │   └── end_keyword_loc: (151,26)-(151,29) = "end"
        ├── @ CaseMatchNode (location: (152,0)-(152,27))
        │   ├── predicate:
        │   │   @ CallNode (location: (152,5)-(152,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (152,5)-(152,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (152,10)-(152,23))
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (152,13)-(152,18))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (152,13)-(152,14) = "\""
        │   │       │   ├── content_loc: (152,14)-(152,17) = "foo"
        │   │       │   ├── closing_loc: (152,17)-(152,18) = "\""
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (152,10)-(152,12) = "in"
        │   │       └── then_loc: (152,19)-(152,23) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (152,0)-(152,4) = "case"
        │   └── end_keyword_loc: (152,24)-(152,27) = "end"
        ├── @ CaseMatchNode (location: (153,0)-(153,25))
        │   ├── predicate:
        │   │   @ CallNode (location: (153,5)-(153,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (153,5)-(153,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (153,10)-(153,21))
        │   │       ├── pattern:
        │   │       │   @ NilNode (location: (153,13)-(153,16))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (153,10)-(153,12) = "in"
        │   │       └── then_loc: (153,17)-(153,21) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (153,0)-(153,4) = "case"
        │   └── end_keyword_loc: (153,22)-(153,25) = "end"
        ├── @ CaseMatchNode (location: (154,0)-(154,26))
        │   ├── predicate:
        │   │   @ CallNode (location: (154,5)-(154,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (154,5)-(154,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (154,10)-(154,22))
        │   │       ├── pattern:
        │   │       │   @ SelfNode (location: (154,13)-(154,17))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (154,10)-(154,12) = "in"
        │   │       └── then_loc: (154,18)-(154,22) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (154,0)-(154,4) = "case"
        │   └── end_keyword_loc: (154,23)-(154,26) = "end"
        ├── @ CaseMatchNode (location: (155,0)-(155,26))
        │   ├── predicate:
        │   │   @ CallNode (location: (155,5)-(155,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (155,5)-(155,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (155,10)-(155,22))
        │   │       ├── pattern:
        │   │       │   @ TrueNode (location: (155,13)-(155,17))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (155,10)-(155,12) = "in"
        │   │       └── then_loc: (155,18)-(155,22) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (155,0)-(155,4) = "case"
        │   └── end_keyword_loc: (155,23)-(155,26) = "end"
        ├── @ CaseMatchNode (location: (156,0)-(156,27))
        │   ├── predicate:
        │   │   @ CallNode (location: (156,5)-(156,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (156,5)-(156,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (156,10)-(156,23))
        │   │       ├── pattern:
        │   │       │   @ FalseNode (location: (156,13)-(156,18))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (156,10)-(156,12) = "in"
        │   │       └── then_loc: (156,19)-(156,23) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (156,0)-(156,4) = "case"
        │   └── end_keyword_loc: (156,24)-(156,27) = "end"
        ├── @ CaseMatchNode (location: (157,0)-(157,30))
        │   ├── predicate:
        │   │   @ CallNode (location: (157,5)-(157,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (157,5)-(157,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (157,10)-(157,26))
        │   │       ├── pattern:
        │   │       │   @ SourceFileNode (location: (157,13)-(157,21))
        │   │       │   ├── flags: ∅
        │   │       │   └── filepath: "patterns.txt"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (157,10)-(157,12) = "in"
        │   │       └── then_loc: (157,22)-(157,26) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (157,0)-(157,4) = "case"
        │   └── end_keyword_loc: (157,27)-(157,30) = "end"
        ├── @ CaseMatchNode (location: (158,0)-(158,30))
        │   ├── predicate:
        │   │   @ CallNode (location: (158,5)-(158,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (158,5)-(158,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (158,10)-(158,26))
        │   │       ├── pattern:
        │   │       │   @ SourceLineNode (location: (158,13)-(158,21))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (158,10)-(158,12) = "in"
        │   │       └── then_loc: (158,22)-(158,26) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (158,0)-(158,4) = "case"
        │   └── end_keyword_loc: (158,27)-(158,30) = "end"
        ├── @ CaseMatchNode (location: (159,0)-(159,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (159,5)-(159,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (159,5)-(159,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (159,10)-(159,30))
        │   │       ├── pattern:
        │   │       │   @ SourceEncodingNode (location: (159,13)-(159,25))
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (159,10)-(159,12) = "in"
        │   │       └── then_loc: (159,26)-(159,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (159,0)-(159,4) = "case"
        │   └── end_keyword_loc: (159,31)-(159,34) = "end"
        ├── @ CaseMatchNode (location: (160,0)-(160,32))
        │   ├── predicate:
        │   │   @ CallNode (location: (160,5)-(160,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (160,5)-(160,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (160,10)-(160,28))
        │   │       ├── pattern:
        │   │       │   @ LambdaNode (location: (160,13)-(160,23))
        │   │       │   ├── locals: []
        │   │       │   ├── operator_loc: (160,13)-(160,15) = "->"
        │   │       │   ├── opening_loc: (160,16)-(160,17) = "{"
        │   │       │   ├── closing_loc: (160,22)-(160,23) = "}"
        │   │       │   ├── parameters: ∅
        │   │       │   └── body:
        │   │       │       @ StatementsNode (location: (160,18)-(160,21))
        │   │       │       └── body: (length: 1)
        │   │       │           └── @ LocalVariableReadNode (location: (160,18)-(160,21))
        │   │       │               ├── name: :bar
        │   │       │               └── depth: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (160,10)-(160,12) = "in"
        │   │       └── then_loc: (160,24)-(160,28) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (160,0)-(160,4) = "case"
        │   └── end_keyword_loc: (160,29)-(160,32) = "end"
        ├── @ CaseMatchNode (location: (162,0)-(162,32))
        │   ├── predicate:
        │   │   @ CallNode (location: (162,5)-(162,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (162,5)-(162,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (162,10)-(162,28))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (162,13)-(162,23))
        │   │       │   ├── if_keyword_loc: (162,17)-(162,19) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (162,20)-(162,23))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (162,13)-(162,16))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LocalVariableTargetNode (location: (162,13)-(162,16))
        │   │       │   │           ├── name: :bar
        │   │       │   │           └── depth: 0
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (162,10)-(162,12) = "in"
        │   │       └── then_loc: (162,24)-(162,28) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (162,0)-(162,4) = "case"
        │   └── end_keyword_loc: (162,29)-(162,32) = "end"
        ├── @ CaseMatchNode (location: (163,0)-(163,30))
        │   ├── predicate:
        │   │   @ CallNode (location: (163,5)-(163,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (163,5)-(163,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (163,10)-(163,26))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (163,13)-(163,21))
        │   │       │   ├── if_keyword_loc: (163,15)-(163,17) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (163,18)-(163,21))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (163,13)-(163,14))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ IntegerNode (location: (163,13)-(163,14))
        │   │       │   │           ├── flags: decimal
        │   │       │   │           └── value: 1
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (163,10)-(163,12) = "in"
        │   │       └── then_loc: (163,22)-(163,26) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (163,0)-(163,4) = "case"
        │   └── end_keyword_loc: (163,27)-(163,30) = "end"
        ├── @ CaseMatchNode (location: (164,0)-(164,32))
        │   ├── predicate:
        │   │   @ CallNode (location: (164,5)-(164,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (164,5)-(164,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (164,10)-(164,28))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (164,13)-(164,23))
        │   │       │   ├── if_keyword_loc: (164,17)-(164,19) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (164,20)-(164,23))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (164,13)-(164,16))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ FloatNode (location: (164,13)-(164,16))
        │   │       │   │           └── value: 1.0
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (164,10)-(164,12) = "in"
        │   │       └── then_loc: (164,24)-(164,28) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (164,0)-(164,4) = "case"
        │   └── end_keyword_loc: (164,29)-(164,32) = "end"
        ├── @ CaseMatchNode (location: (165,0)-(165,31))
        │   ├── predicate:
        │   │   @ CallNode (location: (165,5)-(165,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (165,5)-(165,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (165,10)-(165,27))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (165,13)-(165,22))
        │   │       │   ├── if_keyword_loc: (165,16)-(165,18) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (165,19)-(165,22))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (165,13)-(165,15))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ImaginaryNode (location: (165,13)-(165,15))
        │   │       │   │           └── numeric:
        │   │       │   │               @ IntegerNode (location: (165,13)-(165,14))
        │   │       │   │               ├── flags: decimal
        │   │       │   │               └── value: 1
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (165,10)-(165,12) = "in"
        │   │       └── then_loc: (165,23)-(165,27) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (165,0)-(165,4) = "case"
        │   └── end_keyword_loc: (165,28)-(165,31) = "end"
        ├── @ CaseMatchNode (location: (166,0)-(166,31))
        │   ├── predicate:
        │   │   @ CallNode (location: (166,5)-(166,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (166,5)-(166,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (166,10)-(166,27))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (166,13)-(166,22))
        │   │       │   ├── if_keyword_loc: (166,16)-(166,18) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (166,19)-(166,22))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (166,13)-(166,15))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ RationalNode (location: (166,13)-(166,15))
        │   │       │   │           └── numeric:
        │   │       │   │               @ IntegerNode (location: (166,13)-(166,14))
        │   │       │   │               ├── flags: decimal
        │   │       │   │               └── value: 1
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (166,10)-(166,12) = "in"
        │   │       └── then_loc: (166,23)-(166,27) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (166,0)-(166,4) = "case"
        │   └── end_keyword_loc: (166,28)-(166,31) = "end"
        ├── @ CaseMatchNode (location: (167,0)-(167,33))
        │   ├── predicate:
        │   │   @ CallNode (location: (167,5)-(167,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (167,5)-(167,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (167,10)-(167,29))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (167,13)-(167,24))
        │   │       │   ├── if_keyword_loc: (167,18)-(167,20) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (167,21)-(167,24))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (167,13)-(167,17))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (167,13)-(167,17))
        │   │       │   │           ├── flags: forced_us_ascii_encoding
        │   │       │   │           ├── opening_loc: (167,13)-(167,14) = ":"
        │   │       │   │           ├── value_loc: (167,14)-(167,17) = "foo"
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (167,10)-(167,12) = "in"
        │   │       └── then_loc: (167,25)-(167,29) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (167,0)-(167,4) = "case"
        │   └── end_keyword_loc: (167,30)-(167,33) = "end"
        ├── @ CaseMatchNode (location: (168,0)-(168,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (168,5)-(168,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (168,5)-(168,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (168,10)-(168,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (168,13)-(168,27))
        │   │       │   ├── if_keyword_loc: (168,21)-(168,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (168,24)-(168,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (168,13)-(168,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (168,13)-(168,20))
        │   │       │   │           ├── flags: forced_us_ascii_encoding
        │   │       │   │           ├── opening_loc: (168,13)-(168,16) = "%s["
        │   │       │   │           ├── value_loc: (168,16)-(168,19) = "foo"
        │   │       │   │           ├── closing_loc: (168,19)-(168,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (168,10)-(168,12) = "in"
        │   │       └── then_loc: (168,28)-(168,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (168,0)-(168,4) = "case"
        │   └── end_keyword_loc: (168,33)-(168,36) = "end"
        ├── @ CaseMatchNode (location: (169,0)-(169,35))
        │   ├── predicate:
        │   │   @ CallNode (location: (169,5)-(169,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (169,5)-(169,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (169,10)-(169,31))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (169,13)-(169,26))
        │   │       │   ├── if_keyword_loc: (169,20)-(169,22) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (169,23)-(169,26))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (169,13)-(169,19))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (169,13)-(169,19))
        │   │       │   │           ├── flags: forced_us_ascii_encoding
        │   │       │   │           ├── opening_loc: (169,13)-(169,15) = ":\""
        │   │       │   │           ├── value_loc: (169,15)-(169,18) = "foo"
        │   │       │   │           ├── closing_loc: (169,18)-(169,19) = "\""
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (169,10)-(169,12) = "in"
        │   │       └── then_loc: (169,27)-(169,31) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (169,0)-(169,4) = "case"
        │   └── end_keyword_loc: (169,32)-(169,35) = "end"
        ├── @ CaseMatchNode (location: (170,0)-(170,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (170,5)-(170,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (170,5)-(170,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (170,10)-(170,30))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (170,13)-(170,25))
        │   │       │   ├── if_keyword_loc: (170,19)-(170,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (170,22)-(170,25))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (170,13)-(170,18))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ RegularExpressionNode (location: (170,13)-(170,18))
        │   │       │   │           ├── flags: forced_us_ascii_encoding
        │   │       │   │           ├── opening_loc: (170,13)-(170,14) = "/"
        │   │       │   │           ├── content_loc: (170,14)-(170,17) = "foo"
        │   │       │   │           ├── closing_loc: (170,17)-(170,18) = "/"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (170,10)-(170,12) = "in"
        │   │       └── then_loc: (170,26)-(170,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (170,0)-(170,4) = "case"
        │   └── end_keyword_loc: (170,31)-(170,34) = "end"
        ├── @ CaseMatchNode (location: (171,0)-(171,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (171,5)-(171,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (171,5)-(171,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (171,10)-(171,30))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (171,13)-(171,25))
        │   │       │   ├── if_keyword_loc: (171,19)-(171,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (171,22)-(171,25))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (171,13)-(171,18))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ XStringNode (location: (171,13)-(171,18))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── opening_loc: (171,13)-(171,14) = "`"
        │   │       │   │           ├── content_loc: (171,14)-(171,17) = "foo"
        │   │       │   │           ├── closing_loc: (171,17)-(171,18) = "`"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (171,10)-(171,12) = "in"
        │   │       └── then_loc: (171,26)-(171,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (171,0)-(171,4) = "case"
        │   └── end_keyword_loc: (171,31)-(171,34) = "end"
        ├── @ CaseMatchNode (location: (172,0)-(172,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (172,5)-(172,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (172,5)-(172,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (172,10)-(172,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (172,13)-(172,27))
        │   │       │   ├── if_keyword_loc: (172,21)-(172,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (172,24)-(172,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (172,13)-(172,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ XStringNode (location: (172,13)-(172,20))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── opening_loc: (172,13)-(172,16) = "%x["
        │   │       │   │           ├── content_loc: (172,16)-(172,19) = "foo"
        │   │       │   │           ├── closing_loc: (172,19)-(172,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (172,10)-(172,12) = "in"
        │   │       └── then_loc: (172,28)-(172,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (172,0)-(172,4) = "case"
        │   └── end_keyword_loc: (172,33)-(172,36) = "end"
        ├── @ CaseMatchNode (location: (173,0)-(173,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (173,5)-(173,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (173,5)-(173,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (173,10)-(173,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (173,13)-(173,27))
        │   │       │   ├── if_keyword_loc: (173,21)-(173,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (173,24)-(173,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (173,13)-(173,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (173,13)-(173,20))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ SymbolNode (location: (173,16)-(173,19))
        │   │       │   │           │       ├── flags: forced_us_ascii_encoding
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── value_loc: (173,16)-(173,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (173,13)-(173,16) = "%i["
        │   │       │   │           └── closing_loc: (173,19)-(173,20) = "]"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (173,10)-(173,12) = "in"
        │   │       └── then_loc: (173,28)-(173,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (173,0)-(173,4) = "case"
        │   └── end_keyword_loc: (173,33)-(173,36) = "end"
        ├── @ CaseMatchNode (location: (174,0)-(174,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (174,5)-(174,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (174,5)-(174,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (174,10)-(174,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (174,13)-(174,27))
        │   │       │   ├── if_keyword_loc: (174,21)-(174,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (174,24)-(174,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (174,13)-(174,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (174,13)-(174,20))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ SymbolNode (location: (174,16)-(174,19))
        │   │       │   │           │       ├── flags: forced_us_ascii_encoding
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── value_loc: (174,16)-(174,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (174,13)-(174,16) = "%I["
        │   │       │   │           └── closing_loc: (174,19)-(174,20) = "]"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (174,10)-(174,12) = "in"
        │   │       └── then_loc: (174,28)-(174,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (174,0)-(174,4) = "case"
        │   └── end_keyword_loc: (174,33)-(174,36) = "end"
        ├── @ CaseMatchNode (location: (175,0)-(175,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (175,5)-(175,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (175,5)-(175,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (175,10)-(175,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (175,13)-(175,27))
        │   │       │   ├── if_keyword_loc: (175,21)-(175,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (175,24)-(175,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (175,13)-(175,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (175,13)-(175,20))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ StringNode (location: (175,16)-(175,19))
        │   │       │   │           │       ├── flags: ∅
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── content_loc: (175,16)-(175,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (175,13)-(175,16) = "%w["
        │   │       │   │           └── closing_loc: (175,19)-(175,20) = "]"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (175,10)-(175,12) = "in"
        │   │       └── then_loc: (175,28)-(175,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (175,0)-(175,4) = "case"
        │   └── end_keyword_loc: (175,33)-(175,36) = "end"
        ├── @ CaseMatchNode (location: (176,0)-(176,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (176,5)-(176,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (176,5)-(176,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (176,10)-(176,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (176,13)-(176,27))
        │   │       │   ├── if_keyword_loc: (176,21)-(176,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (176,24)-(176,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (176,13)-(176,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (176,13)-(176,20))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ StringNode (location: (176,16)-(176,19))
        │   │       │   │           │       ├── flags: ∅
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── content_loc: (176,16)-(176,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (176,13)-(176,16) = "%W["
        │   │       │   │           └── closing_loc: (176,19)-(176,20) = "]"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (176,10)-(176,12) = "in"
        │   │       └── then_loc: (176,28)-(176,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (176,0)-(176,4) = "case"
        │   └── end_keyword_loc: (176,33)-(176,36) = "end"
        ├── @ CaseMatchNode (location: (177,0)-(177,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (177,5)-(177,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (177,5)-(177,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (177,10)-(177,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (177,13)-(177,27))
        │   │       │   ├── if_keyword_loc: (177,21)-(177,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (177,24)-(177,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (177,13)-(177,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (177,13)-(177,20))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── opening_loc: (177,13)-(177,16) = "%q["
        │   │       │   │           ├── content_loc: (177,16)-(177,19) = "foo"
        │   │       │   │           ├── closing_loc: (177,19)-(177,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (177,10)-(177,12) = "in"
        │   │       └── then_loc: (177,28)-(177,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (177,0)-(177,4) = "case"
        │   └── end_keyword_loc: (177,33)-(177,36) = "end"
        ├── @ CaseMatchNode (location: (178,0)-(178,36))
        │   ├── predicate:
        │   │   @ CallNode (location: (178,5)-(178,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (178,5)-(178,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (178,10)-(178,32))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (178,13)-(178,27))
        │   │       │   ├── if_keyword_loc: (178,21)-(178,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (178,24)-(178,27))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (178,13)-(178,20))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (178,13)-(178,20))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── opening_loc: (178,13)-(178,16) = "%Q["
        │   │       │   │           ├── content_loc: (178,16)-(178,19) = "foo"
        │   │       │   │           ├── closing_loc: (178,19)-(178,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (178,10)-(178,12) = "in"
        │   │       └── then_loc: (178,28)-(178,32) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (178,0)-(178,4) = "case"
        │   └── end_keyword_loc: (178,33)-(178,36) = "end"
        ├── @ CaseMatchNode (location: (179,0)-(179,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (179,5)-(179,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (179,5)-(179,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (179,10)-(179,30))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (179,13)-(179,25))
        │   │       │   ├── if_keyword_loc: (179,19)-(179,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (179,22)-(179,25))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (179,13)-(179,18))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (179,13)-(179,18))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── opening_loc: (179,13)-(179,14) = "\""
        │   │       │   │           ├── content_loc: (179,14)-(179,17) = "foo"
        │   │       │   │           ├── closing_loc: (179,17)-(179,18) = "\""
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (179,10)-(179,12) = "in"
        │   │       └── then_loc: (179,26)-(179,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (179,0)-(179,4) = "case"
        │   └── end_keyword_loc: (179,31)-(179,34) = "end"
        ├── @ CaseMatchNode (location: (180,0)-(180,32))
        │   ├── predicate:
        │   │   @ CallNode (location: (180,5)-(180,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (180,5)-(180,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (180,10)-(180,28))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (180,13)-(180,23))
        │   │       │   ├── if_keyword_loc: (180,17)-(180,19) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (180,20)-(180,23))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (180,13)-(180,16))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ NilNode (location: (180,13)-(180,16))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (180,10)-(180,12) = "in"
        │   │       └── then_loc: (180,24)-(180,28) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (180,0)-(180,4) = "case"
        │   └── end_keyword_loc: (180,29)-(180,32) = "end"
        ├── @ CaseMatchNode (location: (181,0)-(181,33))
        │   ├── predicate:
        │   │   @ CallNode (location: (181,5)-(181,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (181,5)-(181,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (181,10)-(181,29))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (181,13)-(181,24))
        │   │       │   ├── if_keyword_loc: (181,18)-(181,20) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (181,21)-(181,24))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (181,13)-(181,17))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SelfNode (location: (181,13)-(181,17))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (181,10)-(181,12) = "in"
        │   │       └── then_loc: (181,25)-(181,29) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (181,0)-(181,4) = "case"
        │   └── end_keyword_loc: (181,30)-(181,33) = "end"
        ├── @ CaseMatchNode (location: (182,0)-(182,33))
        │   ├── predicate:
        │   │   @ CallNode (location: (182,5)-(182,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (182,5)-(182,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (182,10)-(182,29))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (182,13)-(182,24))
        │   │       │   ├── if_keyword_loc: (182,18)-(182,20) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (182,21)-(182,24))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (182,13)-(182,17))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ TrueNode (location: (182,13)-(182,17))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (182,10)-(182,12) = "in"
        │   │       └── then_loc: (182,25)-(182,29) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (182,0)-(182,4) = "case"
        │   └── end_keyword_loc: (182,30)-(182,33) = "end"
        ├── @ CaseMatchNode (location: (183,0)-(183,34))
        │   ├── predicate:
        │   │   @ CallNode (location: (183,5)-(183,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (183,5)-(183,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (183,10)-(183,30))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (183,13)-(183,25))
        │   │       │   ├── if_keyword_loc: (183,19)-(183,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (183,22)-(183,25))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (183,13)-(183,18))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ FalseNode (location: (183,13)-(183,18))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (183,10)-(183,12) = "in"
        │   │       └── then_loc: (183,26)-(183,30) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (183,0)-(183,4) = "case"
        │   └── end_keyword_loc: (183,31)-(183,34) = "end"
        ├── @ CaseMatchNode (location: (184,0)-(184,37))
        │   ├── predicate:
        │   │   @ CallNode (location: (184,5)-(184,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (184,5)-(184,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (184,10)-(184,33))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (184,13)-(184,28))
        │   │       │   ├── if_keyword_loc: (184,22)-(184,24) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (184,25)-(184,28))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (184,13)-(184,21))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceFileNode (location: (184,13)-(184,21))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           └── filepath: "patterns.txt"
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (184,10)-(184,12) = "in"
        │   │       └── then_loc: (184,29)-(184,33) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (184,0)-(184,4) = "case"
        │   └── end_keyword_loc: (184,34)-(184,37) = "end"
        ├── @ CaseMatchNode (location: (185,0)-(185,37))
        │   ├── predicate:
        │   │   @ CallNode (location: (185,5)-(185,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (185,5)-(185,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (185,10)-(185,33))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (185,13)-(185,28))
        │   │       │   ├── if_keyword_loc: (185,22)-(185,24) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (185,25)-(185,28))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (185,13)-(185,21))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceLineNode (location: (185,13)-(185,21))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (185,10)-(185,12) = "in"
        │   │       └── then_loc: (185,29)-(185,33) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (185,0)-(185,4) = "case"
        │   └── end_keyword_loc: (185,34)-(185,37) = "end"
        ├── @ CaseMatchNode (location: (186,0)-(186,41))
        │   ├── predicate:
        │   │   @ CallNode (location: (186,5)-(186,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (186,5)-(186,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (186,10)-(186,37))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (186,13)-(186,32))
        │   │       │   ├── if_keyword_loc: (186,26)-(186,28) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (186,29)-(186,32))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (186,13)-(186,25))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceEncodingNode (location: (186,13)-(186,25))
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (186,10)-(186,12) = "in"
        │   │       └── then_loc: (186,33)-(186,37) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (186,0)-(186,4) = "case"
        │   └── end_keyword_loc: (186,38)-(186,41) = "end"
        ├── @ CaseMatchNode (location: (187,0)-(187,39))
        │   ├── predicate:
        │   │   @ CallNode (location: (187,5)-(187,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (187,5)-(187,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (187,10)-(187,35))
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (187,13)-(187,30))
        │   │       │   ├── if_keyword_loc: (187,24)-(187,26) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (187,27)-(187,30))
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (187,13)-(187,23))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LambdaNode (location: (187,13)-(187,23))
        │   │       │   │           ├── locals: []
        │   │       │   │           ├── operator_loc: (187,13)-(187,15) = "->"
        │   │       │   │           ├── opening_loc: (187,16)-(187,17) = "{"
        │   │       │   │           ├── closing_loc: (187,22)-(187,23) = "}"
        │   │       │   │           ├── parameters: ∅
        │   │       │   │           └── body:
        │   │       │   │               @ StatementsNode (location: (187,18)-(187,21))
        │   │       │   │               └── body: (length: 1)
        │   │       │   │                   └── @ LocalVariableReadNode (location: (187,18)-(187,21))
        │   │       │   │                       ├── name: :bar
        │   │       │   │                       └── depth: 1
        │   │       │   ├── consequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (187,10)-(187,12) = "in"
        │   │       └── then_loc: (187,31)-(187,35) = "then"
        │   ├── consequent: ∅
        │   ├── case_keyword_loc: (187,0)-(187,4) = "case"
        │   └── end_keyword_loc: (187,36)-(187,39) = "end"
        ├── @ IfNode (location: (189,0)-(190,3))
        │   ├── if_keyword_loc: (189,0)-(189,2) = "if"
        │   ├── predicate:
        │   │   @ MatchPredicateNode (location: (189,3)-(189,10))
        │   │   ├── value:
        │   │   │   @ CallNode (location: (189,3)-(189,4))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── message_loc: (189,3)-(189,4) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── pattern:
        │   │   │   @ ArrayPatternNode (location: (189,8)-(189,10))
        │   │   │   ├── constant: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── opening_loc: (189,8)-(189,9) = "["
        │   │   │   └── closing_loc: (189,9)-(189,10) = "]"
        │   │   └── operator_loc: (189,5)-(189,7) = "in"
        │   ├── then_keyword_loc: ∅
        │   ├── statements: ∅
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (190,0)-(190,3) = "end"
        ├── @ MatchRequiredNode (location: (192,0)-(194,1))
        │   ├── value:
        │   │   @ CallNode (location: (192,0)-(192,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (192,0)-(192,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (192,5)-(194,1))
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (193,2)-(193,3))
        │   │   │       ├── name: :b
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (192,5)-(192,6) = "["
        │   │   └── closing_loc: (194,0)-(194,1) = "]"
        │   └── operator_loc: (192,2)-(192,4) = "=>"
        ├── @ MatchPredicateNode (location: (196,0)-(200,1))
        │   ├── value:
        │   │   @ CallNode (location: (196,0)-(196,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (196,0)-(196,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (196,7)-(200,1))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (196,7)-(196,8))
        │   │   │   └── name: :A
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (197,2)-(199,3))
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (197,2)-(197,6))
        │   │   │       │   ├── flags: forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (197,2)-(197,5) = "bar"
        │   │   │       │   ├── closing_loc: (197,5)-(197,6) = ":"
        │   │   │       │   └── unescaped: "bar"
        │   │   │       ├── value:
        │   │   │       │   @ HashPatternNode (location: (197,7)-(199,3))
        │   │   │       │   ├── constant:
        │   │   │       │   │   @ ConstantReadNode (location: (197,7)-(197,8))
        │   │   │       │   │   └── name: :B
        │   │   │       │   ├── elements: (length: 1)
        │   │   │       │   │   └── @ AssocNode (location: (198,4)-(198,12))
        │   │   │       │   │       ├── key:
        │   │   │       │   │       │   @ SymbolNode (location: (198,4)-(198,10))
        │   │   │       │   │       │   ├── flags: forced_us_ascii_encoding
        │   │   │       │   │       │   ├── opening_loc: ∅
        │   │   │       │   │       │   ├── value_loc: (198,4)-(198,9) = "value"
        │   │   │       │   │       │   ├── closing_loc: (198,9)-(198,10) = ":"
        │   │   │       │   │       │   └── unescaped: "value"
        │   │   │       │   │       ├── value:
        │   │   │       │   │       │   @ LocalVariableTargetNode (location: (198,11)-(198,12))
        │   │   │       │   │       │   ├── name: :a
        │   │   │       │   │       │   └── depth: 0
        │   │   │       │   │       └── operator_loc: ∅
        │   │   │       │   ├── rest: ∅
        │   │   │       │   ├── opening_loc: (197,8)-(197,9) = "["
        │   │   │       │   └── closing_loc: (199,2)-(199,3) = "]"
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: (196,8)-(196,9) = "["
        │   │   └── closing_loc: (200,0)-(200,1) = "]"
        │   └── operator_loc: (196,4)-(196,6) = "in"
        ├── @ MatchPredicateNode (location: (202,0)-(202,17))
        │   ├── value:
        │   │   @ CallNode (location: (202,0)-(202,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (202,0)-(202,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ CapturePatternNode (location: (202,7)-(202,17))
        │   │   ├── value:
        │   │   │   @ LocalVariableTargetNode (location: (202,7)-(202,10))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── target:
        │   │   │   @ LocalVariableTargetNode (location: (202,14)-(202,17))
        │   │   │   ├── name: :baz
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (202,11)-(202,13) = "=>"
        │   └── operator_loc: (202,4)-(202,6) = "in"
        ├── @ MatchRequiredNode (location: (203,0)-(203,17))
        │   ├── value:
        │   │   @ CallNode (location: (203,0)-(203,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (203,0)-(203,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ CapturePatternNode (location: (203,7)-(203,17))
        │   │   ├── value:
        │   │   │   @ LocalVariableTargetNode (location: (203,7)-(203,10))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── target:
        │   │   │   @ LocalVariableTargetNode (location: (203,14)-(203,17))
        │   │   │   ├── name: :baz
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (203,11)-(203,13) = "=>"
        │   └── operator_loc: (203,4)-(203,6) = "=>"
        ├── @ MultiWriteNode (location: (205,0)-(205,20))
        │   ├── lefts: (length: 3)
        │   │   ├── @ LocalVariableTargetNode (location: (205,0)-(205,3))
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   ├── @ LocalVariableTargetNode (location: (205,5)-(205,8))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (205,10)-(205,13))
        │   │       ├── name: :baz
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (205,14)-(205,15) = "="
        │   └── value:
        │       @ ArrayNode (location: (205,16)-(205,20))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (205,16)-(205,17))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (205,19)-(205,20))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: ∅
        │       └── closing_loc: ∅
        ├── @ CallNode (location: (206,0)-(208,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (206,0)-(206,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (206,4)-(208,3))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (207,2)-(207,29))
        │       │   └── body: (length: 1)
        │       │       └── @ MatchRequiredNode (location: (207,2)-(207,29))
        │       │           ├── value:
        │       │           │   @ ArrayNode (location: (207,2)-(207,8))
        │       │           │   ├── flags: ∅
        │       │           │   ├── elements: (length: 2)
        │       │           │   │   ├── @ IntegerNode (location: (207,3)-(207,4))
        │       │           │   │   │   ├── flags: decimal
        │       │           │   │   │   └── value: 1
        │       │           │   │   └── @ IntegerNode (location: (207,6)-(207,7))
        │       │           │   │       ├── flags: decimal
        │       │           │   │       └── value: 2
        │       │           │   ├── opening_loc: (207,2)-(207,3) = "["
        │       │           │   └── closing_loc: (207,7)-(207,8) = "]"
        │       │           ├── pattern:
        │       │           │   @ CapturePatternNode (location: (207,12)-(207,29))
        │       │           │   ├── value:
        │       │           │   │   @ ArrayPatternNode (location: (207,12)-(207,22))
        │       │           │   │   ├── constant: ∅
        │       │           │   │   ├── requireds: (length: 2)
        │       │           │   │   │   ├── @ LocalVariableTargetNode (location: (207,13)-(207,16))
        │       │           │   │   │   │   ├── name: :foo
        │       │           │   │   │   │   └── depth: 1
        │       │           │   │   │   └── @ LocalVariableTargetNode (location: (207,18)-(207,21))
        │       │           │   │   │       ├── name: :bar
        │       │           │   │   │       └── depth: 1
        │       │           │   │   ├── rest: ∅
        │       │           │   │   ├── posts: (length: 0)
        │       │           │   │   ├── opening_loc: (207,12)-(207,13) = "["
        │       │           │   │   └── closing_loc: (207,21)-(207,22) = "]"
        │       │           │   ├── target:
        │       │           │   │   @ LocalVariableTargetNode (location: (207,26)-(207,29))
        │       │           │   │   ├── name: :baz
        │       │           │   │   └── depth: 1
        │       │           │   └── operator_loc: (207,23)-(207,25) = "=>"
        │       │           └── operator_loc: (207,9)-(207,11) = "=>"
        │       ├── opening_loc: (206,4)-(206,6) = "do"
        │       └── closing_loc: (208,0)-(208,3) = "end"
        ├── @ MatchRequiredNode (location: (210,0)-(210,19))
        │   ├── value:
        │   │   @ LocalVariableReadNode (location: (210,0)-(210,3))
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (210,7)-(210,19))
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (210,7)-(210,13))
        │   │   │   └── name: :Object
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ HashPatternNode (location: (210,14)-(210,18))
        │   │   │       ├── constant: ∅
        │   │   │       ├── elements: (length: 1)
        │   │   │       │   └── @ AssocNode (location: (210,15)-(210,17))
        │   │   │       │       ├── key:
        │   │   │       │       │   @ SymbolNode (location: (210,15)-(210,17))
        │   │   │       │       │   ├── flags: forced_us_ascii_encoding
        │   │   │       │       │   ├── opening_loc: ∅
        │   │   │       │       │   ├── value_loc: (210,15)-(210,16) = "x"
        │   │   │       │       │   ├── closing_loc: (210,16)-(210,17) = ":"
        │   │   │       │       │   └── unescaped: "x"
        │   │   │       │       ├── value:
        │   │   │       │       │   @ ImplicitNode (location: (210,15)-(210,16))
        │   │   │       │       │   └── value:
        │   │   │       │       │       @ LocalVariableTargetNode (location: (210,15)-(210,16))
        │   │   │       │       │       ├── name: :x
        │   │   │       │       │       └── depth: 0
        │   │   │       │       └── operator_loc: ∅
        │   │   │       ├── rest: ∅
        │   │   │       ├── opening_loc: (210,14)-(210,15) = "{"
        │   │   │       └── closing_loc: (210,17)-(210,18) = "}"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (210,13)-(210,14) = "["
        │   │   └── closing_loc: (210,18)-(210,19) = "]"
        │   └── operator_loc: (210,4)-(210,6) = "=>"
        ├── @ CallNode (location: (212,0)-(212,19))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ IntegerNode (location: (212,0)-(212,1))
        │   │   ├── flags: decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: (212,1)-(212,2) = "."
        │   ├── name: :then
        │   ├── message_loc: (212,2)-(212,6) = "then"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (212,7)-(212,19))
        │       ├── locals: [:_1]
        │       ├── parameters:
        │       │   @ NumberedParametersNode (location: (212,7)-(212,19))
        │       │   └── maximum: 1
        │       ├── body:
        │       │   @ StatementsNode (location: (212,9)-(212,17))
        │       │   └── body: (length: 1)
        │       │       └── @ MatchPredicateNode (location: (212,9)-(212,17))
        │       │           ├── value:
        │       │           │   @ IntegerNode (location: (212,9)-(212,10))
        │       │           │   ├── flags: decimal
        │       │           │   └── value: 1
        │       │           ├── pattern:
        │       │           │   @ PinnedVariableNode (location: (212,14)-(212,17))
        │       │           │   ├── variable:
        │       │           │   │   @ LocalVariableReadNode (location: (212,15)-(212,17))
        │       │           │   │   ├── name: :_1
        │       │           │   │   └── depth: 0
        │       │           │   └── operator_loc: (212,14)-(212,15) = "^"
        │       │           └── operator_loc: (212,11)-(212,13) = "in"
        │       ├── opening_loc: (212,7)-(212,8) = "{"
        │       └── closing_loc: (212,18)-(212,19) = "}"
        └── @ MultiWriteNode (location: (214,0)-(217,5))
            ├── lefts: (length: 2)
            │   ├── @ LocalVariableTargetNode (location: (215,2)-(215,3))
            │   │   ├── name: :a
            │   │   └── depth: 0
            │   └── @ LocalVariableTargetNode (location: (216,2)-(216,3))
            │       ├── name: :b
            │       └── depth: 0
            ├── rest: ∅
            ├── rights: (length: 0)
            ├── lparen_loc: (214,0)-(214,1) = "("
            ├── rparen_loc: (217,0)-(217,1) = ")"
            ├── operator_loc: (217,2)-(217,3) = "="
            └── value:
                @ CallNode (location: (217,4)-(217,5))
                ├── flags: variable_call, ignore_visibility
                ├── receiver: ∅
                ├── call_operator_loc: ∅
                ├── name: :c
                ├── message_loc: (217,4)-(217,5) = "c"
                ├── opening_loc: ∅
                ├── arguments: ∅
                ├── closing_loc: ∅
                └── block: ∅