@ ProgramNode (location: (0...999))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...999))
    └── body: (length: 62)
        ├── @ ModuleNode (location: (0...35))
        │   ├── locals: [:foo, :a, :_]
        │   ├── module_keyword_loc: (0...6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (7...8))
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (11...31))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableOrWriteNode (location: (11...31))
        │   │           ├── name_loc: (11...14) = "foo"
        │   │           ├── operator_loc: (15...18) = "||="
        │   │           ├── value:
        │   │           │   @ ParenthesesNode (location: (19...31))
        │   │           │   ├── body:
        │   │           │   │   @ StatementsNode (location: (20...30))
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ MultiWriteNode (location: (20...30))
        │   │           │   │           ├── targets: (length: 2)
        │   │           │   │           │   ├── @ LocalVariableTargetNode (location: (21...22))
        │   │           │   │           │   │   ├── name: :a
        │   │           │   │           │   │   └── depth: 0
        │   │           │   │           │   └── @ LocalVariableTargetNode (location: (24...25))
        │   │           │   │           │       ├── name: :_
        │   │           │   │           │       └── depth: 0
        │   │           │   │           ├── lparen_loc: (20...21) = "("
        │   │           │   │           ├── rparen_loc: (25...26) = ")"
        │   │           │   │           ├── operator_loc: (27...28) = "="
        │   │           │   │           └── value:
        │   │           │   │               @ CallNode (location: (29...30))
        │   │           │   │               ├── receiver: ∅
        │   │           │   │               ├── call_operator_loc: ∅
        │   │           │   │               ├── message_loc: (29...30) = "b"
        │   │           │   │               ├── opening_loc: ∅
        │   │           │   │               ├── arguments: ∅
        │   │           │   │               ├── closing_loc: ∅
        │   │           │   │               ├── block: ∅
        │   │           │   │               ├── flags: variable_call
        │   │           │   │               └── name: "b"
        │   │           │   ├── opening_loc: (19...20) = "("
        │   │           │   └── closing_loc: (30...31) = ")"
        │   │           ├── name: :foo
        │   │           └── depth: 0
        │   ├── end_keyword_loc: (32...35) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (37...73))
        │   ├── locals: [:local]
        │   ├── module_keyword_loc: (37...43) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (44...45))
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (48...69))
        │   │   └── body: (length: 2)
        │   │       ├── @ LocalVariableWriteNode (location: (48...57))
        │   │       │   ├── name: :local
        │   │       │   ├── depth: 0
        │   │       │   ├── name_loc: (48...53) = "local"
        │   │       │   ├── value:
        │   │       │   │   @ IntegerNode (location: (56...57))
        │   │       │   │   └── flags: decimal
        │   │       │   └── operator_loc: (54...55) = "="
        │   │       └── @ CallNode (location: (60...69))
        │   │           ├── receiver:
        │   │           │   @ LocalVariableReadNode (location: (60...65))
        │   │           │   ├── name: :local
        │   │           │   └── depth: 0
        │   │           ├── call_operator_loc: (65...66) = "."
        │   │           ├── message_loc: (66...69) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "bar"
        │   ├── end_keyword_loc: (70...73) = "end"
        │   └── name: :A
        ├── @ CallNode (location: (74...89))
        │   ├── receiver:
        │   │   @ ClassNode (location: (74...85))
        │   │   ├── locals: []
        │   │   ├── class_keyword_loc: (74...79) = "class"
        │   │   ├── constant_path:
        │   │   │   @ ConstantReadNode (location: (80...81))
        │   │   │   └── name: :A
        │   │   ├── inheritance_operator_loc: ∅
        │   │   ├── superclass: ∅
        │   │   ├── body: ∅
        │   │   ├── end_keyword_loc: (82...85) = "end"
        │   │   └── name: :A
        │   ├── call_operator_loc: (85...86) = "."
        │   ├── message_loc: (86...89) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (90...106))
        │   ├── receiver:
        │   │   @ ModuleNode (location: (90...102))
        │   │   ├── locals: []
        │   │   ├── module_keyword_loc: (90...96) = "module"
        │   │   ├── constant_path:
        │   │   │   @ ConstantReadNode (location: (97...98))
        │   │   │   └── name: :A
        │   │   ├── body: ∅
        │   │   ├── end_keyword_loc: (99...102) = "end"
        │   │   └── name: :A
        │   ├── call_operator_loc: (102...103) = "."
        │   ├── message_loc: (103...106) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (107...127))
        │   ├── receiver:
        │   │   @ BeginNode (location: (107...123))
        │   │   ├── begin_keyword_loc: (107...112) = "begin"
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (113...119))
        │   │   │   ├── keyword_loc: (113...119) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── consequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (120...123) = "end"
        │   ├── call_operator_loc: (123...124) = "."
        │   ├── message_loc: (124...127) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (128...169))
        │   ├── receiver:
        │   │   @ CaseNode (location: (128...165))
        │   │   ├── predicate:
        │   │   │   @ ParenthesesNode (location: (133...152))
        │   │   │   ├── body:
        │   │   │   │   @ StatementsNode (location: (134...151))
        │   │   │   │   └── body: (length: 2)
        │   │   │   │       ├── @ DefNode (location: (134...145))
        │   │   │   │       │   ├── name: :foo
        │   │   │   │       │   ├── name_loc: (138...141) = "foo"
        │   │   │   │       │   ├── receiver: ∅
        │   │   │   │       │   ├── parameters: ∅
        │   │   │   │       │   ├── body: ∅
        │   │   │   │       │   ├── locals: []
        │   │   │   │       │   ├── def_keyword_loc: (134...137) = "def"
        │   │   │   │       │   ├── operator_loc: ∅
        │   │   │   │       │   ├── lparen_loc: ∅
        │   │   │   │       │   ├── rparen_loc: ∅
        │   │   │   │       │   ├── equal_loc: ∅
        │   │   │   │       │   └── end_keyword_loc: (142...145) = "end"
        │   │   │   │       └── @ SymbolNode (location: (147...151))
        │   │   │   │           ├── opening_loc: (147...148) = ":"
        │   │   │   │           ├── value_loc: (148...151) = "bar"
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── unescaped: "bar"
        │   │   │   ├── opening_loc: (133...134) = "("
        │   │   │   └── closing_loc: (151...152) = ")"
        │   │   ├── conditions: (length: 1)
        │   │   │   └── @ WhenNode (location: (153...161))
        │   │   │       ├── keyword_loc: (153...157) = "when"
        │   │   │       ├── conditions: (length: 1)
        │   │   │       │   └── @ CallNode (location: (158...161))
        │   │   │       │       ├── receiver: ∅
        │   │   │       │       ├── call_operator_loc: ∅
        │   │   │       │       ├── message_loc: (158...161) = "bar"
        │   │   │       │       ├── opening_loc: ∅
        │   │   │       │       ├── arguments: ∅
        │   │   │       │       ├── closing_loc: ∅
        │   │   │       │       ├── block: ∅
        │   │   │       │       ├── flags: variable_call
        │   │   │       │       └── name: "bar"
        │   │   │       └── statements: ∅
        │   │   ├── consequent: ∅
        │   │   ├── case_keyword_loc: (128...132) = "case"
        │   │   └── end_keyword_loc: (162...165) = "end"
        │   ├── call_operator_loc: (165...166) = "."
        │   ├── message_loc: (166...169) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "baz"
        ├── @ CallNode (location: (170...195))
        │   ├── receiver:
        │   │   @ CaseNode (location: (170...191))
        │   │   ├── predicate:
        │   │   │   @ CallNode (location: (175...178))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (175...178) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "foo"
        │   │   ├── conditions: (length: 1)
        │   │   │   └── @ WhenNode (location: (179...187))
        │   │   │       ├── keyword_loc: (179...183) = "when"
        │   │   │       ├── conditions: (length: 1)
        │   │   │       │   └── @ CallNode (location: (184...187))
        │   │   │       │       ├── receiver: ∅
        │   │   │       │       ├── call_operator_loc: ∅
        │   │   │       │       ├── message_loc: (184...187) = "bar"
        │   │   │       │       ├── opening_loc: ∅
        │   │   │       │       ├── arguments: ∅
        │   │   │       │       ├── closing_loc: ∅
        │   │   │       │       ├── block: ∅
        │   │   │       │       ├── flags: variable_call
        │   │   │       │       └── name: "bar"
        │   │   │       └── statements: ∅
        │   │   ├── consequent: ∅
        │   │   ├── case_keyword_loc: (170...174) = "case"
        │   │   └── end_keyword_loc: (188...191) = "end"
        │   ├── call_operator_loc: (191...192) = "."
        │   ├── message_loc: (192...195) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "baz"
        ├── @ CallNode (location: (196...217))
        │   ├── receiver:
        │   │   @ SingletonClassNode (location: (196...213))
        │   │   ├── locals: []
        │   │   ├── class_keyword_loc: (196...201) = "class"
        │   │   ├── operator_loc: (202...204) = "<<"
        │   │   ├── expression:
        │   │   │   @ SelfNode (location: (205...209))
        │   │   ├── body: ∅
        │   │   └── end_keyword_loc: (210...213) = "end"
        │   ├── call_operator_loc: (213...214) = "."
        │   ├── message_loc: (214...217) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (218...238))
        │   ├── receiver:
        │   │   @ DefNode (location: (218...234))
        │   │   ├── name: :foo
        │   │   ├── name_loc: (227...230) = "foo"
        │   │   ├── receiver:
        │   │   │   @ SelfNode (location: (222...226))
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── locals: []
        │   │   ├── def_keyword_loc: (218...221) = "def"
        │   │   ├── operator_loc: (226...227) = "."
        │   │   ├── lparen_loc: ∅
        │   │   ├── rparen_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── end_keyword_loc: (231...234) = "end"
        │   ├── call_operator_loc: (234...235) = "."
        │   ├── message_loc: (235...238) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (239...254))
        │   ├── receiver:
        │   │   @ DefNode (location: (239...250))
        │   │   ├── name: :foo
        │   │   ├── name_loc: (243...246) = "foo"
        │   │   ├── receiver: ∅
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── locals: []
        │   │   ├── def_keyword_loc: (239...242) = "def"
        │   │   ├── operator_loc: ∅
        │   │   ├── lparen_loc: ∅
        │   │   ├── rparen_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── end_keyword_loc: (247...250) = "end"
        │   ├── call_operator_loc: (250...251) = "."
        │   ├── message_loc: (251...254) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (255...272))
        │   ├── receiver:
        │   │   @ UntilNode (location: (255...268))
        │   │   ├── keyword_loc: (255...260) = "until"
        │   │   ├── closing_loc: (265...268) = "end"
        │   │   ├── predicate:
        │   │   │   @ CallNode (location: (261...264))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (261...264) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "foo"
        │   │   ├── statements: ∅
        │   │   └── flags: ∅
        │   ├── call_operator_loc: (268...269) = "."
        │   ├── message_loc: (269...272) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (273...290))
        │   ├── receiver:
        │   │   @ WhileNode (location: (273...286))
        │   │   ├── keyword_loc: (273...278) = "while"
        │   │   ├── closing_loc: (283...286) = "end"
        │   │   ├── predicate:
        │   │   │   @ CallNode (location: (279...282))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (279...282) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "foo"
        │   │   ├── statements: ∅
        │   │   └── flags: ∅
        │   ├── call_operator_loc: (286...287) = "."
        │   ├── message_loc: (287...290) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (291...303))
        │   ├── receiver:
        │   │   @ CallNode (location: (291...299))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (291...295) = "loop"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block:
        │   │   │   @ BlockNode (location: (296...299))
        │   │   │   ├── locals: []
        │   │   │   ├── parameters: ∅
        │   │   │   ├── body: ∅
        │   │   │   ├── opening_loc: (296...297) = "{"
        │   │   │   └── closing_loc: (298...299) = "}"
        │   │   ├── flags: ∅
        │   │   └── name: "loop"
        │   ├── call_operator_loc: (299...300) = "."
        │   ├── message_loc: (300...303) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (304...318))
        │   ├── receiver:
        │   │   @ IfNode (location: (304...314))
        │   │   ├── if_keyword_loc: (304...306) = "if"
        │   │   ├── predicate:
        │   │   │   @ CallNode (location: (307...310))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (307...310) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "foo"
        │   │   ├── statements: ∅
        │   │   ├── consequent: ∅
        │   │   └── end_keyword_loc: (311...314) = "end"
        │   ├── call_operator_loc: (314...315) = "."
        │   ├── message_loc: (315...318) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "baz"
        ├── @ CallNode (location: (319...338))
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (319...334))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (320...333))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (320...333))
        │   │   │           ├── receiver:
        │   │   │           │   @ RegularExpressionNode (location: (320...325))
        │   │   │           │   ├── opening_loc: (320...321) = "/"
        │   │   │           │   ├── content_loc: (321...324) = "bar"
        │   │   │           │   ├── closing_loc: (324...325) = "/"
        │   │   │           │   ├── unescaped: "bar"
        │   │   │           │   └── flags: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (326...328) = "=~"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (329...333))
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ SymbolNode (location: (329...333))
        │   │   │           │           ├── opening_loc: (329...330) = ":"
        │   │   │           │           ├── value_loc: (330...333) = "foo"
        │   │   │           │           ├── closing_loc: ∅
        │   │   │           │           └── unescaped: "foo"
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: ∅
        │   │   │           └── name: "=~"
        │   │   ├── opening_loc: (319...320) = "("
        │   │   └── closing_loc: (333...334) = ")"
        │   ├── call_operator_loc: (334...335) = "."
        │   ├── message_loc: (335...338) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (339...349))
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (339...345))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (340...344))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ RangeNode (location: (340...344))
        │   │   │           ├── left:
        │   │   │           │   @ IntegerNode (location: (340...341))
        │   │   │           │   └── flags: decimal
        │   │   │           ├── right:
        │   │   │           │   @ IntegerNode (location: (343...344))
        │   │   │           │   └── flags: decimal
        │   │   │           ├── operator_loc: (341...343) = ".."
        │   │   │           └── flags: ∅
        │   │   ├── opening_loc: (339...340) = "("
        │   │   └── closing_loc: (344...345) = ")"
        │   ├── call_operator_loc: (345...346) = "."
        │   ├── message_loc: (346...349) = "max"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "max"
        ├── @ CallNode (location: (350...368))
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (350...364))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (351...363))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (351...363))
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (351...354))
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── message_loc: (351...354) = "foo"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   ├── block: ∅
        │   │   │           │   ├── flags: variable_call
        │   │   │           │   └── name: "foo"
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (355...357) = "=~"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (358...363))
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ RegularExpressionNode (location: (358...363))
        │   │   │           │           ├── opening_loc: (358...359) = "/"
        │   │   │           │           ├── content_loc: (359...362) = "bar"
        │   │   │           │           ├── closing_loc: (362...363) = "/"
        │   │   │           │           ├── unescaped: "bar"
        │   │   │           │           └── flags: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: ∅
        │   │   │           └── name: "=~"
        │   │   ├── opening_loc: (350...351) = "("
        │   │   └── closing_loc: (363...364) = ")"
        │   ├── call_operator_loc: (364...365) = "."
        │   ├── message_loc: (365...368) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (369...382))
        │   ├── receiver:
        │   │   @ RegularExpressionNode (location: (369...374))
        │   │   ├── opening_loc: (369...370) = "/"
        │   │   ├── content_loc: (370...373) = "bar"
        │   │   ├── closing_loc: (373...374) = "/"
        │   │   ├── unescaped: "bar"
        │   │   └── flags: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (375...377) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (378...382))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (378...382))
        │   │           ├── opening_loc: (378...379) = ":"
        │   │           ├── value_loc: (379...382) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "=~"
        ├── @ CallNode (location: (383...395))
        │   ├── receiver:
        │   │   @ RegularExpressionNode (location: (383...388))
        │   │   ├── opening_loc: (383...384) = "/"
        │   │   ├── content_loc: (384...387) = "bar"
        │   │   ├── closing_loc: (387...388) = "/"
        │   │   ├── unescaped: "bar"
        │   │   └── flags: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (389...391) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (392...395))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (392...395))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (392...395) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "foo"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "=~"
        ├── @ RangeNode (location: (396...404))
        │   ├── left:
        │   │   @ IntegerNode (location: (396...397))
        │   │   └── flags: decimal
        │   ├── right:
        │   │   @ CallNode (location: (399...404))
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (399...400))
        │   │   │   └── flags: decimal
        │   │   ├── call_operator_loc: (400...401) = "."
        │   │   ├── message_loc: (401...404) = "max"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: ∅
        │   │   └── name: "max"
        │   ├── operator_loc: (397...399) = ".."
        │   └── flags: ∅
        ├── @ CallNode (location: (405...410))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (405...406))
        │   │   └── name: :A
        │   ├── call_operator_loc: (406...407) = "."
        │   ├── message_loc: (407...410) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (411...416))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (411...414) = "FOO"
        │   ├── opening_loc: (414...415) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (415...416) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "FOO"
        ├── @ CallNode (location: (417...421))
        │   ├── receiver:
        │   │   @ CallNode (location: (417...418))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (417...418) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (418...420) = "&."
        │   ├── message_loc: (420...421) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: safe_navigation
        │   └── name: "b"
        ├── @ CallNode (location: (422...427))
        │   ├── receiver:
        │   │   @ CallNode (location: (422...423))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (422...423) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (423...424) = "."
        │   ├── message_loc: (424...427) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (428...431))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (428...431) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: variable_call
        │   └── name: "foo"
        ├── @ CallNode (location: (432...450))
        │   ├── receiver:
        │   │   @ CallNode (location: (432...435))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (432...435) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (436...438) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (439...450))
        │   │   └── arguments: (length: 1)
        │   │       └── @ ParenthesesNode (location: (439...450))
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (440...449))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (440...449))
        │   │           │           ├── receiver:
        │   │           │           │   @ CallNode (location: (440...443))
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── message_loc: (440...443) = "bar"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   ├── block: ∅
        │   │           │           │   ├── flags: variable_call
        │   │           │           │   └── name: "bar"
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (444...445) = "*"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (446...449))
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ CallNode (location: (446...449))
        │   │           │           │           ├── receiver: ∅
        │   │           │           │           ├── call_operator_loc: ∅
        │   │           │           │           ├── message_loc: (446...449) = "baz"
        │   │           │           │           ├── opening_loc: ∅
        │   │           │           │           ├── arguments: ∅
        │   │           │           │           ├── closing_loc: ∅
        │   │           │           │           ├── block: ∅
        │   │           │           │           ├── flags: variable_call
        │   │           │           │           └── name: "baz"
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: ∅
        │   │           │           └── name: "*"
        │   │           ├── opening_loc: (439...440) = "("
        │   │           └── closing_loc: (449...450) = ")"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "<<"
        ├── @ CallNode (location: (451...463))
        │   ├── receiver:
        │   │   @ CallNode (location: (451...454))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (451...454) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (455...457) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (458...463))
        │   │   └── arguments: (length: 1)
        │   │       └── @ RegularExpressionNode (location: (458...463))
        │   │           ├── opening_loc: (458...459) = "/"
        │   │           ├── content_loc: (459...462) = "bar"
        │   │           ├── closing_loc: (462...463) = "/"
        │   │           ├── unescaped: "bar"
        │   │           └── flags: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "=~"
        ├── @ CallNode (location: (464...482))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (464...467) = "foo"
        │   ├── opening_loc: (467...468) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (468...481))
        │   │   └── arguments: (length: 1)
        │   │       └── @ BlockArgumentNode (location: (468...481))
        │   │           ├── expression:
        │   │           │   @ ParenthesesNode (location: (469...481))
        │   │           │   ├── body:
        │   │           │   │   @ StatementsNode (location: (470...480))
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ OrNode (location: (470...480))
        │   │           │   │           ├── left:
        │   │           │   │           │   @ CallNode (location: (470...473))
        │   │           │   │           │   ├── receiver: ∅
        │   │           │   │           │   ├── call_operator_loc: ∅
        │   │           │   │           │   ├── message_loc: (470...473) = "foo"
        │   │           │   │           │   ├── opening_loc: ∅
        │   │           │   │           │   ├── arguments: ∅
        │   │           │   │           │   ├── closing_loc: ∅
        │   │           │   │           │   ├── block: ∅
        │   │           │   │           │   ├── flags: variable_call
        │   │           │   │           │   └── name: "foo"
        │   │           │   │           ├── right:
        │   │           │   │           │   @ CallNode (location: (477...480))
        │   │           │   │           │   ├── receiver: ∅
        │   │           │   │           │   ├── call_operator_loc: ∅
        │   │           │   │           │   ├── message_loc: (477...480) = "bar"
        │   │           │   │           │   ├── opening_loc: ∅
        │   │           │   │           │   ├── arguments: ∅
        │   │           │   │           │   ├── closing_loc: ∅
        │   │           │   │           │   ├── block: ∅
        │   │           │   │           │   ├── flags: variable_call
        │   │           │   │           │   └── name: "bar"
        │   │           │   │           └── operator_loc: (474...476) = "||"
        │   │           │   ├── opening_loc: (469...470) = "("
        │   │           │   └── closing_loc: (480...481) = ")"
        │   │           └── operator_loc: (468...469) = "&"
        │   ├── closing_loc: (481...482) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (483...494))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (483...486) = "foo"
        │   ├── opening_loc: (486...487) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (487...493))
        │   │   └── arguments: (length: 1)
        │   │       └── @ BlockArgumentNode (location: (487...493))
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (488...493))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (488...493) = "block"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "block"
        │   │           └── operator_loc: (487...488) = "&"
        │   ├── closing_loc: (493...494) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (495...513))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (495...498) = "foo"
        │   ├── opening_loc: (498...499) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (499...512))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SplatNode (location: (499...504))
        │   │       │   ├── operator_loc: (499...500) = "*"
        │   │       │   └── expression:
        │   │       │       @ CallNode (location: (500...504))
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── message_loc: (500...504) = "args"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       ├── block: ∅
        │   │       │       ├── flags: variable_call
        │   │       │       └── name: "args"
        │   │       └── @ BlockArgumentNode (location: (506...512))
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (507...512))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (507...512) = "block"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "block"
        │   │           └── operator_loc: (506...507) = "&"
        │   ├── closing_loc: (512...513) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (514...529))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (514...517) = "foo"
        │   ├── opening_loc: (517...518) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (518...528))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (518...528))
        │   │           ├── operator_loc: (518...519) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (519...528))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (519...528) = "arguments"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "arguments"
        │   ├── closing_loc: (528...529) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (530...539))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (530...533) = "foo"
        │   ├── opening_loc: (533...534) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (534...538))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (534...535))
        │   │       │   └── flags: decimal
        │   │       └── @ IntegerNode (location: (537...538))
        │   │           └── flags: decimal
        │   ├── closing_loc: (538...539) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (540...548))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (540...543) = "foo"
        │   ├── opening_loc: (543...544) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (544...547))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (544...547))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (544...547) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── closing_loc: (547...548) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (549...564))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (549...552) = "foo"
        │   ├── opening_loc: (552...553) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (553...563))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (553...556))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (553...556) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "bar"
        │   │       └── @ SplatNode (location: (558...563))
        │   │           ├── operator_loc: (558...559) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (559...563))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (559...563) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "args"
        │   ├── closing_loc: (563...564) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (565...582))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (565...568) = "foo"
        │   ├── opening_loc: (568...569) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (569...581))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (569...581))
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (569...572))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (569...572) = "foo"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "foo"
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (573...575) = "=~"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (576...581))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ RegularExpressionNode (location: (576...581))
        │   │           │           ├── opening_loc: (576...577) = "/"
        │   │           │           ├── content_loc: (577...580) = "bar"
        │   │           │           ├── closing_loc: (580...581) = "/"
        │   │           │           ├── unescaped: "bar"
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "=~"
        │   ├── closing_loc: (581...582) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (583...596))
        │   ├── receiver:
        │   │   @ CallNode (location: (583...586))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (583...586) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (586...587) = "."
        │   ├── message_loc: (587...590) = "bar"
        │   ├── opening_loc: (590...591) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (591...595))
        │   │   └── arguments: (length: 1)
        │   │       └── @ BlockArgumentNode (location: (591...595))
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (592...595))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (592...595) = "baz"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "baz"
        │   │           └── operator_loc: (591...592) = "&"
        │   ├── closing_loc: (595...596) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (597...623))
        │   ├── receiver:
        │   │   @ CallNode (location: (597...600))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (597...600) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (600...601) = "."
        │   ├── message_loc: (601...604) = "bar"
        │   ├── opening_loc: (604...605) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (605...622))
        │   │   └── arguments: (length: 3)
        │   │       ├── @ SplatNode (location: (605...610))
        │   │       │   ├── operator_loc: (605...606) = "*"
        │   │       │   └── expression:
        │   │       │       @ CallNode (location: (606...610))
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── message_loc: (606...610) = "arga"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       ├── block: ∅
        │   │       │       ├── flags: variable_call
        │   │       │       └── name: "arga"
        │   │       ├── @ CallNode (location: (612...615))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (612...615) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "foo"
        │   │       └── @ SplatNode (location: (617...622))
        │   │           ├── operator_loc: (617...618) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (618...622))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (618...622) = "argb"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "argb"
        │   ├── closing_loc: (622...623) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (624...638))
        │   ├── receiver:
        │   │   @ CallNode (location: (624...627))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (624...627) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (627...628) = "."
        │   ├── message_loc: (628...631) = "bar"
        │   ├── opening_loc: (631...632) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (632...637))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (632...637))
        │   │           ├── operator_loc: (632...633) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (633...637))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (633...637) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "args"
        │   ├── closing_loc: (637...638) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (639...658))
        │   ├── receiver:
        │   │   @ CallNode (location: (639...642))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (639...642) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (642...643) = "."
        │   ├── message_loc: (643...646) = "bar"
        │   ├── opening_loc: (646...647) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (647...657))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SplatNode (location: (647...652))
        │   │       │   ├── operator_loc: (647...648) = "*"
        │   │       │   └── expression:
        │   │       │       @ CallNode (location: (648...652))
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── message_loc: (648...652) = "args"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       ├── block: ∅
        │   │       │       ├── flags: variable_call
        │   │       │       └── name: "args"
        │   │       └── @ CallNode (location: (654...657))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (654...657) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "foo"
        │   ├── closing_loc: (657...658) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (659...678))
        │   ├── receiver:
        │   │   @ CallNode (location: (659...662))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (659...662) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (662...663) = "."
        │   ├── message_loc: (663...666) = "bar"
        │   ├── opening_loc: (666...667) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (667...677))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (667...671))
        │   │       │   ├── opening_loc: (667...668) = ":"
        │   │       │   ├── value_loc: (668...671) = "baz"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "baz"
        │   │       └── @ BlockArgumentNode (location: (673...677))
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (674...677))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (674...677) = "baz"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "baz"
        │   │           └── operator_loc: (673...674) = "&"
        │   ├── closing_loc: (677...678) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (679...696))
        │   ├── receiver:
        │   │   @ CallNode (location: (679...682))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (679...682) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (682...683) = "."
        │   ├── message_loc: (683...686) = "bar"
        │   ├── opening_loc: (686...687) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (687...695))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (687...695))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (687...695))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (687...691))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (687...690) = "baz"
        │   │                   │   ├── closing_loc: (690...691) = ":"
        │   │                   │   └── unescaped: "baz"
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (692...695))
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── message_loc: (692...695) = "boz"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   ├── block: ∅
        │   │                   │   ├── flags: variable_call
        │   │                   │   └── name: "boz"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (695...696) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (697...723))
        │   ├── receiver:
        │   │   @ CallNode (location: (697...700))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (697...700) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (700...701) = "."
        │   ├── message_loc: (701...704) = "bar"
        │   ├── opening_loc: (704...705) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (705...722))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (705...708))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (705...708) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "foo"
        │   │       └── @ KeywordHashNode (location: (710...722))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (710...722))
        │   │                   ├── key:
        │   │                   │   @ StringNode (location: (710...715))
        │   │                   │   ├── opening_loc: (710...711) = "\""
        │   │                   │   ├── content_loc: (711...714) = "baz"
        │   │                   │   ├── closing_loc: (714...715) = "\""
        │   │                   │   └── unescaped: "baz"
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (719...722))
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── message_loc: (719...722) = "boz"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   ├── block: ∅
        │   │                   │   ├── flags: variable_call
        │   │                   │   └── name: "boz"
        │   │                   └── operator_loc: (716...718) = "=>"
        │   ├── closing_loc: (722...723) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (724...743))
        │   ├── receiver:
        │   │   @ CallNode (location: (724...727))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (724...727) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (727...728) = "."
        │   ├── message_loc: (728...731) = "bar"
        │   ├── opening_loc: (731...732) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (732...742))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (732...735))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (732...735) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "foo"
        │   │       └── @ SplatNode (location: (737...742))
        │   │           ├── operator_loc: (737...738) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (738...742))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (738...742) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "args"
        │   ├── closing_loc: (742...743) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (744...771))
        │   ├── receiver:
        │   │   @ CallNode (location: (744...747))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (744...747) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (747...748) = "."
        │   ├── message_loc: (748...751) = "bar"
        │   ├── opening_loc: (751...752) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (752...770))
        │   │   └── arguments: (length: 3)
        │   │       ├── @ CallNode (location: (752...755))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (752...755) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "foo"
        │   │       ├── @ SplatNode (location: (757...762))
        │   │       │   ├── operator_loc: (757...758) = "*"
        │   │       │   └── expression:
        │   │       │       @ CallNode (location: (758...762))
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── message_loc: (758...762) = "args"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       ├── block: ∅
        │   │       │       ├── flags: variable_call
        │   │       │       └── name: "args"
        │   │       └── @ BlockArgumentNode (location: (764...770))
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (765...770))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (765...770) = "block"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "block"
        │   │           └── operator_loc: (764...765) = "&"
        │   ├── closing_loc: (770...771) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (772...788))
        │   ├── receiver:
        │   │   @ CallNode (location: (772...775))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (772...775) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (775...776) = "."
        │   ├── message_loc: (776...779) = "bar"
        │   ├── opening_loc: (779...780) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (780...787))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (780...783))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (780...783) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "foo"
        │   │       └── @ HashNode (location: (785...787))
        │   │           ├── opening_loc: (785...786) = "{"
        │   │           ├── elements: (length: 0)
        │   │           └── closing_loc: (786...787) = "}"
        │   ├── closing_loc: (787...788) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (789...815))
        │   ├── receiver:
        │   │   @ CallNode (location: (789...792))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (789...792) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (792...793) = "."
        │   ├── message_loc: (793...796) = "bar"
        │   ├── opening_loc: (796...797) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (797...814))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ HashNode (location: (797...809))
        │   │       │   ├── opening_loc: (797...798) = "{"
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (799...807))
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (799...803))
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (799...802) = "foo"
        │   │       │   │       │   ├── closing_loc: (802...803) = ":"
        │   │       │   │       │   └── unescaped: "foo"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ CallNode (location: (804...807))
        │   │       │   │       │   ├── receiver: ∅
        │   │       │   │       │   ├── call_operator_loc: ∅
        │   │       │   │       │   ├── message_loc: (804...807) = "boz"
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── arguments: ∅
        │   │       │   │       │   ├── closing_loc: ∅
        │   │       │   │       │   ├── block: ∅
        │   │       │   │       │   ├── flags: variable_call
        │   │       │   │       │   └── name: "boz"
        │   │       │   │       └── operator_loc: ∅
        │   │       │   └── closing_loc: (808...809) = "}"
        │   │       └── @ CallNode (location: (811...814))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (811...814) = "boz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "boz"
        │   ├── closing_loc: (814...815) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar"
        ├── @ CallNode (location: (816...828))
        │   ├── receiver:
        │   │   @ CallNode (location: (816...819))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (816...819) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (819...820) = "."
        │   ├── message_loc: (820...823) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (824...828))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (824...828))
        │   │           ├── opening_loc: (824...825) = ":"
        │   │           ├── value_loc: (825...828) = "baz"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "baz"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "bar="
        ├── @ CallNode (location: (829...838))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (829...832) = "foo"
        │   ├── opening_loc: (832...833) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (833...837))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (833...837))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (833...837))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (833...835))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (833...834) = "a"
        │   │                   │   ├── closing_loc: (834...835) = ":"
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (836...837))
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── message_loc: (836...837) = "b"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   ├── block: ∅
        │   │                   │   ├── flags: variable_call
        │   │                   │   └── name: "b"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (837...838) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (839...850))
        │   ├── receiver:
        │   │   @ CallNode (location: (839...842))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (839...842) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (842...843) = "."
        │   ├── message_loc: (843...844) = "&"
        │   ├── opening_loc: (844...845) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (845...849))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (845...849))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (845...849))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (845...847))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (845...846) = "a"
        │   │                   │   ├── closing_loc: (846...847) = ":"
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (848...849))
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── message_loc: (848...849) = "b"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   ├── block: ∅
        │   │                   │   ├── flags: variable_call
        │   │                   │   └── name: "b"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (849...850) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "&"
        ├── @ CallNode (location: (851...861))
        │   ├── receiver:
        │   │   @ CallNode (location: (851...854))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (851...854) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (854...855) = "."
        │   ├── message_loc: (855...856) = "&"
        │   ├── opening_loc: (856...857) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (857...860))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (857...860))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (857...860))
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (859...860))
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── message_loc: (859...860) = "a"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   ├── block: ∅
        │   │                   │   ├── flags: variable_call
        │   │                   │   └── name: "a"
        │   │                   └── operator_loc: (857...859) = "**"
        │   ├── closing_loc: (860...861) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "&"
        ├── @ CallNode (location: (862...871))
        │   ├── receiver:
        │   │   @ CallNode (location: (862...865))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (862...865) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (865...871) = "[*baz]"
        │   ├── opening_loc: (865...866) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (866...870))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (866...870))
        │   │           ├── operator_loc: (866...867) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (867...870))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (867...870) = "baz"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "baz"
        │   ├── closing_loc: (870...871) = "]"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "[]"
        ├── @ CallNode (location: (872...881))
        │   ├── receiver:
        │   │   @ CallNode (location: (872...875))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (872...875) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (875...881) = "[1, 2]"
        │   ├── opening_loc: (875...876) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (876...880))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (876...877))
        │   │       │   └── flags: decimal
        │   │       └── @ IntegerNode (location: (879...880))
        │   │           └── flags: decimal
        │   ├── closing_loc: (880...881) = "]"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "[]"
        ├── @ CallNode (location: (882...887))
        │   ├── receiver:
        │   │   @ CallNode (location: (882...885))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (882...885) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (885...887) = "[]"
        │   ├── opening_loc: (885...886) = "["
        │   ├── arguments: ∅
        │   ├── closing_loc: (886...887) = "]"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "[]"
        ├── @ CallNode (location: (888...896))
        │   ├── receiver:
        │   │   @ SelfNode (location: (888...892))
        │   ├── call_operator_loc: (892...893) = "."
        │   ├── message_loc: (893...896) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (897...910))
        │   ├── receiver:
        │   │   @ SelfNode (location: (897...901))
        │   ├── call_operator_loc: (901...902) = "."
        │   ├── message_loc: (902...905) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (906...910))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (906...910))
        │   │           ├── opening_loc: (906...907) = ":"
        │   │           ├── value_loc: (907...910) = "bar"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "bar"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo="
        ├── @ CallNode (location: (911...928))
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (911...918))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (912...917))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (912...917))
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (912...913))
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── message_loc: (912...913) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   ├── block: ∅
        │   │   │           │   ├── flags: variable_call
        │   │   │           │   └── name: "a"
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (914...915) = "+"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (916...917))
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ CallNode (location: (916...917))
        │   │   │           │           ├── receiver: ∅
        │   │   │           │           ├── call_operator_loc: ∅
        │   │   │           │           ├── message_loc: (916...917) = "b"
        │   │   │           │           ├── opening_loc: ∅
        │   │   │           │           ├── arguments: ∅
        │   │   │           │           ├── closing_loc: ∅
        │   │   │           │           ├── block: ∅
        │   │   │           │           ├── flags: variable_call
        │   │   │           │           └── name: "b"
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: ∅
        │   │   │           └── name: "+"
        │   │   ├── opening_loc: (911...912) = "("
        │   │   └── closing_loc: (917...918) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (919...920) = "/"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (921...928))
        │   │   └── arguments: (length: 1)
        │   │       └── @ ParenthesesNode (location: (921...928))
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (922...927))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (922...927))
        │   │           │           ├── receiver:
        │   │           │           │   @ CallNode (location: (922...923))
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── message_loc: (922...923) = "c"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   ├── block: ∅
        │   │           │           │   ├── flags: variable_call
        │   │           │           │   └── name: "c"
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (924...925) = "-"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (926...927))
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ CallNode (location: (926...927))
        │   │           │           │           ├── receiver: ∅
        │   │           │           │           ├── call_operator_loc: ∅
        │   │           │           │           ├── message_loc: (926...927) = "d"
        │   │           │           │           ├── opening_loc: ∅
        │   │           │           │           ├── arguments: ∅
        │   │           │           │           ├── closing_loc: ∅
        │   │           │           │           ├── block: ∅
        │   │           │           │           ├── flags: variable_call
        │   │           │           │           └── name: "d"
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: ∅
        │   │           │           └── name: "-"
        │   │           ├── opening_loc: (921...922) = "("
        │   │           └── closing_loc: (927...928) = ")"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "/"
        ├── @ CallNode (location: (929...948))
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (929...936))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (930...935))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (930...935))
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (930...931))
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── message_loc: (930...931) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   ├── block: ∅
        │   │   │           │   ├── flags: variable_call
        │   │   │           │   └── name: "a"
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (932...933) = "+"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (934...935))
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ CallNode (location: (934...935))
        │   │   │           │           ├── receiver: ∅
        │   │   │           │           ├── call_operator_loc: ∅
        │   │   │           │           ├── message_loc: (934...935) = "b"
        │   │   │           │           ├── opening_loc: ∅
        │   │   │           │           ├── arguments: ∅
        │   │   │           │           ├── closing_loc: ∅
        │   │   │           │           ├── block: ∅
        │   │   │           │           ├── flags: variable_call
        │   │   │           │           └── name: "b"
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: ∅
        │   │   │           └── name: "+"
        │   │   ├── opening_loc: (929...930) = "("
        │   │   └── closing_loc: (935...936) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (937...938) = "/"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (939...948))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (939...948))
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (939...940))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (939...940) = "c"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "c"
        │   │           ├── call_operator_loc: (940...941) = "."
        │   │           ├── message_loc: (941...942) = "-"
        │   │           ├── opening_loc: (942...943) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (943...947))
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ CallNode (location: (943...944))
        │   │           │       │   ├── receiver: ∅
        │   │           │       │   ├── call_operator_loc: ∅
        │   │           │       │   ├── message_loc: (943...944) = "e"
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── arguments: ∅
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   ├── block: ∅
        │   │           │       │   ├── flags: variable_call
        │   │           │       │   └── name: "e"
        │   │           │       └── @ CallNode (location: (946...947))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (946...947) = "f"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: variable_call
        │   │           │           └── name: "f"
        │   │           ├── closing_loc: (947...948) = ")"
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "-"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "/"
        ├── @ CallNode (location: (949...966))
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (949...956))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (950...955))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (950...955))
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (950...951))
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── message_loc: (950...951) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   ├── block: ∅
        │   │   │           │   ├── flags: variable_call
        │   │   │           │   └── name: "a"
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (952...953) = "+"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (954...955))
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ CallNode (location: (954...955))
        │   │   │           │           ├── receiver: ∅
        │   │   │           │           ├── call_operator_loc: ∅
        │   │   │           │           ├── message_loc: (954...955) = "b"
        │   │   │           │           ├── opening_loc: ∅
        │   │   │           │           ├── arguments: ∅
        │   │   │           │           ├── closing_loc: ∅
        │   │   │           │           ├── block: ∅
        │   │   │           │           ├── flags: variable_call
        │   │   │           │           └── name: "b"
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: ∅
        │   │   │           └── name: "+"
        │   │   ├── opening_loc: (949...950) = "("
        │   │   └── closing_loc: (955...956) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (957...958) = "/"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (959...966))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (959...966))
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (959...960))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (959...960) = "c"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "c"
        │   │           ├── call_operator_loc: (960...961) = "."
        │   │           ├── message_loc: (961...962) = "-"
        │   │           ├── opening_loc: (962...963) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (963...965))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ SplatNode (location: (963...965))
        │   │           │           ├── operator_loc: (963...964) = "*"
        │   │           │           └── expression:
        │   │           │               @ CallNode (location: (964...965))
        │   │           │               ├── receiver: ∅
        │   │           │               ├── call_operator_loc: ∅
        │   │           │               ├── message_loc: (964...965) = "f"
        │   │           │               ├── opening_loc: ∅
        │   │           │               ├── arguments: ∅
        │   │           │               ├── closing_loc: ∅
        │   │           │               ├── block: ∅
        │   │           │               ├── flags: variable_call
        │   │           │               └── name: "f"
        │   │           ├── closing_loc: (965...966) = ")"
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "-"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "/"
        ├── @ CallNode (location: (967...975))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (967...968) = "x"
        │   ├── opening_loc: (968...969) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (969...974))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (969...974))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (969...974))
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (971...974))
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── message_loc: (971...974) = "foo"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   ├── block: ∅
        │   │                   │   ├── flags: variable_call
        │   │                   │   └── name: "foo"
        │   │                   └── operator_loc: (969...971) = "**"
        │   ├── closing_loc: (974...975) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "x"
        ├── @ CallNode (location: (976...982))
        │   ├── receiver:
        │   │   @ CallNode (location: (976...979))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (976...979) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (979...981) = "&."
        │   ├── message_loc: (981...982) = "!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: safe_navigation
        │   └── name: "!"
        ├── @ CallNode (location: (983...991))
        │   ├── receiver:
        │   │   @ CallNode (location: (983...986))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (983...986) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (986...987) = "."
        │   ├── message_loc: (987...988) = "~"
        │   ├── opening_loc: (988...989) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (989...990))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (989...990))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (989...990) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "b"
        │   ├── closing_loc: (990...991) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "~"
        └── @ CallNode (location: (992...999))
            ├── receiver:
            │   @ CallNode (location: (992...993))
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── message_loc: (992...993) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   ├── block: ∅
            │   ├── flags: variable_call
            │   └── name: "a"
            ├── call_operator_loc: (993...995) = "&."
            ├── message_loc: (995...996) = "+"
            ├── opening_loc: (996...997) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (997...998))
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (997...998))
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── message_loc: (997...998) = "b"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           ├── block: ∅
            │           ├── flags: variable_call
            │           └── name: "b"
            ├── closing_loc: (998...999) = ")"
            ├── block: ∅
            ├── flags: safe_navigation
            └── name: "+"
