diff options
Diffstat (limited to 'test/prism/snapshots/unparser/corpus/literal/while.txt')
| -rw-r--r-- | test/prism/snapshots/unparser/corpus/literal/while.txt | 704 |
1 files changed, 704 insertions, 0 deletions
diff --git a/test/prism/snapshots/unparser/corpus/literal/while.txt b/test/prism/snapshots/unparser/corpus/literal/while.txt new file mode 100644 index 0000000000..0f752f3392 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/while.txt @@ -0,0 +1,704 @@ +@ 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" |