diff options
Diffstat (limited to 'test/prism/snapshots/blocks.txt')
-rw-r--r-- | test/prism/snapshots/blocks.txt | 774 |
1 files changed, 774 insertions, 0 deletions
diff --git a/test/prism/snapshots/blocks.txt b/test/prism/snapshots/blocks.txt new file mode 100644 index 0000000000..1c996ebd09 --- /dev/null +++ b/test/prism/snapshots/blocks.txt @@ -0,0 +1,774 @@ +@ ProgramNode (location: (1,0)-(54,17)) +├── locals: [:fork] +└── statements: + @ StatementsNode (location: (1,0)-(54,17)) + └── body: (length: 20) + ├── @ CallNode (location: (1,0)-(1,16)) + │ ├── 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: ∅ + │ ├── name: :[] + │ ├── message_loc: (1,3)-(1,8) = "[bar]" + │ ├── opening_loc: (1,3)-(1,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (1,4)-(1,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (1,4)-(1,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (1,4)-(1,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (1,7)-(1,8) = "]" + │ └── block: + │ @ BlockNode (location: (1,9)-(1,16)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (1,11)-(1,14)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (1,11)-(1,14)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (1,11)-(1,14) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (1,9)-(1,10) = "{" + │ └── closing_loc: (1,15)-(1,16) = "}" + ├── @ CallNode (location: (3,0)-(5,3)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ 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: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (3,3)-(3,8) = "[bar]" + │ ├── opening_loc: (3,3)-(3,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (3,4)-(3,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (3,4)-(3,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (3,4)-(3,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (3,7)-(3,8) = "]" + │ └── block: + │ @ BlockNode (location: (3,9)-(5,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (4,0)-(4,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (4,0)-(4,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (4,0)-(4,3) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (3,9)-(3,11) = "do" + │ └── closing_loc: (5,0)-(5,3) = "end" + ├── @ CallNode (location: (7,0)-(7,35)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (7,0)-(7,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :x + │ │ ├── message_loc: (7,0)-(7,1) = "x" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (7,1)-(7,2) = "." + │ ├── name: :reduce + │ ├── message_loc: (7,2)-(7,8) = "reduce" + │ ├── opening_loc: (7,8)-(7,9) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (7,9)-(7,10)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (7,9)-(7,10)) + │ │ ├── flags: decimal + │ │ └── value: 0 + │ ├── closing_loc: (7,10)-(7,11) = ")" + │ └── block: + │ @ BlockNode (location: (7,12)-(7,35)) + │ ├── locals: [:x, :memo] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (7,14)-(7,23)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (7,15)-(7,22)) + │ │ │ ├── requireds: (length: 2) + │ │ │ │ ├── @ RequiredParameterNode (location: (7,15)-(7,16)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :x + │ │ │ │ └── @ RequiredParameterNode (location: (7,18)-(7,22)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :memo + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (7,14)-(7,15) = "|" + │ │ └── closing_loc: (7,22)-(7,23) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (7,24)-(7,33)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableOperatorWriteNode (location: (7,24)-(7,33)) + │ │ ├── name_loc: (7,24)-(7,28) = "memo" + │ │ ├── binary_operator_loc: (7,29)-(7,31) = "+=" + │ │ ├── value: + │ │ │ @ LocalVariableReadNode (location: (7,32)-(7,33)) + │ │ │ ├── name: :x + │ │ │ └── depth: 0 + │ │ ├── name: :memo + │ │ ├── binary_operator: :+ + │ │ └── depth: 0 + │ ├── opening_loc: (7,12)-(7,13) = "{" + │ └── closing_loc: (7,34)-(7,35) = "}" + ├── @ CallNode (location: (9,0)-(9,10)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (9,0)-(9,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (9,4)-(9,10)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (9,4)-(9,6) = "do" + │ └── closing_loc: (9,7)-(9,10) = "end" + ├── @ CallNode (location: (11,0)-(11,21)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (11,0)-(11,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (11,4)-(11,21)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (11,4)-(11,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (11,4)-(11,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ ParenthesesNode (location: (11,9)-(11,21)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (11,10)-(11,20)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (11,10)-(11,20)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (11,10)-(11,13) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (11,14)-(11,20)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (11,14)-(11,16) = "do" + │ │ │ └── closing_loc: (11,17)-(11,20) = "end" + │ │ ├── opening_loc: (11,9)-(11,10) = "(" + │ │ └── closing_loc: (11,20)-(11,21) = ")" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (13,0)-(13,14)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (13,0)-(13,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (13,4)-(13,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (13,4)-(13,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (13,4)-(13,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (13,8)-(13,14)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (13,8)-(13,10) = "do" + │ └── closing_loc: (13,11)-(13,14) = "end" + ├── @ CallNode (location: (15,0)-(15,18)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (15,0)-(15,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (15,4)-(15,11)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (15,4)-(15,11)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (15,4)-(15,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (15,8)-(15,11)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ CallNode (location: (15,8)-(15,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (15,8)-(15,11) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (15,12)-(15,18)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (15,12)-(15,14) = "do" + │ └── closing_loc: (15,15)-(15,18) = "end" + ├── @ CallNode (location: (17,0)-(18,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (17,0)-(17,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (17,4)-(18,3)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (17,7)-(17,17)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (17,8)-(17,16)) + │ │ │ ├── requireds: (length: 0) + │ │ │ ├── optionals: (length: 1) + │ │ │ │ └── @ OptionalParameterNode (location: (17,8)-(17,16)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── name_loc: (17,8)-(17,9) = "a" + │ │ │ │ ├── operator_loc: (17,10)-(17,11) = "=" + │ │ │ │ └── value: + │ │ │ │ @ CallNode (location: (17,12)-(17,16)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── receiver: + │ │ │ │ │ @ CallNode (location: (17,12)-(17,13)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :b + │ │ │ │ │ ├── message_loc: (17,12)-(17,13) = "b" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :[] + │ │ │ │ ├── message_loc: (17,13)-(17,16) = "[1]" + │ │ │ │ ├── opening_loc: (17,13)-(17,14) = "[" + │ │ │ │ ├── arguments: + │ │ │ │ │ @ ArgumentsNode (location: (17,14)-(17,15)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ └── @ IntegerNode (location: (17,14)-(17,15)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ ├── closing_loc: (17,15)-(17,16) = "]" + │ │ │ │ └── block: ∅ + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (17,7)-(17,8) = "|" + │ │ └── closing_loc: (17,16)-(17,17) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (17,4)-(17,6) = "do" + │ └── closing_loc: (18,0)-(18,3) = "end" + ├── @ CallNode (location: (20,0)-(22,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (20,0)-(20,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (20,4)-(22,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (20,4)-(22,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (21,0)-(21,6)) + │ │ │ ├── keyword_loc: (21,0)-(21,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (22,0)-(22,3) = "end" + │ ├── opening_loc: (20,4)-(20,6) = "do" + │ └── closing_loc: (22,0)-(22,3) = "end" + ├── @ CallNode (location: (24,0)-(29,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (24,0)-(24,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (24,4)-(29,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (25,2)-(28,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (25,2)-(28,5)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (25,2)-(25,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (25,6)-(28,5)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: + │ │ │ @ StatementsNode (location: (26,4)-(27,7)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (26,4)-(27,7)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (26,4)-(26,7) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (26,8)-(27,7)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (26,8)-(26,10) = "do" + │ │ │ └── closing_loc: (27,4)-(27,7) = "end" + │ │ ├── opening_loc: (25,6)-(25,8) = "do" + │ │ └── closing_loc: (28,2)-(28,5) = "end" + │ ├── opening_loc: (24,4)-(24,6) = "do" + │ └── closing_loc: (29,0)-(29,3) = "end" + ├── @ CallNode (location: (31,0)-(31,16)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ 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: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (31,3)-(31,8) = "[bar]" + │ ├── opening_loc: (31,3)-(31,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (31,4)-(31,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (31,4)-(31,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (31,4)-(31,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (31,7)-(31,8) = "]" + │ └── block: + │ @ BlockNode (location: (31,9)-(31,16)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (31,11)-(31,14)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (31,11)-(31,14)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (31,11)-(31,14) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (31,9)-(31,10) = "{" + │ └── closing_loc: (31,15)-(31,16) = "}" + ├── @ CallNode (location: (33,0)-(33,24)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (33,0)-(33,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (33,4)-(33,24)) + │ ├── locals: [:x, :y, :z] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (33,6)-(33,20)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (33,7)-(33,19)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (33,7)-(33,8)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :x + │ │ │ ├── optionals: (length: 1) + │ │ │ │ └── @ OptionalParameterNode (location: (33,10)-(33,15)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── name: :y + │ │ │ │ ├── name_loc: (33,10)-(33,11) = "y" + │ │ │ │ ├── operator_loc: (33,12)-(33,13) = "=" + │ │ │ │ └── value: + │ │ │ │ @ IntegerNode (location: (33,14)-(33,15)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 1) + │ │ │ │ └── @ RequiredKeywordParameterNode (location: (33,17)-(33,19)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── name: :z + │ │ │ │ └── name_loc: (33,17)-(33,19) = "z:" + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (33,6)-(33,7) = "|" + │ │ └── closing_loc: (33,19)-(33,20) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (33,21)-(33,22)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (33,21)-(33,22)) + │ │ ├── name: :x + │ │ └── depth: 0 + │ ├── opening_loc: (33,4)-(33,5) = "{" + │ └── closing_loc: (33,23)-(33,24) = "}" + ├── @ CallNode (location: (35,0)-(35,11)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (35,0)-(35,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (35,4)-(35,11)) + │ ├── locals: [:x] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (35,6)-(35,9)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (35,7)-(35,8)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (35,7)-(35,8)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :x + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (35,6)-(35,7) = "|" + │ │ └── closing_loc: (35,8)-(35,9) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (35,4)-(35,5) = "{" + │ └── closing_loc: (35,10)-(35,11) = "}" + ├── @ LocalVariableWriteNode (location: (37,0)-(37,8)) + │ ├── name: :fork + │ ├── depth: 0 + │ ├── name_loc: (37,0)-(37,4) = "fork" + │ ├── value: + │ │ @ IntegerNode (location: (37,7)-(37,8)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (37,5)-(37,6) = "=" + ├── @ CallNode (location: (38,0)-(39,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :fork + │ ├── message_loc: (38,0)-(38,4) = "fork" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (38,5)-(39,3)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (38,8)-(38,11)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (38,9)-(38,10)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (38,9)-(38,10)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (38,8)-(38,9) = "|" + │ │ └── closing_loc: (38,10)-(38,11) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (38,5)-(38,7) = "do" + │ └── closing_loc: (39,0)-(39,3) = "end" + ├── @ CallNode (location: (41,0)-(41,12)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :fork + │ ├── message_loc: (41,0)-(41,4) = "fork" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (41,5)-(41,12)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (41,7)-(41,10)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (41,8)-(41,9)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (41,8)-(41,9)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (41,7)-(41,8) = "|" + │ │ └── closing_loc: (41,9)-(41,10) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (41,5)-(41,6) = "{" + │ └── closing_loc: (41,11)-(41,12) = "}" + ├── @ CallNode (location: (43,0)-(44,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :C + │ ├── message_loc: (43,0)-(43,1) = "C" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (43,2)-(44,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (43,2)-(43,4) = "do" + │ └── closing_loc: (44,0)-(44,3) = "end" + ├── @ CallNode (location: (46,0)-(46,4)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :C + │ ├── message_loc: (46,0)-(46,1) = "C" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (46,2)-(46,4)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (46,2)-(46,3) = "{" + │ └── closing_loc: (46,3)-(46,4) = "}" + ├── @ CallNode (location: (48,0)-(52,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (48,0)-(48,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (48,4)-(52,1)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (48,4)-(52,1)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :lambda + │ │ ├── message_loc: (48,4)-(48,10) = "lambda" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (48,11)-(52,1)) + │ │ ├── locals: [:a, :b] + │ │ ├── parameters: + │ │ │ @ BlockParametersNode (location: (48,13)-(51,3)) + │ │ │ ├── parameters: + │ │ │ │ @ ParametersNode (location: (49,2)-(50,6)) + │ │ │ │ ├── requireds: (length: 0) + │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── posts: (length: 0) + │ │ │ │ ├── keywords: (length: 2) + │ │ │ │ │ ├── @ OptionalKeywordParameterNode (location: (49,2)-(49,6)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ ├── name: :a + │ │ │ │ │ │ ├── name_loc: (49,2)-(49,4) = "a:" + │ │ │ │ │ │ └── value: + │ │ │ │ │ │ @ IntegerNode (location: (49,5)-(49,6)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 1 + │ │ │ │ │ └── @ OptionalKeywordParameterNode (location: (50,2)-(50,6)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ ├── name: :b + │ │ │ │ │ ├── name_loc: (50,2)-(50,4) = "b:" + │ │ │ │ │ └── value: + │ │ │ │ │ @ IntegerNode (location: (50,5)-(50,6)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 2 + │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── locals: (length: 0) + │ │ │ ├── opening_loc: (48,13)-(48,14) = "|" + │ │ │ └── closing_loc: (51,2)-(51,3) = "|" + │ │ ├── body: ∅ + │ │ ├── opening_loc: (48,11)-(48,12) = "{" + │ │ └── closing_loc: (52,0)-(52,1) = "}" + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── @ CallNode (location: (54,0)-(54,17)) + ├── flags: ignore_visibility + ├── receiver: ∅ + ├── call_operator_loc: ∅ + ├── name: :foo + ├── message_loc: (54,0)-(54,3) = "foo" + ├── opening_loc: ∅ + ├── arguments: ∅ + ├── closing_loc: ∅ + └── block: + @ BlockNode (location: (54,4)-(54,17)) + ├── locals: [:bar] + ├── parameters: + │ @ BlockParametersNode (location: (54,7)-(54,13)) + │ ├── parameters: + │ │ @ ParametersNode (location: (54,8)-(54,12)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (54,8)-(54,11)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :bar + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ ImplicitRestNode (location: (54,11)-(54,12)) + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── locals: (length: 0) + │ ├── opening_loc: (54,7)-(54,8) = "|" + │ └── closing_loc: (54,12)-(54,13) = "|" + ├── body: ∅ + ├── opening_loc: (54,4)-(54,6) = "do" + └── closing_loc: (54,14)-(54,17) = "end" |