path: root/test/yarp/snapshots/method_calls.txt

@ ProgramNode (location: (0...1237))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...1237))
    └── body: (length: 62)
        ├── @ CallNode (location: (0...14))
        │   ├── receiver:
        │   │   @ CallNode (location: (0...3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (0...3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (3...4) = "."
        │   ├── message_loc: (4...7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (8...14))
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (8...14))
        │   │           ├── opening_loc: (8...10) = "%{"
        │   │           ├── content_loc: (10...13) = "baz"
        │   │           ├── closing_loc: (13...14) = "}"
        │   │           └── unescaped: "baz"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "bar"
        ├── @ CallNode (location: (16...25))
        │   ├── receiver:
        │   │   @ CallNode (location: (16...17))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (16...17) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (17...18) = "."
        │   ├── message_loc: (18...19) = "b"
        │   ├── opening_loc: (19...20) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (20...24))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (20...21))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (20...21) = "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "c"
        │   │       └── @ CallNode (location: (23...24))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (23...24) = "d"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "d"
        │   ├── closing_loc: (24...25) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "b"
        ├── @ CallNode (location: (27...32))
        │   ├── receiver:
        │   │   @ CallNode (location: (27...28))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (27...28) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (28...29) = "."
        │   ├── message_loc: (29...30) = "b"
        │   ├── opening_loc: (30...31) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (31...32) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "b"
        ├── @ CallNode (location: (34...52))
        │   ├── receiver:
        │   │   @ CallNode (location: (34...44))
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (34...37))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (34...37) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "foo"
        │   │   ├── call_operator_loc: (40...41) = "."
        │   │   ├── message_loc: (41...44) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: 
        │   │   └── name: "bar"
        │   ├── call_operator_loc: (47...49) = "&."
        │   ├── message_loc: (49...52) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: safe_navigation
        │   └── name: "baz"
        ├── @ CallNode (location: (54...56))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (54...56) = "a!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "a!"
        ├── @ CallNode (location: (58...62))
        │   ├── receiver:
        │   │   @ CallNode (location: (58...59))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (58...59) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (59...60) = "."
        │   ├── message_loc: ∅
        │   ├── opening_loc: (60...61) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (61...62) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "call"
        ├── @ CallNode (location: (64...75))
        │   ├── receiver:
        │   │   @ CallNode (location: (64...65))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (64...65) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (65...66) = "."
        │   ├── message_loc: ∅
        │   ├── opening_loc: (66...67) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (67...74))
        │   │   └── arguments: (length: 3)
        │   │       ├── @ IntegerNode (location: (67...68))
        │   │       │   └── flags: decimal
        │   │       ├── @ IntegerNode (location: (70...71))
        │   │       │   └── flags: decimal
        │   │       └── @ IntegerNode (location: (73...74))
        │   │           └── flags: decimal
        │   ├── closing_loc: (74...75) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "call"
        ├── @ CallNode (location: (77...81))
        │   ├── receiver:
        │   │   @ CallNode (location: (77...78))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (77...78) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (78...80) = "::"
        │   ├── message_loc: (80...81) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "b"
        ├── @ CallNode (location: (83...89))
        │   ├── receiver:
        │   │   @ CallNode (location: (83...84))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (83...84) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (84...86) = "::"
        │   ├── message_loc: (86...87) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (88...89))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (88...89))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (88...89) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "c"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "b"
        ├── @ CallNode (location: (91...102))
        │   ├── receiver:
        │   │   @ CallNode (location: (91...94))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (91...94) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (94...95) = "."
        │   ├── message_loc: (95...98) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (101...102))
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (101...102))
        │   │           └── flags: decimal
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "bar="
        ├── @ CallNode (location: (104...106))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (104...106) = "a?"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "a?"
        ├── @ CallNode (location: (108...117))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (108...109) = "a"
        │   ├── opening_loc: (109...110) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (110...116))
        │   │   └── arguments: (length: 1)
        │   │       └── @ BlockArgumentNode (location: (110...116))
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (111...116))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (111...116) = "block"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "block"
        │   │           └── operator_loc: (110...111) = "&"
        │   ├── closing_loc: (116...117) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "a"
        ├── @ CallNode (location: (119...130))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (119...120) = "a"
        │   ├── opening_loc: (120...121) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (121...129))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (121...129))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (121...129))
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (123...129))
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── message_loc: (123...129) = "kwargs"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   ├── block: ∅
        │   │                   │   ├── flags: variable_call
        │   │                   │   └── name: "kwargs"
        │   │                   └── operator_loc: (121...123) = "**"
        │   ├── closing_loc: (129...130) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "a"
        ├── @ CallNode (location: (132...137))
        │   ├── receiver:
        │   │   @ CallNode (location: (132...135))
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (132...133))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (132...133) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "a"
        │   │   ├── call_operator_loc: (133...134) = "."
        │   │   ├── message_loc: (134...135) = "b"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: 
        │   │   └── name: "b"
        │   ├── call_operator_loc: (135...136) = "."
        │   ├── message_loc: (136...137) = "c"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "c"
        ├── @ CallNode (location: (139...146))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (139...140) = "a"
        │   ├── opening_loc: (140...141) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (141...145))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (141...142))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (141...142) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "b"
        │   │       └── @ CallNode (location: (144...145))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (144...145) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "c"
        │   ├── closing_loc: (145...146) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "a"
        ├── @ CallNode (location: (148...151))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (148...149) = "a"
        │   ├── opening_loc: (149...150) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (150...151) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "a"
        ├── @ CallNode (location: (153...161))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (153...154) = "a"
        │   ├── opening_loc: (154...155) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (155...160))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (155...160))
        │   │           ├── operator_loc: (155...156) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (156...160))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (156...160) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "args"
        │   ├── closing_loc: (160...161) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "a"
        ├── @ CallNode (location: (163...169))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (163...164) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (165...169))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (165...166))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (165...166) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "b"
        │   │       └── @ CallNode (location: (168...169))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (168...169) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "c"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "a"
        ├── @ CallNode (location: (171...179))
        │   ├── receiver:
        │   │   @ CallNode (location: (171...172))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (171...172) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (172...173) = "."
        │   ├── message_loc: (173...174) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (175...179))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (175...176))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (175...176) = "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "c"
        │   │       └── @ CallNode (location: (178...179))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (178...179) = "d"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "d"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "b"
        ├── @ MultiWriteNode (location: (181...204))
        │   ├── targets: (length: 2)
        │   │   ├── @ CallNode (location: (181...188))
        │   │   │   ├── receiver:
        │   │   │   │   @ CallNode (location: (181...184))
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── message_loc: (181...184) = "foo"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   ├── block: ∅
        │   │   │   │   ├── flags: variable_call
        │   │   │   │   └── name: "foo"
        │   │   │   ├── call_operator_loc: (184...185) = "."
        │   │   │   ├── message_loc: (185...188) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: 
        │   │   │   └── name: "foo="
        │   │   └── @ CallNode (location: (190...197))
        │   │       ├── receiver:
        │   │       │   @ CallNode (location: (190...193))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (190...193) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "bar"
        │   │       ├── call_operator_loc: (193...194) = "."
        │   │       ├── message_loc: (194...197) = "bar"
        │   │       ├── opening_loc: ∅
        │   │       ├── arguments: ∅
        │   │       ├── closing_loc: ∅
        │   │       ├── block: ∅
        │   │       ├── flags: 
        │   │       └── name: "bar="
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (198...199) = "="
        │   └── value:
        │       @ ArrayNode (location: (200...204))
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (200...201))
        │       │   │   └── flags: decimal
        │       │   └── @ IntegerNode (location: (203...204))
        │       │       └── flags: decimal
        │       ├── opening_loc: ∅
        │       └── closing_loc: ∅
        ├── @ CallNode (location: (206...210))
        │   ├── receiver:
        │   │   @ CallNode (location: (206...207))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (206...207) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (207...209) = "&."
        │   ├── message_loc: (209...210) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: safe_navigation
        │   └── name: "b"
        ├── @ CallNode (location: (212...217))
        │   ├── receiver:
        │   │   @ CallNode (location: (212...213))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (212...213) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (213...215) = "&."
        │   ├── message_loc: ∅
        │   ├── opening_loc: (215...216) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (216...217) = ")"
        │   ├── block: ∅
        │   ├── flags: safe_navigation
        │   └── name: "call"
        ├── @ CallNode (location: (219...226))
        │   ├── receiver:
        │   │   @ CallNode (location: (219...220))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (219...220) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (220...222) = "&."
        │   ├── message_loc: (222...223) = "b"
        │   ├── opening_loc: (223...224) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (224...225))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (224...225))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (224...225) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "c"
        │   ├── closing_loc: (225...226) = ")"
        │   ├── block: ∅
        │   ├── flags: safe_navigation
        │   └── name: "b"
        ├── @ CallNode (location: (228...234))
        │   ├── receiver:
        │   │   @ CallNode (location: (228...229))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (228...229) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── call_operator_loc: (229...231) = "&."
        │   ├── message_loc: (231...232) = "b"
        │   ├── opening_loc: (232...233) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (233...234) = ")"
        │   ├── block: ∅
        │   ├── flags: safe_navigation
        │   └── name: "b"
        ├── @ IfNode (location: (236...269))
        │   ├── if_keyword_loc: (247...249) = "if"
        │   ├── predicate:
        │   │   @ AndNode (location: (250...269))
        │   │   ├── left:
        │   │   │   @ OrNode (location: (250...261))
        │   │   │   ├── left:
        │   │   │   │   @ CallNode (location: (250...254))
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── message_loc: (250...254) = "bar?"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   ├── block: ∅
        │   │   │   │   ├── flags: 
        │   │   │   │   └── name: "bar?"
        │   │   │   ├── right:
        │   │   │   │   @ CallNode (location: (258...261))
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── message_loc: (258...261) = "baz"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   ├── block: ∅
        │   │   │   │   ├── flags: variable_call
        │   │   │   │   └── name: "baz"
        │   │   │   └── operator_loc: (255...257) = "or"
        │   │   ├── right:
        │   │   │   @ CallNode (location: (266...269))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (266...269) = "qux"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "qux"
        │   │   └── operator_loc: (262...265) = "and"
        │   ├── statements:
        │   │   @ StatementsNode (location: (236...246))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (236...246))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (236...239) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (240...246))
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ SymbolNode (location: (240...242))
        │   │           │       │   ├── opening_loc: (240...241) = ":"
        │   │           │       │   ├── value_loc: (241...242) = "a"
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── unescaped: "a"
        │   │           │       └── @ SymbolNode (location: (244...246))
        │   │           │           ├── opening_loc: (244...245) = ":"
        │   │           │           ├── value_loc: (245...246) = "b"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── unescaped: "b"
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: 
        │   │           └── name: "foo"
        │   ├── consequent: ∅
        │   └── end_keyword_loc: ∅
        ├── @ CallNode (location: (271...286))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (271...274) = "foo"
        │   ├── opening_loc: (274...275) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (275...284))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (275...277))
        │   │       │   ├── opening_loc: (275...276) = ":"
        │   │       │   ├── value_loc: (276...277) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ SymbolNode (location: (282...284))
        │   │           ├── opening_loc: (282...283) = ":"
        │   │           ├── value_loc: (283...284) = "b"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "b"
        │   ├── closing_loc: (285...286) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (288...298))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (288...291) = "foo"
        │   ├── opening_loc: (291...292) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (292...297))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (292...297))
        │   │           ├── operator_loc: (292...293) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (293...297))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (293...297) = "rest"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "rest"
        │   ├── closing_loc: (297...298) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (300...340))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (300...303) = "foo"
        │   ├── opening_loc: (303...304) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (304...339))
        │   │   └── arguments: (length: 3)
        │   │       ├── @ SymbolNode (location: (304...306))
        │   │       │   ├── opening_loc: (304...305) = ":"
        │   │       │   ├── value_loc: (305...306) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       ├── @ KeywordHashNode (location: (308...332))
        │   │       │   └── elements: (length: 2)
        │   │       │       ├── @ AssocNode (location: (308...322))
        │   │       │       │   ├── key:
        │   │       │       │   │   @ SymbolNode (location: (308...310))
        │   │       │       │   │   ├── opening_loc: (308...309) = ":"
        │   │       │       │   │   ├── value_loc: (309...310) = "h"
        │   │       │       │   │   ├── closing_loc: ∅
        │   │       │       │   │   └── unescaped: "h"
        │   │       │       │   ├── value:
        │   │       │       │   │   @ ArrayNode (location: (314...322))
        │   │       │       │   │   ├── elements: (length: 2)
        │   │       │       │   │   │   ├── @ SymbolNode (location: (315...317))
        │   │       │       │   │   │   │   ├── opening_loc: (315...316) = ":"
        │   │       │       │   │   │   │   ├── value_loc: (316...317) = "x"
        │   │       │       │   │   │   │   ├── closing_loc: ∅
        │   │       │       │   │   │   │   └── unescaped: "x"
        │   │       │       │   │   │   └── @ SymbolNode (location: (319...321))
        │   │       │       │   │   │       ├── opening_loc: (319...320) = ":"
        │   │       │       │   │   │       ├── value_loc: (320...321) = "y"
        │   │       │       │   │   │       ├── closing_loc: ∅
        │   │       │       │   │   │       └── unescaped: "y"
        │   │       │       │   │   ├── opening_loc: (314...315) = "["
        │   │       │       │   │   └── closing_loc: (321...322) = "]"
        │   │       │       │   └── operator_loc: (311...313) = "=>"
        │   │       │       └── @ AssocNode (location: (324...332))
        │   │       │           ├── key:
        │   │       │           │   @ SymbolNode (location: (324...326))
        │   │       │           │   ├── opening_loc: (324...325) = ":"
        │   │       │           │   ├── value_loc: (325...326) = "a"
        │   │       │           │   ├── closing_loc: ∅
        │   │       │           │   └── unescaped: "a"
        │   │       │           ├── value:
        │   │       │           │   @ SymbolNode (location: (330...332))
        │   │       │           │   ├── opening_loc: (330...331) = ":"
        │   │       │           │   ├── value_loc: (331...332) = "b"
        │   │       │           │   ├── closing_loc: ∅
        │   │       │           │   └── unescaped: "b"
        │   │       │           └── operator_loc: (327...329) = "=>"
        │   │       └── @ BlockArgumentNode (location: (334...339))
        │   │           ├── expression:
        │   │           │   @ SymbolNode (location: (335...339))
        │   │           │   ├── opening_loc: (335...336) = ":"
        │   │           │   ├── value_loc: (336...339) = "bar"
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── unescaped: "bar"
        │   │           └── operator_loc: (334...335) = "&"
        │   ├── closing_loc: (339...340) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (342...391))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (342...344) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (345...391))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (345...348))
        │   │       │   └── flags: decimal
        │   │       └── @ HashNode (location: (350...391))
        │   │           ├── opening_loc: (350...351) = "{"
        │   │           ├── elements: (length: 3)
        │   │           │   ├── @ AssocNode (location: (352...369))
        │   │           │   │   ├── key:
        │   │           │   │   │   @ SymbolNode (location: (352...358))
        │   │           │   │   │   ├── opening_loc: (352...353) = ":"
        │   │           │   │   │   ├── value_loc: (353...358) = "there"
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── unescaped: "there"
        │   │           │   │   ├── value:
        │   │           │   │   │   @ SymbolNode (location: (362...369))
        │   │           │   │   │   ├── opening_loc: (362...363) = ":"
        │   │           │   │   │   ├── value_loc: (363...369) = "friend"
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── unescaped: "friend"
        │   │           │   │   └── operator_loc: (359...361) = "=>"
        │   │           │   ├── @ AssocSplatNode (location: (371...375))
        │   │           │   │   ├── value:
        │   │           │   │   │   @ HashNode (location: (373...375))
        │   │           │   │   │   ├── opening_loc: (373...374) = "{"
        │   │           │   │   │   ├── elements: (length: 0)
        │   │           │   │   │   └── closing_loc: (374...375) = "}"
        │   │           │   │   └── operator_loc: (371...373) = "**"
        │   │           │   └── @ AssocNode (location: (377...389))
        │   │           │       ├── key:
        │   │           │       │   @ SymbolNode (location: (377...384))
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── value_loc: (377...383) = "whatup"
        │   │           │       │   ├── closing_loc: (383...384) = ":"
        │   │           │       │   └── unescaped: "whatup"
        │   │           │       ├── value:
        │   │           │       │   @ SymbolNode (location: (385...389))
        │   │           │       │   ├── opening_loc: (385...386) = ":"
        │   │           │       │   ├── value_loc: (386...389) = "dog"
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── unescaped: "dog"
        │   │           │       └── operator_loc: ∅
        │   │           └── closing_loc: (390...391) = "}"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "hi"
        ├── @ CallNode (location: (393...429))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (393...396) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (397...408))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (397...399))
        │   │       │   ├── opening_loc: (397...398) = ":"
        │   │       │   ├── value_loc: (398...399) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ KeywordHashNode (location: (401...408))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (401...408))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (401...403))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (401...402) = "b"
        │   │                   │   ├── closing_loc: (402...403) = ":"
        │   │                   │   └── unescaped: "b"
        │   │                   ├── value:
        │   │                   │   @ TrueNode (location: (404...408))
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (409...429))
        │   │   ├── locals: [:a, :b]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (412...418))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (413...417))
        │   │   │   │   ├── requireds: (length: 2)
        │   │   │   │   │   ├── @ RequiredParameterNode (location: (413...414))
        │   │   │   │   │   │   └── name: :a
        │   │   │   │   │   └── @ RequiredParameterNode (location: (416...417))
        │   │   │   │   │       └── name: :b
        │   │   │   │   ├── optionals: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (412...413) = "|"
        │   │   │   └── closing_loc: (417...418) = "|"
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (419...425))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (419...425))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (419...423) = "puts"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (424...425))
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ LocalVariableReadNode (location: (424...425))
        │   │   │           │           ├── name: :a
        │   │   │           │           └── depth: 0
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: 
        │   │   │           └── name: "puts"
        │   │   ├── opening_loc: (409...411) = "do"
        │   │   └── closing_loc: (426...429) = "end"
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (431...448))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (431...433) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (434...448))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (434...448))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (434...448))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (434...440))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (434...439) = "there"
        │   │                   │   ├── closing_loc: (439...440) = ":"
        │   │                   │   └── unescaped: "there"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (441...448))
        │   │                   │   ├── opening_loc: (441...442) = ":"
        │   │                   │   ├── value_loc: (442...448) = "friend"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "friend"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "hi"
        ├── @ CallNode (location: (450...490))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (450...452) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (453...490))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (453...490))
        │   │           └── elements: (length: 3)
        │   │               ├── @ AssocNode (location: (453...470))
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (453...459))
        │   │               │   │   ├── opening_loc: (453...454) = ":"
        │   │               │   │   ├── value_loc: (454...459) = "there"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "there"
        │   │               │   ├── value:
        │   │               │   │   @ SymbolNode (location: (463...470))
        │   │               │   │   ├── opening_loc: (463...464) = ":"
        │   │               │   │   ├── value_loc: (464...470) = "friend"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "friend"
        │   │               │   └── operator_loc: (460...462) = "=>"
        │   │               ├── @ AssocSplatNode (location: (472...476))
        │   │               │   ├── value:
        │   │               │   │   @ HashNode (location: (474...476))
        │   │               │   │   ├── opening_loc: (474...475) = "{"
        │   │               │   │   ├── elements: (length: 0)
        │   │               │   │   └── closing_loc: (475...476) = "}"
        │   │               │   └── operator_loc: (472...474) = "**"
        │   │               └── @ AssocNode (location: (478...490))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (478...485))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (478...484) = "whatup"
        │   │                   │   ├── closing_loc: (484...485) = ":"
        │   │                   │   └── unescaped: "whatup"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (486...490))
        │   │                   │   ├── opening_loc: (486...487) = ":"
        │   │                   │   ├── value_loc: (487...490) = "dog"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "dog"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "hi"
        ├── @ CallNode (location: (492...533))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (492...494) = "hi"
        │   ├── opening_loc: (494...495) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (495...532))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (495...532))
        │   │           └── elements: (length: 3)
        │   │               ├── @ AssocNode (location: (495...512))
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (495...501))
        │   │               │   │   ├── opening_loc: (495...496) = ":"
        │   │               │   │   ├── value_loc: (496...501) = "there"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "there"
        │   │               │   ├── value:
        │   │               │   │   @ SymbolNode (location: (505...512))
        │   │               │   │   ├── opening_loc: (505...506) = ":"
        │   │               │   │   ├── value_loc: (506...512) = "friend"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "friend"
        │   │               │   └── operator_loc: (502...504) = "=>"
        │   │               ├── @ AssocSplatNode (location: (514...518))
        │   │               │   ├── value:
        │   │               │   │   @ HashNode (location: (516...518))
        │   │               │   │   ├── opening_loc: (516...517) = "{"
        │   │               │   │   ├── elements: (length: 0)
        │   │               │   │   └── closing_loc: (517...518) = "}"
        │   │               │   └── operator_loc: (514...516) = "**"
        │   │               └── @ AssocNode (location: (520...532))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (520...527))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (520...526) = "whatup"
        │   │                   │   ├── closing_loc: (526...527) = ":"
        │   │                   │   └── unescaped: "whatup"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (528...532))
        │   │                   │   ├── opening_loc: (528...529) = ":"
        │   │                   │   ├── value_loc: (529...532) = "dog"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "dog"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (532...533) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "hi"
        ├── @ CallNode (location: (535...571))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (535...538) = "foo"
        │   ├── opening_loc: (538...539) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (539...570))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ HashNode (location: (539...561))
        │   │       │   ├── opening_loc: (539...540) = "{"
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ AssocNode (location: (541...548))
        │   │       │   │   │   ├── key:
        │   │       │   │   │   │   @ SymbolNode (location: (541...543))
        │   │       │   │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   │   ├── value_loc: (541...542) = "a"
        │   │       │   │   │   │   ├── closing_loc: (542...543) = ":"
        │   │       │   │   │   │   └── unescaped: "a"
        │   │       │   │   │   ├── value:
        │   │       │   │   │   │   @ TrueNode (location: (544...548))
        │   │       │   │   │   └── operator_loc: ∅
        │   │       │   │   └── @ AssocNode (location: (550...558))
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (550...552))
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (550...551) = "b"
        │   │       │   │       │   ├── closing_loc: (551...552) = ":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ FalseNode (location: (553...558))
        │   │       │   │       └── operator_loc: ∅
        │   │       │   └── closing_loc: (560...561) = "}"
        │   │       └── @ BlockArgumentNode (location: (563...570))
        │   │           ├── expression:
        │   │           │   @ SymbolNode (location: (564...570))
        │   │           │   ├── opening_loc: (564...565) = ":"
        │   │           │   ├── value_loc: (565...570) = "block"
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── unescaped: "block"
        │   │           └── operator_loc: (563...564) = "&"
        │   ├── closing_loc: (570...571) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (573...593))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (573...575) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (576...593))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (576...593))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (576...593))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (576...582))
        │   │                   │   ├── opening_loc: (576...577) = ":"
        │   │                   │   ├── value_loc: (577...582) = "there"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "there"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (586...593))
        │   │                   │   ├── opening_loc: (586...587) = ":"
        │   │                   │   ├── value_loc: (587...593) = "friend"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "friend"
        │   │                   └── operator_loc: (583...585) = "=>"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "hi"
        ├── @ CallNode (location: (595...608))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (595...598) = "foo"
        │   ├── opening_loc: (598...599) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (599...605))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (599...601))
        │   │       │   ├── opening_loc: (599...600) = ":"
        │   │       │   ├── value_loc: (600...601) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ SymbolNode (location: (603...605))
        │   │           ├── opening_loc: (603...604) = ":"
        │   │           ├── value_loc: (604...605) = "b"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "b"
        │   ├── closing_loc: (607...608) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (610...627))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (610...613) = "foo"
        │   ├── opening_loc: (613...614) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (615...624))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (615...617))
        │   │       │   ├── opening_loc: (615...616) = ":"
        │   │       │   ├── value_loc: (616...617) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ KeywordHashNode (location: (619...624))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (619...624))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (619...621))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (619...620) = "b"
        │   │                   │   ├── closing_loc: (620...621) = ":"
        │   │                   │   └── unescaped: "b"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (622...624))
        │   │                   │   ├── opening_loc: (622...623) = ":"
        │   │                   │   ├── value_loc: (623...624) = "c"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "c"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (626...627) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (629...640))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (629...632) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (633...640))
        │   │   └── arguments: (length: 1)
        │   │       └── @ BlockArgumentNode (location: (633...640))
        │   │           ├── expression:
        │   │           │   @ SymbolNode (location: (634...640))
        │   │           │   ├── opening_loc: (634...635) = ":"
        │   │           │   ├── value_loc: (635...640) = "block"
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── unescaped: "block"
        │   │           └── operator_loc: (633...634) = "&"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (642...672))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (642...645) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (646...672))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ KeywordHashNode (location: (646...663))
        │   │       │   └── elements: (length: 2)
        │   │       │       ├── @ AssocNode (location: (646...653))
        │   │       │       │   ├── key:
        │   │       │       │   │   @ SymbolNode (location: (646...648))
        │   │       │       │   │   ├── opening_loc: ∅
        │   │       │       │   │   ├── value_loc: (646...647) = "a"
        │   │       │       │   │   ├── closing_loc: (647...648) = ":"
        │   │       │       │   │   └── unescaped: "a"
        │   │       │       │   ├── value:
        │   │       │       │   │   @ TrueNode (location: (649...653))
        │   │       │       │   └── operator_loc: ∅
        │   │       │       └── @ AssocNode (location: (655...663))
        │   │       │           ├── key:
        │   │       │           │   @ SymbolNode (location: (655...657))
        │   │       │           │   ├── opening_loc: ∅
        │   │       │           │   ├── value_loc: (655...656) = "b"
        │   │       │           │   ├── closing_loc: (656...657) = ":"
        │   │       │           │   └── unescaped: "b"
        │   │       │           ├── value:
        │   │       │           │   @ FalseNode (location: (658...663))
        │   │       │           └── operator_loc: ∅
        │   │       └── @ BlockArgumentNode (location: (665...672))
        │   │           ├── expression:
        │   │           │   @ SymbolNode (location: (666...672))
        │   │           │   ├── opening_loc: (666...667) = ":"
        │   │           │   ├── value_loc: (667...672) = "block"
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── unescaped: "block"
        │   │           └── operator_loc: (665...666) = "&"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (674...695))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (674...683) = "some_func"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (684...695))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (684...685))
        │   │       │   └── flags: decimal
        │   │       └── @ KeywordHashNode (location: (687...695))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (687...695))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (687...693))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (687...692) = "kwarg"
        │   │                   │   ├── closing_loc: (692...693) = ":"
        │   │                   │   └── unescaped: "kwarg"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (694...695))
        │   │                   │   └── flags: decimal
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "some_func"
        ├── @ CallNode (location: (697...715))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (697...703))
        │   │   └── name: :Kernel
        │   ├── call_operator_loc: (703...704) = "."
        │   ├── message_loc: (704...711) = "Integer"
        │   ├── opening_loc: (711...712) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (712...714))
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (712...714))
        │   │           └── flags: decimal
        │   ├── closing_loc: (714...715) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "Integer"
        ├── @ CallNode (location: (717...727))
        │   ├── receiver:
        │   │   @ CallNode (location: (717...718))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (717...718) = "x"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "x"
        │   ├── call_operator_loc: (718...719) = "."
        │   ├── message_loc: (719...723) = "each"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (724...727))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (724...725) = "{"
        │   │   └── closing_loc: (726...727) = "}"
        │   ├── flags: 
        │   └── name: "each"
        ├── @ CallNode (location: (729...743))
        │   ├── receiver:
        │   │   @ CallNode (location: (729...732))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (729...732) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: (732...733) = "."
        │   ├── message_loc: (733...736) = "map"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (737...743))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (739...741))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ BackReferenceReadNode (location: (739...741))
        │   │   ├── opening_loc: (737...738) = "{"
        │   │   └── closing_loc: (742...743) = "}"
        │   ├── flags: 
        │   └── name: "map"
        ├── @ CallNode (location: (745...757))
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (745...749))
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (745...746))
        │   │   │   └── name: :A
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (748...749))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (746...748) = "::"
        │   ├── call_operator_loc: (749...751) = "::"
        │   ├── message_loc: (751...752) = "C"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (753...757))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (753...757))
        │   │           ├── opening_loc: (753...754) = ":"
        │   │           ├── value_loc: (754...757) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "C"
        ├── @ CallNode (location: (759...772))
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (759...763))
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (759...760))
        │   │   │   └── name: :A
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (762...763))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (760...762) = "::"
        │   ├── call_operator_loc: (763...765) = "::"
        │   ├── message_loc: (765...766) = "C"
        │   ├── opening_loc: (766...767) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (767...771))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (767...771))
        │   │           ├── opening_loc: (767...768) = ":"
        │   │           ├── value_loc: (768...771) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: (771...772) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "C"
        ├── @ CallNode (location: (774...791))
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (774...778))
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (774...775))
        │   │   │   └── name: :A
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (777...778))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (775...777) = "::"
        │   ├── call_operator_loc: (778...780) = "::"
        │   ├── message_loc: (780...781) = "C"
        │   ├── opening_loc: (781...782) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (782...786))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (782...786))
        │   │           ├── opening_loc: (782...783) = ":"
        │   │           ├── value_loc: (783...786) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: (786...787) = ")"
        │   ├── block:
        │   │   @ BlockNode (location: (788...791))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (788...789) = "{"
        │   │   └── closing_loc: (790...791) = "}"
        │   ├── flags: 
        │   └── name: "C"
        ├── @ CallNode (location: (793...805))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (793...796) = "foo"
        │   ├── opening_loc: (796...797) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (797...804))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (797...804))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (797...804))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (797...801))
        │   │                   │   ├── opening_loc: (797...798) = "\""
        │   │                   │   ├── value_loc: (798...799) = "a"
        │   │                   │   ├── closing_loc: (799...801) = "\":"
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (802...804))
        │   │                   │   └── flags: decimal
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (804...805) = ")"
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (807...835))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (807...810) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (811...835))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (811...835))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (811...835))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (811...815))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (811...814) = "bar"
        │   │                   │   ├── closing_loc: (814...815) = ":"
        │   │                   │   └── unescaped: "bar"
        │   │                   ├── value:
        │   │                   │   @ HashNode (location: (816...835))
        │   │                   │   ├── opening_loc: (816...817) = "{"
        │   │                   │   ├── elements: (length: 1)
        │   │                   │   │   └── @ AssocNode (location: (818...833))
        │   │                   │   │       ├── key:
        │   │                   │   │       │   @ SymbolNode (location: (818...822))
        │   │                   │   │       │   ├── opening_loc: ∅
        │   │                   │   │       │   ├── value_loc: (818...821) = "baz"
        │   │                   │   │       │   ├── closing_loc: (821...822) = ":"
        │   │                   │   │       │   └── unescaped: "baz"
        │   │                   │   │       ├── value:
        │   │                   │   │       │   @ CallNode (location: (823...833))
        │   │                   │   │       │   ├── receiver: ∅
        │   │                   │   │       │   ├── call_operator_loc: ∅
        │   │                   │   │       │   ├── message_loc: (823...826) = "qux"
        │   │                   │   │       │   ├── opening_loc: ∅
        │   │                   │   │       │   ├── arguments: ∅
        │   │                   │   │       │   ├── closing_loc: ∅
        │   │                   │   │       │   ├── block:
        │   │                   │   │       │   │   @ BlockNode (location: (827...833))
        │   │                   │   │       │   │   ├── locals: []
        │   │                   │   │       │   │   ├── parameters: ∅
        │   │                   │   │       │   │   ├── body: ∅
        │   │                   │   │       │   │   ├── opening_loc: (827...829) = "do"
        │   │                   │   │       │   │   └── closing_loc: (830...833) = "end"
        │   │                   │   │       │   ├── flags: 
        │   │                   │   │       │   └── name: "qux"
        │   │                   │   │       └── operator_loc: ∅
        │   │                   │   └── closing_loc: (834...835) = "}"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (837...861))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (837...840) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (841...861))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (841...861))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (841...861))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (841...845))
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (841...844) = "bar"
        │   │                   │   ├── closing_loc: (844...845) = ":"
        │   │                   │   └── unescaped: "bar"
        │   │                   ├── value:
        │   │                   │   @ HashNode (location: (846...861))
        │   │                   │   ├── opening_loc: (846...847) = "{"
        │   │                   │   ├── elements: (length: 1)
        │   │                   │   │   └── @ AssocSplatNode (location: (848...859))
        │   │                   │   │       ├── value:
        │   │                   │   │       │   @ CallNode (location: (850...859))
        │   │                   │   │       │   ├── receiver: ∅
        │   │                   │   │       │   ├── call_operator_loc: ∅
        │   │                   │   │       │   ├── message_loc: (850...852) = "kw"
        │   │                   │   │       │   ├── opening_loc: ∅
        │   │                   │   │       │   ├── arguments: ∅
        │   │                   │   │       │   ├── closing_loc: ∅
        │   │                   │   │       │   ├── block:
        │   │                   │   │       │   │   @ BlockNode (location: (853...859))
        │   │                   │   │       │   │   ├── locals: []
        │   │                   │   │       │   │   ├── parameters: ∅
        │   │                   │   │       │   │   ├── body: ∅
        │   │                   │   │       │   │   ├── opening_loc: (853...855) = "do"
        │   │                   │   │       │   │   └── closing_loc: (856...859) = "end"
        │   │                   │   │       │   ├── flags: 
        │   │                   │   │       │   └── name: "kw"
        │   │                   │   │       └── operator_loc: (848...850) = "**"
        │   │                   │   └── closing_loc: (860...861) = "}"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (863...899))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (863...866) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (867...892))
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (867...892))
        │   │           ├── opening_loc: (867...868) = "\""
        │   │           ├── parts: (length: 1)
        │   │           │   └── @ EmbeddedStatementsNode (location: (868...891))
        │   │           │       ├── opening_loc: (868...870) = "\#{"
        │   │           │       ├── statements:
        │   │           │       │   @ StatementsNode (location: (870...890))
        │   │           │       │   └── body: (length: 1)
        │   │           │       │       └── @ CallNode (location: (870...890))
        │   │           │       │           ├── receiver:
        │   │           │       │           │   @ CallNode (location: (870...873))
        │   │           │       │           │   ├── receiver: ∅
        │   │           │       │           │   ├── call_operator_loc: ∅
        │   │           │       │           │   ├── message_loc: (870...873) = "bar"
        │   │           │       │           │   ├── opening_loc: ∅
        │   │           │       │           │   ├── arguments: ∅
        │   │           │       │           │   ├── closing_loc: ∅
        │   │           │       │           │   ├── block: ∅
        │   │           │       │           │   ├── flags: variable_call
        │   │           │       │           │   └── name: "bar"
        │   │           │       │           ├── call_operator_loc: (873...874) = "."
        │   │           │       │           ├── message_loc: (874...877) = "map"
        │   │           │       │           ├── opening_loc: ∅
        │   │           │       │           ├── arguments: ∅
        │   │           │       │           ├── closing_loc: ∅
        │   │           │       │           ├── block:
        │   │           │       │           │   @ BlockNode (location: (878...890))
        │   │           │       │           │   ├── locals: []
        │   │           │       │           │   ├── parameters: ∅
        │   │           │       │           │   ├── body:
        │   │           │       │           │   │   @ StatementsNode (location: (881...886))
        │   │           │       │           │   │   └── body: (length: 1)
        │   │           │       │           │   │       └── @ StringNode (location: (881...886))
        │   │           │       │           │   │           ├── opening_loc: (881...882) = "\""
        │   │           │       │           │   │           ├── content_loc: (882...885) = "baz"
        │   │           │       │           │   │           ├── closing_loc: (885...886) = "\""
        │   │           │       │           │   │           └── unescaped: "baz"
        │   │           │       │           │   ├── opening_loc: (878...880) = "do"
        │   │           │       │           │   └── closing_loc: (887...890) = "end"
        │   │           │       │           ├── flags: 
        │   │           │       │           └── name: "map"
        │   │           │       └── closing_loc: (890...891) = "}"
        │   │           └── closing_loc: (891...892) = "\""
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (893...899))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (893...895) = "do"
        │   │   └── closing_loc: (896...899) = "end"
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (901...929))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (901...904) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (905...929))
        │   │   └── arguments: (length: 1)
        │   │       └── @ ClassNode (location: (905...929))
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (905...910) = "class"
        │   │           ├── constant_path:
        │   │           │   @ ConstantReadNode (location: (911...914))
        │   │           │   └── name: :Bar
        │   │           ├── inheritance_operator_loc: ∅
        │   │           ├── superclass: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (915...925))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (915...925))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (915...918) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block:
        │   │           │           │   @ BlockNode (location: (919...925))
        │   │           │           │   ├── locals: []
        │   │           │           │   ├── parameters: ∅
        │   │           │           │   ├── body: ∅
        │   │           │           │   ├── opening_loc: (919...921) = "do"
        │   │           │           │   └── closing_loc: (922...925) = "end"
        │   │           │           ├── flags: 
        │   │           │           └── name: "baz"
        │   │           ├── end_keyword_loc: (926...929) = "end"
        │   │           └── name: :Bar
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (931...960))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (931...934) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (935...960))
        │   │   └── arguments: (length: 1)
        │   │       └── @ ModuleNode (location: (935...960))
        │   │           ├── locals: []
        │   │           ├── module_keyword_loc: (935...941) = "module"
        │   │           ├── constant_path:
        │   │           │   @ ConstantReadNode (location: (942...945))
        │   │           │   └── name: :Bar
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (946...956))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (946...956))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (946...949) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block:
        │   │           │           │   @ BlockNode (location: (950...956))
        │   │           │           │   ├── locals: []
        │   │           │           │   ├── parameters: ∅
        │   │           │           │   ├── body: ∅
        │   │           │           │   ├── opening_loc: (950...952) = "do"
        │   │           │           │   └── closing_loc: (953...956) = "end"
        │   │           │           ├── flags: 
        │   │           │           └── name: "baz"
        │   │           ├── end_keyword_loc: (957...960) = "end"
        │   │           └── name: :Bar
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (962...978))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (962...965) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (966...978))
        │   │   └── arguments: (length: 1)
        │   │       └── @ ArrayNode (location: (966...978))
        │   │           ├── elements: (length: 1)
        │   │           │   └── @ CallNode (location: (967...977))
        │   │           │       ├── receiver: ∅
        │   │           │       ├── call_operator_loc: ∅
        │   │           │       ├── message_loc: (967...970) = "baz"
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── arguments: ∅
        │   │           │       ├── closing_loc: ∅
        │   │           │       ├── block:
        │   │           │       │   @ BlockNode (location: (971...977))
        │   │           │       │   ├── locals: []
        │   │           │       │   ├── parameters: ∅
        │   │           │       │   ├── body: ∅
        │   │           │       │   ├── opening_loc: (971...973) = "do"
        │   │           │       │   └── closing_loc: (974...977) = "end"
        │   │           │       ├── flags: 
        │   │           │       └── name: "baz"
        │   │           ├── opening_loc: (966...967) = "["
        │   │           └── closing_loc: (977...978) = "]"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (980...1008))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (980...981) = "p"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (982...1008))
        │   │   └── arguments: (length: 1)
        │   │       └── @ BeginNode (location: (982...1008))
        │   │           ├── begin_keyword_loc: (982...987) = "begin"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (988...1004))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (988...1004))
        │   │           │           ├── receiver:
        │   │           │           │   @ IntegerNode (location: (988...989))
        │   │           │           │   └── flags: decimal
        │   │           │           ├── call_operator_loc: (989...990) = "."
        │   │           │           ├── message_loc: (990...995) = "times"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block:
        │   │           │           │   @ BlockNode (location: (996...1004))
        │   │           │           │   ├── locals: []
        │   │           │           │   ├── parameters: ∅
        │   │           │           │   ├── body:
        │   │           │           │   │   @ StatementsNode (location: (999...1000))
        │   │           │           │   │   └── body: (length: 1)
        │   │           │           │   │       └── @ IntegerNode (location: (999...1000))
        │   │           │           │   │           └── flags: decimal
        │   │           │           │   ├── opening_loc: (996...998) = "do"
        │   │           │           │   └── closing_loc: (1001...1004) = "end"
        │   │           │           ├── flags: 
        │   │           │           └── name: "times"
        │   │           ├── rescue_clause: ∅
        │   │           ├── else_clause: ∅
        │   │           ├── ensure_clause: ∅
        │   │           └── end_keyword_loc: (1005...1008) = "end"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "p"
        ├── @ CallNode (location: (1010...1061))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (1010...1013) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1014...1061))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (1014...1016))
        │   │       │   ├── opening_loc: (1014...1015) = ":"
        │   │       │   ├── value_loc: (1015...1016) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ IfNode (location: (1020...1061))
        │   │           ├── if_keyword_loc: (1020...1022) = "if"
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (1023...1024))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (1023...1024) = "x"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "x"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (1029...1055))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (1029...1055))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (1029...1032) = "bar"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block:
        │   │           │           │   @ BlockNode (location: (1033...1055))
        │   │           │           │   ├── locals: [:a]
        │   │           │           │   ├── parameters:
        │   │           │           │   │   @ BlockParametersNode (location: (1036...1039))
        │   │           │           │   │   ├── parameters:
        │   │           │           │   │   │   @ ParametersNode (location: (1037...1038))
        │   │           │           │   │   │   ├── requireds: (length: 1)
        │   │           │           │   │   │   │   └── @ RequiredParameterNode (location: (1037...1038))
        │   │           │           │   │   │   │       └── name: :a
        │   │           │           │   │   │   ├── optionals: (length: 0)
        │   │           │           │   │   │   ├── rest: ∅
        │   │           │           │   │   │   ├── posts: (length: 0)
        │   │           │           │   │   │   ├── keywords: (length: 0)
        │   │           │           │   │   │   ├── keyword_rest: ∅
        │   │           │           │   │   │   └── block: ∅
        │   │           │           │   │   ├── locals: (length: 0)
        │   │           │           │   │   ├── opening_loc: (1036...1037) = "|"
        │   │           │           │   │   └── closing_loc: (1038...1039) = "|"
        │   │           │           │   ├── body:
        │   │           │           │   │   @ StatementsNode (location: (1046...1047))
        │   │           │           │   │   └── body: (length: 1)
        │   │           │           │   │       └── @ LocalVariableReadNode (location: (1046...1047))
        │   │           │           │   │           ├── name: :a
        │   │           │           │   │           └── depth: 0
        │   │           │           │   ├── opening_loc: (1033...1035) = "do"
        │   │           │           │   └── closing_loc: (1052...1055) = "end"
        │   │           │           ├── flags: 
        │   │           │           └── name: "bar"
        │   │           ├── consequent: ∅
        │   │           └── end_keyword_loc: (1058...1061) = "end"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (1063...1153))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (1063...1066) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1067...1153))
        │   │   └── arguments: (length: 3)
        │   │       ├── @ SymbolNode (location: (1067...1069))
        │   │       │   ├── opening_loc: (1067...1068) = ":"
        │   │       │   ├── value_loc: (1068...1069) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       ├── @ WhileNode (location: (1073...1117))
        │   │       │   ├── keyword_loc: (1073...1078) = "while"
        │   │       │   ├── closing_loc: (1114...1117) = "end"
        │   │       │   ├── predicate:
        │   │       │   │   @ CallNode (location: (1079...1080))
        │   │       │   │   ├── receiver: ∅
        │   │       │   │   ├── call_operator_loc: ∅
        │   │       │   │   ├── message_loc: (1079...1080) = "x"
        │   │       │   │   ├── opening_loc: ∅
        │   │       │   │   ├── arguments: ∅
        │   │       │   │   ├── closing_loc: ∅
        │   │       │   │   ├── block: ∅
        │   │       │   │   ├── flags: variable_call
        │   │       │   │   └── name: "x"
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (1085...1111))
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ CallNode (location: (1085...1111))
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── message_loc: (1085...1088) = "bar"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           ├── block:
        │   │       │   │           │   @ BlockNode (location: (1089...1111))
        │   │       │   │           │   ├── locals: [:a]
        │   │       │   │           │   ├── parameters:
        │   │       │   │           │   │   @ BlockParametersNode (location: (1092...1095))
        │   │       │   │           │   │   ├── parameters:
        │   │       │   │           │   │   │   @ ParametersNode (location: (1093...1094))
        │   │       │   │           │   │   │   ├── requireds: (length: 1)
        │   │       │   │           │   │   │   │   └── @ RequiredParameterNode (location: (1093...1094))
        │   │       │   │           │   │   │   │       └── name: :a
        │   │       │   │           │   │   │   ├── optionals: (length: 0)
        │   │       │   │           │   │   │   ├── rest: ∅
        │   │       │   │           │   │   │   ├── posts: (length: 0)
        │   │       │   │           │   │   │   ├── keywords: (length: 0)
        │   │       │   │           │   │   │   ├── keyword_rest: ∅
        │   │       │   │           │   │   │   └── block: ∅
        │   │       │   │           │   │   ├── locals: (length: 0)
        │   │       │   │           │   │   ├── opening_loc: (1092...1093) = "|"
        │   │       │   │           │   │   └── closing_loc: (1094...1095) = "|"
        │   │       │   │           │   ├── body:
        │   │       │   │           │   │   @ StatementsNode (location: (1102...1103))
        │   │       │   │           │   │   └── body: (length: 1)
        │   │       │   │           │   │       └── @ LocalVariableReadNode (location: (1102...1103))
        │   │       │   │           │   │           ├── name: :a
        │   │       │   │           │   │           └── depth: 0
        │   │       │   │           │   ├── opening_loc: (1089...1091) = "do"
        │   │       │   │           │   └── closing_loc: (1108...1111) = "end"
        │   │       │   │           ├── flags: 
        │   │       │   │           └── name: "bar"
        │   │       │   └── flags: 
        │   │       └── @ UntilNode (location: (1121...1153))
        │   │           ├── keyword_loc: (1121...1126) = "until"
        │   │           ├── closing_loc: (1150...1153) = "end"
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (1127...1128))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (1127...1128) = "x"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "x"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (1133...1147))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (1133...1147))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (1133...1136) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block:
        │   │           │           │   @ BlockNode (location: (1137...1147))
        │   │           │           │   ├── locals: []
        │   │           │           │   ├── parameters: ∅
        │   │           │           │   ├── body: ∅
        │   │           │           │   ├── opening_loc: (1137...1139) = "do"
        │   │           │           │   └── closing_loc: (1144...1147) = "end"
        │   │           │           ├── flags: 
        │   │           │           └── name: "baz"
        │   │           └── flags: 
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "foo"
        ├── @ CallNode (location: (1155...1164))
        │   ├── receiver:
        │   │   @ HashNode (location: (1155...1157))
        │   │   ├── opening_loc: (1155...1156) = "{"
        │   │   ├── elements: (length: 0)
        │   │   └── closing_loc: (1156...1157) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (1158...1159) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1160...1164))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (1160...1164))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (1160...1161) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block:
        │   │           │   @ BlockNode (location: (1162...1164))
        │   │           │   ├── locals: []
        │   │           │   ├── parameters: ∅
        │   │           │   ├── body: ∅
        │   │           │   ├── opening_loc: (1162...1163) = "{"
        │   │           │   └── closing_loc: (1163...1164) = "}"
        │   │           ├── flags: 
        │   │           └── name: "A"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "+"
        ├── @ CallNode (location: (1166...1182))
        │   ├── receiver:
        │   │   @ HashNode (location: (1166...1168))
        │   │   ├── opening_loc: (1166...1167) = "{"
        │   │   ├── elements: (length: 0)
        │   │   └── closing_loc: (1167...1168) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (1169...1170) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1171...1182))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (1171...1182))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (1171...1172) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block:
        │   │           │   @ BlockNode (location: (1173...1182))
        │   │           │   ├── locals: [:a]
        │   │           │   ├── parameters:
        │   │           │   │   @ BlockParametersNode (location: (1175...1178))
        │   │           │   │   ├── parameters:
        │   │           │   │   │   @ ParametersNode (location: (1176...1177))
        │   │           │   │   │   ├── requireds: (length: 1)
        │   │           │   │   │   │   └── @ RequiredParameterNode (location: (1176...1177))
        │   │           │   │   │   │       └── name: :a
        │   │           │   │   │   ├── optionals: (length: 0)
        │   │           │   │   │   ├── rest: ∅
        │   │           │   │   │   ├── posts: (length: 0)
        │   │           │   │   │   ├── keywords: (length: 0)
        │   │           │   │   │   ├── keyword_rest: ∅
        │   │           │   │   │   └── block: ∅
        │   │           │   │   ├── locals: (length: 0)
        │   │           │   │   ├── opening_loc: (1175...1176) = "|"
        │   │           │   │   └── closing_loc: (1177...1178) = "|"
        │   │           │   ├── body:
        │   │           │   │   @ StatementsNode (location: (1179...1180))
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ LocalVariableReadNode (location: (1179...1180))
        │   │           │   │           ├── name: :a
        │   │           │   │           └── depth: 0
        │   │           │   ├── opening_loc: (1173...1174) = "{"
        │   │           │   └── closing_loc: (1181...1182) = "}"
        │   │           ├── flags: 
        │   │           └── name: "A"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "+"
        ├── @ CallNode (location: (1184...1195))
        │   ├── receiver:
        │   │   @ CallNode (location: (1184...1188))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1184...1185) = "A"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block:
        │   │   │   @ BlockNode (location: (1186...1188))
        │   │   │   ├── locals: []
        │   │   │   ├── parameters: ∅
        │   │   │   ├── body: ∅
        │   │   │   ├── opening_loc: (1186...1187) = "{"
        │   │   │   └── closing_loc: (1187...1188) = "}"
        │   │   ├── flags: 
        │   │   └── name: "A"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (1189...1190) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1191...1195))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (1191...1195))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (1191...1192) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block:
        │   │           │   @ BlockNode (location: (1193...1195))
        │   │           │   ├── locals: []
        │   │           │   ├── parameters: ∅
        │   │           │   ├── body: ∅
        │   │           │   ├── opening_loc: (1193...1194) = "{"
        │   │           │   └── closing_loc: (1194...1195) = "}"
        │   │           ├── flags: 
        │   │           └── name: "A"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "+"
        ├── @ CallNode (location: (1197...1208))
        │   ├── receiver:
        │   │   @ CallNode (location: (1197...1200))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (1197...1200) = "lst"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "lst"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (1201...1203) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1204...1208))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (1204...1208))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (1204...1205) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block:
        │   │           │   @ BlockNode (location: (1206...1208))
        │   │           │   ├── locals: []
        │   │           │   ├── parameters: ∅
        │   │           │   ├── body: ∅
        │   │           │   ├── opening_loc: (1206...1207) = "{"
        │   │           │   └── closing_loc: (1207...1208) = "}"
        │   │           ├── flags: 
        │   │           └── name: "A"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: 
        │   └── name: "<<"
        ├── @ InterpolatedStringNode (location: (1210...1227))
        │   ├── opening_loc: (1210...1211) = "\""
        │   ├── parts: (length: 1)
        │   │   └── @ EmbeddedStatementsNode (location: (1211...1226))
        │   │       ├── opening_loc: (1211...1213) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (1214...1224))
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (1214...1224))
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── message_loc: (1214...1218) = "join"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments:
        │   │       │           │   @ ArgumentsNode (location: (1219...1224))
        │   │       │           │   └── arguments: (length: 1)
        │   │       │           │       └── @ ParenthesesNode (location: (1219...1224))
        │   │       │           │           ├── body:
        │   │       │           │           │   @ StatementsNode (location: (1220...1223))
        │   │       │           │           │   └── body: (length: 1)
        │   │       │           │           │       └── @ StringNode (location: (1220...1223))
        │   │       │           │           │           ├── opening_loc: (1220...1221) = "\""
        │   │       │           │           │           ├── content_loc: (1221...1222) = " "
        │   │       │           │           │           ├── closing_loc: (1222...1223) = "\""
        │   │       │           │           │           └── unescaped: " "
        │   │       │           │           ├── opening_loc: (1219...1220) = "("
        │   │       │           │           └── closing_loc: (1223...1224) = ")"
        │   │       │           ├── closing_loc: ∅
        │   │       │           ├── block: ∅
        │   │       │           ├── flags: 
        │   │       │           └── name: "join"
        │   │       └── closing_loc: (1225...1226) = "}"
        │   └── closing_loc: (1226...1227) = "\""
        └── @ InterpolatedStringNode (location: (1229...1237))
            ├── opening_loc: (1229...1230) = "\""
            ├── parts: (length: 1)
            │   └── @ EmbeddedStatementsNode (location: (1230...1236))
            │       ├── opening_loc: (1230...1232) = "\#{"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1232...1235))
            │       │   └── body: (length: 1)
            │       │       └── @ ParenthesesNode (location: (1232...1235))
            │       │           ├── body:
            │       │           │   @ StatementsNode (location: (1233...1234))
            │       │           │   └── body: (length: 1)
            │       │           │       └── @ CallNode (location: (1233...1234))
            │       │           │           ├── receiver: ∅
            │       │           │           ├── call_operator_loc: ∅
            │       │           │           ├── message_loc: (1233...1234) = "v"
            │       │           │           ├── opening_loc: ∅
            │       │           │           ├── arguments: ∅
            │       │           │           ├── closing_loc: ∅
            │       │           │           ├── block: ∅
            │       │           │           ├── flags: variable_call
            │       │           │           └── name: "v"
            │       │           ├── opening_loc: (1232...1233) = "("
            │       │           └── closing_loc: (1234...1235) = ")"
            │       └── closing_loc: (1235...1236) = "}"
            └── closing_loc: (1236...1237) = "\""