@ ProgramNode (location: (1,0)-(73,3)) ├── locals: [:x] └── statements: @ StatementsNode (location: (1,0)-(73,3)) └── body: (length: 17) ├── @ ModuleNode (location: (1,0)-(7,3)) │ ├── locals: [] │ ├── module_keyword_loc: (1,0)-(1,6) = "module" │ ├── constant_path: │ │ @ ConstantReadNode (location: (1,7)-(1,8)) │ │ └── name: :A │ ├── body: │ │ @ StatementsNode (location: (2,2)-(6,3)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (2,2)-(6,3)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (2,2)-(2,5) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: │ │ @ BlockNode (location: (2,6)-(6,3)) │ │ ├── locals: [:bar, :foo] │ │ ├── parameters: │ │ │ @ BlockParametersNode (location: (2,8)-(2,13)) │ │ │ ├── parameters: │ │ │ │ @ ParametersNode (location: (2,9)-(2,12)) │ │ │ │ ├── requireds: (length: 1) │ │ │ │ │ └── @ RequiredParameterNode (location: (2,9)-(2,12)) │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ └── name: :bar │ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── rest: ∅ │ │ │ │ ├── posts: (length: 0) │ │ │ │ ├── keywords: (length: 0) │ │ │ │ ├── keyword_rest: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── locals: (length: 0) │ │ │ ├── opening_loc: (2,8)-(2,9) = "|" │ │ │ └── closing_loc: (2,12)-(2,13) = "|" │ │ ├── body: │ │ │ @ StatementsNode (location: (3,4)-(5,7)) │ │ │ └── body: (length: 1) │ │ │ └── @ WhileNode (location: (3,4)-(5,7)) │ │ │ ├── flags: ∅ │ │ │ ├── keyword_loc: (3,4)-(3,9) = "while" │ │ │ ├── closing_loc: (5,4)-(5,7) = "end" │ │ │ ├── predicate: │ │ │ │ @ CallNode (location: (3,10)-(3,13)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :foo │ │ │ │ ├── message_loc: (3,10)-(3,13) = "foo" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ └── statements: │ │ │ @ StatementsNode (location: (4,6)-(4,15)) │ │ │ └── body: (length: 1) │ │ │ └── @ LocalVariableWriteNode (location: (4,6)-(4,15)) │ │ │ ├── name: :foo │ │ │ ├── depth: 0 │ │ │ ├── name_loc: (4,6)-(4,9) = "foo" │ │ │ ├── value: │ │ │ │ @ LocalVariableReadNode (location: (4,12)-(4,15)) │ │ │ │ ├── name: :bar │ │ │ │ └── depth: 0 │ │ │ └── operator_loc: (4,10)-(4,11) = "=" │ │ ├── opening_loc: (2,6)-(2,7) = "{" │ │ └── closing_loc: (6,2)-(6,3) = "}" │ ├── end_keyword_loc: (7,0)-(7,3) = "end" │ └── name: :A ├── @ DefNode (location: (9,0)-(11,3)) │ ├── name: :foo │ ├── name_loc: (9,4)-(9,7) = "foo" │ ├── receiver: ∅ │ ├── parameters: ∅ │ ├── body: │ │ @ StatementsNode (location: (10,2)-(10,28)) │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (10,2)-(10,28)) │ │ ├── flags: ∅ │ │ ├── keyword_loc: (10,12)-(10,17) = "while" │ │ ├── closing_loc: ∅ │ │ ├── predicate: │ │ │ @ CallNode (location: (10,18)-(10,28)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: │ │ │ │ @ LocalVariableReadNode (location: (10,18)-(10,21)) │ │ │ │ ├── name: :foo │ │ │ │ └── depth: 0 │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :!= │ │ │ ├── message_loc: (10,22)-(10,24) = "!=" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (10,25)-(10,28)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ CallNode (location: (10,25)-(10,28)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :baz │ │ │ │ ├── message_loc: (10,25)-(10,28) = "baz" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── statements: │ │ @ StatementsNode (location: (10,2)-(10,11)) │ │ └── body: (length: 1) │ │ └── @ LocalVariableWriteNode (location: (10,2)-(10,11)) │ │ ├── name: :foo │ │ ├── depth: 0 │ │ ├── name_loc: (10,2)-(10,5) = "foo" │ │ ├── value: │ │ │ @ CallNode (location: (10,8)-(10,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (10,8)-(10,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: (10,6)-(10,7) = "=" │ ├── locals: [:foo] │ ├── def_keyword_loc: (9,0)-(9,3) = "def" │ ├── operator_loc: ∅ │ ├── lparen_loc: ∅ │ ├── rparen_loc: ∅ │ ├── equal_loc: ∅ │ └── end_keyword_loc: (11,0)-(11,3) = "end" ├── @ ModuleNode (location: (13,0)-(15,3)) │ ├── locals: [:foo] │ ├── module_keyword_loc: (13,0)-(13,6) = "module" │ ├── constant_path: │ │ @ ConstantReadNode (location: (13,7)-(13,8)) │ │ └── name: :A │ ├── body: │ │ @ StatementsNode (location: (14,2)-(14,21)) │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (14,2)-(14,21)) │ │ ├── flags: ∅ │ │ ├── keyword_loc: (14,12)-(14,17) = "while" │ │ ├── closing_loc: ∅ │ │ ├── predicate: │ │ │ @ LocalVariableReadNode (location: (14,18)-(14,21)) │ │ │ ├── name: :foo │ │ │ └── depth: 0 │ │ └── statements: │ │ @ StatementsNode (location: (14,2)-(14,11)) │ │ └── body: (length: 1) │ │ └── @ LocalVariableWriteNode (location: (14,2)-(14,11)) │ │ ├── name: :foo │ │ ├── depth: 0 │ │ ├── name_loc: (14,2)-(14,5) = "foo" │ │ ├── value: │ │ │ @ CallNode (location: (14,8)-(14,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (14,8)-(14,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: (14,6)-(14,7) = "=" │ ├── end_keyword_loc: (15,0)-(15,3) = "end" │ └── name: :A ├── @ ModuleNode (location: (17,0)-(19,3)) │ ├── locals: [:foo] │ ├── module_keyword_loc: (17,0)-(17,6) = "module" │ ├── constant_path: │ │ @ ConstantReadNode (location: (17,7)-(17,8)) │ │ └── name: :A │ ├── body: │ │ @ StatementsNode (location: (18,2)-(18,21)) │ │ └── body: (length: 1) │ │ └── @ UntilNode (location: (18,2)-(18,21)) │ │ ├── flags: ∅ │ │ ├── keyword_loc: (18,12)-(18,17) = "until" │ │ ├── closing_loc: ∅ │ │ ├── predicate: │ │ │ @ LocalVariableReadNode (location: (18,18)-(18,21)) │ │ │ ├── name: :foo │ │ │ └── depth: 0 │ │ └── statements: │ │ @ StatementsNode (location: (18,2)-(18,11)) │ │ └── body: (length: 1) │ │ └── @ LocalVariableWriteNode (location: (18,2)-(18,11)) │ │ ├── name: :foo │ │ ├── depth: 0 │ │ ├── name_loc: (18,2)-(18,5) = "foo" │ │ ├── value: │ │ │ @ CallNode (location: (18,8)-(18,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (18,8)-(18,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: (18,6)-(18,7) = "=" │ ├── end_keyword_loc: (19,0)-(19,3) = "end" │ └── name: :A ├── @ ModuleNode (location: (21,0)-(25,3)) │ ├── locals: [:foo] │ ├── module_keyword_loc: (21,0)-(21,6) = "module" │ ├── constant_path: │ │ @ ConstantReadNode (location: (21,7)-(21,8)) │ │ └── name: :A │ ├── body: │ │ @ StatementsNode (location: (22,2)-(24,5)) │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (22,2)-(24,5)) │ │ ├── flags: ∅ │ │ ├── keyword_loc: (22,2)-(22,7) = "while" │ │ ├── closing_loc: (24,2)-(24,5) = "end" │ │ ├── predicate: │ │ │ @ CallNode (location: (22,8)-(22,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (22,8)-(22,11) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── statements: │ │ @ StatementsNode (location: (23,4)-(23,13)) │ │ └── body: (length: 1) │ │ └── @ LocalVariableWriteNode (location: (23,4)-(23,13)) │ │ ├── name: :foo │ │ ├── depth: 0 │ │ ├── name_loc: (23,4)-(23,7) = "foo" │ │ ├── value: │ │ │ @ CallNode (location: (23,10)-(23,13)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (23,10)-(23,13) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: (23,8)-(23,9) = "=" │ ├── end_keyword_loc: (25,0)-(25,3) = "end" │ └── name: :A ├── @ ModuleNode (location: (27,0)-(33,3)) │ ├── locals: [] │ ├── module_keyword_loc: (27,0)-(27,6) = "module" │ ├── constant_path: │ │ @ ConstantReadNode (location: (27,7)-(27,8)) │ │ └── name: :A │ ├── body: │ │ @ StatementsNode (location: (28,2)-(32,3)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (28,2)-(32,3)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :each │ │ ├── message_loc: (28,2)-(28,6) = "each" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: │ │ @ BlockNode (location: (28,7)-(32,3)) │ │ ├── locals: [:baz, :foo] │ │ ├── parameters: │ │ │ @ BlockParametersNode (location: (28,9)-(28,14)) │ │ │ ├── parameters: │ │ │ │ @ ParametersNode (location: (28,10)-(28,13)) │ │ │ │ ├── requireds: (length: 1) │ │ │ │ │ └── @ RequiredParameterNode (location: (28,10)-(28,13)) │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ └── name: :baz │ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── rest: ∅ │ │ │ │ ├── posts: (length: 0) │ │ │ │ ├── keywords: (length: 0) │ │ │ │ ├── keyword_rest: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── locals: (length: 0) │ │ │ ├── opening_loc: (28,9)-(28,10) = "|" │ │ │ └── closing_loc: (28,13)-(28,14) = "|" │ │ ├── body: │ │ │ @ StatementsNode (location: (29,4)-(31,7)) │ │ │ └── body: (length: 1) │ │ │ └── @ WhileNode (location: (29,4)-(31,7)) │ │ │ ├── flags: ∅ │ │ │ ├── keyword_loc: (29,4)-(29,9) = "while" │ │ │ ├── closing_loc: (31,4)-(31,7) = "end" │ │ │ ├── predicate: │ │ │ │ @ CallNode (location: (29,10)-(29,13)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :foo │ │ │ │ ├── message_loc: (29,10)-(29,13) = "foo" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ └── statements: │ │ │ @ StatementsNode (location: (30,6)-(30,15)) │ │ │ └── body: (length: 1) │ │ │ └── @ LocalVariableWriteNode (location: (30,6)-(30,15)) │ │ │ ├── name: :foo │ │ │ ├── depth: 0 │ │ │ ├── name_loc: (30,6)-(30,9) = "foo" │ │ │ ├── value: │ │ │ │ @ CallNode (location: (30,12)-(30,15)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (30,12)-(30,15) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ └── operator_loc: (30,10)-(30,11) = "=" │ │ ├── opening_loc: (28,7)-(28,8) = "{" │ │ └── closing_loc: (32,2)-(32,3) = "}" │ ├── end_keyword_loc: (33,0)-(33,3) = "end" │ └── name: :A ├── @ ModuleNode (location: (35,0)-(41,3)) │ ├── locals: [] │ ├── module_keyword_loc: (35,0)-(35,6) = "module" │ ├── constant_path: │ │ @ ConstantReadNode (location: (35,7)-(35,8)) │ │ └── name: :A │ ├── body: │ │ @ StatementsNode (location: (36,2)-(40,3)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (36,2)-(40,3)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :each │ │ ├── message_loc: (36,2)-(36,6) = "each" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: │ │ @ BlockNode (location: (36,7)-(40,3)) │ │ ├── locals: [:foo] │ │ ├── parameters: │ │ │ @ BlockParametersNode (location: (36,9)-(36,14)) │ │ │ ├── parameters: │ │ │ │ @ ParametersNode (location: (36,10)-(36,13)) │ │ │ │ ├── requireds: (length: 1) │ │ │ │ │ └── @ RequiredParameterNode (location: (36,10)-(36,13)) │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ └── name: :foo │ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── rest: ∅ │ │ │ │ ├── posts: (length: 0) │ │ │ │ ├── keywords: (length: 0) │ │ │ │ ├── keyword_rest: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── locals: (length: 0) │ │ │ ├── opening_loc: (36,9)-(36,10) = "|" │ │ │ └── closing_loc: (36,13)-(36,14) = "|" │ │ ├── body: │ │ │ @ StatementsNode (location: (37,4)-(39,7)) │ │ │ └── body: (length: 1) │ │ │ └── @ WhileNode (location: (37,4)-(39,7)) │ │ │ ├── flags: ∅ │ │ │ ├── keyword_loc: (37,4)-(37,9) = "while" │ │ │ ├── closing_loc: (39,4)-(39,7) = "end" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (37,10)-(37,13)) │ │ │ │ ├── name: :foo │ │ │ │ └── depth: 0 │ │ │ └── statements: │ │ │ @ StatementsNode (location: (38,6)-(38,15)) │ │ │ └── body: (length: 1) │ │ │ └── @ LocalVariableWriteNode (location: (38,6)-(38,15)) │ │ │ ├── name: :foo │ │ │ ├── depth: 0 │ │ │ ├── name_loc: (38,6)-(38,9) = "foo" │ │ │ ├── value: │ │ │ │ @ CallNode (location: (38,12)-(38,15)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (38,12)-(38,15) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ └── operator_loc: (38,10)-(38,11) = "=" │ │ ├── opening_loc: (36,7)-(36,8) = "{" │ │ └── closing_loc: (40,2)-(40,3) = "}" │ ├── end_keyword_loc: (41,0)-(41,3) = "end" │ └── name: :A ├── @ LocalVariableWriteNode (location: (42,0)-(44,14)) │ ├── name: :x │ ├── depth: 0 │ ├── name_loc: (42,0)-(42,1) = "x" │ ├── value: │ │ @ ParenthesesNode (location: (42,4)-(44,14)) │ │ ├── body: │ │ │ @ StatementsNode (location: (42,5)-(44,13)) │ │ │ └── body: (length: 1) │ │ │ └── @ WhileNode (location: (42,5)-(44,13)) │ │ │ ├── flags: begin_modifier │ │ │ ├── keyword_loc: (44,4)-(44,9) = "while" │ │ │ ├── closing_loc: ∅ │ │ │ ├── predicate: │ │ │ │ @ CallNode (location: (44,10)-(44,13)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :baz │ │ │ │ ├── message_loc: (44,10)-(44,13) = "baz" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ └── statements: │ │ │ @ StatementsNode (location: (42,5)-(44,3)) │ │ │ └── body: (length: 1) │ │ │ └── @ BeginNode (location: (42,5)-(44,3)) │ │ │ ├── begin_keyword_loc: (42,5)-(42,10) = "begin" │ │ │ ├── statements: │ │ │ │ @ StatementsNode (location: (43,2)-(43,5)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ CallNode (location: (43,2)-(43,5)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :foo │ │ │ │ ├── message_loc: (43,2)-(43,5) = "foo" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── rescue_clause: ∅ │ │ │ ├── else_clause: ∅ │ │ │ ├── ensure_clause: ∅ │ │ │ └── end_keyword_loc: (44,0)-(44,3) = "end" │ │ ├── opening_loc: (42,4)-(42,5) = "(" │ │ └── closing_loc: (44,13)-(44,14) = ")" │ └── operator_loc: (42,2)-(42,3) = "=" ├── @ WhileNode (location: (45,0)-(47,13)) │ ├── flags: begin_modifier │ ├── keyword_loc: (47,4)-(47,9) = "while" │ ├── closing_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (47,10)-(47,13)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :baz │ │ ├── message_loc: (47,10)-(47,13) = "baz" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ └── statements: │ @ StatementsNode (location: (45,0)-(47,3)) │ └── body: (length: 1) │ └── @ BeginNode (location: (45,0)-(47,3)) │ ├── begin_keyword_loc: (45,0)-(45,5) = "begin" │ ├── statements: │ │ @ StatementsNode (location: (46,2)-(46,5)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (46,2)-(46,5)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (46,2)-(46,5) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── rescue_clause: ∅ │ ├── else_clause: ∅ │ ├── ensure_clause: ∅ │ └── end_keyword_loc: (47,0)-(47,3) = "end" ├── @ UntilNode (location: (48,0)-(51,13)) │ ├── flags: begin_modifier │ ├── keyword_loc: (51,4)-(51,9) = "until" │ ├── closing_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (51,10)-(51,13)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :baz │ │ ├── message_loc: (51,10)-(51,13) = "baz" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ └── statements: │ @ StatementsNode (location: (48,0)-(51,3)) │ └── body: (length: 1) │ └── @ BeginNode (location: (48,0)-(51,3)) │ ├── begin_keyword_loc: (48,0)-(48,5) = "begin" │ ├── statements: │ │ @ StatementsNode (location: (49,2)-(50,5)) │ │ └── body: (length: 2) │ │ ├── @ CallNode (location: (49,2)-(49,5)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (49,2)-(49,5) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── @ CallNode (location: (50,2)-(50,5)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :bar │ │ ├── message_loc: (50,2)-(50,5) = "bar" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── rescue_clause: ∅ │ ├── else_clause: ∅ │ ├── ensure_clause: ∅ │ └── end_keyword_loc: (51,0)-(51,3) = "end" ├── @ WhileNode (location: (52,0)-(55,13)) │ ├── flags: begin_modifier │ ├── keyword_loc: (55,4)-(55,9) = "while" │ ├── closing_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (55,10)-(55,13)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :baz │ │ ├── message_loc: (55,10)-(55,13) = "baz" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ └── statements: │ @ StatementsNode (location: (52,0)-(55,3)) │ └── body: (length: 1) │ └── @ BeginNode (location: (52,0)-(55,3)) │ ├── begin_keyword_loc: (52,0)-(52,5) = "begin" │ ├── statements: │ │ @ StatementsNode (location: (53,2)-(54,5)) │ │ └── body: (length: 2) │ │ ├── @ CallNode (location: (53,2)-(53,5)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (53,2)-(53,5) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── @ CallNode (location: (54,2)-(54,5)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :bar │ │ ├── message_loc: (54,2)-(54,5) = "bar" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── rescue_clause: ∅ │ ├── else_clause: ∅ │ ├── ensure_clause: ∅ │ └── end_keyword_loc: (55,0)-(55,3) = "end" ├── @ WhileNode (location: (56,0)-(57,3)) │ ├── flags: ∅ │ ├── keyword_loc: (56,0)-(56,5) = "while" │ ├── closing_loc: (57,0)-(57,3) = "end" │ ├── predicate: │ │ @ FalseNode (location: (56,6)-(56,11)) │ └── statements: ∅ ├── @ WhileNode (location: (58,0)-(60,3)) │ ├── flags: ∅ │ ├── keyword_loc: (58,0)-(58,5) = "while" │ ├── closing_loc: (60,0)-(60,3) = "end" │ ├── predicate: │ │ @ FalseNode (location: (58,6)-(58,11)) │ └── statements: │ @ StatementsNode (location: (59,2)-(59,3)) │ └── body: (length: 1) │ └── @ IntegerNode (location: (59,2)-(59,3)) │ ├── flags: decimal │ └── value: 3 ├── @ WhileNode (location: (61,0)-(64,3)) │ ├── flags: ∅ │ ├── keyword_loc: (61,0)-(61,5) = "while" │ ├── closing_loc: (64,0)-(64,3) = "end" │ ├── predicate: │ │ @ ParenthesesNode (location: (61,6)-(62,2)) │ │ ├── body: │ │ │ @ StatementsNode (location: (61,7)-(62,1)) │ │ │ └── body: (length: 1) │ │ │ └── @ CallNode (location: (61,7)-(62,1)) │ │ │ ├── flags: ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (61,7)-(61,10) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: │ │ │ @ BlockNode (location: (61,11)-(62,1)) │ │ │ ├── locals: [] │ │ │ ├── parameters: ∅ │ │ │ ├── body: ∅ │ │ │ ├── opening_loc: (61,11)-(61,12) = "{" │ │ │ └── closing_loc: (62,0)-(62,1) = "}" │ │ ├── opening_loc: (61,6)-(61,7) = "(" │ │ └── closing_loc: (62,1)-(62,2) = ")" │ └── statements: │ @ StatementsNode (location: (63,2)-(63,7)) │ └── body: (length: 1) │ └── @ SymbolNode (location: (63,2)-(63,7)) │ ├── flags: forced_us_ascii_encoding │ ├── opening_loc: (63,2)-(63,3) = ":" │ ├── value_loc: (63,3)-(63,7) = "body" │ ├── closing_loc: ∅ │ └── unescaped: "body" ├── @ UntilNode (location: (65,0)-(66,3)) │ ├── flags: ∅ │ ├── keyword_loc: (65,0)-(65,5) = "until" │ ├── closing_loc: (66,0)-(66,3) = "end" │ ├── predicate: │ │ @ FalseNode (location: (65,6)-(65,11)) │ └── statements: ∅ ├── @ UntilNode (location: (67,0)-(69,3)) │ ├── flags: ∅ │ ├── keyword_loc: (67,0)-(67,5) = "until" │ ├── closing_loc: (69,0)-(69,3) = "end" │ ├── predicate: │ │ @ FalseNode (location: (67,6)-(67,11)) │ └── statements: │ @ StatementsNode (location: (68,2)-(68,3)) │ └── body: (length: 1) │ └── @ IntegerNode (location: (68,2)-(68,3)) │ ├── flags: decimal │ └── value: 3 └── @ UntilNode (location: (70,0)-(73,3)) ├── flags: ∅ ├── keyword_loc: (70,0)-(70,5) = "until" ├── closing_loc: (73,0)-(73,3) = "end" ├── predicate: │ @ ParenthesesNode (location: (70,6)-(71,2)) │ ├── body: │ │ @ StatementsNode (location: (70,7)-(71,1)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (70,7)-(71,1)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (70,7)-(70,10) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: │ │ @ BlockNode (location: (70,11)-(71,1)) │ │ ├── locals: [] │ │ ├── parameters: ∅ │ │ ├── body: ∅ │ │ ├── opening_loc: (70,11)-(70,12) = "{" │ │ └── closing_loc: (71,0)-(71,1) = "}" │ ├── opening_loc: (70,6)-(70,7) = "(" │ └── closing_loc: (71,1)-(71,2) = ")" └── statements: @ StatementsNode (location: (72,2)-(72,7)) └── body: (length: 1) └── @ SymbolNode (location: (72,2)-(72,7)) ├── flags: forced_us_ascii_encoding ├── opening_loc: (72,2)-(72,3) = ":" ├── value_loc: (72,3)-(72,7) = "body" ├── closing_loc: ∅ └── unescaped: "body"