diff options
Diffstat (limited to 'test/prism/snapshots/method_calls.txt')
| -rw-r--r-- | test/prism/snapshots/method_calls.txt | 2456 |
1 files changed, 2456 insertions, 0 deletions
diff --git a/test/prism/snapshots/method_calls.txt b/test/prism/snapshots/method_calls.txt new file mode 100644 index 0000000000..6082b567f7 --- /dev/null +++ b/test/prism/snapshots/method_calls.txt @@ -0,0 +1,2456 @@ +@ ProgramNode (location: (1,0)-(156,19)) +├── locals: [:foo] +└── statements: + @ StatementsNode (location: (1,0)-(156,19)) + └── body: (length: 67) + ├── @ CallNode (location: (1,0)-(1,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ 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: ∅ + │ ├── call_operator_loc: (1,3)-(1,4) = "." + │ ├── name: :bar + │ ├── message_loc: (1,4)-(1,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (1,8)-(1,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ StringNode (location: (1,8)-(1,14)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (1,8)-(1,10) = "%{" + │ │ ├── content_loc: (1,10)-(1,13) = "baz" + │ │ ├── closing_loc: (1,13)-(1,14) = "}" + │ │ └── unescaped: "baz" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (3,0)-(3,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (3,0)-(3,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (3,0)-(3,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (3,1)-(3,2) = "." + │ ├── name: :b + │ ├── message_loc: (3,2)-(3,3) = "b" + │ ├── opening_loc: (3,3)-(3,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (3,4)-(3,8)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (3,4)-(3,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (3,4)-(3,5) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (3,7)-(3,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (3,7)-(3,8) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (3,8)-(3,9) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (5,0)-(5,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (5,0)-(5,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (5,0)-(5,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (5,1)-(5,2) = "." + │ ├── name: :b + │ ├── message_loc: (5,2)-(5,3) = "b" + │ ├── opening_loc: (5,3)-(5,4) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (5,4)-(5,5) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (7,0)-(9,7)) + │ ├── flags: safe_navigation + │ ├── receiver: + │ │ @ CallNode (location: (7,0)-(8,6)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ 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: ∅ + │ │ ├── call_operator_loc: (8,2)-(8,3) = "." + │ │ ├── name: :bar + │ │ ├── message_loc: (8,3)-(8,6) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (9,2)-(9,4) = "&." + │ ├── name: :baz + │ ├── message_loc: (9,4)-(9,7) = "baz" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (11,0)-(11,2)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a! + │ ├── message_loc: (11,0)-(11,2) = "a!" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (13,0)-(13,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (13,0)-(13,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (13,0)-(13,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (13,1)-(13,2) = "." + │ ├── name: :call + │ ├── message_loc: ∅ + │ ├── opening_loc: (13,2)-(13,3) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (13,3)-(13,4) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (15,0)-(15,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (15,0)-(15,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (15,0)-(15,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (15,1)-(15,2) = "." + │ ├── name: :call + │ ├── message_loc: ∅ + │ ├── opening_loc: (15,2)-(15,3) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (15,3)-(15,10)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 3) + │ │ ├── @ IntegerNode (location: (15,3)-(15,4)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── @ IntegerNode (location: (15,6)-(15,7)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── @ IntegerNode (location: (15,9)-(15,10)) + │ │ ├── flags: decimal + │ │ └── value: 3 + │ ├── closing_loc: (15,10)-(15,11) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (17,0)-(17,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (17,0)-(17,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (17,0)-(17,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (17,1)-(17,3) = "::" + │ ├── name: :b + │ ├── message_loc: (17,3)-(17,4) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (19,0)-(19,6)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (19,0)-(19,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (19,0)-(19,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (19,1)-(19,3) = "::" + │ ├── name: :b + │ ├── message_loc: (19,3)-(19,4) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (19,5)-(19,6)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (19,5)-(19,6)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :c + │ │ ├── message_loc: (19,5)-(19,6) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (21,0)-(21,11)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ 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: ∅ + │ ├── call_operator_loc: (21,3)-(21,4) = "." + │ ├── name: :bar= + │ ├── message_loc: (21,4)-(21,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (21,10)-(21,11)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (21,10)-(21,11)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (23,0)-(23,2)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a? + │ ├── message_loc: (23,0)-(23,2) = "a?" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (25,0)-(25,8)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (25,0)-(25,1) = "a" + │ ├── opening_loc: (25,1)-(25,2) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (25,8)-(25,9) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (25,2)-(25,8)) + │ ├── expression: + │ │ @ CallNode (location: (25,3)-(25,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :block + │ │ ├── message_loc: (25,3)-(25,8) = "block" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (25,2)-(25,3) = "&" + ├── @ CallNode (location: (27,0)-(27,11)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (27,0)-(27,1) = "a" + │ ├── opening_loc: (27,1)-(27,2) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (27,2)-(27,10)) + │ │ ├── flags: contains_keywords, contains_keyword_splat + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (27,2)-(27,10)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocSplatNode (location: (27,2)-(27,10)) + │ │ ├── value: + │ │ │ @ CallNode (location: (27,4)-(27,10)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :kwargs + │ │ │ ├── message_loc: (27,4)-(27,10) = "kwargs" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (27,2)-(27,4) = "**" + │ ├── closing_loc: (27,10)-(27,11) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (29,0)-(29,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (29,0)-(29,3)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (29,0)-(29,1)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (29,0)-(29,1) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (29,1)-(29,2) = "." + │ │ ├── name: :b + │ │ ├── message_loc: (29,2)-(29,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (29,3)-(29,4) = "." + │ ├── name: :c + │ ├── message_loc: (29,4)-(29,5) = "c" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (31,0)-(31,7)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (31,0)-(31,1) = "a" + │ ├── opening_loc: (31,1)-(31,2) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (31,2)-(31,6)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (31,2)-(31,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (31,2)-(31,3) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (31,5)-(31,6)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :c + │ │ ├── message_loc: (31,5)-(31,6) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (31,6)-(31,7) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (33,0)-(33,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (33,0)-(33,1) = "a" + │ ├── opening_loc: (33,1)-(33,2) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (33,2)-(33,3) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (35,0)-(35,8)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (35,0)-(35,1) = "a" + │ ├── opening_loc: (35,1)-(35,2) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (35,2)-(35,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SplatNode (location: (35,2)-(35,7)) + │ │ ├── operator_loc: (35,2)-(35,3) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (35,3)-(35,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :args + │ │ ├── message_loc: (35,3)-(35,7) = "args" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (35,7)-(35,8) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (37,0)-(37,6)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (37,0)-(37,1) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (37,2)-(37,6)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (37,2)-(37,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (37,2)-(37,3) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (37,5)-(37,6)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :c + │ │ ├── message_loc: (37,5)-(37,6) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (39,0)-(39,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (39,0)-(39,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (39,0)-(39,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (39,1)-(39,2) = "." + │ ├── name: :b + │ ├── message_loc: (39,2)-(39,3) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (39,4)-(39,8)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (39,4)-(39,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (39,4)-(39,5) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (39,7)-(39,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (39,7)-(39,8) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ MultiWriteNode (location: (41,0)-(41,23)) + │ ├── lefts: (length: 2) + │ │ ├── @ CallTargetNode (location: (41,0)-(41,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ 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: ∅ + │ │ │ ├── call_operator_loc: (41,3)-(41,4) = "." + │ │ │ ├── name: :foo= + │ │ │ └── message_loc: (41,4)-(41,7) = "foo" + │ │ └── @ CallTargetNode (location: (41,9)-(41,16)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (41,9)-(41,12)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (41,9)-(41,12) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (41,12)-(41,13) = "." + │ │ ├── name: :bar= + │ │ └── message_loc: (41,13)-(41,16) = "bar" + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── operator_loc: (41,17)-(41,18) = "=" + │ └── value: + │ @ ArrayNode (location: (41,19)-(41,23)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (41,19)-(41,20)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (41,22)-(41,23)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: ∅ + │ └── closing_loc: ∅ + ├── @ CallNode (location: (43,0)-(43,4)) + │ ├── flags: safe_navigation + │ ├── receiver: + │ │ @ CallNode (location: (43,0)-(43,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (43,0)-(43,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (43,1)-(43,3) = "&." + │ ├── name: :b + │ ├── message_loc: (43,3)-(43,4) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (45,0)-(45,5)) + │ ├── flags: safe_navigation + │ ├── receiver: + │ │ @ CallNode (location: (45,0)-(45,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (45,0)-(45,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (45,1)-(45,3) = "&." + │ ├── name: :call + │ ├── message_loc: ∅ + │ ├── opening_loc: (45,3)-(45,4) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (45,4)-(45,5) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (47,0)-(47,7)) + │ ├── flags: safe_navigation + │ ├── receiver: + │ │ @ CallNode (location: (47,0)-(47,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (47,0)-(47,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (47,1)-(47,3) = "&." + │ ├── name: :b + │ ├── message_loc: (47,3)-(47,4) = "b" + │ ├── opening_loc: (47,4)-(47,5) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (47,5)-(47,6)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (47,5)-(47,6)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :c + │ │ ├── message_loc: (47,5)-(47,6) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (47,6)-(47,7) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (49,0)-(49,6)) + │ ├── flags: safe_navigation + │ ├── receiver: + │ │ @ CallNode (location: (49,0)-(49,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (49,0)-(49,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (49,1)-(49,3) = "&." + │ ├── name: :b + │ ├── message_loc: (49,3)-(49,4) = "b" + │ ├── opening_loc: (49,4)-(49,5) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (49,5)-(49,6) = ")" + │ └── block: ∅ + ├── @ IfNode (location: (51,0)-(51,33)) + │ ├── if_keyword_loc: (51,11)-(51,13) = "if" + │ ├── predicate: + │ │ @ AndNode (location: (51,14)-(51,33)) + │ │ ├── left: + │ │ │ @ OrNode (location: (51,14)-(51,25)) + │ │ │ ├── left: + │ │ │ │ @ CallNode (location: (51,14)-(51,18)) + │ │ │ │ ├── flags: ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar? + │ │ │ │ ├── message_loc: (51,14)-(51,18) = "bar?" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── right: + │ │ │ │ @ CallNode (location: (51,22)-(51,25)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (51,22)-(51,25) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (51,19)-(51,21) = "or" + │ │ ├── right: + │ │ │ @ CallNode (location: (51,30)-(51,33)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :qux + │ │ │ ├── message_loc: (51,30)-(51,33) = "qux" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (51,26)-(51,29) = "and" + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (51,0)-(51,10)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (51,0)-(51,10)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (51,0)-(51,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (51,4)-(51,10)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 2) + │ │ │ ├── @ SymbolNode (location: (51,4)-(51,6)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (51,4)-(51,5) = ":" + │ │ │ │ ├── value_loc: (51,5)-(51,6) = "a" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "a" + │ │ │ └── @ SymbolNode (location: (51,8)-(51,10)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (51,8)-(51,9) = ":" + │ │ │ ├── value_loc: (51,9)-(51,10) = "b" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "b" + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: ∅ + ├── @ CallNode (location: (53,0)-(56,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (53,0)-(53,3) = "foo" + │ ├── opening_loc: (53,3)-(53,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (53,4)-(55,4)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ SymbolNode (location: (53,4)-(53,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (53,4)-(53,5) = ":" + │ │ │ ├── value_loc: (53,5)-(53,6) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ SymbolNode (location: (55,2)-(55,4)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (55,2)-(55,3) = ":" + │ │ ├── value_loc: (55,3)-(55,4) = "b" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "b" + │ ├── closing_loc: (56,0)-(56,1) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (58,0)-(58,10)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (58,0)-(58,3) = "foo" + │ ├── opening_loc: (58,3)-(58,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (58,4)-(58,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SplatNode (location: (58,4)-(58,9)) + │ │ ├── operator_loc: (58,4)-(58,5) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (58,5)-(58,9)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :rest + │ │ ├── message_loc: (58,5)-(58,9) = "rest" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (58,9)-(58,10) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (60,0)-(60,39)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (60,0)-(60,3) = "foo" + │ ├── opening_loc: (60,3)-(60,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (60,4)-(60,32)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 2) + │ │ ├── @ SymbolNode (location: (60,4)-(60,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (60,4)-(60,5) = ":" + │ │ │ ├── value_loc: (60,5)-(60,6) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ KeywordHashNode (location: (60,8)-(60,32)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 2) + │ │ ├── @ AssocNode (location: (60,8)-(60,22)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (60,8)-(60,10)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (60,8)-(60,9) = ":" + │ │ │ │ ├── value_loc: (60,9)-(60,10) = "h" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "h" + │ │ │ ├── value: + │ │ │ │ @ ArrayNode (location: (60,14)-(60,22)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── elements: (length: 2) + │ │ │ │ │ ├── @ SymbolNode (location: (60,15)-(60,17)) + │ │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ │ ├── opening_loc: (60,15)-(60,16) = ":" + │ │ │ │ │ │ ├── value_loc: (60,16)-(60,17) = "x" + │ │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ │ └── unescaped: "x" + │ │ │ │ │ └── @ SymbolNode (location: (60,19)-(60,21)) + │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ ├── opening_loc: (60,19)-(60,20) = ":" + │ │ │ │ │ ├── value_loc: (60,20)-(60,21) = "y" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "y" + │ │ │ │ ├── opening_loc: (60,14)-(60,15) = "[" + │ │ │ │ └── closing_loc: (60,21)-(60,22) = "]" + │ │ │ └── operator_loc: (60,11)-(60,13) = "=>" + │ │ └── @ AssocNode (location: (60,24)-(60,32)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (60,24)-(60,26)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (60,24)-(60,25) = ":" + │ │ │ ├── value_loc: (60,25)-(60,26) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (60,30)-(60,32)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (60,30)-(60,31) = ":" + │ │ │ ├── value_loc: (60,31)-(60,32) = "b" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "b" + │ │ └── operator_loc: (60,27)-(60,29) = "=>" + │ ├── closing_loc: (60,39)-(60,40) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (60,34)-(60,39)) + │ ├── expression: + │ │ @ SymbolNode (location: (60,35)-(60,39)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (60,35)-(60,36) = ":" + │ │ ├── value_loc: (60,36)-(60,39) = "bar" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "bar" + │ └── operator_loc: (60,34)-(60,35) = "&" + ├── @ CallNode (location: (62,0)-(62,49)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :hi + │ ├── message_loc: (62,0)-(62,2) = "hi" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (62,3)-(62,49)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ IntegerNode (location: (62,3)-(62,6)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 123 + │ │ └── @ HashNode (location: (62,8)-(62,49)) + │ │ ├── opening_loc: (62,8)-(62,9) = "{" + │ │ ├── elements: (length: 3) + │ │ │ ├── @ AssocNode (location: (62,10)-(62,27)) + │ │ │ │ ├── key: + │ │ │ │ │ @ SymbolNode (location: (62,10)-(62,16)) + │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ ├── opening_loc: (62,10)-(62,11) = ":" + │ │ │ │ │ ├── value_loc: (62,11)-(62,16) = "there" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "there" + │ │ │ │ ├── value: + │ │ │ │ │ @ SymbolNode (location: (62,20)-(62,27)) + │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ ├── opening_loc: (62,20)-(62,21) = ":" + │ │ │ │ │ ├── value_loc: (62,21)-(62,27) = "friend" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "friend" + │ │ │ │ └── operator_loc: (62,17)-(62,19) = "=>" + │ │ │ ├── @ AssocSplatNode (location: (62,29)-(62,33)) + │ │ │ │ ├── value: + │ │ │ │ │ @ HashNode (location: (62,31)-(62,33)) + │ │ │ │ │ ├── opening_loc: (62,31)-(62,32) = "{" + │ │ │ │ │ ├── elements: (length: 0) + │ │ │ │ │ └── closing_loc: (62,32)-(62,33) = "}" + │ │ │ │ └── operator_loc: (62,29)-(62,31) = "**" + │ │ │ └── @ AssocNode (location: (62,35)-(62,47)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (62,35)-(62,42)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── value_loc: (62,35)-(62,41) = "whatup" + │ │ │ │ ├── closing_loc: (62,41)-(62,42) = ":" + │ │ │ │ └── unescaped: "whatup" + │ │ │ ├── value: + │ │ │ │ @ SymbolNode (location: (62,43)-(62,47)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (62,43)-(62,44) = ":" + │ │ │ │ ├── value_loc: (62,44)-(62,47) = "dog" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "dog" + │ │ │ └── operator_loc: ∅ + │ │ └── closing_loc: (62,48)-(62,49) = "}" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (64,0)-(64,36)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (64,0)-(64,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (64,4)-(64,15)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 2) + │ │ ├── @ SymbolNode (location: (64,4)-(64,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (64,4)-(64,5) = ":" + │ │ │ ├── value_loc: (64,5)-(64,6) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ KeywordHashNode (location: (64,8)-(64,15)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (64,8)-(64,15)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (64,8)-(64,10)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (64,8)-(64,9) = "b" + │ │ │ ├── closing_loc: (64,9)-(64,10) = ":" + │ │ │ └── unescaped: "b" + │ │ ├── value: + │ │ │ @ TrueNode (location: (64,11)-(64,15)) + │ │ └── operator_loc: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (64,16)-(64,36)) + │ ├── locals: [:a, :b] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (64,19)-(64,25)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (64,20)-(64,24)) + │ │ │ ├── requireds: (length: 2) + │ │ │ │ ├── @ RequiredParameterNode (location: (64,20)-(64,21)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :a + │ │ │ │ └── @ RequiredParameterNode (location: (64,23)-(64,24)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :b + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (64,19)-(64,20) = "|" + │ │ └── closing_loc: (64,24)-(64,25) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (64,26)-(64,32)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (64,26)-(64,32)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :puts + │ │ ├── message_loc: (64,26)-(64,30) = "puts" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (64,31)-(64,32)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ LocalVariableReadNode (location: (64,31)-(64,32)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (64,16)-(64,18) = "do" + │ └── closing_loc: (64,33)-(64,36) = "end" + ├── @ CallNode (location: (66,0)-(66,17)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :hi + │ ├── message_loc: (66,0)-(66,2) = "hi" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (66,3)-(66,17)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (66,3)-(66,17)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (66,3)-(66,17)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (66,3)-(66,9)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (66,3)-(66,8) = "there" + │ │ │ ├── closing_loc: (66,8)-(66,9) = ":" + │ │ │ └── unescaped: "there" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (66,10)-(66,17)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (66,10)-(66,11) = ":" + │ │ │ ├── value_loc: (66,11)-(66,17) = "friend" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "friend" + │ │ └── operator_loc: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (68,0)-(68,40)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :hi + │ ├── message_loc: (68,0)-(68,2) = "hi" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (68,3)-(68,40)) + │ │ ├── flags: contains_keywords, contains_keyword_splat + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (68,3)-(68,40)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 3) + │ │ ├── @ AssocNode (location: (68,3)-(68,20)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (68,3)-(68,9)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (68,3)-(68,4) = ":" + │ │ │ │ ├── value_loc: (68,4)-(68,9) = "there" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "there" + │ │ │ ├── value: + │ │ │ │ @ SymbolNode (location: (68,13)-(68,20)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (68,13)-(68,14) = ":" + │ │ │ │ ├── value_loc: (68,14)-(68,20) = "friend" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "friend" + │ │ │ └── operator_loc: (68,10)-(68,12) = "=>" + │ │ ├── @ AssocSplatNode (location: (68,22)-(68,26)) + │ │ │ ├── value: + │ │ │ │ @ HashNode (location: (68,24)-(68,26)) + │ │ │ │ ├── opening_loc: (68,24)-(68,25) = "{" + │ │ │ │ ├── elements: (length: 0) + │ │ │ │ └── closing_loc: (68,25)-(68,26) = "}" + │ │ │ └── operator_loc: (68,22)-(68,24) = "**" + │ │ └── @ AssocNode (location: (68,28)-(68,40)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (68,28)-(68,35)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (68,28)-(68,34) = "whatup" + │ │ │ ├── closing_loc: (68,34)-(68,35) = ":" + │ │ │ └── unescaped: "whatup" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (68,36)-(68,40)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (68,36)-(68,37) = ":" + │ │ │ ├── value_loc: (68,37)-(68,40) = "dog" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "dog" + │ │ └── operator_loc: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (70,0)-(70,41)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :hi + │ ├── message_loc: (70,0)-(70,2) = "hi" + │ ├── opening_loc: (70,2)-(70,3) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (70,3)-(70,40)) + │ │ ├── flags: contains_keywords, contains_keyword_splat + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (70,3)-(70,40)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 3) + │ │ ├── @ AssocNode (location: (70,3)-(70,20)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (70,3)-(70,9)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (70,3)-(70,4) = ":" + │ │ │ │ ├── value_loc: (70,4)-(70,9) = "there" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "there" + │ │ │ ├── value: + │ │ │ │ @ SymbolNode (location: (70,13)-(70,20)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (70,13)-(70,14) = ":" + │ │ │ │ ├── value_loc: (70,14)-(70,20) = "friend" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "friend" + │ │ │ └── operator_loc: (70,10)-(70,12) = "=>" + │ │ ├── @ AssocSplatNode (location: (70,22)-(70,26)) + │ │ │ ├── value: + │ │ │ │ @ HashNode (location: (70,24)-(70,26)) + │ │ │ │ ├── opening_loc: (70,24)-(70,25) = "{" + │ │ │ │ ├── elements: (length: 0) + │ │ │ │ └── closing_loc: (70,25)-(70,26) = "}" + │ │ │ └── operator_loc: (70,22)-(70,24) = "**" + │ │ └── @ AssocNode (location: (70,28)-(70,40)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (70,28)-(70,35)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (70,28)-(70,34) = "whatup" + │ │ │ ├── closing_loc: (70,34)-(70,35) = ":" + │ │ │ └── unescaped: "whatup" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (70,36)-(70,40)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (70,36)-(70,37) = ":" + │ │ │ ├── value_loc: (70,37)-(70,40) = "dog" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "dog" + │ │ └── operator_loc: ∅ + │ ├── closing_loc: (70,40)-(70,41) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (72,0)-(72,35)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (72,0)-(72,3) = "foo" + │ ├── opening_loc: (72,3)-(72,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (72,4)-(72,26)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ HashNode (location: (72,4)-(72,26)) + │ │ ├── opening_loc: (72,4)-(72,5) = "{" + │ │ ├── elements: (length: 2) + │ │ │ ├── @ AssocNode (location: (72,6)-(72,13)) + │ │ │ │ ├── key: + │ │ │ │ │ @ SymbolNode (location: (72,6)-(72,8)) + │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── value_loc: (72,6)-(72,7) = "a" + │ │ │ │ │ ├── closing_loc: (72,7)-(72,8) = ":" + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ ├── value: + │ │ │ │ │ @ TrueNode (location: (72,9)-(72,13)) + │ │ │ │ └── operator_loc: ∅ + │ │ │ └── @ AssocNode (location: (72,15)-(72,23)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (72,15)-(72,17)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── value_loc: (72,15)-(72,16) = "b" + │ │ │ │ ├── closing_loc: (72,16)-(72,17) = ":" + │ │ │ │ └── unescaped: "b" + │ │ │ ├── value: + │ │ │ │ @ FalseNode (location: (72,18)-(72,23)) + │ │ │ └── operator_loc: ∅ + │ │ └── closing_loc: (72,25)-(72,26) = "}" + │ ├── closing_loc: (72,35)-(72,36) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (72,28)-(72,35)) + │ ├── expression: + │ │ @ SymbolNode (location: (72,29)-(72,35)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (72,29)-(72,30) = ":" + │ │ ├── value_loc: (72,30)-(72,35) = "block" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "block" + │ └── operator_loc: (72,28)-(72,29) = "&" + ├── @ CallNode (location: (74,0)-(74,20)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :hi + │ ├── message_loc: (74,0)-(74,2) = "hi" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (74,3)-(74,20)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (74,3)-(74,20)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (74,3)-(74,20)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (74,3)-(74,9)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (74,3)-(74,4) = ":" + │ │ │ ├── value_loc: (74,4)-(74,9) = "there" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "there" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (74,13)-(74,20)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (74,13)-(74,14) = ":" + │ │ │ ├── value_loc: (74,14)-(74,20) = "friend" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "friend" + │ │ └── operator_loc: (74,10)-(74,12) = "=>" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (76,0)-(78,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (76,0)-(76,3) = "foo" + │ ├── opening_loc: (76,3)-(76,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (76,4)-(77,2)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ SymbolNode (location: (76,4)-(76,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (76,4)-(76,5) = ":" + │ │ │ ├── value_loc: (76,5)-(76,6) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ SymbolNode (location: (77,0)-(77,2)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (77,0)-(77,1) = ":" + │ │ ├── value_loc: (77,1)-(77,2) = "b" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "b" + │ ├── closing_loc: (78,0)-(78,1) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (80,0)-(83,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (80,0)-(80,3) = "foo" + │ ├── opening_loc: (80,3)-(80,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (81,0)-(82,5)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 2) + │ │ ├── @ SymbolNode (location: (81,0)-(81,2)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (81,0)-(81,1) = ":" + │ │ │ ├── value_loc: (81,1)-(81,2) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ KeywordHashNode (location: (82,0)-(82,5)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (82,0)-(82,5)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (82,0)-(82,2)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (82,0)-(82,1) = "b" + │ │ │ ├── closing_loc: (82,1)-(82,2) = ":" + │ │ │ └── unescaped: "b" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (82,3)-(82,5)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (82,3)-(82,4) = ":" + │ │ │ ├── value_loc: (82,4)-(82,5) = "c" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "c" + │ │ └── operator_loc: ∅ + │ ├── closing_loc: (83,0)-(83,1) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (85,0)-(85,11)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (85,0)-(85,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockArgumentNode (location: (85,4)-(85,11)) + │ ├── expression: + │ │ @ SymbolNode (location: (85,5)-(85,11)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (85,5)-(85,6) = ":" + │ │ ├── value_loc: (85,6)-(85,11) = "block" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "block" + │ └── operator_loc: (85,4)-(85,5) = "&" + ├── @ CallNode (location: (87,0)-(87,30)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (87,0)-(87,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (87,4)-(87,21)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (87,4)-(87,21)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 2) + │ │ ├── @ AssocNode (location: (87,4)-(87,11)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (87,4)-(87,6)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── value_loc: (87,4)-(87,5) = "a" + │ │ │ │ ├── closing_loc: (87,5)-(87,6) = ":" + │ │ │ │ └── unescaped: "a" + │ │ │ ├── value: + │ │ │ │ @ TrueNode (location: (87,7)-(87,11)) + │ │ │ └── operator_loc: ∅ + │ │ └── @ AssocNode (location: (87,13)-(87,21)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (87,13)-(87,15)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (87,13)-(87,14) = "b" + │ │ │ ├── closing_loc: (87,14)-(87,15) = ":" + │ │ │ └── unescaped: "b" + │ │ ├── value: + │ │ │ @ FalseNode (location: (87,16)-(87,21)) + │ │ └── operator_loc: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockArgumentNode (location: (87,23)-(87,30)) + │ ├── expression: + │ │ @ SymbolNode (location: (87,24)-(87,30)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (87,24)-(87,25) = ":" + │ │ ├── value_loc: (87,25)-(87,30) = "block" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "block" + │ └── operator_loc: (87,23)-(87,24) = "&" + ├── @ CallNode (location: (89,0)-(89,21)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :some_func + │ ├── message_loc: (89,0)-(89,9) = "some_func" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (89,10)-(89,21)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 2) + │ │ ├── @ IntegerNode (location: (89,10)-(89,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ KeywordHashNode (location: (89,13)-(89,21)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (89,13)-(89,21)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (89,13)-(89,19)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (89,13)-(89,18) = "kwarg" + │ │ │ ├── closing_loc: (89,18)-(89,19) = ":" + │ │ │ └── unescaped: "kwarg" + │ │ ├── value: + │ │ │ @ IntegerNode (location: (89,20)-(89,21)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── operator_loc: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (91,0)-(91,18)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (91,0)-(91,6)) + │ │ └── name: :Kernel + │ ├── call_operator_loc: (91,6)-(91,7) = "." + │ ├── name: :Integer + │ ├── message_loc: (91,7)-(91,14) = "Integer" + │ ├── opening_loc: (91,14)-(91,15) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (91,15)-(91,17)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (91,15)-(91,17)) + │ │ ├── flags: decimal + │ │ └── value: 10 + │ ├── closing_loc: (91,17)-(91,18) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (93,0)-(93,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (93,0)-(93,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :x + │ │ ├── message_loc: (93,0)-(93,1) = "x" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (93,1)-(93,2) = "." + │ ├── name: :each + │ ├── message_loc: (93,2)-(93,6) = "each" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (93,7)-(93,10)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (93,7)-(93,8) = "{" + │ └── closing_loc: (93,9)-(93,10) = "}" + ├── @ CallNode (location: (95,0)-(95,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ 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: ∅ + │ ├── call_operator_loc: (95,3)-(95,4) = "." + │ ├── name: :map + │ ├── message_loc: (95,4)-(95,7) = "map" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (95,8)-(95,14)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (95,10)-(95,12)) + │ │ └── body: (length: 1) + │ │ └── @ BackReferenceReadNode (location: (95,10)-(95,12)) + │ │ └── name: :$& + │ ├── opening_loc: (95,8)-(95,9) = "{" + │ └── closing_loc: (95,13)-(95,14) = "}" + ├── @ CallNode (location: (97,0)-(97,12)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantPathNode (location: (97,0)-(97,4)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (97,0)-(97,1)) + │ │ │ └── name: :A + │ │ ├── name: :B + │ │ ├── delimiter_loc: (97,1)-(97,3) = "::" + │ │ └── name_loc: (97,3)-(97,4) = "B" + │ ├── call_operator_loc: (97,4)-(97,6) = "::" + │ ├── name: :C + │ ├── message_loc: (97,6)-(97,7) = "C" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (97,8)-(97,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SymbolNode (location: (97,8)-(97,12)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (97,8)-(97,9) = ":" + │ │ ├── value_loc: (97,9)-(97,12) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (99,0)-(99,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantPathNode (location: (99,0)-(99,4)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (99,0)-(99,1)) + │ │ │ └── name: :A + │ │ ├── name: :B + │ │ ├── delimiter_loc: (99,1)-(99,3) = "::" + │ │ └── name_loc: (99,3)-(99,4) = "B" + │ ├── call_operator_loc: (99,4)-(99,6) = "::" + │ ├── name: :C + │ ├── message_loc: (99,6)-(99,7) = "C" + │ ├── opening_loc: (99,7)-(99,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (99,8)-(99,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SymbolNode (location: (99,8)-(99,12)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (99,8)-(99,9) = ":" + │ │ ├── value_loc: (99,9)-(99,12) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ ├── closing_loc: (99,12)-(99,13) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (101,0)-(101,17)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantPathNode (location: (101,0)-(101,4)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (101,0)-(101,1)) + │ │ │ └── name: :A + │ │ ├── name: :B + │ │ ├── delimiter_loc: (101,1)-(101,3) = "::" + │ │ └── name_loc: (101,3)-(101,4) = "B" + │ ├── call_operator_loc: (101,4)-(101,6) = "::" + │ ├── name: :C + │ ├── message_loc: (101,6)-(101,7) = "C" + │ ├── opening_loc: (101,7)-(101,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (101,8)-(101,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SymbolNode (location: (101,8)-(101,12)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (101,8)-(101,9) = ":" + │ │ ├── value_loc: (101,9)-(101,12) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ ├── closing_loc: (101,12)-(101,13) = ")" + │ └── block: + │ @ BlockNode (location: (101,14)-(101,17)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (101,14)-(101,15) = "{" + │ └── closing_loc: (101,16)-(101,17) = "}" + ├── @ CallNode (location: (103,0)-(103,12)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (103,0)-(103,3) = "foo" + │ ├── opening_loc: (103,3)-(103,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (103,4)-(103,11)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (103,4)-(103,11)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (103,4)-(103,11)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (103,4)-(103,8)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (103,4)-(103,5) = "\"" + │ │ │ ├── value_loc: (103,5)-(103,6) = "a" + │ │ │ ├── closing_loc: (103,6)-(103,8) = "\":" + │ │ │ └── unescaped: "a" + │ │ ├── value: + │ │ │ @ IntegerNode (location: (103,9)-(103,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: -1 + │ │ └── operator_loc: ∅ + │ ├── closing_loc: (103,11)-(103,12) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (105,0)-(105,28)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (105,0)-(105,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (105,4)-(105,28)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (105,4)-(105,28)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (105,4)-(105,28)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (105,4)-(105,8)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (105,4)-(105,7) = "bar" + │ │ │ ├── closing_loc: (105,7)-(105,8) = ":" + │ │ │ └── unescaped: "bar" + │ │ ├── value: + │ │ │ @ HashNode (location: (105,9)-(105,28)) + │ │ │ ├── opening_loc: (105,9)-(105,10) = "{" + │ │ │ ├── elements: (length: 1) + │ │ │ │ └── @ AssocNode (location: (105,11)-(105,26)) + │ │ │ │ ├── key: + │ │ │ │ │ @ SymbolNode (location: (105,11)-(105,15)) + │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── value_loc: (105,11)-(105,14) = "baz" + │ │ │ │ │ ├── closing_loc: (105,14)-(105,15) = ":" + │ │ │ │ │ └── unescaped: "baz" + │ │ │ │ ├── value: + │ │ │ │ │ @ CallNode (location: (105,16)-(105,26)) + │ │ │ │ │ ├── flags: ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :qux + │ │ │ │ │ ├── message_loc: (105,16)-(105,19) = "qux" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: + │ │ │ │ │ @ BlockNode (location: (105,20)-(105,26)) + │ │ │ │ │ ├── locals: [] + │ │ │ │ │ ├── parameters: ∅ + │ │ │ │ │ ├── body: ∅ + │ │ │ │ │ ├── opening_loc: (105,20)-(105,22) = "do" + │ │ │ │ │ └── closing_loc: (105,23)-(105,26) = "end" + │ │ │ │ └── operator_loc: ∅ + │ │ │ └── closing_loc: (105,27)-(105,28) = "}" + │ │ └── operator_loc: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (107,0)-(107,24)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (107,0)-(107,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (107,4)-(107,24)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (107,4)-(107,24)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (107,4)-(107,24)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (107,4)-(107,8)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (107,4)-(107,7) = "bar" + │ │ │ ├── closing_loc: (107,7)-(107,8) = ":" + │ │ │ └── unescaped: "bar" + │ │ ├── value: + │ │ │ @ HashNode (location: (107,9)-(107,24)) + │ │ │ ├── opening_loc: (107,9)-(107,10) = "{" + │ │ │ ├── elements: (length: 1) + │ │ │ │ └── @ AssocSplatNode (location: (107,11)-(107,22)) + │ │ │ │ ├── value: + │ │ │ │ │ @ CallNode (location: (107,13)-(107,22)) + │ │ │ │ │ ├── flags: ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :kw + │ │ │ │ │ ├── message_loc: (107,13)-(107,15) = "kw" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: + │ │ │ │ │ @ BlockNode (location: (107,16)-(107,22)) + │ │ │ │ │ ├── locals: [] + │ │ │ │ │ ├── parameters: ∅ + │ │ │ │ │ ├── body: ∅ + │ │ │ │ │ ├── opening_loc: (107,16)-(107,18) = "do" + │ │ │ │ │ └── closing_loc: (107,19)-(107,22) = "end" + │ │ │ │ └── operator_loc: (107,11)-(107,13) = "**" + │ │ │ └── closing_loc: (107,23)-(107,24) = "}" + │ │ └── operator_loc: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (109,0)-(109,36)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (109,0)-(109,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (109,4)-(109,29)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (109,4)-(109,29)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (109,4)-(109,5) = "\"" + │ │ ├── parts: (length: 1) + │ │ │ └── @ EmbeddedStatementsNode (location: (109,5)-(109,28)) + │ │ │ ├── opening_loc: (109,5)-(109,7) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (109,7)-(109,27)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (109,7)-(109,27)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── receiver: + │ │ │ │ │ @ CallNode (location: (109,7)-(109,10)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :bar + │ │ │ │ │ ├── message_loc: (109,7)-(109,10) = "bar" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── call_operator_loc: (109,10)-(109,11) = "." + │ │ │ │ ├── name: :map + │ │ │ │ ├── message_loc: (109,11)-(109,14) = "map" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: + │ │ │ │ @ BlockNode (location: (109,15)-(109,27)) + │ │ │ │ ├── locals: [] + │ │ │ │ ├── parameters: ∅ + │ │ │ │ ├── body: + │ │ │ │ │ @ StatementsNode (location: (109,18)-(109,23)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ StringNode (location: (109,18)-(109,23)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ ├── opening_loc: (109,18)-(109,19) = "\"" + │ │ │ │ │ ├── content_loc: (109,19)-(109,22) = "baz" + │ │ │ │ │ ├── closing_loc: (109,22)-(109,23) = "\"" + │ │ │ │ │ └── unescaped: "baz" + │ │ │ │ ├── opening_loc: (109,15)-(109,17) = "do" + │ │ │ │ └── closing_loc: (109,24)-(109,27) = "end" + │ │ │ └── closing_loc: (109,27)-(109,28) = "}" + │ │ └── closing_loc: (109,28)-(109,29) = "\"" + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (109,30)-(109,36)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (109,30)-(109,32) = "do" + │ └── closing_loc: (109,33)-(109,36) = "end" + ├── @ CallNode (location: (111,0)-(111,28)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (111,0)-(111,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (111,4)-(111,28)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ ClassNode (location: (111,4)-(111,28)) + │ │ ├── locals: [] + │ │ ├── class_keyword_loc: (111,4)-(111,9) = "class" + │ │ ├── constant_path: + │ │ │ @ ConstantReadNode (location: (111,10)-(111,13)) + │ │ │ └── name: :Bar + │ │ ├── inheritance_operator_loc: ∅ + │ │ ├── superclass: ∅ + │ │ ├── body: + │ │ │ @ StatementsNode (location: (111,14)-(111,24)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (111,14)-(111,24)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (111,14)-(111,17) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (111,18)-(111,24)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (111,18)-(111,20) = "do" + │ │ │ └── closing_loc: (111,21)-(111,24) = "end" + │ │ ├── end_keyword_loc: (111,25)-(111,28) = "end" + │ │ └── name: :Bar + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (113,0)-(113,29)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (113,0)-(113,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (113,4)-(113,29)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ ModuleNode (location: (113,4)-(113,29)) + │ │ ├── locals: [] + │ │ ├── module_keyword_loc: (113,4)-(113,10) = "module" + │ │ ├── constant_path: + │ │ │ @ ConstantReadNode (location: (113,11)-(113,14)) + │ │ │ └── name: :Bar + │ │ ├── body: + │ │ │ @ StatementsNode (location: (113,15)-(113,25)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (113,15)-(113,25)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (113,15)-(113,18) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (113,19)-(113,25)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (113,19)-(113,21) = "do" + │ │ │ └── closing_loc: (113,22)-(113,25) = "end" + │ │ ├── end_keyword_loc: (113,26)-(113,29) = "end" + │ │ └── name: :Bar + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (115,0)-(115,16)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (115,0)-(115,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (115,4)-(115,16)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ ArrayNode (location: (115,4)-(115,16)) + │ │ ├── flags: ∅ + │ │ ├── elements: (length: 1) + │ │ │ └── @ CallNode (location: (115,5)-(115,15)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (115,5)-(115,8) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (115,9)-(115,15)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (115,9)-(115,11) = "do" + │ │ │ └── closing_loc: (115,12)-(115,15) = "end" + │ │ ├── opening_loc: (115,4)-(115,5) = "[" + │ │ └── closing_loc: (115,15)-(115,16) = "]" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (117,0)-(117,28)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :p + │ ├── message_loc: (117,0)-(117,1) = "p" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (117,2)-(117,28)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ BeginNode (location: (117,2)-(117,28)) + │ │ ├── begin_keyword_loc: (117,2)-(117,7) = "begin" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (117,8)-(117,24)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (117,8)-(117,24)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ IntegerNode (location: (117,8)-(117,9)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── call_operator_loc: (117,9)-(117,10) = "." + │ │ │ ├── name: :times + │ │ │ ├── message_loc: (117,10)-(117,15) = "times" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (117,16)-(117,24)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (117,19)-(117,20)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (117,19)-(117,20)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── opening_loc: (117,16)-(117,18) = "do" + │ │ │ └── closing_loc: (117,21)-(117,24) = "end" + │ │ ├── rescue_clause: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (117,25)-(117,28) = "end" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (119,0)-(124,5)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (119,0)-(119,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (119,4)-(124,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ SymbolNode (location: (119,4)-(119,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (119,4)-(119,5) = ":" + │ │ │ ├── value_loc: (119,5)-(119,6) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ IfNode (location: (120,2)-(124,5)) + │ │ ├── if_keyword_loc: (120,2)-(120,4) = "if" + │ │ ├── predicate: + │ │ │ @ CallNode (location: (120,5)-(120,6)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :x + │ │ │ ├── message_loc: (120,5)-(120,6) = "x" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (121,4)-(123,7)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (121,4)-(123,7)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (121,4)-(121,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (121,8)-(123,7)) + │ │ │ ├── locals: [:a] + │ │ │ ├── parameters: + │ │ │ │ @ BlockParametersNode (location: (121,11)-(121,14)) + │ │ │ │ ├── parameters: + │ │ │ │ │ @ ParametersNode (location: (121,12)-(121,13)) + │ │ │ │ │ ├── requireds: (length: 1) + │ │ │ │ │ │ └── @ RequiredParameterNode (location: (121,12)-(121,13)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── name: :a + │ │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ │ ├── rest: ∅ + │ │ │ │ │ ├── posts: (length: 0) + │ │ │ │ │ ├── keywords: (length: 0) + │ │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── locals: (length: 0) + │ │ │ │ ├── opening_loc: (121,11)-(121,12) = "|" + │ │ │ │ └── closing_loc: (121,13)-(121,14) = "|" + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (122,6)-(122,7)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ LocalVariableReadNode (location: (122,6)-(122,7)) + │ │ │ │ ├── name: :a + │ │ │ │ └── depth: 0 + │ │ │ ├── opening_loc: (121,8)-(121,10) = "do" + │ │ │ └── closing_loc: (123,4)-(123,7) = "end" + │ │ ├── consequent: ∅ + │ │ └── end_keyword_loc: (124,2)-(124,5) = "end" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (126,0)-(135,5)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (126,0)-(126,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (126,4)-(135,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 3) + │ │ ├── @ SymbolNode (location: (126,4)-(126,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (126,4)-(126,5) = ":" + │ │ │ ├── value_loc: (126,5)-(126,6) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ ├── @ WhileNode (location: (127,2)-(131,5)) + │ │ │ ├── flags: ∅ + │ │ │ ├── keyword_loc: (127,2)-(127,7) = "while" + │ │ │ ├── closing_loc: (131,2)-(131,5) = "end" + │ │ │ ├── predicate: + │ │ │ │ @ CallNode (location: (127,8)-(127,9)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :x + │ │ │ │ ├── message_loc: (127,8)-(127,9) = "x" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── statements: + │ │ │ @ StatementsNode (location: (128,4)-(130,7)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (128,4)-(130,7)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (128,4)-(128,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (128,8)-(130,7)) + │ │ │ ├── locals: [:a] + │ │ │ ├── parameters: + │ │ │ │ @ BlockParametersNode (location: (128,11)-(128,14)) + │ │ │ │ ├── parameters: + │ │ │ │ │ @ ParametersNode (location: (128,12)-(128,13)) + │ │ │ │ │ ├── requireds: (length: 1) + │ │ │ │ │ │ └── @ RequiredParameterNode (location: (128,12)-(128,13)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── name: :a + │ │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ │ ├── rest: ∅ + │ │ │ │ │ ├── posts: (length: 0) + │ │ │ │ │ ├── keywords: (length: 0) + │ │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── locals: (length: 0) + │ │ │ │ ├── opening_loc: (128,11)-(128,12) = "|" + │ │ │ │ └── closing_loc: (128,13)-(128,14) = "|" + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (129,6)-(129,7)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ LocalVariableReadNode (location: (129,6)-(129,7)) + │ │ │ │ ├── name: :a + │ │ │ │ └── depth: 0 + │ │ │ ├── opening_loc: (128,8)-(128,10) = "do" + │ │ │ └── closing_loc: (130,4)-(130,7) = "end" + │ │ └── @ UntilNode (location: (132,2)-(135,5)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (132,2)-(132,7) = "until" + │ │ ├── closing_loc: (135,2)-(135,5) = "end" + │ │ ├── predicate: + │ │ │ @ CallNode (location: (132,8)-(132,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :x + │ │ │ ├── message_loc: (132,8)-(132,9) = "x" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (133,4)-(134,7)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (133,4)-(134,7)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (133,4)-(133,7) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (133,8)-(134,7)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (133,8)-(133,10) = "do" + │ │ └── closing_loc: (134,4)-(134,7) = "end" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (137,0)-(137,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ HashNode (location: (137,0)-(137,2)) + │ │ ├── opening_loc: (137,0)-(137,1) = "{" + │ │ ├── elements: (length: 0) + │ │ └── closing_loc: (137,1)-(137,2) = "}" + │ ├── call_operator_loc: ∅ + │ ├── name: :+ + │ ├── message_loc: (137,3)-(137,4) = "+" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (137,5)-(137,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (137,5)-(137,9)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :A + │ │ ├── message_loc: (137,5)-(137,6) = "A" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (137,7)-(137,9)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (137,7)-(137,8) = "{" + │ │ └── closing_loc: (137,8)-(137,9) = "}" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (139,0)-(139,16)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ HashNode (location: (139,0)-(139,2)) + │ │ ├── opening_loc: (139,0)-(139,1) = "{" + │ │ ├── elements: (length: 0) + │ │ └── closing_loc: (139,1)-(139,2) = "}" + │ ├── call_operator_loc: ∅ + │ ├── name: :+ + │ ├── message_loc: (139,3)-(139,4) = "+" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (139,5)-(139,16)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (139,5)-(139,16)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :A + │ │ ├── message_loc: (139,5)-(139,6) = "A" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (139,7)-(139,16)) + │ │ ├── locals: [:a] + │ │ ├── parameters: + │ │ │ @ BlockParametersNode (location: (139,9)-(139,12)) + │ │ │ ├── parameters: + │ │ │ │ @ ParametersNode (location: (139,10)-(139,11)) + │ │ │ │ ├── requireds: (length: 1) + │ │ │ │ │ └── @ RequiredParameterNode (location: (139,10)-(139,11)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :a + │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── posts: (length: 0) + │ │ │ │ ├── keywords: (length: 0) + │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── locals: (length: 0) + │ │ │ ├── opening_loc: (139,9)-(139,10) = "|" + │ │ │ └── closing_loc: (139,11)-(139,12) = "|" + │ │ ├── body: + │ │ │ @ StatementsNode (location: (139,13)-(139,14)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableReadNode (location: (139,13)-(139,14)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── opening_loc: (139,7)-(139,8) = "{" + │ │ └── closing_loc: (139,15)-(139,16) = "}" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (141,0)-(141,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (141,0)-(141,4)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :A + │ │ ├── message_loc: (141,0)-(141,1) = "A" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (141,2)-(141,4)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (141,2)-(141,3) = "{" + │ │ └── closing_loc: (141,3)-(141,4) = "}" + │ ├── call_operator_loc: ∅ + │ ├── name: :+ + │ ├── message_loc: (141,5)-(141,6) = "+" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (141,7)-(141,11)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (141,7)-(141,11)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :A + │ │ ├── message_loc: (141,7)-(141,8) = "A" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (141,9)-(141,11)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (141,9)-(141,10) = "{" + │ │ └── closing_loc: (141,10)-(141,11) = "}" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (143,0)-(143,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (143,0)-(143,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :lst + │ │ ├── message_loc: (143,0)-(143,3) = "lst" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :<< + │ ├── message_loc: (143,4)-(143,6) = "<<" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (143,7)-(143,11)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (143,7)-(143,11)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :A + │ │ ├── message_loc: (143,7)-(143,8) = "A" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (143,9)-(143,11)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (143,9)-(143,10) = "{" + │ │ └── closing_loc: (143,10)-(143,11) = "}" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ InterpolatedStringNode (location: (145,0)-(145,17)) + │ ├── flags: ∅ + │ ├── opening_loc: (145,0)-(145,1) = "\"" + │ ├── parts: (length: 1) + │ │ └── @ EmbeddedStatementsNode (location: (145,1)-(145,16)) + │ │ ├── opening_loc: (145,1)-(145,3) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (145,4)-(145,14)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (145,4)-(145,14)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :join + │ │ │ ├── message_loc: (145,4)-(145,8) = "join" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (145,9)-(145,14)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ ParenthesesNode (location: (145,9)-(145,14)) + │ │ │ │ ├── body: + │ │ │ │ │ @ StatementsNode (location: (145,10)-(145,13)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ StringNode (location: (145,10)-(145,13)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ ├── opening_loc: (145,10)-(145,11) = "\"" + │ │ │ │ │ ├── content_loc: (145,11)-(145,12) = " " + │ │ │ │ │ ├── closing_loc: (145,12)-(145,13) = "\"" + │ │ │ │ │ └── unescaped: " " + │ │ │ │ ├── opening_loc: (145,9)-(145,10) = "(" + │ │ │ │ └── closing_loc: (145,13)-(145,14) = ")" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── closing_loc: (145,15)-(145,16) = "}" + │ └── closing_loc: (145,16)-(145,17) = "\"" + ├── @ InterpolatedStringNode (location: (147,0)-(147,8)) + │ ├── flags: ∅ + │ ├── opening_loc: (147,0)-(147,1) = "\"" + │ ├── parts: (length: 1) + │ │ └── @ EmbeddedStatementsNode (location: (147,1)-(147,7)) + │ │ ├── opening_loc: (147,1)-(147,3) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (147,3)-(147,6)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ ParenthesesNode (location: (147,3)-(147,6)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (147,4)-(147,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (147,4)-(147,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :v + │ │ │ │ ├── message_loc: (147,4)-(147,5) = "v" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── opening_loc: (147,3)-(147,4) = "(" + │ │ │ └── closing_loc: (147,5)-(147,6) = ")" + │ │ └── closing_loc: (147,6)-(147,7) = "}" + │ └── closing_loc: (147,7)-(147,8) = "\"" + ├── @ DefNode (location: (149,0)-(149,18)) + │ ├── name: :f + │ ├── name_loc: (149,4)-(149,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (149,6)-(149,7)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (149,6)-(149,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (149,6)-(149,7) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (149,10)-(149,13)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (149,10)-(149,13)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :p + │ │ ├── message_loc: (149,10)-(149,11) = "p" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (149,12)-(149,13)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ SplatNode (location: (149,12)-(149,13)) + │ │ │ ├── operator_loc: (149,12)-(149,13) = "*" + │ │ │ └── expression: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (149,0)-(149,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (149,5)-(149,6) = "(" + │ ├── rparen_loc: (149,7)-(149,8) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (149,15)-(149,18) = "end" + ├── @ CallNode (location: (151,0)-(151,16)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (151,0)-(151,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (151,4)-(151,16)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ IntegerNode (location: (151,4)-(151,5)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ CallNode (location: (151,7)-(151,16)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :Bar + │ │ ├── message_loc: (151,7)-(151,10) = "Bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (151,11)-(151,16)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: + │ │ │ @ StatementsNode (location: (151,13)-(151,14)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ IntegerNode (location: (151,13)-(151,14)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── opening_loc: (151,11)-(151,12) = "{" + │ │ └── closing_loc: (151,15)-(151,16) = "}" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ LocalVariableWriteNode (location: (153,0)-(153,7)) + │ ├── name: :foo + │ ├── depth: 0 + │ ├── name_loc: (153,0)-(153,3) = "foo" + │ ├── value: + │ │ @ IntegerNode (location: (153,6)-(153,7)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (153,4)-(153,5) = "=" + ├── @ CallNode (location: (154,0)-(154,6)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (154,0)-(154,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (154,4)-(154,6)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (154,4)-(154,5) = "{" + │ └── closing_loc: (154,5)-(154,6) = "}" + └── @ CallNode (location: (156,0)-(156,19)) + ├── flags: ∅ + ├── receiver: + │ @ InstanceVariableReadNode (location: (156,0)-(156,2)) + │ └── name: :@a + ├── call_operator_loc: (156,2)-(156,3) = "." + ├── name: :b + ├── message_loc: (156,3)-(156,4) = "b" + ├── opening_loc: ∅ + ├── arguments: + │ @ ArgumentsNode (location: (156,5)-(156,19)) + │ ├── flags: contains_keywords + │ └── arguments: (length: 1) + │ └── @ KeywordHashNode (location: (156,5)-(156,19)) + │ ├── flags: ∅ + │ └── elements: (length: 1) + │ └── @ AssocNode (location: (156,5)-(156,19)) + │ ├── key: + │ │ @ InterpolatedSymbolNode (location: (156,5)-(156,16)) + │ │ ├── opening_loc: (156,5)-(156,6) = "\"" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ StringNode (location: (156,6)-(156,7)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (156,6)-(156,7) = "c" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "c" + │ │ │ └── @ EmbeddedStatementsNode (location: (156,7)-(156,14)) + │ │ │ ├── opening_loc: (156,7)-(156,9) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (156,9)-(156,13)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (156,9)-(156,13)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :name + │ │ │ │ ├── message_loc: (156,9)-(156,13) = "name" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── closing_loc: (156,13)-(156,14) = "}" + │ │ └── closing_loc: (156,14)-(156,16) = "\":" + │ ├── value: + │ │ @ IntegerNode (location: (156,17)-(156,19)) + │ │ ├── flags: decimal + │ │ └── value: 42 + │ └── operator_loc: ∅ + ├── closing_loc: ∅ + └── block: ∅ |