@ ProgramNode (location: (1,0)-(209,5)) ├── locals: [:bar, :baz, :qux, :b, :a, :foo, :x] └── statements: @ StatementsNode (location: (1,0)-(209,5)) └── body: (length: 178) ├── @ 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 │ └── 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)) │ └── 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 │ └── 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 │ └── 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: ∅ │ │ ├── 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)) │ │ └── 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: [] │ │ ├── locals_body_index: 0 │ │ ├── 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 │ │ ├── right: │ │ │ @ IntegerNode (location: (28,12)-(28,13)) │ │ │ └── flags: decimal │ │ └── 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)) │ │ ├── right: │ │ │ @ FloatNode (location: (29,14)-(29,17)) │ │ └── 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 │ │ ├── right: │ │ │ @ ImaginaryNode (location: (30,13)-(30,15)) │ │ │ └── numeric: │ │ │ @ IntegerNode (location: (30,13)-(30,14)) │ │ │ └── flags: decimal │ │ └── 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 │ │ ├── right: │ │ │ @ RationalNode (location: (31,13)-(31,15)) │ │ │ └── numeric: │ │ │ @ IntegerNode (location: (31,13)-(31,14)) │ │ │ └── flags: decimal │ │ └── 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: ∅ │ │ │ ├── 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: ∅ │ │ │ ├── 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)) │ │ │ └── filepath: "patterns.txt" │ │ ├── right: │ │ │ @ SourceFileNode (location: (49,19)-(49,27)) │ │ │ └── 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: [] │ │ │ ├── locals_body_index: 0 │ │ │ ├── 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: [] │ │ │ ├── locals_body_index: 0 │ │ │ ├── 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 │ └── 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 │ │ ├── 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 │ │ ├── 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 │ │ │ ├── @ IntegerNode (location: (70,14)-(70,15)) │ │ │ │ └── flags: decimal │ │ │ └── @ IntegerNode (location: (70,17)-(70,18)) │ │ │ └── flags: decimal │ │ ├── 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 │ │ ├── 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 │ │ │ ├── @ IntegerNode (location: (78,14)-(78,15)) │ │ │ │ └── flags: decimal │ │ │ └── @ IntegerNode (location: (78,17)-(78,18)) │ │ │ └── flags: decimal │ │ ├── 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,9)) │ ├── 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,9)) │ │ ├── constant: ∅ │ │ ├── requireds: (length: 0) │ │ ├── rest: ∅ │ │ ├── posts: (length: 0) │ │ ├── opening_loc: (91,7)-(91,8) = "[" │ │ └── closing_loc: (91,8)-(91,9) = "]" │ └── operator_loc: (91,4)-(91,6) = "=>" ├── @ MatchRequiredNode (location: (92,0)-(92,17)) │ ├── value: │ │ @ CallNode (location: (92,0)-(92,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (92,0)-(92,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── pattern: │ │ @ ArrayPatternNode (location: (92,7)-(92,17)) │ │ ├── constant: ∅ │ │ ├── requireds: (length: 1) │ │ │ └── @ ArrayPatternNode (location: (92,8)-(92,16)) │ │ │ ├── constant: ∅ │ │ │ ├── requireds: (length: 1) │ │ │ │ └── @ ArrayPatternNode (location: (92,9)-(92,15)) │ │ │ │ ├── constant: ∅ │ │ │ │ ├── requireds: (length: 1) │ │ │ │ │ └── @ ArrayPatternNode (location: (92,10)-(92,14)) │ │ │ │ │ ├── constant: ∅ │ │ │ │ │ ├── requireds: (length: 1) │ │ │ │ │ │ └── @ ArrayPatternNode (location: (92,11)-(92,13)) │ │ │ │ │ │ ├── constant: ∅ │ │ │ │ │ │ ├── requireds: (length: 0) │ │ │ │ │ │ ├── rest: ∅ │ │ │ │ │ │ ├── posts: (length: 0) │ │ │ │ │ │ ├── opening_loc: (92,11)-(92,12) = "[" │ │ │ │ │ │ └── closing_loc: (92,12)-(92,13) = "]" │ │ │ │ │ ├── rest: ∅ │ │ │ │ │ ├── posts: (length: 0) │ │ │ │ │ ├── opening_loc: (92,10)-(92,11) = "[" │ │ │ │ │ └── closing_loc: (92,13)-(92,14) = "]" │ │ │ │ ├── rest: ∅ │ │ │ │ ├── posts: (length: 0) │ │ │ │ ├── opening_loc: (92,9)-(92,10) = "[" │ │ │ │ └── closing_loc: (92,14)-(92,15) = "]" │ │ │ ├── rest: ∅ │ │ │ ├── posts: (length: 0) │ │ │ ├── opening_loc: (92,8)-(92,9) = "[" │ │ │ └── closing_loc: (92,15)-(92,16) = "]" │ │ ├── rest: ∅ │ │ ├── posts: (length: 0) │ │ ├── opening_loc: (92,7)-(92,8) = "[" │ │ └── closing_loc: (92,16)-(92,17) = "]" │ └── operator_loc: (92,4)-(92,6) = "=>" ├── @ MatchRequiredNode (location: (94,0)-(94,13)) │ ├── value: │ │ @ CallNode (location: (94,0)-(94,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (94,0)-(94,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── pattern: │ │ @ ArrayPatternNode (location: (94,7)-(94,13)) │ │ ├── constant: ∅ │ │ ├── requireds: (length: 0) │ │ ├── rest: │ │ │ @ SplatNode (location: (94,8)-(94,12)) │ │ │ ├── operator_loc: (94,8)-(94,9) = "*" │ │ │ └── expression: │ │ │ @ LocalVariableTargetNode (location: (94,9)-(94,12)) │ │ │ ├── name: :bar │ │ │ └── depth: 0 │ │ ├── posts: (length: 0) │ │ ├── opening_loc: (94,7)-(94,8) = "[" │ │ └── closing_loc: (94,12)-(94,13) = "]" │ └── operator_loc: (94,4)-(94,6) = "=>" ├── @ MatchRequiredNode (location: (95,0)-(95,23)) │ ├── 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,23)) │ │ ├── constant: ∅ │ │ ├── requireds: (length: 0) │ │ ├── rest: │ │ │ @ SplatNode (location: (95,8)-(95,12)) │ │ │ ├── operator_loc: (95,8)-(95,9) = "*" │ │ │ └── expression: │ │ │ @ LocalVariableTargetNode (location: (95,9)-(95,12)) │ │ │ ├── name: :bar │ │ │ └── depth: 0 │ │ ├── posts: (length: 2) │ │ │ ├── @ LocalVariableTargetNode (location: (95,14)-(95,17)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ └── @ LocalVariableTargetNode (location: (95,19)-(95,22)) │ │ │ ├── name: :qux │ │ │ └── depth: 0 │ │ ├── opening_loc: (95,7)-(95,8) = "[" │ │ └── closing_loc: (95,22)-(95,23) = "]" │ └── operator_loc: (95,4)-(95,6) = "=>" ├── @ MatchRequiredNode (location: (96,0)-(96,23)) │ ├── 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,23)) │ │ ├── constant: ∅ │ │ ├── requireds: (length: 1) │ │ │ └── @ LocalVariableTargetNode (location: (96,8)-(96,11)) │ │ │ ├── name: :bar │ │ │ └── depth: 0 │ │ ├── rest: │ │ │ @ SplatNode (location: (96,13)-(96,17)) │ │ │ ├── operator_loc: (96,13)-(96,14) = "*" │ │ │ └── expression: │ │ │ @ LocalVariableTargetNode (location: (96,14)-(96,17)) │ │ │ ├── name: :baz │ │ │ └── depth: 0 │ │ ├── posts: (length: 1) │ │ │ └── @ LocalVariableTargetNode (location: (96,19)-(96,22)) │ │ │ ├── name: :qux │ │ │ └── depth: 0 │ │ ├── opening_loc: (96,7)-(96,8) = "[" │ │ └── closing_loc: (96,22)-(96,23) = "]" │ └── operator_loc: (96,4)-(96,6) = "=>" ├── @ MatchRequiredNode (location: (97,0)-(97,23)) │ ├── value: │ │ @ CallNode (location: (97,0)-(97,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (97,0)-(97,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── pattern: │ │ @ ArrayPatternNode (location: (97,7)-(97,23)) │ │ ├── constant: ∅ │ │ ├── requireds: (length: 2) │ │ │ ├── @ LocalVariableTargetNode (location: (97,8)-(97,11)) │ │ │ │ ├── name: :bar │ │ │ │ └── depth: 0 │ │ │ └── @ LocalVariableTargetNode (location: (97,13)-(97,16)) │ │ │ ├── name: :baz │ │ │ └── depth: 0 │ │ ├── rest: │ │ │ @ SplatNode (location: (97,18)-(97,22)) │ │ │ ├── operator_loc: (97,18)-(97,19) = "*" │ │ │ └── expression: │ │ │ @ LocalVariableTargetNode (location: (97,19)-(97,22)) │ │ │ ├── name: :qux │ │ │ └── depth: 0 │ │ ├── posts: (length: 0) │ │ ├── opening_loc: (97,7)-(97,8) = "[" │ │ └── closing_loc: (97,22)-(97,23) = "]" │ └── operator_loc: (97,4)-(97,6) = "=>" ├── @ MatchRequiredNode (location: (98,0)-(98,24)) │ ├── 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: │ │ @ FindPatternNode (location: (98,7)-(98,24)) │ │ ├── constant: ∅ │ │ ├── left: │ │ │ @ SplatNode (location: (98,8)-(98,12)) │ │ │ ├── operator_loc: (98,8)-(98,9) = "*" │ │ │ └── expression: │ │ │ @ LocalVariableTargetNode (location: (98,9)-(98,12)) │ │ │ ├── name: :bar │ │ │ └── depth: 0 │ │ ├── requireds: (length: 1) │ │ │ └── @ LocalVariableTargetNode (location: (98,14)-(98,17)) │ │ │ ├── name: :baz │ │ │ └── depth: 0 │ │ ├── right: │ │ │ @ SplatNode (location: (98,19)-(98,23)) │ │ │ ├── operator_loc: (98,19)-(98,20) = "*" │ │ │ └── expression: │ │ │ @ LocalVariableTargetNode (location: (98,20)-(98,23)) │ │ │ ├── name: :qux │ │ │ └── depth: 0 │ │ ├── opening_loc: (98,7)-(98,8) = "[" │ │ └── closing_loc: (98,23)-(98,24) = "]" │ └── operator_loc: (98,4)-(98,6) = "=>" ├── @ MatchPredicateNode (location: (100,0)-(100,10)) │ ├── 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: │ │ @ LocalVariableTargetNode (location: (100,7)-(100,10)) │ │ ├── name: :bar │ │ └── depth: 0 │ └── operator_loc: (100,4)-(100,6) = "in" ├── @ MatchPredicateNode (location: (101,0)-(101,8)) │ ├── 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: │ │ @ IntegerNode (location: (101,7)-(101,8)) │ │ └── flags: decimal │ └── operator_loc: (101,4)-(101,6) = "in" ├── @ MatchPredicateNode (location: (102,0)-(102,10)) │ ├── 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: │ │ @ FloatNode (location: (102,7)-(102,10)) │ └── operator_loc: (102,4)-(102,6) = "in" ├── @ MatchPredicateNode (location: (103,0)-(103,9)) │ ├── value: │ │ @ CallNode (location: (103,0)-(103,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (103,0)-(103,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── pattern: │ │ @ ImaginaryNode (location: (103,7)-(103,9)) │ │ └── numeric: │ │ @ IntegerNode (location: (103,7)-(103,8)) │ │ └── flags: decimal │ └── operator_loc: (103,4)-(103,6) = "in" ├── @ MatchPredicateNode (location: (104,0)-(104,9)) │ ├── 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: │ │ @ RationalNode (location: (104,7)-(104,9)) │ │ └── numeric: │ │ @ IntegerNode (location: (104,7)-(104,8)) │ │ └── flags: decimal │ └── operator_loc: (104,4)-(104,6) = "in" ├── @ MatchPredicateNode (location: (105,0)-(105,11)) │ ├── 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: │ │ @ SymbolNode (location: (105,7)-(105,11)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (105,7)-(105,8) = ":" │ │ ├── value_loc: (105,8)-(105,11) = "foo" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "foo" │ └── operator_loc: (105,4)-(105,6) = "in" ├── @ MatchPredicateNode (location: (106,0)-(106,14)) │ ├── 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: │ │ @ SymbolNode (location: (106,7)-(106,14)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (106,7)-(106,10) = "%s[" │ │ ├── value_loc: (106,10)-(106,13) = "foo" │ │ ├── closing_loc: (106,13)-(106,14) = "]" │ │ └── unescaped: "foo" │ └── operator_loc: (106,4)-(106,6) = "in" ├── @ MatchPredicateNode (location: (107,0)-(107,13)) │ ├── 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: │ │ @ SymbolNode (location: (107,7)-(107,13)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (107,7)-(107,9) = ":\"" │ │ ├── value_loc: (107,9)-(107,12) = "foo" │ │ ├── closing_loc: (107,12)-(107,13) = "\"" │ │ └── unescaped: "foo" │ └── operator_loc: (107,4)-(107,6) = "in" ├── @ MatchPredicateNode (location: (108,0)-(108,12)) │ ├── 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: │ │ @ RegularExpressionNode (location: (108,7)-(108,12)) │ │ ├── flags: ∅ │ │ ├── opening_loc: (108,7)-(108,8) = "/" │ │ ├── content_loc: (108,8)-(108,11) = "foo" │ │ ├── closing_loc: (108,11)-(108,12) = "/" │ │ └── unescaped: "foo" │ └── operator_loc: (108,4)-(108,6) = "in" ├── @ MatchPredicateNode (location: (109,0)-(109,12)) │ ├── 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: │ │ @ XStringNode (location: (109,7)-(109,12)) │ │ ├── flags: ∅ │ │ ├── opening_loc: (109,7)-(109,8) = "`" │ │ ├── content_loc: (109,8)-(109,11) = "foo" │ │ ├── closing_loc: (109,11)-(109,12) = "`" │ │ └── 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: │ │ @ XStringNode (location: (110,7)-(110,14)) │ │ ├── flags: ∅ │ │ ├── opening_loc: (110,7)-(110,10) = "%x[" │ │ ├── content_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,14)) │ ├── 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: │ │ @ ArrayNode (location: (111,7)-(111,14)) │ │ ├── flags: ∅ │ │ ├── elements: (length: 1) │ │ │ └── @ SymbolNode (location: (111,10)-(111,13)) │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (111,10)-(111,13) = "foo" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "foo" │ │ ├── opening_loc: (111,7)-(111,10) = "%i[" │ │ └── closing_loc: (111,13)-(111,14) = "]" │ └── operator_loc: (111,4)-(111,6) = "in" ├── @ MatchPredicateNode (location: (112,0)-(112,14)) │ ├── 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: │ │ @ ArrayNode (location: (112,7)-(112,14)) │ │ ├── flags: ∅ │ │ ├── elements: (length: 1) │ │ │ └── @ SymbolNode (location: (112,10)-(112,13)) │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (112,10)-(112,13) = "foo" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "foo" │ │ ├── opening_loc: (112,7)-(112,10) = "%I[" │ │ └── closing_loc: (112,13)-(112,14) = "]" │ └── operator_loc: (112,4)-(112,6) = "in" ├── @ MatchPredicateNode (location: (113,0)-(113,14)) │ ├── 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: │ │ @ ArrayNode (location: (113,7)-(113,14)) │ │ ├── flags: ∅ │ │ ├── elements: (length: 1) │ │ │ └── @ StringNode (location: (113,10)-(113,13)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ │ │ │ ├── content_loc: (113,10)-(113,13) = "foo" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "foo" │ │ ├── opening_loc: (113,7)-(113,10) = "%w[" │ │ └── closing_loc: (113,13)-(113,14) = "]" │ └── 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: │ │ @ ArrayNode (location: (114,7)-(114,14)) │ │ ├── flags: ∅ │ │ ├── elements: (length: 1) │ │ │ └── @ StringNode (location: (114,10)-(114,13)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ │ │ │ ├── content_loc: (114,10)-(114,13) = "foo" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "foo" │ │ ├── opening_loc: (114,7)-(114,10) = "%W[" │ │ └── closing_loc: (114,13)-(114,14) = "]" │ └── 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: │ │ @ StringNode (location: (115,7)-(115,14)) │ │ ├── flags: ∅ │ │ ├── opening_loc: (115,7)-(115,10) = "%q[" │ │ ├── content_loc: (115,10)-(115,13) = "foo" │ │ ├── closing_loc: (115,13)-(115,14) = "]" │ │ └── unescaped: "foo" │ └── 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: │ │ @ StringNode (location: (116,7)-(116,14)) │ │ ├── flags: ∅ │ │ ├── opening_loc: (116,7)-(116,10) = "%Q[" │ │ ├── content_loc: (116,10)-(116,13) = "foo" │ │ ├── closing_loc: (116,13)-(116,14) = "]" │ │ └── unescaped: "foo" │ └── operator_loc: (116,4)-(116,6) = "in" ├── @ MatchPredicateNode (location: (117,0)-(117,12)) │ ├── 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: │ │ @ StringNode (location: (117,7)-(117,12)) │ │ ├── flags: ∅ │ │ ├── opening_loc: (117,7)-(117,8) = "\"" │ │ ├── content_loc: (117,8)-(117,11) = "foo" │ │ ├── closing_loc: (117,11)-(117,12) = "\"" │ │ └── unescaped: "foo" │ └── operator_loc: (117,4)-(117,6) = "in" ├── @ MatchPredicateNode (location: (118,0)-(118,10)) │ ├── 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: │ │ @ NilNode (location: (118,7)-(118,10)) │ └── operator_loc: (118,4)-(118,6) = "in" ├── @ MatchPredicateNode (location: (119,0)-(119,11)) │ ├── 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: │ │ @ SelfNode (location: (119,7)-(119,11)) │ └── operator_loc: (119,4)-(119,6) = "in" ├── @ MatchPredicateNode (location: (120,0)-(120,11)) │ ├── 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: │ │ @ TrueNode (location: (120,7)-(120,11)) │ └── 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: │ │ @ FalseNode (location: (121,7)-(121,12)) │ └── operator_loc: (121,4)-(121,6) = "in" ├── @ MatchPredicateNode (location: (122,0)-(122,15)) │ ├── 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: │ │ @ SourceFileNode (location: (122,7)-(122,15)) │ │ └── filepath: "patterns.txt" │ └── operator_loc: (122,4)-(122,6) = "in" ├── @ MatchPredicateNode (location: (123,0)-(123,15)) │ ├── 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: │ │ @ SourceLineNode (location: (123,7)-(123,15)) │ └── operator_loc: (123,4)-(123,6) = "in" ├── @ MatchPredicateNode (location: (124,0)-(124,19)) │ ├── 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: │ │ @ SourceEncodingNode (location: (124,7)-(124,19)) │ └── operator_loc: (124,4)-(124,6) = "in" ├── @ MatchPredicateNode (location: (125,0)-(125,17)) │ ├── 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: │ │ @ LambdaNode (location: (125,7)-(125,17)) │ │ ├── locals: [] │ │ ├── locals_body_index: 0 │ │ ├── operator_loc: (125,7)-(125,9) = "->" │ │ ├── opening_loc: (125,10)-(125,11) = "{" │ │ ├── closing_loc: (125,16)-(125,17) = "}" │ │ ├── parameters: ∅ │ │ └── body: │ │ @ StatementsNode (location: (125,12)-(125,15)) │ │ └── body: (length: 1) │ │ └── @ LocalVariableReadNode (location: (125,12)-(125,15)) │ │ ├── name: :bar │ │ └── depth: 1 │ └── operator_loc: (125,4)-(125,6) = "in" ├── @ CaseMatchNode (location: (127,0)-(127,25)) │ ├── predicate: │ │ @ CallNode (location: (127,5)-(127,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (127,5)-(127,8) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (127,10)-(127,21)) │ │ ├── pattern: │ │ │ @ LocalVariableTargetNode (location: (127,13)-(127,16)) │ │ │ ├── name: :bar │ │ │ └── depth: 0 │ │ ├── statements: ∅ │ │ ├── in_loc: (127,10)-(127,12) = "in" │ │ └── then_loc: (127,17)-(127,21) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (127,0)-(127,4) = "case" │ └── end_keyword_loc: (127,22)-(127,25) = "end" ├── @ CaseMatchNode (location: (128,0)-(128,23)) │ ├── predicate: │ │ @ CallNode (location: (128,5)-(128,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (128,5)-(128,8) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (128,10)-(128,19)) │ │ ├── pattern: │ │ │ @ IntegerNode (location: (128,13)-(128,14)) │ │ │ └── flags: decimal │ │ ├── statements: ∅ │ │ ├── in_loc: (128,10)-(128,12) = "in" │ │ └── then_loc: (128,15)-(128,19) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (128,0)-(128,4) = "case" │ └── end_keyword_loc: (128,20)-(128,23) = "end" ├── @ CaseMatchNode (location: (129,0)-(129,25)) │ ├── predicate: │ │ @ CallNode (location: (129,5)-(129,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (129,5)-(129,8) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (129,10)-(129,21)) │ │ ├── pattern: │ │ │ @ FloatNode (location: (129,13)-(129,16)) │ │ ├── statements: ∅ │ │ ├── in_loc: (129,10)-(129,12) = "in" │ │ └── then_loc: (129,17)-(129,21) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (129,0)-(129,4) = "case" │ └── end_keyword_loc: (129,22)-(129,25) = "end" ├── @ CaseMatchNode (location: (130,0)-(130,24)) │ ├── predicate: │ │ @ CallNode (location: (130,5)-(130,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (130,5)-(130,8) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (130,10)-(130,20)) │ │ ├── pattern: │ │ │ @ ImaginaryNode (location: (130,13)-(130,15)) │ │ │ └── numeric: │ │ │ @ IntegerNode (location: (130,13)-(130,14)) │ │ │ └── flags: decimal │ │ ├── statements: ∅ │ │ ├── in_loc: (130,10)-(130,12) = "in" │ │ └── then_loc: (130,16)-(130,20) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (130,0)-(130,4) = "case" │ └── end_keyword_loc: (130,21)-(130,24) = "end" ├── @ CaseMatchNode (location: (131,0)-(131,24)) │ ├── predicate: │ │ @ CallNode (location: (131,5)-(131,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (131,5)-(131,8) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (131,10)-(131,20)) │ │ ├── pattern: │ │ │ @ RationalNode (location: (131,13)-(131,15)) │ │ │ └── numeric: │ │ │ @ IntegerNode (location: (131,13)-(131,14)) │ │ │ └── flags: decimal │ │ ├── statements: ∅ │ │ ├── in_loc: (131,10)-(131,12) = "in" │ │ └── then_loc: (131,16)-(131,20) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (131,0)-(131,4) = "case" │ └── end_keyword_loc: (131,21)-(131,24) = "end" ├── @ CaseMatchNode (location: (132,0)-(132,26)) │ ├── predicate: │ │ @ CallNode (location: (132,5)-(132,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (132,5)-(132,8) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (132,10)-(132,22)) │ │ ├── pattern: │ │ │ @ SymbolNode (location: (132,13)-(132,17)) │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ ├── opening_loc: (132,13)-(132,14) = ":" │ │ │ ├── value_loc: (132,14)-(132,17) = "foo" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ │ │ ├── in_loc: (132,10)-(132,12) = "in" │ │ └── then_loc: (132,18)-(132,22) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (132,0)-(132,4) = "case" │ └── end_keyword_loc: (132,23)-(132,26) = "end" ├── @ CaseMatchNode (location: (133,0)-(133,29)) │ ├── predicate: │ │ @ CallNode (location: (133,5)-(133,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (133,5)-(133,8) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (133,10)-(133,25)) │ │ ├── pattern: │ │ │ @ SymbolNode (location: (133,13)-(133,20)) │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ ├── opening_loc: (133,13)-(133,16) = "%s[" │ │ │ ├── value_loc: (133,16)-(133,19) = "foo" │ │ │ ├── closing_loc: (133,19)-(133,20) = "]" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ │ │ ├── in_loc: (133,10)-(133,12) = "in" │ │ └── then_loc: (133,21)-(133,25) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (133,0)-(133,4) = "case" │ └── end_keyword_loc: (133,26)-(133,29) = "end" ├── @ CaseMatchNode (location: (134,0)-(134,28)) │ ├── predicate: │ │ @ CallNode (location: (134,5)-(134,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (134,5)-(134,8) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (134,10)-(134,24)) │ │ ├── pattern: │ │ │ @ SymbolNode (location: (134,13)-(134,19)) │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ ├── opening_loc: (134,13)-(134,15) = ":\"" │ │ │ ├── value_loc: (134,15)-(134,18) = "foo" │ │ │ ├── closing_loc: (134,18)-(134,19) = "\"" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ │ │ ├── in_loc: (134,10)-(134,12) = "in" │ │ └── then_loc: (134,20)-(134,24) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (134,0)-(134,4) = "case" │ └── end_keyword_loc: (134,25)-(134,28) = "end" ├── @ CaseMatchNode (location: (135,0)-(135,27)) │ ├── 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,23)) │ │ ├── pattern: │ │ │ @ RegularExpressionNode (location: (135,13)-(135,18)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: (135,13)-(135,14) = "/" │ │ │ ├── content_loc: (135,14)-(135,17) = "foo" │ │ │ ├── closing_loc: (135,17)-(135,18) = "/" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ │ │ ├── in_loc: (135,10)-(135,12) = "in" │ │ └── then_loc: (135,19)-(135,23) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (135,0)-(135,4) = "case" │ └── end_keyword_loc: (135,24)-(135,27) = "end" ├── @ CaseMatchNode (location: (136,0)-(136,27)) │ ├── 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,23)) │ │ ├── pattern: │ │ │ @ XStringNode (location: (136,13)-(136,18)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: (136,13)-(136,14) = "`" │ │ │ ├── content_loc: (136,14)-(136,17) = "foo" │ │ │ ├── closing_loc: (136,17)-(136,18) = "`" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ │ │ ├── in_loc: (136,10)-(136,12) = "in" │ │ └── then_loc: (136,19)-(136,23) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (136,0)-(136,4) = "case" │ └── end_keyword_loc: (136,24)-(136,27) = "end" ├── @ CaseMatchNode (location: (137,0)-(137,29)) │ ├── 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,25)) │ │ ├── pattern: │ │ │ @ XStringNode (location: (137,13)-(137,20)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: (137,13)-(137,16) = "%x[" │ │ │ ├── content_loc: (137,16)-(137,19) = "foo" │ │ │ ├── closing_loc: (137,19)-(137,20) = "]" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ │ │ ├── in_loc: (137,10)-(137,12) = "in" │ │ └── then_loc: (137,21)-(137,25) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (137,0)-(137,4) = "case" │ └── end_keyword_loc: (137,26)-(137,29) = "end" ├── @ CaseMatchNode (location: (138,0)-(138,29)) │ ├── 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,25)) │ │ ├── pattern: │ │ │ @ ArrayNode (location: (138,13)-(138,20)) │ │ │ ├── flags: ∅ │ │ │ ├── elements: (length: 1) │ │ │ │ └── @ SymbolNode (location: (138,16)-(138,19)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── value_loc: (138,16)-(138,19) = "foo" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "foo" │ │ │ ├── opening_loc: (138,13)-(138,16) = "%i[" │ │ │ └── closing_loc: (138,19)-(138,20) = "]" │ │ ├── statements: ∅ │ │ ├── in_loc: (138,10)-(138,12) = "in" │ │ └── then_loc: (138,21)-(138,25) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (138,0)-(138,4) = "case" │ └── end_keyword_loc: (138,26)-(138,29) = "end" ├── @ CaseMatchNode (location: (139,0)-(139,29)) │ ├── 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,25)) │ │ ├── pattern: │ │ │ @ ArrayNode (location: (139,13)-(139,20)) │ │ │ ├── flags: ∅ │ │ │ ├── elements: (length: 1) │ │ │ │ └── @ SymbolNode (location: (139,16)-(139,19)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── value_loc: (139,16)-(139,19) = "foo" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "foo" │ │ │ ├── opening_loc: (139,13)-(139,16) = "%I[" │ │ │ └── closing_loc: (139,19)-(139,20) = "]" │ │ ├── statements: ∅ │ │ ├── in_loc: (139,10)-(139,12) = "in" │ │ └── then_loc: (139,21)-(139,25) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (139,0)-(139,4) = "case" │ └── end_keyword_loc: (139,26)-(139,29) = "end" ├── @ CaseMatchNode (location: (140,0)-(140,29)) │ ├── 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,25)) │ │ ├── pattern: │ │ │ @ ArrayNode (location: (140,13)-(140,20)) │ │ │ ├── flags: ∅ │ │ │ ├── elements: (length: 1) │ │ │ │ └── @ StringNode (location: (140,16)-(140,19)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── content_loc: (140,16)-(140,19) = "foo" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "foo" │ │ │ ├── opening_loc: (140,13)-(140,16) = "%w[" │ │ │ └── closing_loc: (140,19)-(140,20) = "]" │ │ ├── statements: ∅ │ │ ├── in_loc: (140,10)-(140,12) = "in" │ │ └── then_loc: (140,21)-(140,25) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (140,0)-(140,4) = "case" │ └── end_keyword_loc: (140,26)-(140,29) = "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: │ │ │ @ ArrayNode (location: (141,13)-(141,20)) │ │ │ ├── flags: ∅ │ │ │ ├── elements: (length: 1) │ │ │ │ └── @ StringNode (location: (141,16)-(141,19)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── content_loc: (141,16)-(141,19) = "foo" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "foo" │ │ │ ├── opening_loc: (141,13)-(141,16) = "%W[" │ │ │ └── closing_loc: (141,19)-(141,20) = "]" │ │ ├── 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,29)) │ ├── 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,25)) │ │ ├── pattern: │ │ │ @ StringNode (location: (142,13)-(142,20)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: (142,13)-(142,16) = "%q[" │ │ │ ├── content_loc: (142,16)-(142,19) = "foo" │ │ │ ├── closing_loc: (142,19)-(142,20) = "]" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ │ │ ├── in_loc: (142,10)-(142,12) = "in" │ │ └── then_loc: (142,21)-(142,25) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (142,0)-(142,4) = "case" │ └── end_keyword_loc: (142,26)-(142,29) = "end" ├── @ CaseMatchNode (location: (143,0)-(143,29)) │ ├── 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,25)) │ │ ├── pattern: │ │ │ @ StringNode (location: (143,13)-(143,20)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: (143,13)-(143,16) = "%Q[" │ │ │ ├── content_loc: (143,16)-(143,19) = "foo" │ │ │ ├── closing_loc: (143,19)-(143,20) = "]" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ │ │ ├── in_loc: (143,10)-(143,12) = "in" │ │ └── then_loc: (143,21)-(143,25) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (143,0)-(143,4) = "case" │ └── end_keyword_loc: (143,26)-(143,29) = "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: │ │ │ @ StringNode (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,25)) │ ├── 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,21)) │ │ ├── pattern: │ │ │ @ NilNode (location: (145,13)-(145,16)) │ │ ├── statements: ∅ │ │ ├── in_loc: (145,10)-(145,12) = "in" │ │ └── then_loc: (145,17)-(145,21) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (145,0)-(145,4) = "case" │ └── end_keyword_loc: (145,22)-(145,25) = "end" ├── @ CaseMatchNode (location: (146,0)-(146,26)) │ ├── 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,22)) │ │ ├── pattern: │ │ │ @ SelfNode (location: (146,13)-(146,17)) │ │ ├── statements: ∅ │ │ ├── in_loc: (146,10)-(146,12) = "in" │ │ └── then_loc: (146,18)-(146,22) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (146,0)-(146,4) = "case" │ └── end_keyword_loc: (146,23)-(146,26) = "end" ├── @ CaseMatchNode (location: (147,0)-(147,26)) │ ├── 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,22)) │ │ ├── pattern: │ │ │ @ TrueNode (location: (147,13)-(147,17)) │ │ ├── statements: ∅ │ │ ├── in_loc: (147,10)-(147,12) = "in" │ │ └── then_loc: (147,18)-(147,22) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (147,0)-(147,4) = "case" │ └── end_keyword_loc: (147,23)-(147,26) = "end" ├── @ CaseMatchNode (location: (148,0)-(148,27)) │ ├── 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,23)) │ │ ├── pattern: │ │ │ @ FalseNode (location: (148,13)-(148,18)) │ │ ├── statements: ∅ │ │ ├── in_loc: (148,10)-(148,12) = "in" │ │ └── then_loc: (148,19)-(148,23) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (148,0)-(148,4) = "case" │ └── end_keyword_loc: (148,24)-(148,27) = "end" ├── @ CaseMatchNode (location: (149,0)-(149,30)) │ ├── 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,26)) │ │ ├── pattern: │ │ │ @ SourceFileNode (location: (149,13)-(149,21)) │ │ │ └── filepath: "patterns.txt" │ │ ├── statements: ∅ │ │ ├── in_loc: (149,10)-(149,12) = "in" │ │ └── then_loc: (149,22)-(149,26) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (149,0)-(149,4) = "case" │ └── end_keyword_loc: (149,27)-(149,30) = "end" ├── @ CaseMatchNode (location: (150,0)-(150,30)) │ ├── 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,26)) │ │ ├── pattern: │ │ │ @ SourceLineNode (location: (150,13)-(150,21)) │ │ ├── statements: ∅ │ │ ├── in_loc: (150,10)-(150,12) = "in" │ │ └── then_loc: (150,22)-(150,26) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (150,0)-(150,4) = "case" │ └── end_keyword_loc: (150,27)-(150,30) = "end" ├── @ CaseMatchNode (location: (151,0)-(151,34)) │ ├── 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,30)) │ │ ├── pattern: │ │ │ @ SourceEncodingNode (location: (151,13)-(151,25)) │ │ ├── statements: ∅ │ │ ├── in_loc: (151,10)-(151,12) = "in" │ │ └── then_loc: (151,26)-(151,30) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (151,0)-(151,4) = "case" │ └── end_keyword_loc: (151,31)-(151,34) = "end" ├── @ CaseMatchNode (location: (152,0)-(152,32)) │ ├── 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,28)) │ │ ├── pattern: │ │ │ @ LambdaNode (location: (152,13)-(152,23)) │ │ │ ├── locals: [] │ │ │ ├── locals_body_index: 0 │ │ │ ├── operator_loc: (152,13)-(152,15) = "->" │ │ │ ├── opening_loc: (152,16)-(152,17) = "{" │ │ │ ├── closing_loc: (152,22)-(152,23) = "}" │ │ │ ├── parameters: ∅ │ │ │ └── body: │ │ │ @ StatementsNode (location: (152,18)-(152,21)) │ │ │ └── body: (length: 1) │ │ │ └── @ LocalVariableReadNode (location: (152,18)-(152,21)) │ │ │ ├── name: :bar │ │ │ └── depth: 1 │ │ ├── statements: ∅ │ │ ├── in_loc: (152,10)-(152,12) = "in" │ │ └── then_loc: (152,24)-(152,28) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (152,0)-(152,4) = "case" │ └── end_keyword_loc: (152,29)-(152,32) = "end" ├── @ CaseMatchNode (location: (154,0)-(154,32)) │ ├── 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,28)) │ │ ├── pattern: │ │ │ @ IfNode (location: (154,13)-(154,23)) │ │ │ ├── if_keyword_loc: (154,17)-(154,19) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (154,20)-(154,23)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (154,13)-(154,16)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ LocalVariableTargetNode (location: (154,13)-(154,16)) │ │ │ │ ├── name: :bar │ │ │ │ └── depth: 0 │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (154,10)-(154,12) = "in" │ │ └── then_loc: (154,24)-(154,28) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (154,0)-(154,4) = "case" │ └── end_keyword_loc: (154,29)-(154,32) = "end" ├── @ CaseMatchNode (location: (155,0)-(155,30)) │ ├── 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,26)) │ │ ├── pattern: │ │ │ @ IfNode (location: (155,13)-(155,21)) │ │ │ ├── if_keyword_loc: (155,15)-(155,17) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (155,18)-(155,21)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (155,13)-(155,14)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ IntegerNode (location: (155,13)-(155,14)) │ │ │ │ └── flags: decimal │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (155,10)-(155,12) = "in" │ │ └── then_loc: (155,22)-(155,26) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (155,0)-(155,4) = "case" │ └── end_keyword_loc: (155,27)-(155,30) = "end" ├── @ CaseMatchNode (location: (156,0)-(156,32)) │ ├── 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,28)) │ │ ├── pattern: │ │ │ @ IfNode (location: (156,13)-(156,23)) │ │ │ ├── if_keyword_loc: (156,17)-(156,19) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (156,20)-(156,23)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (156,13)-(156,16)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ FloatNode (location: (156,13)-(156,16)) │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (156,10)-(156,12) = "in" │ │ └── then_loc: (156,24)-(156,28) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (156,0)-(156,4) = "case" │ └── end_keyword_loc: (156,29)-(156,32) = "end" ├── @ CaseMatchNode (location: (157,0)-(157,31)) │ ├── 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,27)) │ │ ├── pattern: │ │ │ @ IfNode (location: (157,13)-(157,22)) │ │ │ ├── if_keyword_loc: (157,16)-(157,18) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (157,19)-(157,22)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (157,13)-(157,15)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ ImaginaryNode (location: (157,13)-(157,15)) │ │ │ │ └── numeric: │ │ │ │ @ IntegerNode (location: (157,13)-(157,14)) │ │ │ │ └── flags: decimal │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (157,10)-(157,12) = "in" │ │ └── then_loc: (157,23)-(157,27) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (157,0)-(157,4) = "case" │ └── end_keyword_loc: (157,28)-(157,31) = "end" ├── @ CaseMatchNode (location: (158,0)-(158,31)) │ ├── 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,27)) │ │ ├── pattern: │ │ │ @ IfNode (location: (158,13)-(158,22)) │ │ │ ├── if_keyword_loc: (158,16)-(158,18) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (158,19)-(158,22)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (158,13)-(158,15)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ RationalNode (location: (158,13)-(158,15)) │ │ │ │ └── numeric: │ │ │ │ @ IntegerNode (location: (158,13)-(158,14)) │ │ │ │ └── flags: decimal │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (158,10)-(158,12) = "in" │ │ └── then_loc: (158,23)-(158,27) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (158,0)-(158,4) = "case" │ └── end_keyword_loc: (158,28)-(158,31) = "end" ├── @ CaseMatchNode (location: (159,0)-(159,33)) │ ├── 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,29)) │ │ ├── pattern: │ │ │ @ IfNode (location: (159,13)-(159,24)) │ │ │ ├── if_keyword_loc: (159,18)-(159,20) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (159,21)-(159,24)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (159,13)-(159,17)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ SymbolNode (location: (159,13)-(159,17)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: (159,13)-(159,14) = ":" │ │ │ │ ├── value_loc: (159,14)-(159,17) = "foo" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "foo" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (159,10)-(159,12) = "in" │ │ └── then_loc: (159,25)-(159,29) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (159,0)-(159,4) = "case" │ └── end_keyword_loc: (159,30)-(159,33) = "end" ├── @ CaseMatchNode (location: (160,0)-(160,36)) │ ├── 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,32)) │ │ ├── pattern: │ │ │ @ IfNode (location: (160,13)-(160,27)) │ │ │ ├── if_keyword_loc: (160,21)-(160,23) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (160,24)-(160,27)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (160,13)-(160,20)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ SymbolNode (location: (160,13)-(160,20)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: (160,13)-(160,16) = "%s[" │ │ │ │ ├── value_loc: (160,16)-(160,19) = "foo" │ │ │ │ ├── closing_loc: (160,19)-(160,20) = "]" │ │ │ │ └── unescaped: "foo" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (160,10)-(160,12) = "in" │ │ └── then_loc: (160,28)-(160,32) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (160,0)-(160,4) = "case" │ └── end_keyword_loc: (160,33)-(160,36) = "end" ├── @ CaseMatchNode (location: (161,0)-(161,35)) │ ├── predicate: │ │ @ CallNode (location: (161,5)-(161,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (161,5)-(161,8) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (161,10)-(161,31)) │ │ ├── pattern: │ │ │ @ IfNode (location: (161,13)-(161,26)) │ │ │ ├── if_keyword_loc: (161,20)-(161,22) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (161,23)-(161,26)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (161,13)-(161,19)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ SymbolNode (location: (161,13)-(161,19)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: (161,13)-(161,15) = ":\"" │ │ │ │ ├── value_loc: (161,15)-(161,18) = "foo" │ │ │ │ ├── closing_loc: (161,18)-(161,19) = "\"" │ │ │ │ └── unescaped: "foo" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (161,10)-(161,12) = "in" │ │ └── then_loc: (161,27)-(161,31) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (161,0)-(161,4) = "case" │ └── end_keyword_loc: (161,32)-(161,35) = "end" ├── @ CaseMatchNode (location: (162,0)-(162,34)) │ ├── 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,30)) │ │ ├── pattern: │ │ │ @ IfNode (location: (162,13)-(162,25)) │ │ │ ├── if_keyword_loc: (162,19)-(162,21) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (162,22)-(162,25)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (162,13)-(162,18)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ RegularExpressionNode (location: (162,13)-(162,18)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: (162,13)-(162,14) = "/" │ │ │ │ ├── content_loc: (162,14)-(162,17) = "foo" │ │ │ │ ├── closing_loc: (162,17)-(162,18) = "/" │ │ │ │ └── unescaped: "foo" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (162,10)-(162,12) = "in" │ │ └── then_loc: (162,26)-(162,30) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (162,0)-(162,4) = "case" │ └── end_keyword_loc: (162,31)-(162,34) = "end" ├── @ CaseMatchNode (location: (163,0)-(163,34)) │ ├── 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,30)) │ │ ├── pattern: │ │ │ @ IfNode (location: (163,13)-(163,25)) │ │ │ ├── if_keyword_loc: (163,19)-(163,21) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (163,22)-(163,25)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (163,13)-(163,18)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ XStringNode (location: (163,13)-(163,18)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: (163,13)-(163,14) = "`" │ │ │ │ ├── content_loc: (163,14)-(163,17) = "foo" │ │ │ │ ├── closing_loc: (163,17)-(163,18) = "`" │ │ │ │ └── unescaped: "foo" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (163,10)-(163,12) = "in" │ │ └── then_loc: (163,26)-(163,30) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (163,0)-(163,4) = "case" │ └── end_keyword_loc: (163,31)-(163,34) = "end" ├── @ CaseMatchNode (location: (164,0)-(164,36)) │ ├── 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,32)) │ │ ├── pattern: │ │ │ @ IfNode (location: (164,13)-(164,27)) │ │ │ ├── if_keyword_loc: (164,21)-(164,23) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (164,24)-(164,27)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (164,13)-(164,20)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ XStringNode (location: (164,13)-(164,20)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: (164,13)-(164,16) = "%x[" │ │ │ │ ├── content_loc: (164,16)-(164,19) = "foo" │ │ │ │ ├── closing_loc: (164,19)-(164,20) = "]" │ │ │ │ └── unescaped: "foo" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (164,10)-(164,12) = "in" │ │ └── then_loc: (164,28)-(164,32) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (164,0)-(164,4) = "case" │ └── end_keyword_loc: (164,33)-(164,36) = "end" ├── @ CaseMatchNode (location: (165,0)-(165,36)) │ ├── 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,32)) │ │ ├── pattern: │ │ │ @ IfNode (location: (165,13)-(165,27)) │ │ │ ├── if_keyword_loc: (165,21)-(165,23) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (165,24)-(165,27)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (165,13)-(165,20)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ ArrayNode (location: (165,13)-(165,20)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── elements: (length: 1) │ │ │ │ │ └── @ SymbolNode (location: (165,16)-(165,19)) │ │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── value_loc: (165,16)-(165,19) = "foo" │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── unescaped: "foo" │ │ │ │ ├── opening_loc: (165,13)-(165,16) = "%i[" │ │ │ │ └── closing_loc: (165,19)-(165,20) = "]" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (165,10)-(165,12) = "in" │ │ └── then_loc: (165,28)-(165,32) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (165,0)-(165,4) = "case" │ └── end_keyword_loc: (165,33)-(165,36) = "end" ├── @ CaseMatchNode (location: (166,0)-(166,36)) │ ├── 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,32)) │ │ ├── pattern: │ │ │ @ IfNode (location: (166,13)-(166,27)) │ │ │ ├── if_keyword_loc: (166,21)-(166,23) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (166,24)-(166,27)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (166,13)-(166,20)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ ArrayNode (location: (166,13)-(166,20)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── elements: (length: 1) │ │ │ │ │ └── @ SymbolNode (location: (166,16)-(166,19)) │ │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── value_loc: (166,16)-(166,19) = "foo" │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── unescaped: "foo" │ │ │ │ ├── opening_loc: (166,13)-(166,16) = "%I[" │ │ │ │ └── closing_loc: (166,19)-(166,20) = "]" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (166,10)-(166,12) = "in" │ │ └── then_loc: (166,28)-(166,32) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (166,0)-(166,4) = "case" │ └── end_keyword_loc: (166,33)-(166,36) = "end" ├── @ CaseMatchNode (location: (167,0)-(167,36)) │ ├── 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,32)) │ │ ├── pattern: │ │ │ @ IfNode (location: (167,13)-(167,27)) │ │ │ ├── if_keyword_loc: (167,21)-(167,23) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (167,24)-(167,27)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (167,13)-(167,20)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ ArrayNode (location: (167,13)-(167,20)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── elements: (length: 1) │ │ │ │ │ └── @ StringNode (location: (167,16)-(167,19)) │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── content_loc: (167,16)-(167,19) = "foo" │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── unescaped: "foo" │ │ │ │ ├── opening_loc: (167,13)-(167,16) = "%w[" │ │ │ │ └── closing_loc: (167,19)-(167,20) = "]" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (167,10)-(167,12) = "in" │ │ └── then_loc: (167,28)-(167,32) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (167,0)-(167,4) = "case" │ └── end_keyword_loc: (167,33)-(167,36) = "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) │ │ │ │ └── @ ArrayNode (location: (168,13)-(168,20)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── elements: (length: 1) │ │ │ │ │ └── @ StringNode (location: (168,16)-(168,19)) │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── content_loc: (168,16)-(168,19) = "foo" │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── unescaped: "foo" │ │ │ │ ├── opening_loc: (168,13)-(168,16) = "%W[" │ │ │ │ └── closing_loc: (168,19)-(168,20) = "]" │ │ │ ├── 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,36)) │ ├── 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,32)) │ │ ├── pattern: │ │ │ @ IfNode (location: (169,13)-(169,27)) │ │ │ ├── if_keyword_loc: (169,21)-(169,23) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (169,24)-(169,27)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (169,13)-(169,20)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ StringNode (location: (169,13)-(169,20)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: (169,13)-(169,16) = "%q[" │ │ │ │ ├── content_loc: (169,16)-(169,19) = "foo" │ │ │ │ ├── closing_loc: (169,19)-(169,20) = "]" │ │ │ │ └── unescaped: "foo" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (169,10)-(169,12) = "in" │ │ └── then_loc: (169,28)-(169,32) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (169,0)-(169,4) = "case" │ └── end_keyword_loc: (169,33)-(169,36) = "end" ├── @ CaseMatchNode (location: (170,0)-(170,36)) │ ├── 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,32)) │ │ ├── pattern: │ │ │ @ IfNode (location: (170,13)-(170,27)) │ │ │ ├── if_keyword_loc: (170,21)-(170,23) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (170,24)-(170,27)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (170,13)-(170,20)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ StringNode (location: (170,13)-(170,20)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: (170,13)-(170,16) = "%Q[" │ │ │ │ ├── content_loc: (170,16)-(170,19) = "foo" │ │ │ │ ├── closing_loc: (170,19)-(170,20) = "]" │ │ │ │ └── unescaped: "foo" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (170,10)-(170,12) = "in" │ │ └── then_loc: (170,28)-(170,32) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (170,0)-(170,4) = "case" │ └── end_keyword_loc: (170,33)-(170,36) = "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) │ │ │ │ └── @ StringNode (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,32)) │ ├── 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,28)) │ │ ├── pattern: │ │ │ @ IfNode (location: (172,13)-(172,23)) │ │ │ ├── if_keyword_loc: (172,17)-(172,19) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (172,20)-(172,23)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (172,13)-(172,16)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ NilNode (location: (172,13)-(172,16)) │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (172,10)-(172,12) = "in" │ │ └── then_loc: (172,24)-(172,28) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (172,0)-(172,4) = "case" │ └── end_keyword_loc: (172,29)-(172,32) = "end" ├── @ CaseMatchNode (location: (173,0)-(173,33)) │ ├── 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,29)) │ │ ├── pattern: │ │ │ @ IfNode (location: (173,13)-(173,24)) │ │ │ ├── if_keyword_loc: (173,18)-(173,20) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (173,21)-(173,24)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (173,13)-(173,17)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ SelfNode (location: (173,13)-(173,17)) │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (173,10)-(173,12) = "in" │ │ └── then_loc: (173,25)-(173,29) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (173,0)-(173,4) = "case" │ └── end_keyword_loc: (173,30)-(173,33) = "end" ├── @ CaseMatchNode (location: (174,0)-(174,33)) │ ├── 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,29)) │ │ ├── pattern: │ │ │ @ IfNode (location: (174,13)-(174,24)) │ │ │ ├── if_keyword_loc: (174,18)-(174,20) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (174,21)-(174,24)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (174,13)-(174,17)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (174,13)-(174,17)) │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (174,10)-(174,12) = "in" │ │ └── then_loc: (174,25)-(174,29) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (174,0)-(174,4) = "case" │ └── end_keyword_loc: (174,30)-(174,33) = "end" ├── @ CaseMatchNode (location: (175,0)-(175,34)) │ ├── 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,30)) │ │ ├── pattern: │ │ │ @ IfNode (location: (175,13)-(175,25)) │ │ │ ├── if_keyword_loc: (175,19)-(175,21) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (175,22)-(175,25)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (175,13)-(175,18)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ FalseNode (location: (175,13)-(175,18)) │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (175,10)-(175,12) = "in" │ │ └── then_loc: (175,26)-(175,30) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (175,0)-(175,4) = "case" │ └── end_keyword_loc: (175,31)-(175,34) = "end" ├── @ CaseMatchNode (location: (176,0)-(176,37)) │ ├── 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,33)) │ │ ├── pattern: │ │ │ @ IfNode (location: (176,13)-(176,28)) │ │ │ ├── if_keyword_loc: (176,22)-(176,24) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (176,25)-(176,28)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (176,13)-(176,21)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ SourceFileNode (location: (176,13)-(176,21)) │ │ │ │ └── filepath: "patterns.txt" │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (176,10)-(176,12) = "in" │ │ └── then_loc: (176,29)-(176,33) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (176,0)-(176,4) = "case" │ └── end_keyword_loc: (176,34)-(176,37) = "end" ├── @ CaseMatchNode (location: (177,0)-(177,37)) │ ├── 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,33)) │ │ ├── pattern: │ │ │ @ IfNode (location: (177,13)-(177,28)) │ │ │ ├── if_keyword_loc: (177,22)-(177,24) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (177,25)-(177,28)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (177,13)-(177,21)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ SourceLineNode (location: (177,13)-(177,21)) │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (177,10)-(177,12) = "in" │ │ └── then_loc: (177,29)-(177,33) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (177,0)-(177,4) = "case" │ └── end_keyword_loc: (177,34)-(177,37) = "end" ├── @ CaseMatchNode (location: (178,0)-(178,41)) │ ├── 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,37)) │ │ ├── pattern: │ │ │ @ IfNode (location: (178,13)-(178,32)) │ │ │ ├── if_keyword_loc: (178,26)-(178,28) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (178,29)-(178,32)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (178,13)-(178,25)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ SourceEncodingNode (location: (178,13)-(178,25)) │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (178,10)-(178,12) = "in" │ │ └── then_loc: (178,33)-(178,37) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (178,0)-(178,4) = "case" │ └── end_keyword_loc: (178,38)-(178,41) = "end" ├── @ CaseMatchNode (location: (179,0)-(179,39)) │ ├── 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,35)) │ │ ├── pattern: │ │ │ @ IfNode (location: (179,13)-(179,30)) │ │ │ ├── if_keyword_loc: (179,24)-(179,26) = "if" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (179,27)-(179,30)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 0 │ │ │ ├── then_keyword_loc: ∅ │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (179,13)-(179,23)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ LambdaNode (location: (179,13)-(179,23)) │ │ │ │ ├── locals: [] │ │ │ │ ├── locals_body_index: 0 │ │ │ │ ├── operator_loc: (179,13)-(179,15) = "->" │ │ │ │ ├── opening_loc: (179,16)-(179,17) = "{" │ │ │ │ ├── closing_loc: (179,22)-(179,23) = "}" │ │ │ │ ├── parameters: ∅ │ │ │ │ └── body: │ │ │ │ @ StatementsNode (location: (179,18)-(179,21)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ LocalVariableReadNode (location: (179,18)-(179,21)) │ │ │ │ ├── name: :bar │ │ │ │ └── depth: 1 │ │ │ ├── consequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── in_loc: (179,10)-(179,12) = "in" │ │ └── then_loc: (179,31)-(179,35) = "then" │ ├── consequent: ∅ │ ├── case_keyword_loc: (179,0)-(179,4) = "case" │ └── end_keyword_loc: (179,36)-(179,39) = "end" ├── @ IfNode (location: (181,0)-(182,3)) │ ├── if_keyword_loc: (181,0)-(181,2) = "if" │ ├── predicate: │ │ @ MatchPredicateNode (location: (181,3)-(181,10)) │ │ ├── value: │ │ │ @ CallNode (location: (181,3)-(181,4)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :a │ │ │ ├── message_loc: (181,3)-(181,4) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── pattern: │ │ │ @ ArrayPatternNode (location: (181,8)-(181,10)) │ │ │ ├── constant: ∅ │ │ │ ├── requireds: (length: 0) │ │ │ ├── rest: ∅ │ │ │ ├── posts: (length: 0) │ │ │ ├── opening_loc: (181,8)-(181,9) = "[" │ │ │ └── closing_loc: (181,9)-(181,10) = "]" │ │ └── operator_loc: (181,5)-(181,7) = "in" │ ├── then_keyword_loc: ∅ │ ├── statements: ∅ │ ├── consequent: ∅ │ └── end_keyword_loc: (182,0)-(182,3) = "end" ├── @ MatchRequiredNode (location: (184,0)-(186,1)) │ ├── value: │ │ @ CallNode (location: (184,0)-(184,1)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :a │ │ ├── message_loc: (184,0)-(184,1) = "a" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── pattern: │ │ @ ArrayPatternNode (location: (184,5)-(186,1)) │ │ ├── constant: ∅ │ │ ├── requireds: (length: 1) │ │ │ └── @ LocalVariableTargetNode (location: (185,2)-(185,3)) │ │ │ ├── name: :b │ │ │ └── depth: 0 │ │ ├── rest: ∅ │ │ ├── posts: (length: 0) │ │ ├── opening_loc: (184,5)-(184,6) = "[" │ │ └── closing_loc: (186,0)-(186,1) = "]" │ └── operator_loc: (184,2)-(184,4) = "=>" ├── @ MatchPredicateNode (location: (188,0)-(192,1)) │ ├── value: │ │ @ CallNode (location: (188,0)-(188,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (188,0)-(188,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── pattern: │ │ @ HashPatternNode (location: (188,7)-(192,1)) │ │ ├── constant: │ │ │ @ ConstantReadNode (location: (188,7)-(188,8)) │ │ │ └── name: :A │ │ ├── elements: (length: 1) │ │ │ └── @ AssocNode (location: (189,2)-(191,3)) │ │ │ ├── key: │ │ │ │ @ SymbolNode (location: (189,2)-(189,6)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── value_loc: (189,2)-(189,5) = "bar" │ │ │ │ ├── closing_loc: (189,5)-(189,6) = ":" │ │ │ │ └── unescaped: "bar" │ │ │ ├── value: │ │ │ │ @ HashPatternNode (location: (189,7)-(191,3)) │ │ │ │ ├── constant: │ │ │ │ │ @ ConstantReadNode (location: (189,7)-(189,8)) │ │ │ │ │ └── name: :B │ │ │ │ ├── elements: (length: 1) │ │ │ │ │ └── @ AssocNode (location: (190,4)-(190,12)) │ │ │ │ │ ├── key: │ │ │ │ │ │ @ SymbolNode (location: (190,4)-(190,10)) │ │ │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ │ ├── value_loc: (190,4)-(190,9) = "value" │ │ │ │ │ │ ├── closing_loc: (190,9)-(190,10) = ":" │ │ │ │ │ │ └── unescaped: "value" │ │ │ │ │ ├── value: │ │ │ │ │ │ @ LocalVariableTargetNode (location: (190,11)-(190,12)) │ │ │ │ │ │ ├── name: :a │ │ │ │ │ │ └── depth: 0 │ │ │ │ │ └── operator_loc: ∅ │ │ │ │ ├── rest: ∅ │ │ │ │ ├── opening_loc: (189,8)-(189,9) = "[" │ │ │ │ └── closing_loc: (191,2)-(191,3) = "]" │ │ │ └── operator_loc: ∅ │ │ ├── rest: ∅ │ │ ├── opening_loc: (188,8)-(188,9) = "[" │ │ └── closing_loc: (192,0)-(192,1) = "]" │ └── operator_loc: (188,4)-(188,6) = "in" ├── @ MatchPredicateNode (location: (194,0)-(194,17)) │ ├── value: │ │ @ CallNode (location: (194,0)-(194,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (194,0)-(194,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── pattern: │ │ @ CapturePatternNode (location: (194,7)-(194,17)) │ │ ├── value: │ │ │ @ LocalVariableTargetNode (location: (194,7)-(194,10)) │ │ │ ├── name: :bar │ │ │ └── depth: 0 │ │ ├── target: │ │ │ @ LocalVariableTargetNode (location: (194,14)-(194,17)) │ │ │ ├── name: :baz │ │ │ └── depth: 0 │ │ └── operator_loc: (194,11)-(194,13) = "=>" │ └── operator_loc: (194,4)-(194,6) = "in" ├── @ MatchRequiredNode (location: (195,0)-(195,17)) │ ├── value: │ │ @ CallNode (location: (195,0)-(195,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (195,0)-(195,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── pattern: │ │ @ CapturePatternNode (location: (195,7)-(195,17)) │ │ ├── value: │ │ │ @ LocalVariableTargetNode (location: (195,7)-(195,10)) │ │ │ ├── name: :bar │ │ │ └── depth: 0 │ │ ├── target: │ │ │ @ LocalVariableTargetNode (location: (195,14)-(195,17)) │ │ │ ├── name: :baz │ │ │ └── depth: 0 │ │ └── operator_loc: (195,11)-(195,13) = "=>" │ └── operator_loc: (195,4)-(195,6) = "=>" ├── @ MultiWriteNode (location: (197,0)-(197,20)) │ ├── lefts: (length: 3) │ │ ├── @ LocalVariableTargetNode (location: (197,0)-(197,3)) │ │ │ ├── name: :foo │ │ │ └── depth: 0 │ │ ├── @ LocalVariableTargetNode (location: (197,5)-(197,8)) │ │ │ ├── name: :bar │ │ │ └── depth: 0 │ │ └── @ LocalVariableTargetNode (location: (197,10)-(197,13)) │ │ ├── name: :baz │ │ └── depth: 0 │ ├── rest: ∅ │ ├── rights: (length: 0) │ ├── lparen_loc: ∅ │ ├── rparen_loc: ∅ │ ├── operator_loc: (197,14)-(197,15) = "=" │ └── value: │ @ ArrayNode (location: (197,16)-(197,20)) │ ├── flags: ∅ │ ├── elements: (length: 2) │ │ ├── @ IntegerNode (location: (197,16)-(197,17)) │ │ │ └── flags: decimal │ │ └── @ IntegerNode (location: (197,19)-(197,20)) │ │ └── flags: decimal │ ├── opening_loc: ∅ │ └── closing_loc: ∅ ├── @ CallNode (location: (198,0)-(200,3)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (198,0)-(198,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: │ @ BlockNode (location: (198,4)-(200,3)) │ ├── locals: [] │ ├── locals_body_index: 0 │ ├── parameters: ∅ │ ├── body: │ │ @ StatementsNode (location: (199,2)-(199,29)) │ │ └── body: (length: 1) │ │ └── @ MatchRequiredNode (location: (199,2)-(199,29)) │ │ ├── value: │ │ │ @ ArrayNode (location: (199,2)-(199,8)) │ │ │ ├── flags: ∅ │ │ │ ├── elements: (length: 2) │ │ │ │ ├── @ IntegerNode (location: (199,3)-(199,4)) │ │ │ │ │ └── flags: decimal │ │ │ │ └── @ IntegerNode (location: (199,6)-(199,7)) │ │ │ │ └── flags: decimal │ │ │ ├── opening_loc: (199,2)-(199,3) = "[" │ │ │ └── closing_loc: (199,7)-(199,8) = "]" │ │ ├── pattern: │ │ │ @ CapturePatternNode (location: (199,12)-(199,29)) │ │ │ ├── value: │ │ │ │ @ ArrayPatternNode (location: (199,12)-(199,22)) │ │ │ │ ├── constant: ∅ │ │ │ │ ├── requireds: (length: 2) │ │ │ │ │ ├── @ LocalVariableTargetNode (location: (199,13)-(199,16)) │ │ │ │ │ │ ├── name: :foo │ │ │ │ │ │ └── depth: 1 │ │ │ │ │ └── @ LocalVariableTargetNode (location: (199,18)-(199,21)) │ │ │ │ │ ├── name: :bar │ │ │ │ │ └── depth: 1 │ │ │ │ ├── rest: ∅ │ │ │ │ ├── posts: (length: 0) │ │ │ │ ├── opening_loc: (199,12)-(199,13) = "[" │ │ │ │ └── closing_loc: (199,21)-(199,22) = "]" │ │ │ ├── target: │ │ │ │ @ LocalVariableTargetNode (location: (199,26)-(199,29)) │ │ │ │ ├── name: :baz │ │ │ │ └── depth: 1 │ │ │ └── operator_loc: (199,23)-(199,25) = "=>" │ │ └── operator_loc: (199,9)-(199,11) = "=>" │ ├── opening_loc: (198,4)-(198,6) = "do" │ └── closing_loc: (200,0)-(200,3) = "end" ├── @ MatchRequiredNode (location: (202,0)-(202,19)) │ ├── value: │ │ @ LocalVariableReadNode (location: (202,0)-(202,3)) │ │ ├── name: :foo │ │ └── depth: 0 │ ├── pattern: │ │ @ ArrayPatternNode (location: (202,7)-(202,19)) │ │ ├── constant: │ │ │ @ ConstantReadNode (location: (202,7)-(202,13)) │ │ │ └── name: :Object │ │ ├── requireds: (length: 1) │ │ │ └── @ HashPatternNode (location: (202,14)-(202,18)) │ │ │ ├── constant: ∅ │ │ │ ├── elements: (length: 1) │ │ │ │ └── @ AssocNode (location: (202,15)-(202,17)) │ │ │ │ ├── key: │ │ │ │ │ @ SymbolNode (location: (202,15)-(202,17)) │ │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── value_loc: (202,15)-(202,16) = "x" │ │ │ │ │ ├── closing_loc: (202,16)-(202,17) = ":" │ │ │ │ │ └── unescaped: "x" │ │ │ │ ├── value: │ │ │ │ │ @ ImplicitNode (location: (202,15)-(202,16)) │ │ │ │ │ └── value: │ │ │ │ │ @ LocalVariableTargetNode (location: (202,15)-(202,16)) │ │ │ │ │ ├── name: :x │ │ │ │ │ └── depth: 0 │ │ │ │ └── operator_loc: ∅ │ │ │ ├── rest: ∅ │ │ │ ├── opening_loc: (202,14)-(202,15) = "{" │ │ │ └── closing_loc: (202,17)-(202,18) = "}" │ │ ├── rest: ∅ │ │ ├── posts: (length: 0) │ │ ├── opening_loc: (202,13)-(202,14) = "[" │ │ └── closing_loc: (202,18)-(202,19) = "]" │ └── operator_loc: (202,4)-(202,6) = "=>" ├── @ CallNode (location: (204,0)-(204,19)) │ ├── flags: ∅ │ ├── receiver: │ │ @ IntegerNode (location: (204,0)-(204,1)) │ │ └── flags: decimal │ ├── call_operator_loc: (204,1)-(204,2) = "." │ ├── name: :then │ ├── message_loc: (204,2)-(204,6) = "then" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: │ @ BlockNode (location: (204,7)-(204,19)) │ ├── locals: [:_1] │ ├── locals_body_index: 1 │ ├── parameters: │ │ @ NumberedParametersNode (location: (204,7)-(204,19)) │ │ └── maximum: 1 │ ├── body: │ │ @ StatementsNode (location: (204,9)-(204,17)) │ │ └── body: (length: 1) │ │ └── @ MatchPredicateNode (location: (204,9)-(204,17)) │ │ ├── value: │ │ │ @ IntegerNode (location: (204,9)-(204,10)) │ │ │ └── flags: decimal │ │ ├── pattern: │ │ │ @ PinnedVariableNode (location: (204,14)-(204,17)) │ │ │ ├── variable: │ │ │ │ @ LocalVariableReadNode (location: (204,15)-(204,17)) │ │ │ │ ├── name: :_1 │ │ │ │ └── depth: 0 │ │ │ └── operator_loc: (204,14)-(204,15) = "^" │ │ └── operator_loc: (204,11)-(204,13) = "in" │ ├── opening_loc: (204,7)-(204,8) = "{" │ └── closing_loc: (204,18)-(204,19) = "}" └── @ MultiWriteNode (location: (206,0)-(209,5)) ├── lefts: (length: 2) │ ├── @ LocalVariableTargetNode (location: (207,2)-(207,3)) │ │ ├── name: :a │ │ └── depth: 0 │ └── @ LocalVariableTargetNode (location: (208,2)-(208,3)) │ ├── name: :b │ └── depth: 0 ├── rest: ∅ ├── rights: (length: 0) ├── lparen_loc: (206,0)-(206,1) = "(" ├── rparen_loc: (209,0)-(209,1) = ")" ├── operator_loc: (209,2)-(209,3) = "=" └── value: @ CallNode (location: (209,4)-(209,5)) ├── flags: variable_call, ignore_visibility ├── receiver: ∅ ├── call_operator_loc: ∅ ├── name: :c ├── message_loc: (209,4)-(209,5) = "c" ├── opening_loc: ∅ ├── arguments: ∅ ├── closing_loc: ∅ └── block: ∅