method_calls.txt

@ ProgramNode (location: (1,0)-(149,18))
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(149,18))
    └── body: (length: 63)
        ├── @ CallNode (location: (1,0)-(1,14))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (1,4)-(1,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,8)-(1,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,8)-(1,14))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,8)-(1,10) = "%{"
        │   │           ├── content_loc: (1,10)-(1,13) = "baz"
        │   │           ├── closing_loc: (1,13)-(1,14) = "}"
        │   │           └── unescaped: "baz"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,9))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (3,0)-(3,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (3,1)-(3,2) = "."
        │   ├── name: :b
        │   ├── message_loc: (3,2)-(3,3) = "b"
        │   ├── opening_loc: (3,3)-(3,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,4)-(3,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (3,4)-(3,5))
        │   │       │   ├── flags: variable_call
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :c
        │   │       │   ├── message_loc: (3,4)-(3,5) = "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (3,7)-(3,8))
        │   │           ├── flags: variable_call
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :d
        │   │           ├── message_loc: (3,7)-(3,8) = "d"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (3,8)-(3,9) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,5))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (5,0)-(5,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (5,0)-(5,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (5,1)-(5,2) = "."
        │   ├── name: :b
        │   ├── message_loc: (5,2)-(5,3) = "b"
        │   ├── opening_loc: (5,3)-(5,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (5,4)-(5,5) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (7,0)-(9,7))
        │   ├── flags: safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (7,0)-(8,6))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (7,0)-(7,3))
        │   │   │   ├── flags: variable_call
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (7,0)-(7,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (8,2)-(8,3) = "."
        │   │   ├── name: :bar
        │   │   ├── message_loc: (8,3)-(8,6) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (9,2)-(9,4) = "&."
        │   ├── name: :baz
        │   ├── message_loc: (9,4)-(9,7) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (11,0)-(11,2))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a!
        │   ├── message_loc: (11,0)-(11,2) = "a!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (13,0)-(13,4))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (13,0)-(13,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (13,0)-(13,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (13,1)-(13,2) = "."
        │   ├── name: :call
        │   ├── message_loc: ∅
        │   ├── opening_loc: (13,2)-(13,3) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (13,3)-(13,4) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (15,0)-(15,11))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (15,0)-(15,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (15,0)-(15,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (15,1)-(15,2) = "."
        │   ├── name: :call
        │   ├── message_loc: ∅
        │   ├── opening_loc: (15,2)-(15,3) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,3)-(15,10))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ IntegerNode (location: (15,3)-(15,4))
        │   │       │   └── flags: decimal
        │   │       ├── @ IntegerNode (location: (15,6)-(15,7))
        │   │       │   └── flags: decimal
        │   │       └── @ IntegerNode (location: (15,9)-(15,10))
        │   │           └── flags: decimal
        │   ├── closing_loc: (15,10)-(15,11) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (17,0)-(17,4))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (17,0)-(17,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (17,0)-(17,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (17,1)-(17,3) = "::"
        │   ├── name: :b
        │   ├── message_loc: (17,3)-(17,4) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (19,0)-(19,6))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (19,0)-(19,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (19,0)-(19,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (19,1)-(19,3) = "::"
        │   ├── name: :b
        │   ├── message_loc: (19,3)-(19,4) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (19,5)-(19,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (19,5)-(19,6))
        │   │           ├── flags: variable_call
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :c
        │   │           ├── message_loc: (19,5)-(19,6) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (21,0)-(21,11))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ CallNode (location: (21,0)-(21,3))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (21,0)-(21,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (21,3)-(21,4) = "."
        │   ├── name: :bar=
        │   ├── message_loc: (21,4)-(21,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (21,10)-(21,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (21,10)-(21,11))
        │   │           └── flags: decimal
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (23,0)-(23,2))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a?
        │   ├── message_loc: (23,0)-(23,2) = "a?"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (25,0)-(25,8))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (25,0)-(25,1) = "a"
        │   ├── opening_loc: (25,1)-(25,2) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (25,8)-(25,9) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (25,2)-(25,8))
        │       ├── expression:
        │       │   @ CallNode (location: (25,3)-(25,8))
        │       │   ├── flags: variable_call
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :block
        │       │   ├── message_loc: (25,3)-(25,8) = "block"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (25,2)-(25,3) = "&"
        ├── @ CallNode (location: (27,0)-(27,11))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (27,0)-(27,1) = "a"
        │   ├── opening_loc: (27,1)-(27,2) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,2)-(27,10))
        │   │   ├── flags: contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (27,2)-(27,10))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (27,2)-(27,10))
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (27,4)-(27,10))
        │   │                   │   ├── flags: variable_call
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :kwargs
        │   │                   │   ├── message_loc: (27,4)-(27,10) = "kwargs"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: (27,2)-(27,4) = "**"
        │   ├── closing_loc: (27,10)-(27,11) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,5))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (29,0)-(29,3))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (29,0)-(29,1))
        │   │   │   ├── flags: variable_call
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── message_loc: (29,0)-(29,1) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (29,1)-(29,2) = "."
        │   │   ├── name: :b
        │   │   ├── message_loc: (29,2)-(29,3) = "b"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (29,3)-(29,4) = "."
        │   ├── name: :c
        │   ├── message_loc: (29,4)-(29,5) = "c"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (31,0)-(31,7))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (31,0)-(31,1) = "a"
        │   ├── opening_loc: (31,1)-(31,2) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,2)-(31,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (31,2)-(31,3))
        │   │       │   ├── flags: variable_call
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (31,2)-(31,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (31,5)-(31,6))
        │   │           ├── flags: variable_call
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :c
        │   │           ├── message_loc: (31,5)-(31,6) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (31,6)-(31,7) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(33,3))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (33,0)-(33,1) = "a"
        │   ├── opening_loc: (33,1)-(33,2) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (33,2)-(33,3) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(35,8))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (35,0)-(35,1) = "a"
        │   ├── opening_loc: (35,1)-(35,2) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,2)-(35,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (35,2)-(35,7))
        │   │           ├── operator_loc: (35,2)-(35,3) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (35,3)-(35,7))
        │   │               ├── flags: variable_call
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :args
        │   │               ├── message_loc: (35,3)-(35,7) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (35,7)-(35,8) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (37,0)-(37,6))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (37,0)-(37,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,2)-(37,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (37,2)-(37,3))
        │   │       │   ├── flags: variable_call
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (37,2)-(37,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (37,5)-(37,6))
        │   │           ├── flags: variable_call
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :c
        │   │           ├── message_loc: (37,5)-(37,6) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (39,0)-(39,8))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (39,0)-(39,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (39,0)-(39,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (39,1)-(39,2) = "."
        │   ├── name: :b
        │   ├── message_loc: (39,2)-(39,3) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (39,4)-(39,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (39,4)-(39,5))
        │   │       │   ├── flags: variable_call
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :c
        │   │       │   ├── message_loc: (39,4)-(39,5) = "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (39,7)-(39,8))
        │   │           ├── flags: variable_call
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :d
        │   │           ├── message_loc: (39,7)-(39,8) = "d"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ MultiWriteNode (location: (41,0)-(41,23))
        │   ├── lefts: (length: 2)
        │   │   ├── @ CallTargetNode (location: (41,0)-(41,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ CallNode (location: (41,0)-(41,3))
        │   │   │   │   ├── flags: variable_call
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :foo
        │   │   │   │   ├── message_loc: (41,0)-(41,3) = "foo"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── call_operator_loc: (41,3)-(41,4) = "."
        │   │   │   ├── name: :foo=
        │   │   │   └── message_loc: (41,4)-(41,7) = "foo"
        │   │   └── @ CallTargetNode (location: (41,9)-(41,16))
        │   │       ├── flags: ∅
        │   │       ├── receiver:
        │   │       │   @ CallNode (location: (41,9)-(41,12))
        │   │       │   ├── flags: variable_call
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (41,9)-(41,12) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       ├── call_operator_loc: (41,12)-(41,13) = "."
        │   │       ├── name: :bar=
        │   │       └── message_loc: (41,13)-(41,16) = "bar"
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (41,17)-(41,18) = "="
        │   └── value:
        │       @ ArrayNode (location: (41,19)-(41,23))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (41,19)-(41,20))
        │       │   │   └── flags: decimal
        │       │   └── @ IntegerNode (location: (41,22)-(41,23))
        │       │       └── flags: decimal
        │       ├── opening_loc: ∅
        │       └── closing_loc: ∅
        ├── @ CallNode (location: (43,0)-(43,4))
        │   ├── flags: safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (43,0)-(43,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (43,0)-(43,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (43,1)-(43,3) = "&."
        │   ├── name: :b
        │   ├── message_loc: (43,3)-(43,4) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,5))
        │   ├── flags: safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (45,0)-(45,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (45,0)-(45,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (45,1)-(45,3) = "&."
        │   ├── name: :call
        │   ├── message_loc: ∅
        │   ├── opening_loc: (45,3)-(45,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (45,4)-(45,5) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (47,0)-(47,7))
        │   ├── flags: safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (47,0)-(47,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (47,0)-(47,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (47,1)-(47,3) = "&."
        │   ├── name: :b
        │   ├── message_loc: (47,3)-(47,4) = "b"
        │   ├── opening_loc: (47,4)-(47,5) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (47,5)-(47,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (47,5)-(47,6))
        │   │           ├── flags: variable_call
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :c
        │   │           ├── message_loc: (47,5)-(47,6) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (47,6)-(47,7) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (49,0)-(49,6))
        │   ├── flags: safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (49,0)-(49,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (49,0)-(49,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (49,1)-(49,3) = "&."
        │   ├── name: :b
        │   ├── message_loc: (49,3)-(49,4) = "b"
        │   ├── opening_loc: (49,4)-(49,5) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (49,5)-(49,6) = ")"
        │   └── block: ∅
        ├── @ IfNode (location: (51,0)-(51,33))
        │   ├── if_keyword_loc: (51,11)-(51,13) = "if"
        │   ├── predicate:
        │   │   @ AndNode (location: (51,14)-(51,33))
        │   │   ├── left:
        │   │   │   @ OrNode (location: (51,14)-(51,25))
        │   │   │   ├── left:
        │   │   │   │   @ CallNode (location: (51,14)-(51,18))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :bar?
        │   │   │   │   ├── message_loc: (51,14)-(51,18) = "bar?"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── right:
        │   │   │   │   @ CallNode (location: (51,22)-(51,25))
        │   │   │   │   ├── flags: variable_call
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :baz
        │   │   │   │   ├── message_loc: (51,22)-(51,25) = "baz"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (51,19)-(51,21) = "or"
        │   │   ├── right:
        │   │   │   @ CallNode (location: (51,30)-(51,33))
        │   │   │   ├── flags: variable_call
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :qux
        │   │   │   ├── message_loc: (51,30)-(51,33) = "qux"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (51,26)-(51,29) = "and"
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (51,0)-(51,10))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (51,0)-(51,10))
        │   │           ├── flags: ∅
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (51,0)-(51,3) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (51,4)-(51,10))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ SymbolNode (location: (51,4)-(51,6))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── opening_loc: (51,4)-(51,5) = ":"
        │   │           │       │   ├── value_loc: (51,5)-(51,6) = "a"
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── unescaped: "a"
        │   │           │       └── @ SymbolNode (location: (51,8)-(51,10))
        │   │           │           ├── flags: ∅
        │   │           │           ├── opening_loc: (51,8)-(51,9) = ":"
        │   │           │           ├── value_loc: (51,9)-(51,10) = "b"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── unescaped: "b"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── consequent: ∅
        │   └── end_keyword_loc: ∅
        ├── @ CallNode (location: (53,0)-(56,1))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (53,0)-(53,3) = "foo"
        │   ├── opening_loc: (53,3)-(53,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (53,4)-(55,4))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (53,4)-(53,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (53,4)-(53,5) = ":"
        │   │       │   ├── value_loc: (53,5)-(53,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ SymbolNode (location: (55,2)-(55,4))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (55,2)-(55,3) = ":"
        │   │           ├── value_loc: (55,3)-(55,4) = "b"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "b"
        │   ├── closing_loc: (56,0)-(56,1) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (58,0)-(58,10))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (58,0)-(58,3) = "foo"
        │   ├── opening_loc: (58,3)-(58,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (58,4)-(58,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (58,4)-(58,9))
        │   │           ├── operator_loc: (58,4)-(58,5) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (58,5)-(58,9))
        │   │               ├── flags: variable_call
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :rest
        │   │               ├── message_loc: (58,5)-(58,9) = "rest"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (58,9)-(58,10) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (60,0)-(60,39))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (60,0)-(60,3) = "foo"
        │   ├── opening_loc: (60,3)-(60,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (60,4)-(60,32))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (60,4)-(60,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (60,4)-(60,5) = ":"
        │   │       │   ├── value_loc: (60,5)-(60,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ KeywordHashNode (location: (60,8)-(60,32))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 2)
        │   │               ├── @ AssocNode (location: (60,8)-(60,22))
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (60,8)-(60,10))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── opening_loc: (60,8)-(60,9) = ":"
        │   │               │   │   ├── value_loc: (60,9)-(60,10) = "h"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "h"
        │   │               │   ├── value:
        │   │               │   │   @ ArrayNode (location: (60,14)-(60,22))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── elements: (length: 2)
        │   │               │   │   │   ├── @ SymbolNode (location: (60,15)-(60,17))
        │   │               │   │   │   │   ├── flags: ∅
        │   │               │   │   │   │   ├── opening_loc: (60,15)-(60,16) = ":"
        │   │               │   │   │   │   ├── value_loc: (60,16)-(60,17) = "x"
        │   │               │   │   │   │   ├── closing_loc: ∅
        │   │               │   │   │   │   └── unescaped: "x"
        │   │               │   │   │   └── @ SymbolNode (location: (60,19)-(60,21))
        │   │               │   │   │       ├── flags: ∅
        │   │               │   │   │       ├── opening_loc: (60,19)-(60,20) = ":"
        │   │               │   │   │       ├── value_loc: (60,20)-(60,21) = "y"
        │   │               │   │   │       ├── closing_loc: ∅
        │   │               │   │   │       └── unescaped: "y"
        │   │               │   │   ├── opening_loc: (60,14)-(60,15) = "["
        │   │               │   │   └── closing_loc: (60,21)-(60,22) = "]"
        │   │               │   └── operator_loc: (60,11)-(60,13) = "=>"
        │   │               └── @ AssocNode (location: (60,24)-(60,32))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (60,24)-(60,26))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (60,24)-(60,25) = ":"
        │   │                   │   ├── value_loc: (60,25)-(60,26) = "a"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (60,30)-(60,32))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (60,30)-(60,31) = ":"
        │   │                   │   ├── value_loc: (60,31)-(60,32) = "b"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "b"
        │   │                   └── operator_loc: (60,27)-(60,29) = "=>"
        │   ├── closing_loc: (60,39)-(60,40) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (60,34)-(60,39))
        │       ├── expression:
        │       │   @ SymbolNode (location: (60,35)-(60,39))
        │       │   ├── flags: ∅
        │       │   ├── opening_loc: (60,35)-(60,36) = ":"
        │       │   ├── value_loc: (60,36)-(60,39) = "bar"
        │       │   ├── closing_loc: ∅
        │       │   └── unescaped: "bar"
        │       └── operator_loc: (60,34)-(60,35) = "&"
        ├── @ CallNode (location: (62,0)-(62,49))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (62,0)-(62,2) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (62,3)-(62,49))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (62,3)-(62,6))
        │   │       │   └── flags: decimal
        │   │       └── @ HashNode (location: (62,8)-(62,49))
        │   │           ├── opening_loc: (62,8)-(62,9) = "{"
        │   │           ├── elements: (length: 3)
        │   │           │   ├── @ AssocNode (location: (62,10)-(62,27))
        │   │           │   │   ├── key:
        │   │           │   │   │   @ SymbolNode (location: (62,10)-(62,16))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── opening_loc: (62,10)-(62,11) = ":"
        │   │           │   │   │   ├── value_loc: (62,11)-(62,16) = "there"
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── unescaped: "there"
        │   │           │   │   ├── value:
        │   │           │   │   │   @ SymbolNode (location: (62,20)-(62,27))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── opening_loc: (62,20)-(62,21) = ":"
        │   │           │   │   │   ├── value_loc: (62,21)-(62,27) = "friend"
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── unescaped: "friend"
        │   │           │   │   └── operator_loc: (62,17)-(62,19) = "=>"
        │   │           │   ├── @ AssocSplatNode (location: (62,29)-(62,33))
        │   │           │   │   ├── value:
        │   │           │   │   │   @ HashNode (location: (62,31)-(62,33))
        │   │           │   │   │   ├── opening_loc: (62,31)-(62,32) = "{"
        │   │           │   │   │   ├── elements: (length: 0)
        │   │           │   │   │   └── closing_loc: (62,32)-(62,33) = "}"
        │   │           │   │   └── operator_loc: (62,29)-(62,31) = "**"
        │   │           │   └── @ AssocNode (location: (62,35)-(62,47))
        │   │           │       ├── key:
        │   │           │       │   @ SymbolNode (location: (62,35)-(62,42))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── value_loc: (62,35)-(62,41) = "whatup"
        │   │           │       │   ├── closing_loc: (62,41)-(62,42) = ":"
        │   │           │       │   └── unescaped: "whatup"
        │   │           │       ├── value:
        │   │           │       │   @ SymbolNode (location: (62,43)-(62,47))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── opening_loc: (62,43)-(62,44) = ":"
        │   │           │       │   ├── value_loc: (62,44)-(62,47) = "dog"
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── unescaped: "dog"
        │   │           │       └── operator_loc: ∅
        │   │           └── closing_loc: (62,48)-(62,49) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (64,0)-(64,36))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (64,0)-(64,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (64,4)-(64,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (64,4)-(64,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (64,4)-(64,5) = ":"
        │   │       │   ├── value_loc: (64,5)-(64,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ KeywordHashNode (location: (64,8)-(64,15))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (64,8)-(64,15))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (64,8)-(64,10))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (64,8)-(64,9) = "b"
        │   │                   │   ├── closing_loc: (64,9)-(64,10) = ":"
        │   │                   │   └── unescaped: "b"
        │   │                   ├── value:
        │   │                   │   @ TrueNode (location: (64,11)-(64,15))
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (64,16)-(64,36))
        │       ├── locals: [:a, :b]
        │       ├── locals_body_index: 2
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (64,19)-(64,25))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (64,20)-(64,24))
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ RequiredParameterNode (location: (64,20)-(64,21))
        │       │   │   │   │   └── name: :a
        │       │   │   │   └── @ RequiredParameterNode (location: (64,23)-(64,24))
        │       │   │   │       └── name: :b
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (64,19)-(64,20) = "|"
        │       │   └── closing_loc: (64,24)-(64,25) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (64,26)-(64,32))
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (64,26)-(64,32))
        │       │           ├── flags: ∅
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :puts
        │       │           ├── message_loc: (64,26)-(64,30) = "puts"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (64,31)-(64,32))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ LocalVariableReadNode (location: (64,31)-(64,32))
        │       │           │           ├── name: :a
        │       │           │           └── depth: 0
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (64,16)-(64,18) = "do"
        │       └── closing_loc: (64,33)-(64,36) = "end"
        ├── @ CallNode (location: (66,0)-(66,17))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (66,0)-(66,2) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (66,3)-(66,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (66,3)-(66,17))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (66,3)-(66,17))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (66,3)-(66,9))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (66,3)-(66,8) = "there"
        │   │                   │   ├── closing_loc: (66,8)-(66,9) = ":"
        │   │                   │   └── unescaped: "there"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (66,10)-(66,17))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (66,10)-(66,11) = ":"
        │   │                   │   ├── value_loc: (66,11)-(66,17) = "friend"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "friend"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (68,0)-(68,40))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (68,0)-(68,2) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (68,3)-(68,40))
        │   │   ├── flags: contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (68,3)-(68,40))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 3)
        │   │               ├── @ AssocNode (location: (68,3)-(68,20))
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (68,3)-(68,9))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── opening_loc: (68,3)-(68,4) = ":"
        │   │               │   │   ├── value_loc: (68,4)-(68,9) = "there"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "there"
        │   │               │   ├── value:
        │   │               │   │   @ SymbolNode (location: (68,13)-(68,20))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── opening_loc: (68,13)-(68,14) = ":"
        │   │               │   │   ├── value_loc: (68,14)-(68,20) = "friend"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "friend"
        │   │               │   └── operator_loc: (68,10)-(68,12) = "=>"
        │   │               ├── @ AssocSplatNode (location: (68,22)-(68,26))
        │   │               │   ├── value:
        │   │               │   │   @ HashNode (location: (68,24)-(68,26))
        │   │               │   │   ├── opening_loc: (68,24)-(68,25) = "{"
        │   │               │   │   ├── elements: (length: 0)
        │   │               │   │   └── closing_loc: (68,25)-(68,26) = "}"
        │   │               │   └── operator_loc: (68,22)-(68,24) = "**"
        │   │               └── @ AssocNode (location: (68,28)-(68,40))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (68,28)-(68,35))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (68,28)-(68,34) = "whatup"
        │   │                   │   ├── closing_loc: (68,34)-(68,35) = ":"
        │   │                   │   └── unescaped: "whatup"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (68,36)-(68,40))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (68,36)-(68,37) = ":"
        │   │                   │   ├── value_loc: (68,37)-(68,40) = "dog"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "dog"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (70,0)-(70,41))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (70,0)-(70,2) = "hi"
        │   ├── opening_loc: (70,2)-(70,3) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (70,3)-(70,40))
        │   │   ├── flags: contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (70,3)-(70,40))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 3)
        │   │               ├── @ AssocNode (location: (70,3)-(70,20))
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (70,3)-(70,9))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── opening_loc: (70,3)-(70,4) = ":"
        │   │               │   │   ├── value_loc: (70,4)-(70,9) = "there"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "there"
        │   │               │   ├── value:
        │   │               │   │   @ SymbolNode (location: (70,13)-(70,20))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── opening_loc: (70,13)-(70,14) = ":"
        │   │               │   │   ├── value_loc: (70,14)-(70,20) = "friend"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "friend"
        │   │               │   └── operator_loc: (70,10)-(70,12) = "=>"
        │   │               ├── @ AssocSplatNode (location: (70,22)-(70,26))
        │   │               │   ├── value:
        │   │               │   │   @ HashNode (location: (70,24)-(70,26))
        │   │               │   │   ├── opening_loc: (70,24)-(70,25) = "{"
        │   │               │   │   ├── elements: (length: 0)
        │   │               │   │   └── closing_loc: (70,25)-(70,26) = "}"
        │   │               │   └── operator_loc: (70,22)-(70,24) = "**"
        │   │               └── @ AssocNode (location: (70,28)-(70,40))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (70,28)-(70,35))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (70,28)-(70,34) = "whatup"
        │   │                   │   ├── closing_loc: (70,34)-(70,35) = ":"
        │   │                   │   └── unescaped: "whatup"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (70,36)-(70,40))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (70,36)-(70,37) = ":"
        │   │                   │   ├── value_loc: (70,37)-(70,40) = "dog"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "dog"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (70,40)-(70,41) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (72,0)-(72,35))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (72,0)-(72,3) = "foo"
        │   ├── opening_loc: (72,3)-(72,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (72,4)-(72,26))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ HashNode (location: (72,4)-(72,26))
        │   │           ├── opening_loc: (72,4)-(72,5) = "{"
        │   │           ├── elements: (length: 2)
        │   │           │   ├── @ AssocNode (location: (72,6)-(72,13))
        │   │           │   │   ├── key:
        │   │           │   │   │   @ SymbolNode (location: (72,6)-(72,8))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   ├── opening_loc: ∅
        │   │           │   │   │   ├── value_loc: (72,6)-(72,7) = "a"
        │   │           │   │   │   ├── closing_loc: (72,7)-(72,8) = ":"
        │   │           │   │   │   └── unescaped: "a"
        │   │           │   │   ├── value:
        │   │           │   │   │   @ TrueNode (location: (72,9)-(72,13))
        │   │           │   │   └── operator_loc: ∅
        │   │           │   └── @ AssocNode (location: (72,15)-(72,23))
        │   │           │       ├── key:
        │   │           │       │   @ SymbolNode (location: (72,15)-(72,17))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── value_loc: (72,15)-(72,16) = "b"
        │   │           │       │   ├── closing_loc: (72,16)-(72,17) = ":"
        │   │           │       │   └── unescaped: "b"
        │   │           │       ├── value:
        │   │           │       │   @ FalseNode (location: (72,18)-(72,23))
        │   │           │       └── operator_loc: ∅
        │   │           └── closing_loc: (72,25)-(72,26) = "}"
        │   ├── closing_loc: (72,35)-(72,36) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (72,28)-(72,35))
        │       ├── expression:
        │       │   @ SymbolNode (location: (72,29)-(72,35))
        │       │   ├── flags: ∅
        │       │   ├── opening_loc: (72,29)-(72,30) = ":"
        │       │   ├── value_loc: (72,30)-(72,35) = "block"
        │       │   ├── closing_loc: ∅
        │       │   └── unescaped: "block"
        │       └── operator_loc: (72,28)-(72,29) = "&"
        ├── @ CallNode (location: (74,0)-(74,20))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (74,0)-(74,2) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (74,3)-(74,20))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (74,3)-(74,20))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (74,3)-(74,20))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (74,3)-(74,9))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (74,3)-(74,4) = ":"
        │   │                   │   ├── value_loc: (74,4)-(74,9) = "there"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "there"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (74,13)-(74,20))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (74,13)-(74,14) = ":"
        │   │                   │   ├── value_loc: (74,14)-(74,20) = "friend"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "friend"
        │   │                   └── operator_loc: (74,10)-(74,12) = "=>"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (76,0)-(78,1))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (76,0)-(76,3) = "foo"
        │   ├── opening_loc: (76,3)-(76,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (76,4)-(77,2))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (76,4)-(76,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (76,4)-(76,5) = ":"
        │   │       │   ├── value_loc: (76,5)-(76,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ SymbolNode (location: (77,0)-(77,2))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (77,0)-(77,1) = ":"
        │   │           ├── value_loc: (77,1)-(77,2) = "b"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "b"
        │   ├── closing_loc: (78,0)-(78,1) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (80,0)-(83,1))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (80,0)-(80,3) = "foo"
        │   ├── opening_loc: (80,3)-(80,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (81,0)-(82,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (81,0)-(81,2))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (81,0)-(81,1) = ":"
        │   │       │   ├── value_loc: (81,1)-(81,2) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ KeywordHashNode (location: (82,0)-(82,5))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (82,0)-(82,5))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (82,0)-(82,2))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (82,0)-(82,1) = "b"
        │   │                   │   ├── closing_loc: (82,1)-(82,2) = ":"
        │   │                   │   └── unescaped: "b"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (82,3)-(82,5))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (82,3)-(82,4) = ":"
        │   │                   │   ├── value_loc: (82,4)-(82,5) = "c"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "c"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (83,0)-(83,1) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (85,0)-(85,11))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (85,0)-(85,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockArgumentNode (location: (85,4)-(85,11))
        │       ├── expression:
        │       │   @ SymbolNode (location: (85,5)-(85,11))
        │       │   ├── flags: ∅
        │       │   ├── opening_loc: (85,5)-(85,6) = ":"
        │       │   ├── value_loc: (85,6)-(85,11) = "block"
        │       │   ├── closing_loc: ∅
        │       │   └── unescaped: "block"
        │       └── operator_loc: (85,4)-(85,5) = "&"
        ├── @ CallNode (location: (87,0)-(87,30))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (87,0)-(87,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (87,4)-(87,21))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (87,4)-(87,21))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 2)
        │   │               ├── @ AssocNode (location: (87,4)-(87,11))
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (87,4)-(87,6))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── opening_loc: ∅
        │   │               │   │   ├── value_loc: (87,4)-(87,5) = "a"
        │   │               │   │   ├── closing_loc: (87,5)-(87,6) = ":"
        │   │               │   │   └── unescaped: "a"
        │   │               │   ├── value:
        │   │               │   │   @ TrueNode (location: (87,7)-(87,11))
        │   │               │   └── operator_loc: ∅
        │   │               └── @ AssocNode (location: (87,13)-(87,21))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (87,13)-(87,15))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (87,13)-(87,14) = "b"
        │   │                   │   ├── closing_loc: (87,14)-(87,15) = ":"
        │   │                   │   └── unescaped: "b"
        │   │                   ├── value:
        │   │                   │   @ FalseNode (location: (87,16)-(87,21))
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockArgumentNode (location: (87,23)-(87,30))
        │       ├── expression:
        │       │   @ SymbolNode (location: (87,24)-(87,30))
        │       │   ├── flags: ∅
        │       │   ├── opening_loc: (87,24)-(87,25) = ":"
        │       │   ├── value_loc: (87,25)-(87,30) = "block"
        │       │   ├── closing_loc: ∅
        │       │   └── unescaped: "block"
        │       └── operator_loc: (87,23)-(87,24) = "&"
        ├── @ CallNode (location: (89,0)-(89,21))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :some_func
        │   ├── message_loc: (89,0)-(89,9) = "some_func"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (89,10)-(89,21))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (89,10)-(89,11))
        │   │       │   └── flags: decimal
        │   │       └── @ KeywordHashNode (location: (89,13)-(89,21))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (89,13)-(89,21))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (89,13)-(89,19))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (89,13)-(89,18) = "kwarg"
        │   │                   │   ├── closing_loc: (89,18)-(89,19) = ":"
        │   │                   │   └── unescaped: "kwarg"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (89,20)-(89,21))
        │   │                   │   └── flags: decimal
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (91,0)-(91,18))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (91,0)-(91,6))
        │   │   └── name: :Kernel
        │   ├── call_operator_loc: (91,6)-(91,7) = "."
        │   ├── name: :Integer
        │   ├── message_loc: (91,7)-(91,14) = "Integer"
        │   ├── opening_loc: (91,14)-(91,15) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (91,15)-(91,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (91,15)-(91,17))
        │   │           └── flags: decimal
        │   ├── closing_loc: (91,17)-(91,18) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (93,0)-(93,10))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (93,0)-(93,1))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :x
        │   │   ├── message_loc: (93,0)-(93,1) = "x"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (93,1)-(93,2) = "."
        │   ├── name: :each
        │   ├── message_loc: (93,2)-(93,6) = "each"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (93,7)-(93,10))
        │       ├── locals: []
        │       ├── locals_body_index: 0
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (93,7)-(93,8) = "{"
        │       └── closing_loc: (93,9)-(93,10) = "}"
        ├── @ CallNode (location: (95,0)-(95,14))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (95,0)-(95,3))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (95,0)-(95,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (95,3)-(95,4) = "."
        │   ├── name: :map
        │   ├── message_loc: (95,4)-(95,7) = "map"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (95,8)-(95,14))
        │       ├── locals: []
        │       ├── locals_body_index: 0
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (95,10)-(95,12))
        │       │   └── body: (length: 1)
        │       │       └── @ BackReferenceReadNode (location: (95,10)-(95,12))
        │       │           └── name: :$&
        │       ├── opening_loc: (95,8)-(95,9) = "{"
        │       └── closing_loc: (95,13)-(95,14) = "}"
        ├── @ CallNode (location: (97,0)-(97,12))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (97,0)-(97,4))
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (97,0)-(97,1))
        │   │   │   └── name: :A
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (97,3)-(97,4))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (97,1)-(97,3) = "::"
        │   ├── call_operator_loc: (97,4)-(97,6) = "::"
        │   ├── name: :C
        │   ├── message_loc: (97,6)-(97,7) = "C"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (97,8)-(97,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (97,8)-(97,12))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (97,8)-(97,9) = ":"
        │   │           ├── value_loc: (97,9)-(97,12) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (99,0)-(99,13))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (99,0)-(99,4))
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (99,0)-(99,1))
        │   │   │   └── name: :A
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (99,3)-(99,4))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (99,1)-(99,3) = "::"
        │   ├── call_operator_loc: (99,4)-(99,6) = "::"
        │   ├── name: :C
        │   ├── message_loc: (99,6)-(99,7) = "C"
        │   ├── opening_loc: (99,7)-(99,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (99,8)-(99,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (99,8)-(99,12))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (99,8)-(99,9) = ":"
        │   │           ├── value_loc: (99,9)-(99,12) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: (99,12)-(99,13) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (101,0)-(101,17))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (101,0)-(101,4))
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (101,0)-(101,1))
        │   │   │   └── name: :A
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (101,3)-(101,4))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (101,1)-(101,3) = "::"
        │   ├── call_operator_loc: (101,4)-(101,6) = "::"
        │   ├── name: :C
        │   ├── message_loc: (101,6)-(101,7) = "C"
        │   ├── opening_loc: (101,7)-(101,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (101,8)-(101,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (101,8)-(101,12))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (101,8)-(101,9) = ":"
        │   │           ├── value_loc: (101,9)-(101,12) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: (101,12)-(101,13) = ")"
        │   └── block:
        │       @ BlockNode (location: (101,14)-(101,17))
        │       ├── locals: []
        │       ├── locals_body_index: 0
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (101,14)-(101,15) = "{"
        │       └── closing_loc: (101,16)-(101,17) = "}"
        ├── @ CallNode (location: (103,0)-(103,12))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (103,0)-(103,3) = "foo"
        │   ├── opening_loc: (103,3)-(103,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (103,4)-(103,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (103,4)-(103,11))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (103,4)-(103,11))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (103,4)-(103,8))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (103,4)-(103,5) = "\""
        │   │                   │   ├── value_loc: (103,5)-(103,6) = "a"
        │   │                   │   ├── closing_loc: (103,6)-(103,8) = "\":"
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (103,9)-(103,11))
        │   │                   │   └── flags: decimal
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (103,11)-(103,12) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (105,0)-(105,28))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (105,0)-(105,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (105,4)-(105,28))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (105,4)-(105,28))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (105,4)-(105,28))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (105,4)-(105,8))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (105,4)-(105,7) = "bar"
        │   │                   │   ├── closing_loc: (105,7)-(105,8) = ":"
        │   │                   │   └── unescaped: "bar"
        │   │                   ├── value:
        │   │                   │   @ HashNode (location: (105,9)-(105,28))
        │   │                   │   ├── opening_loc: (105,9)-(105,10) = "{"
        │   │                   │   ├── elements: (length: 1)
        │   │                   │   │   └── @ AssocNode (location: (105,11)-(105,26))
        │   │                   │   │       ├── key:
        │   │                   │   │       │   @ SymbolNode (location: (105,11)-(105,15))
        │   │                   │   │       │   ├── flags: ∅
        │   │                   │   │       │   ├── opening_loc: ∅
        │   │                   │   │       │   ├── value_loc: (105,11)-(105,14) = "baz"
        │   │                   │   │       │   ├── closing_loc: (105,14)-(105,15) = ":"
        │   │                   │   │       │   └── unescaped: "baz"
        │   │                   │   │       ├── value:
        │   │                   │   │       │   @ CallNode (location: (105,16)-(105,26))
        │   │                   │   │       │   ├── flags: ∅
        │   │                   │   │       │   ├── receiver: ∅
        │   │                   │   │       │   ├── call_operator_loc: ∅
        │   │                   │   │       │   ├── name: :qux
        │   │                   │   │       │   ├── message_loc: (105,16)-(105,19) = "qux"
        │   │                   │   │       │   ├── opening_loc: ∅
        │   │                   │   │       │   ├── arguments: ∅
        │   │                   │   │       │   ├── closing_loc: ∅
        │   │                   │   │       │   └── block:
        │   │                   │   │       │       @ BlockNode (location: (105,20)-(105,26))
        │   │                   │   │       │       ├── locals: []
        │   │                   │   │       │       ├── locals_body_index: 0
        │   │                   │   │       │       ├── parameters: ∅
        │   │                   │   │       │       ├── body: ∅
        │   │                   │   │       │       ├── opening_loc: (105,20)-(105,22) = "do"
        │   │                   │   │       │       └── closing_loc: (105,23)-(105,26) = "end"
        │   │                   │   │       └── operator_loc: ∅
        │   │                   │   └── closing_loc: (105,27)-(105,28) = "}"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (107,0)-(107,24))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (107,0)-(107,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (107,4)-(107,24))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (107,4)-(107,24))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (107,4)-(107,24))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (107,4)-(107,8))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (107,4)-(107,7) = "bar"
        │   │                   │   ├── closing_loc: (107,7)-(107,8) = ":"
        │   │                   │   └── unescaped: "bar"
        │   │                   ├── value:
        │   │                   │   @ HashNode (location: (107,9)-(107,24))
        │   │                   │   ├── opening_loc: (107,9)-(107,10) = "{"
        │   │                   │   ├── elements: (length: 1)
        │   │                   │   │   └── @ AssocSplatNode (location: (107,11)-(107,22))
        │   │                   │   │       ├── value:
        │   │                   │   │       │   @ CallNode (location: (107,13)-(107,22))
        │   │                   │   │       │   ├── flags: ∅
        │   │                   │   │       │   ├── receiver: ∅
        │   │                   │   │       │   ├── call_operator_loc: ∅
        │   │                   │   │       │   ├── name: :kw
        │   │                   │   │       │   ├── message_loc: (107,13)-(107,15) = "kw"
        │   │                   │   │       │   ├── opening_loc: ∅
        │   │                   │   │       │   ├── arguments: ∅
        │   │                   │   │       │   ├── closing_loc: ∅
        │   │                   │   │       │   └── block:
        │   │                   │   │       │       @ BlockNode (location: (107,16)-(107,22))
        │   │                   │   │       │       ├── locals: []
        │   │                   │   │       │       ├── locals_body_index: 0
        │   │                   │   │       │       ├── parameters: ∅
        │   │                   │   │       │       ├── body: ∅
        │   │                   │   │       │       ├── opening_loc: (107,16)-(107,18) = "do"
        │   │                   │   │       │       └── closing_loc: (107,19)-(107,22) = "end"
        │   │                   │   │       └── operator_loc: (107,11)-(107,13) = "**"
        │   │                   │   └── closing_loc: (107,23)-(107,24) = "}"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (109,0)-(109,36))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (109,0)-(109,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (109,4)-(109,29))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (109,4)-(109,29))
        │   │           ├── opening_loc: (109,4)-(109,5) = "\""
        │   │           ├── parts: (length: 1)
        │   │           │   └── @ EmbeddedStatementsNode (location: (109,5)-(109,28))
        │   │           │       ├── opening_loc: (109,5)-(109,7) = "\#{"
        │   │           │       ├── statements:
        │   │           │       │   @ StatementsNode (location: (109,7)-(109,27))
        │   │           │       │   └── body: (length: 1)
        │   │           │       │       └── @ CallNode (location: (109,7)-(109,27))
        │   │           │       │           ├── flags: ∅
        │   │           │       │           ├── receiver:
        │   │           │       │           │   @ CallNode (location: (109,7)-(109,10))
        │   │           │       │           │   ├── flags: variable_call
        │   │           │       │           │   ├── receiver: ∅
        │   │           │       │           │   ├── call_operator_loc: ∅
        │   │           │       │           │   ├── name: :bar
        │   │           │       │           │   ├── message_loc: (109,7)-(109,10) = "bar"
        │   │           │       │           │   ├── opening_loc: ∅
        │   │           │       │           │   ├── arguments: ∅
        │   │           │       │           │   ├── closing_loc: ∅
        │   │           │       │           │   └── block: ∅
        │   │           │       │           ├── call_operator_loc: (109,10)-(109,11) = "."
        │   │           │       │           ├── name: :map
        │   │           │       │           ├── message_loc: (109,11)-(109,14) = "map"
        │   │           │       │           ├── opening_loc: ∅
        │   │           │       │           ├── arguments: ∅
        │   │           │       │           ├── closing_loc: ∅
        │   │           │       │           └── block:
        │   │           │       │               @ BlockNode (location: (109,15)-(109,27))
        │   │           │       │               ├── locals: []
        │   │           │       │               ├── locals_body_index: 0
        │   │           │       │               ├── parameters: ∅
        │   │           │       │               ├── body:
        │   │           │       │               │   @ StatementsNode (location: (109,18)-(109,23))
        │   │           │       │               │   └── body: (length: 1)
        │   │           │       │               │       └── @ StringNode (location: (109,18)-(109,23))
        │   │           │       │               │           ├── flags: ∅
        │   │           │       │               │           ├── opening_loc: (109,18)-(109,19) = "\""
        │   │           │       │               │           ├── content_loc: (109,19)-(109,22) = "baz"
        │   │           │       │               │           ├── closing_loc: (109,22)-(109,23) = "\""
        │   │           │       │               │           └── unescaped: "baz"
        │   │           │       │               ├── opening_loc: (109,15)-(109,17) = "do"
        │   │           │       │               └── closing_loc: (109,24)-(109,27) = "end"
        │   │           │       └── closing_loc: (109,27)-(109,28) = "}"
        │   │           └── closing_loc: (109,28)-(109,29) = "\""
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (109,30)-(109,36))
        │       ├── locals: []
        │       ├── locals_body_index: 0
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (109,30)-(109,32) = "do"
        │       └── closing_loc: (109,33)-(109,36) = "end"
        ├── @ CallNode (location: (111,0)-(111,28))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (111,0)-(111,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (111,4)-(111,28))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ClassNode (location: (111,4)-(111,28))
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (111,4)-(111,9) = "class"
        │   │           ├── constant_path:
        │   │           │   @ ConstantReadNode (location: (111,10)-(111,13))
        │   │           │   └── name: :Bar
        │   │           ├── inheritance_operator_loc: ∅
        │   │           ├── superclass: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (111,14)-(111,24))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (111,14)-(111,24))
        │   │           │           ├── flags: ∅
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :baz
        │   │           │           ├── message_loc: (111,14)-(111,17) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (111,18)-(111,24))
        │   │           │               ├── locals: []
        │   │           │               ├── locals_body_index: 0
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body: ∅
        │   │           │               ├── opening_loc: (111,18)-(111,20) = "do"
        │   │           │               └── closing_loc: (111,21)-(111,24) = "end"
        │   │           ├── end_keyword_loc: (111,25)-(111,28) = "end"
        │   │           └── name: :Bar
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (113,0)-(113,29))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (113,0)-(113,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (113,4)-(113,29))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ModuleNode (location: (113,4)-(113,29))
        │   │           ├── locals: []
        │   │           ├── module_keyword_loc: (113,4)-(113,10) = "module"
        │   │           ├── constant_path:
        │   │           │   @ ConstantReadNode (location: (113,11)-(113,14))
        │   │           │   └── name: :Bar
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (113,15)-(113,25))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (113,15)-(113,25))
        │   │           │           ├── flags: ∅
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :baz
        │   │           │           ├── message_loc: (113,15)-(113,18) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (113,19)-(113,25))
        │   │           │               ├── locals: []
        │   │           │               ├── locals_body_index: 0
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body: ∅
        │   │           │               ├── opening_loc: (113,19)-(113,21) = "do"
        │   │           │               └── closing_loc: (113,22)-(113,25) = "end"
        │   │           ├── end_keyword_loc: (113,26)-(113,29) = "end"
        │   │           └── name: :Bar
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (115,0)-(115,16))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (115,0)-(115,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (115,4)-(115,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ArrayNode (location: (115,4)-(115,16))
        │   │           ├── flags: ∅
        │   │           ├── elements: (length: 1)
        │   │           │   └── @ CallNode (location: (115,5)-(115,15))
        │   │           │       ├── flags: ∅
        │   │           │       ├── receiver: ∅
        │   │           │       ├── call_operator_loc: ∅
        │   │           │       ├── name: :baz
        │   │           │       ├── message_loc: (115,5)-(115,8) = "baz"
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── arguments: ∅
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── block:
        │   │           │           @ BlockNode (location: (115,9)-(115,15))
        │   │           │           ├── locals: []
        │   │           │           ├── locals_body_index: 0
        │   │           │           ├── parameters: ∅
        │   │           │           ├── body: ∅
        │   │           │           ├── opening_loc: (115,9)-(115,11) = "do"
        │   │           │           └── closing_loc: (115,12)-(115,15) = "end"
        │   │           ├── opening_loc: (115,4)-(115,5) = "["
        │   │           └── closing_loc: (115,15)-(115,16) = "]"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (117,0)-(117,28))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :p
        │   ├── message_loc: (117,0)-(117,1) = "p"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (117,2)-(117,28))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ BeginNode (location: (117,2)-(117,28))
        │   │           ├── begin_keyword_loc: (117,2)-(117,7) = "begin"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (117,8)-(117,24))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (117,8)-(117,24))
        │   │           │           ├── flags: ∅
        │   │           │           ├── receiver:
        │   │           │           │   @ IntegerNode (location: (117,8)-(117,9))
        │   │           │           │   └── flags: decimal
        │   │           │           ├── call_operator_loc: (117,9)-(117,10) = "."
        │   │           │           ├── name: :times
        │   │           │           ├── message_loc: (117,10)-(117,15) = "times"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (117,16)-(117,24))
        │   │           │               ├── locals: []
        │   │           │               ├── locals_body_index: 0
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body:
        │   │           │               │   @ StatementsNode (location: (117,19)-(117,20))
        │   │           │               │   └── body: (length: 1)
        │   │           │               │       └── @ IntegerNode (location: (117,19)-(117,20))
        │   │           │               │           └── flags: decimal
        │   │           │               ├── opening_loc: (117,16)-(117,18) = "do"
        │   │           │               └── closing_loc: (117,21)-(117,24) = "end"
        │   │           ├── rescue_clause: ∅
        │   │           ├── else_clause: ∅
        │   │           ├── ensure_clause: ∅
        │   │           └── end_keyword_loc: (117,25)-(117,28) = "end"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (119,0)-(124,5))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (119,0)-(119,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (119,4)-(124,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (119,4)-(119,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (119,4)-(119,5) = ":"
        │   │       │   ├── value_loc: (119,5)-(119,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ IfNode (location: (120,2)-(124,5))
        │   │           ├── if_keyword_loc: (120,2)-(120,4) = "if"
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (120,5)-(120,6))
        │   │           │   ├── flags: variable_call
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :x
        │   │           │   ├── message_loc: (120,5)-(120,6) = "x"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── then_keyword_loc: ∅
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (121,4)-(123,7))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (121,4)-(123,7))
        │   │           │           ├── flags: ∅
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :bar
        │   │           │           ├── message_loc: (121,4)-(121,7) = "bar"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (121,8)-(123,7))
        │   │           │               ├── locals: [:a]
        │   │           │               ├── locals_body_index: 1
        │   │           │               ├── parameters:
        │   │           │               │   @ BlockParametersNode (location: (121,11)-(121,14))
        │   │           │               │   ├── parameters:
        │   │           │               │   │   @ ParametersNode (location: (121,12)-(121,13))
        │   │           │               │   │   ├── requireds: (length: 1)
        │   │           │               │   │   │   └── @ RequiredParameterNode (location: (121,12)-(121,13))
        │   │           │               │   │   │       └── name: :a
        │   │           │               │   │   ├── optionals: (length: 0)
        │   │           │               │   │   ├── rest: ∅
        │   │           │               │   │   ├── posts: (length: 0)
        │   │           │               │   │   ├── keywords: (length: 0)
        │   │           │               │   │   ├── keyword_rest: ∅
        │   │           │               │   │   └── block: ∅
        │   │           │               │   ├── locals: (length: 0)
        │   │           │               │   ├── opening_loc: (121,11)-(121,12) = "|"
        │   │           │               │   └── closing_loc: (121,13)-(121,14) = "|"
        │   │           │               ├── body:
        │   │           │               │   @ StatementsNode (location: (122,6)-(122,7))
        │   │           │               │   └── body: (length: 1)
        │   │           │               │       └── @ LocalVariableReadNode (location: (122,6)-(122,7))
        │   │           │               │           ├── name: :a
        │   │           │               │           └── depth: 0
        │   │           │               ├── opening_loc: (121,8)-(121,10) = "do"
        │   │           │               └── closing_loc: (123,4)-(123,7) = "end"
        │   │           ├── consequent: ∅
        │   │           └── end_keyword_loc: (124,2)-(124,5) = "end"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (126,0)-(135,5))
        │   ├── flags: ∅
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (126,0)-(126,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (126,4)-(135,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ SymbolNode (location: (126,4)-(126,6))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (126,4)-(126,5) = ":"
        │   │       │   ├── value_loc: (126,5)-(126,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       ├── @ WhileNode (location: (127,2)-(131,5))
        │   │       │   ├── flags: ∅
        │   │       │   ├── keyword_loc: (127,2)-(127,7) = "while"
        │   │       │   ├── closing_loc: (131,2)-(131,5) = "end"
        │   │       │   ├── predicate:
        │   │       │   │   @ CallNode (location: (127,8)-(127,9))
        │   │       │   │   ├── flags: variable_call
        │   │       │   │   ├── receiver: ∅
        │   │       │   │   ├── call_operator_loc: ∅
        │   │       │   │   ├── name: :x
        │   │       │   │   ├── message_loc: (127,8)-(127,9) = "x"
        │   │       │   │   ├── opening_loc: ∅
        │   │       │   │   ├── arguments: ∅
        │   │       │   │   ├── closing_loc: ∅
        │   │       │   │   └── block: ∅
        │   │       │   └── statements:
        │   │       │       @ StatementsNode (location: (128,4)-(130,7))
        │   │       │       └── body: (length: 1)
        │   │       │           └── @ CallNode (location: (128,4)-(130,7))
        │   │       │               ├── flags: ∅
        │   │       │               ├── receiver: ∅
        │   │       │               ├── call_operator_loc: ∅
        │   │       │               ├── name: :bar
        │   │       │               ├── message_loc: (128,4)-(128,7) = "bar"
        │   │       │               ├── opening_loc: ∅
        │   │       │               ├── arguments: ∅
        │   │       │               ├── closing_loc: ∅
        │   │       │               └── block:
        │   │       │                   @ BlockNode (location: (128,8)-(130,7))
        │   │       │                   ├── locals: [:a]
        │   │       │                   ├── locals_body_index: 1
        │   │       │                   ├── parameters:
        │   │       │                   │   @ BlockParametersNode (location: (128,11)-(128,14))
        │   │       │                   │   ├── parameters:
        │   │       │                   │   │   @ ParametersNode (location: (128,12)-(128,13))
        │   │       │                   │   │   ├── requireds: (length: 1)
        │   │       │                   │   │   │   └── @ RequiredParameterNode (location: (128,12)-(128,13))
        │   │       │                   │   │   │       └── name: :a
        │   │       │                   │   │   ├── optionals: (length: 0)
        │   │       │                   │   │   ├── rest: ∅
        │   │       │                   │   │   ├── posts: (length: 0)
        │   │       │                   │   │   ├── keywords: (length: 0)
        │   │       │                   │   │   ├── keyword_rest: ∅
        │   │       │                   │   │   └── block: ∅
        │   │       │                   │   ├── locals: (length: 0)
        │   │       │                   │   ├── opening_loc: (128,11)-(128,12) = "|"
        │   │       │                   │   └── closing_loc: (128,13)-(128,14) = "|"
        │   │       │                   ├── body:
        │   │       │                   │   @ StatementsNode (location: (129,6)-(129,7))
        │   │       │                   │   └── body: (length: 1)
        │   │       │                   │       └── @ LocalVariableReadNode (location: (129,6)-(129,7))
        │   │       │                   │           ├── name: :a
        │   │       │                   │           └── depth: 0
        │   │       │                   ├── opening_loc: (128,8)-(128,10) = "do"
        │   │       │                   └── closing_loc: (130,4)-(130,7) = "end"
        │   │       └── @ UntilNode (location: (132,2)-(135,5))
        │   │           ├── flags: ∅
        │   │           ├── keyword_loc: (132,2)-(132,7) = "until"
        │   │           ├── closing_loc: (135,2)-(135,5) = "end"
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (132,8)-(132,9))
        │   │           │   ├── flags: variable_call
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :x
        │   │           │   ├── message_loc: (132,8)-(132,9) = "x"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           └── statements:
        │   │               @ StatementsNode (location: (133,4)-(134,7))
        │   │               └── body: (length: 1)
        │   │                   └── @ CallNode (location: (133,4)-(134,7))
        │   │                       ├── flags: ∅
        │   │                       ├── receiver: ∅
        │   │                       ├── call_operator_loc: ∅
        │   │                       ├── name: :baz
        │   │                       ├── message_loc: (133,4)-(133,7) = "baz"
        │   │                       ├── opening_loc: ∅
        │   │                       ├── arguments: ∅
        │   │                       ├── closing_loc: ∅
        │   │                       └── block:
        │   │                           @ BlockNode (location: (133,8)-(134,7))
        │   │                           ├── locals: []
        │   │                           ├── locals_body_index: 0
        │   │                           ├── parameters: ∅
        │   │                           ├── body: ∅
        │   │                           ├── opening_loc: (133,8)-(133,10) = "do"
        │   │                           └── closing_loc: (134,4)-(134,7) = "end"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (137,0)-(137,9))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ HashNode (location: (137,0)-(137,2))
        │   │   ├── opening_loc: (137,0)-(137,1) = "{"
        │   │   ├── elements: (length: 0)
        │   │   └── closing_loc: (137,1)-(137,2) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (137,3)-(137,4) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (137,5)-(137,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (137,5)-(137,9))
        │   │           ├── flags: ∅
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :A
        │   │           ├── message_loc: (137,5)-(137,6) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (137,7)-(137,9))
        │   │               ├── locals: []
        │   │               ├── locals_body_index: 0
        │   │               ├── parameters: ∅
        │   │               ├── body: ∅
        │   │               ├── opening_loc: (137,7)-(137,8) = "{"
        │   │               └── closing_loc: (137,8)-(137,9) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (139,0)-(139,16))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ HashNode (location: (139,0)-(139,2))
        │   │   ├── opening_loc: (139,0)-(139,1) = "{"
        │   │   ├── elements: (length: 0)
        │   │   └── closing_loc: (139,1)-(139,2) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (139,3)-(139,4) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (139,5)-(139,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (139,5)-(139,16))
        │   │           ├── flags: ∅
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :A
        │   │           ├── message_loc: (139,5)-(139,6) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (139,7)-(139,16))
        │   │               ├── locals: [:a]
        │   │               ├── locals_body_index: 1
        │   │               ├── parameters:
        │   │               │   @ BlockParametersNode (location: (139,9)-(139,12))
        │   │               │   ├── parameters:
        │   │               │   │   @ ParametersNode (location: (139,10)-(139,11))
        │   │               │   │   ├── requireds: (length: 1)
        │   │               │   │   │   └── @ RequiredParameterNode (location: (139,10)-(139,11))
        │   │               │   │   │       └── name: :a
        │   │               │   │   ├── optionals: (length: 0)
        │   │               │   │   ├── rest: ∅
        │   │               │   │   ├── posts: (length: 0)
        │   │               │   │   ├── keywords: (length: 0)
        │   │               │   │   ├── keyword_rest: ∅
        │   │               │   │   └── block: ∅
        │   │               │   ├── locals: (length: 0)
        │   │               │   ├── opening_loc: (139,9)-(139,10) = "|"
        │   │               │   └── closing_loc: (139,11)-(139,12) = "|"
        │   │               ├── body:
        │   │               │   @ StatementsNode (location: (139,13)-(139,14))
        │   │               │   └── body: (length: 1)
        │   │               │       └── @ LocalVariableReadNode (location: (139,13)-(139,14))
        │   │               │           ├── name: :a
        │   │               │           └── depth: 0
        │   │               ├── opening_loc: (139,7)-(139,8) = "{"
        │   │               └── closing_loc: (139,15)-(139,16) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (141,0)-(141,11))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (141,0)-(141,4))
        │   │   ├── flags: ∅
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :A
        │   │   ├── message_loc: (141,0)-(141,1) = "A"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (141,2)-(141,4))
        │   │       ├── locals: []
        │   │       ├── locals_body_index: 0
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (141,2)-(141,3) = "{"
        │   │       └── closing_loc: (141,3)-(141,4) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (141,5)-(141,6) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (141,7)-(141,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (141,7)-(141,11))
        │   │           ├── flags: ∅
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :A
        │   │           ├── message_loc: (141,7)-(141,8) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (141,9)-(141,11))
        │   │               ├── locals: []
        │   │               ├── locals_body_index: 0
        │   │               ├── parameters: ∅
        │   │               ├── body: ∅
        │   │               ├── opening_loc: (141,9)-(141,10) = "{"
        │   │               └── closing_loc: (141,10)-(141,11) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (143,0)-(143,11))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (143,0)-(143,3))
        │   │   ├── flags: variable_call
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :lst
        │   │   ├── message_loc: (143,0)-(143,3) = "lst"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :<<
        │   ├── message_loc: (143,4)-(143,6) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (143,7)-(143,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (143,7)-(143,11))
        │   │           ├── flags: ∅
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :A
        │   │           ├── message_loc: (143,7)-(143,8) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (143,9)-(143,11))
        │   │               ├── locals: []
        │   │               ├── locals_body_index: 0
        │   │               ├── parameters: ∅
        │   │               ├── body: ∅
        │   │               ├── opening_loc: (143,9)-(143,10) = "{"
        │   │               └── closing_loc: (143,10)-(143,11) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ InterpolatedStringNode (location: (145,0)-(145,17))
        │   ├── opening_loc: (145,0)-(145,1) = "\""
        │   ├── parts: (length: 1)
        │   │   └── @ EmbeddedStatementsNode (location: (145,1)-(145,16))
        │   │       ├── opening_loc: (145,1)-(145,3) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (145,4)-(145,14))
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (145,4)-(145,14))
        │   │       │           ├── flags: ∅
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :join
        │   │       │           ├── message_loc: (145,4)-(145,8) = "join"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments:
        │   │       │           │   @ ArgumentsNode (location: (145,9)-(145,14))
        │   │       │           │   ├── flags: ∅
        │   │       │           │   └── arguments: (length: 1)
        │   │       │           │       └── @ ParenthesesNode (location: (145,9)-(145,14))
        │   │       │           │           ├── body:
        │   │       │           │           │   @ StatementsNode (location: (145,10)-(145,13))
        │   │       │           │           │   └── body: (length: 1)
        │   │       │           │           │       └── @ StringNode (location: (145,10)-(145,13))
        │   │       │           │           │           ├── flags: ∅
        │   │       │           │           │           ├── opening_loc: (145,10)-(145,11) = "\""
        │   │       │           │           │           ├── content_loc: (145,11)-(145,12) = " "
        │   │       │           │           │           ├── closing_loc: (145,12)-(145,13) = "\""
        │   │       │           │           │           └── unescaped: " "
        │   │       │           │           ├── opening_loc: (145,9)-(145,10) = "("
        │   │       │           │           └── closing_loc: (145,13)-(145,14) = ")"
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       └── closing_loc: (145,15)-(145,16) = "}"
        │   └── closing_loc: (145,16)-(145,17) = "\""
        ├── @ InterpolatedStringNode (location: (147,0)-(147,8))
        │   ├── opening_loc: (147,0)-(147,1) = "\""
        │   ├── parts: (length: 1)
        │   │   └── @ EmbeddedStatementsNode (location: (147,1)-(147,7))
        │   │       ├── opening_loc: (147,1)-(147,3) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (147,3)-(147,6))
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ ParenthesesNode (location: (147,3)-(147,6))
        │   │       │           ├── body:
        │   │       │           │   @ StatementsNode (location: (147,4)-(147,5))
        │   │       │           │   └── body: (length: 1)
        │   │       │           │       └── @ CallNode (location: (147,4)-(147,5))
        │   │       │           │           ├── flags: variable_call
        │   │       │           │           ├── receiver: ∅
        │   │       │           │           ├── call_operator_loc: ∅
        │   │       │           │           ├── name: :v
        │   │       │           │           ├── message_loc: (147,4)-(147,5) = "v"
        │   │       │           │           ├── opening_loc: ∅
        │   │       │           │           ├── arguments: ∅
        │   │       │           │           ├── closing_loc: ∅
        │   │       │           │           └── block: ∅
        │   │       │           ├── opening_loc: (147,3)-(147,4) = "("
        │   │       │           └── closing_loc: (147,5)-(147,6) = ")"
        │   │       └── closing_loc: (147,6)-(147,7) = "}"
        │   └── closing_loc: (147,7)-(147,8) = "\""
        └── @ DefNode (location: (149,0)-(149,18))
            ├── name: :f
            ├── name_loc: (149,4)-(149,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (149,6)-(149,7))
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest:
            │   │   @ RestParameterNode (location: (149,6)-(149,7))
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (149,6)-(149,7) = "*"
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (149,10)-(149,13))
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (149,10)-(149,13))
            │           ├── flags: ∅
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :p
            │           ├── message_loc: (149,10)-(149,11) = "p"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (149,12)-(149,13))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ SplatNode (location: (149,12)-(149,13))
            │           │           ├── operator_loc: (149,12)-(149,13) = "*"
            │           │           └── expression: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── locals: [:*]
            ├── locals_body_index: 1
            ├── def_keyword_loc: (149,0)-(149,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (149,5)-(149,6) = "("
            ├── rparen_loc: (149,7)-(149,8) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (149,15)-(149,18) = "end"