@ 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: ∅
        │   │           ├── 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]
        │   │               ├── locals_body_index: 1
        │   │               ├── parameters:
        │   │               │   @ BlockParametersNode (location: (2,8)-(2,13))
        │   │               │   ├── parameters:
        │   │               │   │   @ ParametersNode (location: (2,9)-(2,12))
        │   │               │   │   ├── requireds: (length: 1)
        │   │               │   │   │   └── @ RequiredParameterNode (location: (2,9)-(2,12))
        │   │               │   │   │       └── 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
        │   │               │           │   ├── 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
        │   │           │   │           ├── 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
        │   │                       │   ├── 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]
        │   ├── locals_body_index: 0
        │   ├── 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
        │   │                       │   ├── 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
        │   │                       │   ├── 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
        │   │           │   ├── 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
        │   │                       │   ├── 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: ∅
        │   │           ├── 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]
        │   │               ├── locals_body_index: 1
        │   │               ├── parameters:
        │   │               │   @ BlockParametersNode (location: (28,9)-(28,14))
        │   │               │   ├── parameters:
        │   │               │   │   @ ParametersNode (location: (28,10)-(28,13))
        │   │               │   │   ├── requireds: (length: 1)
        │   │               │   │   │   └── @ RequiredParameterNode (location: (28,10)-(28,13))
        │   │               │   │   │       └── 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
        │   │               │           │   ├── 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
        │   │               │                       │   ├── 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: ∅
        │   │           ├── 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]
        │   │               ├── locals_body_index: 1
        │   │               ├── parameters:
        │   │               │   @ BlockParametersNode (location: (36,9)-(36,14))
        │   │               │   ├── parameters:
        │   │               │   │   @ ParametersNode (location: (36,10)-(36,13))
        │   │               │   │   ├── requireds: (length: 1)
        │   │               │   │   │   └── @ RequiredParameterNode (location: (36,10)-(36,13))
        │   │               │   │   │       └── 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
        │   │               │                       │   ├── 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
        │   │   │           │   ├── 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
        │   │   │                       │           ├── 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
        │   │   ├── 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
        │               │           ├── 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
        │   │   ├── 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
        │               │       │   ├── 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
        │               │           ├── 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
        │   │   ├── 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
        │               │       │   ├── 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
        │               │           ├── 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
        ├── @ 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: ∅
        │   │   │           ├── 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: []
        │   │   │               ├── locals_body_index: 0
        │   │   │               ├── 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: ∅
        │               ├── 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
        └── @ 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: ∅
            │   │           ├── 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: []
            │   │               ├── locals_body_index: 0
            │   │               ├── 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: ∅
                        ├── opening_loc: (72,2)-(72,3) = ":"
                        ├── value_loc: (72,3)-(72,7) = "body"
                        ├── closing_loc: ∅
                        └── unescaped: "body"
