@ ProgramNode (location: (0...620))
├── locals: [:x]
└── statements:
    @ StatementsNode (location: (0...620))
    └── body: (length: 17)
        ├── @ ModuleNode (location: (0...68))
        │   ├── locals: []
        │   ├── module_keyword_loc: (0...6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (7...8))
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (11...64))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (11...64))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (11...14) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block:
        │   │           │   @ BlockNode (location: (15...64))
        │   │           │   ├── locals: [:bar, :foo]
        │   │           │   ├── parameters:
        │   │           │   │   @ BlockParametersNode (location: (17...22))
        │   │           │   │   ├── parameters:
        │   │           │   │   │   @ ParametersNode (location: (18...21))
        │   │           │   │   │   ├── requireds: (length: 1)
        │   │           │   │   │   │   └── @ RequiredParameterNode (location: (18...21))
        │   │           │   │   │   │       └── name: :bar
        │   │           │   │   │   ├── optionals: (length: 0)
        │   │           │   │   │   ├── rest: ∅
        │   │           │   │   │   ├── posts: (length: 0)
        │   │           │   │   │   ├── keywords: (length: 0)
        │   │           │   │   │   ├── keyword_rest: ∅
        │   │           │   │   │   └── block: ∅
        │   │           │   │   ├── locals: (length: 0)
        │   │           │   │   ├── opening_loc: (17...18) = "|"
        │   │           │   │   └── closing_loc: (21...22) = "|"
        │   │           │   ├── body:
        │   │           │   │   @ StatementsNode (location: (27...60))
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ WhileNode (location: (27...60))
        │   │           │   │           ├── keyword_loc: (27...32) = "while"
        │   │           │   │           ├── closing_loc: (57...60) = "end"
        │   │           │   │           ├── predicate:
        │   │           │   │           │   @ CallNode (location: (33...36))
        │   │           │   │           │   ├── receiver: ∅
        │   │           │   │           │   ├── call_operator_loc: ∅
        │   │           │   │           │   ├── message_loc: (33...36) = "foo"
        │   │           │   │           │   ├── opening_loc: ∅
        │   │           │   │           │   ├── arguments: ∅
        │   │           │   │           │   ├── closing_loc: ∅
        │   │           │   │           │   ├── block: ∅
        │   │           │   │           │   ├── flags: variable_call
        │   │           │   │           │   └── name: "foo"
        │   │           │   │           ├── statements:
        │   │           │   │           │   @ StatementsNode (location: (43...52))
        │   │           │   │           │   └── body: (length: 1)
        │   │           │   │           │       └── @ LocalVariableWriteNode (location: (43...52))
        │   │           │   │           │           ├── name: :foo
        │   │           │   │           │           ├── depth: 0
        │   │           │   │           │           ├── name_loc: (43...46) = "foo"
        │   │           │   │           │           ├── value:
        │   │           │   │           │           │   @ LocalVariableReadNode (location: (49...52))
        │   │           │   │           │           │   ├── name: :bar
        │   │           │   │           │           │   └── depth: 0
        │   │           │   │           │           └── operator_loc: (47...48) = "="
        │   │           │   │           └── flags: ∅
        │   │           │   ├── opening_loc: (15...16) = "{"
        │   │           │   └── closing_loc: (63...64) = "}"
        │   │           ├── flags: ∅
        │   │           └── name: "foo"
        │   ├── end_keyword_loc: (65...68) = "end"
        │   └── name: :A
        ├── @ DefNode (location: (70...110))
        │   ├── name: :foo
        │   ├── name_loc: (74...77) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (80...106))
        │   │   └── body: (length: 1)
        │   │       └── @ WhileNode (location: (80...106))
        │   │           ├── keyword_loc: (90...95) = "while"
        │   │           ├── closing_loc: ∅
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (96...106))
        │   │           │   ├── receiver:
        │   │           │   │   @ LocalVariableReadNode (location: (96...99))
        │   │           │   │   ├── name: :foo
        │   │           │   │   └── depth: 0
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (100...102) = "!="
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (103...106))
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ CallNode (location: (103...106))
        │   │           │   │           ├── receiver: ∅
        │   │           │   │           ├── call_operator_loc: ∅
        │   │           │   │           ├── message_loc: (103...106) = "baz"
        │   │           │   │           ├── opening_loc: ∅
        │   │           │   │           ├── arguments: ∅
        │   │           │   │           ├── closing_loc: ∅
        │   │           │   │           ├── block: ∅
        │   │           │   │           ├── flags: variable_call
        │   │           │   │           └── name: "baz"
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: ∅
        │   │           │   └── name: "!="
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (80...89))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ LocalVariableWriteNode (location: (80...89))
        │   │           │           ├── name: :foo
        │   │           │           ├── depth: 0
        │   │           │           ├── name_loc: (80...83) = "foo"
        │   │           │           ├── value:
        │   │           │           │   @ CallNode (location: (86...89))
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── message_loc: (86...89) = "bar"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   ├── block: ∅
        │   │           │           │   ├── flags: variable_call
        │   │           │           │   └── name: "bar"
        │   │           │           └── operator_loc: (84...85) = "="
        │   │           └── flags: ∅
        │   ├── locals: [:foo]
        │   ├── def_keyword_loc: (70...73) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (107...110) = "end"
        ├── @ ModuleNode (location: (112...146))
        │   ├── locals: [:foo]
        │   ├── module_keyword_loc: (112...118) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (119...120))
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (123...142))
        │   │   └── body: (length: 1)
        │   │       └── @ WhileNode (location: (123...142))
        │   │           ├── keyword_loc: (133...138) = "while"
        │   │           ├── closing_loc: ∅
        │   │           ├── predicate:
        │   │           │   @ LocalVariableReadNode (location: (139...142))
        │   │           │   ├── name: :foo
        │   │           │   └── depth: 0
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (123...132))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ LocalVariableWriteNode (location: (123...132))
        │   │           │           ├── name: :foo
        │   │           │           ├── depth: 0
        │   │           │           ├── name_loc: (123...126) = "foo"
        │   │           │           ├── value:
        │   │           │           │   @ CallNode (location: (129...132))
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── message_loc: (129...132) = "bar"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   ├── block: ∅
        │   │           │           │   ├── flags: variable_call
        │   │           │           │   └── name: "bar"
        │   │           │           └── operator_loc: (127...128) = "="
        │   │           └── flags: ∅
        │   ├── end_keyword_loc: (143...146) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (148...182))
        │   ├── locals: [:foo]
        │   ├── module_keyword_loc: (148...154) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (155...156))
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (159...178))
        │   │   └── body: (length: 1)
        │   │       └── @ UntilNode (location: (159...178))
        │   │           ├── keyword_loc: (169...174) = "until"
        │   │           ├── closing_loc: ∅
        │   │           ├── predicate:
        │   │           │   @ LocalVariableReadNode (location: (175...178))
        │   │           │   ├── name: :foo
        │   │           │   └── depth: 0
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (159...168))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ LocalVariableWriteNode (location: (159...168))
        │   │           │           ├── name: :foo
        │   │           │           ├── depth: 0
        │   │           │           ├── name_loc: (159...162) = "foo"
        │   │           │           ├── value:
        │   │           │           │   @ CallNode (location: (165...168))
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── message_loc: (165...168) = "bar"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   ├── block: ∅
        │   │           │           │   ├── flags: variable_call
        │   │           │           │   └── name: "bar"
        │   │           │           └── operator_loc: (163...164) = "="
        │   │           └── flags: ∅
        │   ├── end_keyword_loc: (179...182) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (184...228))
        │   ├── locals: [:foo]
        │   ├── module_keyword_loc: (184...190) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (191...192))
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (195...224))
        │   │   └── body: (length: 1)
        │   │       └── @ WhileNode (location: (195...224))
        │   │           ├── keyword_loc: (195...200) = "while"
        │   │           ├── closing_loc: (221...224) = "end"
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (201...204))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (201...204) = "foo"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "foo"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (209...218))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ LocalVariableWriteNode (location: (209...218))
        │   │           │           ├── name: :foo
        │   │           │           ├── depth: 0
        │   │           │           ├── name_loc: (209...212) = "foo"
        │   │           │           ├── value:
        │   │           │           │   @ CallNode (location: (215...218))
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── message_loc: (215...218) = "bar"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   ├── block: ∅
        │   │           │           │   ├── flags: variable_call
        │   │           │           │   └── name: "bar"
        │   │           │           └── operator_loc: (213...214) = "="
        │   │           └── flags: ∅
        │   ├── end_keyword_loc: (225...228) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (230...299))
        │   ├── locals: []
        │   ├── module_keyword_loc: (230...236) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (237...238))
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (241...295))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (241...295))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (241...245) = "each"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block:
        │   │           │   @ BlockNode (location: (246...295))
        │   │           │   ├── locals: [:baz, :foo]
        │   │           │   ├── parameters:
        │   │           │   │   @ BlockParametersNode (location: (248...253))
        │   │           │   │   ├── parameters:
        │   │           │   │   │   @ ParametersNode (location: (249...252))
        │   │           │   │   │   ├── requireds: (length: 1)
        │   │           │   │   │   │   └── @ RequiredParameterNode (location: (249...252))
        │   │           │   │   │   │       └── name: :baz
        │   │           │   │   │   ├── optionals: (length: 0)
        │   │           │   │   │   ├── rest: ∅
        │   │           │   │   │   ├── posts: (length: 0)
        │   │           │   │   │   ├── keywords: (length: 0)
        │   │           │   │   │   ├── keyword_rest: ∅
        │   │           │   │   │   └── block: ∅
        │   │           │   │   ├── locals: (length: 0)
        │   │           │   │   ├── opening_loc: (248...249) = "|"
        │   │           │   │   └── closing_loc: (252...253) = "|"
        │   │           │   ├── body:
        │   │           │   │   @ StatementsNode (location: (258...291))
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ WhileNode (location: (258...291))
        │   │           │   │           ├── keyword_loc: (258...263) = "while"
        │   │           │   │           ├── closing_loc: (288...291) = "end"
        │   │           │   │           ├── predicate:
        │   │           │   │           │   @ CallNode (location: (264...267))
        │   │           │   │           │   ├── receiver: ∅
        │   │           │   │           │   ├── call_operator_loc: ∅
        │   │           │   │           │   ├── message_loc: (264...267) = "foo"
        │   │           │   │           │   ├── opening_loc: ∅
        │   │           │   │           │   ├── arguments: ∅
        │   │           │   │           │   ├── closing_loc: ∅
        │   │           │   │           │   ├── block: ∅
        │   │           │   │           │   ├── flags: variable_call
        │   │           │   │           │   └── name: "foo"
        │   │           │   │           ├── statements:
        │   │           │   │           │   @ StatementsNode (location: (274...283))
        │   │           │   │           │   └── body: (length: 1)
        │   │           │   │           │       └── @ LocalVariableWriteNode (location: (274...283))
        │   │           │   │           │           ├── name: :foo
        │   │           │   │           │           ├── depth: 0
        │   │           │   │           │           ├── name_loc: (274...277) = "foo"
        │   │           │   │           │           ├── value:
        │   │           │   │           │           │   @ CallNode (location: (280...283))
        │   │           │   │           │           │   ├── receiver: ∅
        │   │           │   │           │           │   ├── call_operator_loc: ∅
        │   │           │   │           │           │   ├── message_loc: (280...283) = "bar"
        │   │           │   │           │           │   ├── opening_loc: ∅
        │   │           │   │           │           │   ├── arguments: ∅
        │   │           │   │           │           │   ├── closing_loc: ∅
        │   │           │   │           │           │   ├── block: ∅
        │   │           │   │           │           │   ├── flags: variable_call
        │   │           │   │           │           │   └── name: "bar"
        │   │           │   │           │           └── operator_loc: (278...279) = "="
        │   │           │   │           └── flags: ∅
        │   │           │   ├── opening_loc: (246...247) = "{"
        │   │           │   └── closing_loc: (294...295) = "}"
        │   │           ├── flags: ∅
        │   │           └── name: "each"
        │   ├── end_keyword_loc: (296...299) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (301...370))
        │   ├── locals: []
        │   ├── module_keyword_loc: (301...307) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (308...309))
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (312...366))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (312...366))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (312...316) = "each"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block:
        │   │           │   @ BlockNode (location: (317...366))
        │   │           │   ├── locals: [:foo]
        │   │           │   ├── parameters:
        │   │           │   │   @ BlockParametersNode (location: (319...324))
        │   │           │   │   ├── parameters:
        │   │           │   │   │   @ ParametersNode (location: (320...323))
        │   │           │   │   │   ├── requireds: (length: 1)
        │   │           │   │   │   │   └── @ RequiredParameterNode (location: (320...323))
        │   │           │   │   │   │       └── name: :foo
        │   │           │   │   │   ├── optionals: (length: 0)
        │   │           │   │   │   ├── rest: ∅
        │   │           │   │   │   ├── posts: (length: 0)
        │   │           │   │   │   ├── keywords: (length: 0)
        │   │           │   │   │   ├── keyword_rest: ∅
        │   │           │   │   │   └── block: ∅
        │   │           │   │   ├── locals: (length: 0)
        │   │           │   │   ├── opening_loc: (319...320) = "|"
        │   │           │   │   └── closing_loc: (323...324) = "|"
        │   │           │   ├── body:
        │   │           │   │   @ StatementsNode (location: (329...362))
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ WhileNode (location: (329...362))
        │   │           │   │           ├── keyword_loc: (329...334) = "while"
        │   │           │   │           ├── closing_loc: (359...362) = "end"
        │   │           │   │           ├── predicate:
        │   │           │   │           │   @ LocalVariableReadNode (location: (335...338))
        │   │           │   │           │   ├── name: :foo
        │   │           │   │           │   └── depth: 0
        │   │           │   │           ├── statements:
        │   │           │   │           │   @ StatementsNode (location: (345...354))
        │   │           │   │           │   └── body: (length: 1)
        │   │           │   │           │       └── @ LocalVariableWriteNode (location: (345...354))
        │   │           │   │           │           ├── name: :foo
        │   │           │   │           │           ├── depth: 0
        │   │           │   │           │           ├── name_loc: (345...348) = "foo"
        │   │           │   │           │           ├── value:
        │   │           │   │           │           │   @ CallNode (location: (351...354))
        │   │           │   │           │           │   ├── receiver: ∅
        │   │           │   │           │           │   ├── call_operator_loc: ∅
        │   │           │   │           │           │   ├── message_loc: (351...354) = "bar"
        │   │           │   │           │           │   ├── opening_loc: ∅
        │   │           │   │           │           │   ├── arguments: ∅
        │   │           │   │           │           │   ├── closing_loc: ∅
        │   │           │   │           │           │   ├── block: ∅
        │   │           │   │           │           │   ├── flags: variable_call
        │   │           │   │           │           │   └── name: "bar"
        │   │           │   │           │           └── operator_loc: (349...350) = "="
        │   │           │   │           └── flags: ∅
        │   │           │   ├── opening_loc: (317...318) = "{"
        │   │           │   └── closing_loc: (365...366) = "}"
        │   │           ├── flags: ∅
        │   │           └── name: "each"
        │   ├── end_keyword_loc: (367...370) = "end"
        │   └── name: :A
        ├── @ LocalVariableWriteNode (location: (371...402))
        │   ├── name: :x
        │   ├── depth: 0
        │   ├── name_loc: (371...372) = "x"
        │   ├── value:
        │   │   @ ParenthesesNode (location: (375...402))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (376...401))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ WhileNode (location: (376...401))
        │   │   │           ├── keyword_loc: (392...397) = "while"
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── predicate:
        │   │   │           │   @ CallNode (location: (398...401))
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── message_loc: (398...401) = "baz"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   ├── block: ∅
        │   │   │           │   ├── flags: variable_call
        │   │   │           │   └── name: "baz"
        │   │   │           ├── statements:
        │   │   │           │   @ StatementsNode (location: (376...391))
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ BeginNode (location: (376...391))
        │   │   │           │           ├── begin_keyword_loc: (376...381) = "begin"
        │   │   │           │           ├── statements:
        │   │   │           │           │   @ StatementsNode (location: (384...387))
        │   │   │           │           │   └── body: (length: 1)
        │   │   │           │           │       └── @ CallNode (location: (384...387))
        │   │   │           │           │           ├── receiver: ∅
        │   │   │           │           │           ├── call_operator_loc: ∅
        │   │   │           │           │           ├── message_loc: (384...387) = "foo"
        │   │   │           │           │           ├── opening_loc: ∅
        │   │   │           │           │           ├── arguments: ∅
        │   │   │           │           │           ├── closing_loc: ∅
        │   │   │           │           │           ├── block: ∅
        │   │   │           │           │           ├── flags: variable_call
        │   │   │           │           │           └── name: "foo"
        │   │   │           │           ├── rescue_clause: ∅
        │   │   │           │           ├── else_clause: ∅
        │   │   │           │           ├── ensure_clause: ∅
        │   │   │           │           └── end_keyword_loc: (388...391) = "end"
        │   │   │           └── flags: begin_modifier
        │   │   ├── opening_loc: (375...376) = "("
        │   │   └── closing_loc: (401...402) = ")"
        │   └── operator_loc: (373...374) = "="
        ├── @ WhileNode (location: (403...428))
        │   ├── keyword_loc: (419...424) = "while"
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (425...428))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (425...428) = "baz"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "baz"
        │   ├── statements:
        │   │   @ StatementsNode (location: (403...418))
        │   │   └── body: (length: 1)
        │   │       └── @ BeginNode (location: (403...418))
        │   │           ├── begin_keyword_loc: (403...408) = "begin"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (411...414))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (411...414))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (411...414) = "foo"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: variable_call
        │   │           │           └── name: "foo"
        │   │           ├── rescue_clause: ∅
        │   │           ├── else_clause: ∅
        │   │           ├── ensure_clause: ∅
        │   │           └── end_keyword_loc: (415...418) = "end"
        │   └── flags: begin_modifier
        ├── @ UntilNode (location: (429...460))
        │   ├── keyword_loc: (451...456) = "until"
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (457...460))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (457...460) = "baz"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "baz"
        │   ├── statements:
        │   │   @ StatementsNode (location: (429...450))
        │   │   └── body: (length: 1)
        │   │       └── @ BeginNode (location: (429...450))
        │   │           ├── begin_keyword_loc: (429...434) = "begin"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (437...446))
        │   │           │   └── body: (length: 2)
        │   │           │       ├── @ CallNode (location: (437...440))
        │   │           │       │   ├── receiver: ∅
        │   │           │       │   ├── call_operator_loc: ∅
        │   │           │       │   ├── message_loc: (437...440) = "foo"
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── arguments: ∅
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   ├── block: ∅
        │   │           │       │   ├── flags: variable_call
        │   │           │       │   └── name: "foo"
        │   │           │       └── @ CallNode (location: (443...446))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (443...446) = "bar"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: variable_call
        │   │           │           └── name: "bar"
        │   │           ├── rescue_clause: ∅
        │   │           ├── else_clause: ∅
        │   │           ├── ensure_clause: ∅
        │   │           └── end_keyword_loc: (447...450) = "end"
        │   └── flags: begin_modifier
        ├── @ WhileNode (location: (461...492))
        │   ├── keyword_loc: (483...488) = "while"
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (489...492))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (489...492) = "baz"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "baz"
        │   ├── statements:
        │   │   @ StatementsNode (location: (461...482))
        │   │   └── body: (length: 1)
        │   │       └── @ BeginNode (location: (461...482))
        │   │           ├── begin_keyword_loc: (461...466) = "begin"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (469...478))
        │   │           │   └── body: (length: 2)
        │   │           │       ├── @ CallNode (location: (469...472))
        │   │           │       │   ├── receiver: ∅
        │   │           │       │   ├── call_operator_loc: ∅
        │   │           │       │   ├── message_loc: (469...472) = "foo"
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── arguments: ∅
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   ├── block: ∅
        │   │           │       │   ├── flags: variable_call
        │   │           │       │   └── name: "foo"
        │   │           │       └── @ CallNode (location: (475...478))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (475...478) = "bar"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: variable_call
        │   │           │           └── name: "bar"
        │   │           ├── rescue_clause: ∅
        │   │           ├── else_clause: ∅
        │   │           ├── ensure_clause: ∅
        │   │           └── end_keyword_loc: (479...482) = "end"
        │   └── flags: begin_modifier
        ├── @ WhileNode (location: (493...508))
        │   ├── keyword_loc: (493...498) = "while"
        │   ├── closing_loc: (505...508) = "end"
        │   ├── predicate:
        │   │   @ FalseNode (location: (499...504))
        │   ├── statements: ∅
        │   └── flags: ∅
        ├── @ WhileNode (location: (509...528))
        │   ├── keyword_loc: (509...514) = "while"
        │   ├── closing_loc: (525...528) = "end"
        │   ├── predicate:
        │   │   @ FalseNode (location: (515...520))
        │   ├── statements:
        │   │   @ StatementsNode (location: (523...524))
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (523...524))
        │   │           └── flags: decimal
        │   └── flags: ∅
        ├── @ WhileNode (location: (529...556))
        │   ├── keyword_loc: (529...534) = "while"
        │   ├── closing_loc: (553...556) = "end"
        │   ├── predicate:
        │   │   @ ParenthesesNode (location: (535...544))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (536...543))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (536...543))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (536...539) = "foo"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block:
        │   │   │           │   @ BlockNode (location: (540...543))
        │   │   │           │   ├── locals: []
        │   │   │           │   ├── parameters: ∅
        │   │   │           │   ├── body: ∅
        │   │   │           │   ├── opening_loc: (540...541) = "{"
        │   │   │           │   └── closing_loc: (542...543) = "}"
        │   │   │           ├── flags: ∅
        │   │   │           └── name: "foo"
        │   │   ├── opening_loc: (535...536) = "("
        │   │   └── closing_loc: (543...544) = ")"
        │   ├── statements:
        │   │   @ StatementsNode (location: (547...552))
        │   │   └── body: (length: 1)
        │   │       └── @ SymbolNode (location: (547...552))
        │   │           ├── opening_loc: (547...548) = ":"
        │   │           ├── value_loc: (548...552) = "body"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "body"
        │   └── flags: ∅
        ├── @ UntilNode (location: (557...572))
        │   ├── keyword_loc: (557...562) = "until"
        │   ├── closing_loc: (569...572) = "end"
        │   ├── predicate:
        │   │   @ FalseNode (location: (563...568))
        │   ├── statements: ∅
        │   └── flags: ∅
        ├── @ UntilNode (location: (573...592))
        │   ├── keyword_loc: (573...578) = "until"
        │   ├── closing_loc: (589...592) = "end"
        │   ├── predicate:
        │   │   @ FalseNode (location: (579...584))
        │   ├── statements:
        │   │   @ StatementsNode (location: (587...588))
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (587...588))
        │   │           └── flags: decimal
        │   └── flags: ∅
        └── @ UntilNode (location: (593...620))
            ├── keyword_loc: (593...598) = "until"
            ├── closing_loc: (617...620) = "end"
            ├── predicate:
            │   @ ParenthesesNode (location: (599...608))
            │   ├── body:
            │   │   @ StatementsNode (location: (600...607))
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (600...607))
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── message_loc: (600...603) = "foo"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           ├── block:
            │   │           │   @ BlockNode (location: (604...607))
            │   │           │   ├── locals: []
            │   │           │   ├── parameters: ∅
            │   │           │   ├── body: ∅
            │   │           │   ├── opening_loc: (604...605) = "{"
            │   │           │   └── closing_loc: (606...607) = "}"
            │   │           ├── flags: ∅
            │   │           └── name: "foo"
            │   ├── opening_loc: (599...600) = "("
            │   └── closing_loc: (607...608) = ")"
            ├── statements:
            │   @ StatementsNode (location: (611...616))
            │   └── body: (length: 1)
            │       └── @ SymbolNode (location: (611...616))
            │           ├── opening_loc: (611...612) = ":"
            │           ├── value_loc: (612...616) = "body"
            │           ├── closing_loc: ∅
            │           └── unescaped: "body"
            └── flags: ∅
