path: root/test/prism/snapshots/unparser/corpus/literal/block.txt

@ ProgramNode (location: (1,0)-(96,1))
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(96,1))
    └── body: (length: 30)
        ├── @ CallNode (location: (1,0)-(2,1))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,4)-(2,1))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,4)-(1,5) = "{"
        │       └── closing_loc: (2,0)-(2,1) = "}"
        ├── @ CallNode (location: (3,0)-(4,1))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,4)-(4,1))
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (3,6)-(3,9))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (3,7)-(3,8))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (3,7)-(3,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (3,6)-(3,7) = "|"
        │       │   └── closing_loc: (3,8)-(3,9) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (3,4)-(3,5) = "{"
        │       └── closing_loc: (4,0)-(4,1) = "}"
        ├── @ CallNode (location: (5,0)-(6,1))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (5,0)-(5,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,4)-(6,1))
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (5,6)-(5,10))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (5,7)-(5,9))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (5,7)-(5,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ ImplicitRestNode (location: (5,8)-(5,9))
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (5,6)-(5,7) = "|"
        │       │   └── closing_loc: (5,9)-(5,10) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (5,4)-(5,5) = "{"
        │       └── closing_loc: (6,0)-(6,1) = "}"
        ├── @ CallNode (location: (7,0)-(8,1))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (7,0)-(7,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (7,4)-(8,1))
        │       ├── locals: [:a, :x]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (7,6)-(7,13))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (7,7)-(7,9))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (7,7)-(7,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ ImplicitRestNode (location: (7,8)-(7,9))
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 1)
        │       │   │   └── @ BlockLocalVariableNode (location: (7,11)-(7,12))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :x
        │       │   ├── opening_loc: (7,6)-(7,7) = "|"
        │       │   └── closing_loc: (7,12)-(7,13) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (7,4)-(7,5) = "{"
        │       └── closing_loc: (8,0)-(8,1) = "}"
        ├── @ CallNode (location: (9,0)-(10,1))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (9,4)-(10,1))
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (9,6)-(9,12))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (9,7)-(9,11))
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ RequiredParameterNode (location: (9,7)-(9,8))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   └── name: :a
        │       │   │   │   └── @ RequiredParameterNode (location: (9,10)-(9,11))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :b
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (9,6)-(9,7) = "|"
        │       │   └── closing_loc: (9,11)-(9,12) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (9,4)-(9,5) = "{"
        │       └── closing_loc: (10,0)-(10,1) = "}"
        ├── @ CallNode (location: (11,0)-(13,1))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (11,0)-(11,3) = "foo"
        │   ├── opening_loc: (11,3)-(11,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (11,4)-(11,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (11,4)-(11,5))
        │   │           ├── flags: decimal
        │   │           └── value: 1
        │   ├── closing_loc: (11,5)-(11,6) = ")"
        │   └── block:
        │       @ BlockNode (location: (11,7)-(13,1))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (12,2)-(12,5))
        │       │   └── body: (length: 1)
        │       │       └── @ NilNode (location: (12,2)-(12,5))
        │       ├── opening_loc: (11,7)-(11,8) = "{"
        │       └── closing_loc: (13,0)-(13,1) = "}"
        ├── @ CallNode (location: (14,0)-(16,1))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (14,0)-(14,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (14,4)-(16,1))
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (14,6)-(14,13))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (14,7)-(14,12))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (14,7)-(14,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (14,10)-(14,12))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :b
        │       │   │   │   ├── name_loc: (14,11)-(14,12) = "b"
        │       │   │   │   └── operator_loc: (14,10)-(14,11) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (14,6)-(14,7) = "|"
        │       │   └── closing_loc: (14,12)-(14,13) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (15,2)-(15,5))
        │       │   └── body: (length: 1)
        │       │       └── @ NilNode (location: (15,2)-(15,5))
        │       ├── opening_loc: (14,4)-(14,5) = "{"
        │       └── closing_loc: (16,0)-(16,1) = "}"
        ├── @ CallNode (location: (17,0)-(19,1))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (17,4)-(19,1))
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (17,6)-(17,12))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (17,7)-(17,11))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (17,7)-(17,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (17,10)-(17,11))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: ∅
        │       │   │   │   ├── name_loc: ∅
        │       │   │   │   └── operator_loc: (17,10)-(17,11) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (17,6)-(17,7) = "|"
        │       │   └── closing_loc: (17,11)-(17,12) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (18,2)-(18,5))
        │       │   └── body: (length: 1)
        │       │       └── @ NilNode (location: (18,2)-(18,5))
        │       ├── opening_loc: (17,4)-(17,5) = "{"
        │       └── closing_loc: (19,0)-(19,1) = "}"
        ├── @ CallNode (location: (20,0)-(22,1))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (20,0)-(20,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (20,4)-(22,1))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (21,2)-(21,5))
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (21,2)-(21,5))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :bar
        │       │           ├── message_loc: (21,2)-(21,5) = "bar"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (20,4)-(20,5) = "{"
        │       └── closing_loc: (22,0)-(22,1) = "}"
        ├── @ CallNode (location: (23,0)-(25,1))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (23,0)-(23,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (23,0)-(23,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (23,3)-(23,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (23,4)-(23,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (23,8)-(25,1))
        │       ├── locals: [:a, :b, :c]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (23,10)-(23,21))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (23,11)-(23,20))
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ MultiTargetNode (location: (23,11)-(23,17))
        │       │   │   │   │   ├── lefts: (length: 2)
        │       │   │   │   │   │   ├── @ RequiredParameterNode (location: (23,12)-(23,13))
        │       │   │   │   │   │   │   ├── flags: ∅
        │       │   │   │   │   │   │   └── name: :a
        │       │   │   │   │   │   └── @ RequiredParameterNode (location: (23,15)-(23,16))
        │       │   │   │   │   │       ├── flags: ∅
        │       │   │   │   │   │       └── name: :b
        │       │   │   │   │   ├── rest: ∅
        │       │   │   │   │   ├── rights: (length: 0)
        │       │   │   │   │   ├── lparen_loc: (23,11)-(23,12) = "("
        │       │   │   │   │   └── rparen_loc: (23,16)-(23,17) = ")"
        │       │   │   │   └── @ RequiredParameterNode (location: (23,19)-(23,20))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :c
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (23,10)-(23,11) = "|"
        │       │   └── closing_loc: (23,20)-(23,21) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (24,2)-(24,3))
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (24,2)-(24,3))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (24,2)-(24,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (23,8)-(23,9) = "{"
        │       └── closing_loc: (25,0)-(25,1) = "}"
        ├── @ CallNode (location: (26,0)-(27,1))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (26,0)-(26,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (26,0)-(26,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (26,3)-(26,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (26,4)-(26,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (26,8)-(27,1))
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (26,10)-(26,17))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (26,11)-(26,13))
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (26,11)-(26,13))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :a
        │       │   │   │   ├── name_loc: (26,12)-(26,13) = "a"
        │       │   │   │   └── operator_loc: (26,11)-(26,12) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 1)
        │       │   │   └── @ BlockLocalVariableNode (location: (26,15)-(26,16))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :b
        │       │   ├── opening_loc: (26,10)-(26,11) = "|"
        │       │   └── closing_loc: (26,16)-(26,17) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (26,8)-(26,9) = "{"
        │       └── closing_loc: (27,0)-(27,1) = "}"
        ├── @ CallNode (location: (28,0)-(29,1))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (28,0)-(28,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (28,0)-(28,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (28,3)-(28,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (28,4)-(28,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (28,8)-(29,1))
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (28,10)-(28,16))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (28,11)-(28,12))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (28,11)-(28,12))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 1)
        │       │   │   └── @ BlockLocalVariableNode (location: (28,14)-(28,15))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :b
        │       │   ├── opening_loc: (28,10)-(28,11) = "|"
        │       │   └── closing_loc: (28,15)-(28,16) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (28,8)-(28,9) = "{"
        │       └── closing_loc: (29,0)-(29,1) = "}"
        ├── @ CallNode (location: (30,0)-(31,1))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (30,0)-(30,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (30,0)-(30,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (30,3)-(30,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (30,4)-(30,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (30,8)-(31,1))
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (30,10)-(30,18))
        │       │   ├── parameters: ∅
        │       │   ├── locals: (length: 2)
        │       │   │   ├── @ BlockLocalVariableNode (location: (30,13)-(30,14))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   └── name: :a
        │       │   │   └── @ BlockLocalVariableNode (location: (30,16)-(30,17))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :b
        │       │   ├── opening_loc: (30,10)-(30,11) = "|"
        │       │   └── closing_loc: (30,17)-(30,18) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (30,8)-(30,9) = "{"
        │       └── closing_loc: (31,0)-(31,1) = "}"
        ├── @ CallNode (location: (32,0)-(34,1))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (32,0)-(32,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (32,0)-(32,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (32,3)-(32,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (32,4)-(32,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (32,8)-(34,1))
        │       ├── locals: []
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (32,10)-(32,13))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (32,11)-(32,12))
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (32,11)-(32,12))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: ∅
        │       │   │   │   ├── name_loc: ∅
        │       │   │   │   └── operator_loc: (32,11)-(32,12) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (32,10)-(32,11) = "|"
        │       │   └── closing_loc: (32,12)-(32,13) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (33,2)-(33,3))
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (33,2)-(33,3))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (33,2)-(33,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (32,8)-(32,9) = "{"
        │       └── closing_loc: (34,0)-(34,1) = "}"
        ├── @ CallNode (location: (35,0)-(37,1))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (35,0)-(35,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (35,0)-(35,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (35,3)-(35,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (35,4)-(35,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (35,8)-(37,1))
        │       ├── locals: []
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (35,10)-(35,15))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (35,11)-(35,14))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ MultiTargetNode (location: (35,11)-(35,14))
        │       │   │   │       ├── lefts: (length: 0)
        │       │   │   │       ├── rest:
        │       │   │   │       │   @ SplatNode (location: (35,12)-(35,13))
        │       │   │   │       │   ├── operator_loc: (35,12)-(35,13) = "*"
        │       │   │   │       │   └── expression: ∅
        │       │   │   │       ├── rights: (length: 0)
        │       │   │   │       ├── lparen_loc: (35,11)-(35,12) = "("
        │       │   │   │       └── rparen_loc: (35,13)-(35,14) = ")"
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (35,10)-(35,11) = "|"
        │       │   └── closing_loc: (35,14)-(35,15) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (36,2)-(36,3))
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (36,2)-(36,3))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (36,2)-(36,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (35,8)-(35,9) = "{"
        │       └── closing_loc: (37,0)-(37,1) = "}"
        ├── @ CallNode (location: (38,0)-(40,1))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (38,0)-(38,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (38,0)-(38,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (38,3)-(38,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (38,4)-(38,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (38,8)-(40,1))
        │       ├── locals: []
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (38,10)-(38,17))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (38,11)-(38,16))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ MultiTargetNode (location: (38,11)-(38,16))
        │       │   │   │       ├── lefts: (length: 1)
        │       │   │   │       │   └── @ MultiTargetNode (location: (38,12)-(38,15))
        │       │   │   │       │       ├── lefts: (length: 0)
        │       │   │   │       │       ├── rest:
        │       │   │   │       │       │   @ SplatNode (location: (38,13)-(38,14))
        │       │   │   │       │       │   ├── operator_loc: (38,13)-(38,14) = "*"
        │       │   │   │       │       │   └── expression: ∅
        │       │   │   │       │       ├── rights: (length: 0)
        │       │   │   │       │       ├── lparen_loc: (38,12)-(38,13) = "("
        │       │   │   │       │       └── rparen_loc: (38,14)-(38,15) = ")"
        │       │   │   │       ├── rest: ∅
        │       │   │   │       ├── rights: (length: 0)
        │       │   │   │       ├── lparen_loc: (38,11)-(38,12) = "("
        │       │   │   │       └── rparen_loc: (38,15)-(38,16) = ")"
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (38,10)-(38,11) = "|"
        │       │   └── closing_loc: (38,16)-(38,17) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (39,2)-(39,3))
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (39,2)-(39,3))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (39,2)-(39,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (38,8)-(38,9) = "{"
        │       └── closing_loc: (40,0)-(40,1) = "}"
        ├── @ CallNode (location: (41,0)-(43,1))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (41,0)-(41,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── 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: :bar
        │   ├── message_loc: (41,4)-(41,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (41,8)-(43,1))
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (41,10)-(41,20))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (41,11)-(41,19))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ MultiTargetNode (location: (41,11)-(41,19))
        │       │   │   │       ├── lefts: (length: 2)
        │       │   │   │       │   ├── @ RequiredParameterNode (location: (41,12)-(41,13))
        │       │   │   │       │   │   ├── flags: ∅
        │       │   │   │       │   │   └── name: :a
        │       │   │   │       │   └── @ MultiTargetNode (location: (41,15)-(41,18))
        │       │   │   │       │       ├── lefts: (length: 0)
        │       │   │   │       │       ├── rest:
        │       │   │   │       │       │   @ SplatNode (location: (41,16)-(41,17))
        │       │   │   │       │       │   ├── operator_loc: (41,16)-(41,17) = "*"
        │       │   │   │       │       │   └── expression: ∅
        │       │   │   │       │       ├── rights: (length: 0)
        │       │   │   │       │       ├── lparen_loc: (41,15)-(41,16) = "("
        │       │   │   │       │       └── rparen_loc: (41,17)-(41,18) = ")"
        │       │   │   │       ├── rest: ∅
        │       │   │   │       ├── rights: (length: 0)
        │       │   │   │       ├── lparen_loc: (41,11)-(41,12) = "("
        │       │   │   │       └── rparen_loc: (41,18)-(41,19) = ")"
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (41,10)-(41,11) = "|"
        │       │   └── closing_loc: (41,19)-(41,20) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (42,2)-(42,3))
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (42,2)-(42,3))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (42,2)-(42,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (41,8)-(41,9) = "{"
        │       └── closing_loc: (43,0)-(43,1) = "}"
        ├── @ CallNode (location: (44,0)-(46,1))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (44,0)-(44,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (44,0)-(44,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (44,3)-(44,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (44,4)-(44,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (44,8)-(46,1))
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (44,10)-(44,18))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (44,11)-(44,17))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ MultiTargetNode (location: (44,11)-(44,17))
        │       │   │   │       ├── lefts: (length: 2)
        │       │   │   │       │   ├── @ RequiredParameterNode (location: (44,12)-(44,13))
        │       │   │   │       │   │   ├── flags: ∅
        │       │   │   │       │   │   └── name: :a
        │       │   │   │       │   └── @ RequiredParameterNode (location: (44,15)-(44,16))
        │       │   │   │       │       ├── flags: ∅
        │       │   │   │       │       └── name: :b
        │       │   │   │       ├── rest: ∅
        │       │   │   │       ├── rights: (length: 0)
        │       │   │   │       ├── lparen_loc: (44,11)-(44,12) = "("
        │       │   │   │       └── rparen_loc: (44,16)-(44,17) = ")"
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (44,10)-(44,11) = "|"
        │       │   └── closing_loc: (44,17)-(44,18) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (45,2)-(45,3))
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (45,2)-(45,3))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (45,2)-(45,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (44,8)-(44,9) = "{"
        │       └── closing_loc: (46,0)-(46,1) = "}"
        ├── @ CallNode (location: (47,0)-(48,5))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ CallNode (location: (47,0)-(48,1))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (47,0)-(47,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (47,0)-(47,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (47,3)-(47,4) = "."
        │   │   ├── name: :bar
        │   │   ├── message_loc: (47,4)-(47,7) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (47,8)-(48,1))
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (47,8)-(47,9) = "{"
        │   │       └── closing_loc: (48,0)-(48,1) = "}"
        │   ├── call_operator_loc: (48,1)-(48,2) = "."
        │   ├── name: :baz
        │   ├── message_loc: (48,2)-(48,5) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (49,0)-(51,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (49,0)-(49,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (49,2)-(51,3))
        │       ├── locals: [:e]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (49,2)-(51,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (50,0)-(50,21))
        │       │   │   ├── keyword_loc: (50,0)-(50,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ ConstantReadNode (location: (50,7)-(50,16))
        │       │   │   │       └── name: :Exception
        │       │   │   ├── operator_loc: (50,17)-(50,19) = "=>"
        │       │   │   ├── reference:
        │       │   │   │   @ LocalVariableTargetNode (location: (50,20)-(50,21))
        │       │   │   │   ├── name: :e
        │       │   │   │   └── depth: 0
        │       │   │   ├── statements: ∅
        │       │   │   └── consequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (51,0)-(51,3) = "end"
        │       ├── opening_loc: (49,2)-(49,4) = "do"
        │       └── closing_loc: (51,0)-(51,3) = "end"
        ├── @ CallNode (location: (52,0)-(56,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (52,0)-(52,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (52,2)-(56,3))
        │       ├── locals: [:bar]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (52,2)-(56,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (53,2)-(53,5))
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (53,2)-(53,5))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :foo
        │       │   │           ├── message_loc: (53,2)-(53,5) = "foo"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (54,0)-(55,5))
        │       │   │   ├── keyword_loc: (54,0)-(54,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ ConstantReadNode (location: (54,7)-(54,16))
        │       │   │   │       └── name: :Exception
        │       │   │   ├── operator_loc: (54,17)-(54,19) = "=>"
        │       │   │   ├── reference:
        │       │   │   │   @ LocalVariableTargetNode (location: (54,20)-(54,23))
        │       │   │   │   ├── name: :bar
        │       │   │   │   └── depth: 0
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (55,2)-(55,5))
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ LocalVariableReadNode (location: (55,2)-(55,5))
        │       │   │   │           ├── name: :bar
        │       │   │   │           └── depth: 0
        │       │   │   └── consequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (56,0)-(56,3) = "end"
        │       ├── opening_loc: (52,2)-(52,4) = "do"
        │       └── closing_loc: (56,0)-(56,3) = "end"
        ├── @ CallNode (location: (57,0)-(61,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (57,0)-(57,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (57,2)-(61,3))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (57,2)-(61,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (58,2)-(58,5))
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (58,2)-(58,5))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (58,2)-(58,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (59,0)-(60,5))
        │       │   │   ├── keyword_loc: (59,0)-(59,6) = "rescue"
        │       │   │   ├── exceptions: (length: 2)
        │       │   │   │   ├── @ ConstantReadNode (location: (59,7)-(59,16))
        │       │   │   │   │   └── name: :SomeError
        │       │   │   │   └── @ SplatNode (location: (59,18)-(59,22))
        │       │   │   │       ├── operator_loc: (59,18)-(59,19) = "*"
        │       │   │   │       └── expression:
        │       │   │   │           @ CallNode (location: (59,19)-(59,22))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :bar
        │       │   │   │           ├── message_loc: (59,19)-(59,22) = "bar"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (60,2)-(60,5))
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (60,2)-(60,5))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (60,2)-(60,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── consequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (61,0)-(61,3) = "end"
        │       ├── opening_loc: (57,2)-(57,4) = "do"
        │       └── closing_loc: (61,0)-(61,3) = "end"
        ├── @ CallNode (location: (62,0)-(66,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (62,0)-(62,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (62,2)-(66,3))
        │       ├── locals: [:exception]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (62,2)-(66,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (63,2)-(63,5))
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (63,2)-(63,5))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (63,2)-(63,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (64,0)-(65,5))
        │       │   │   ├── keyword_loc: (64,0)-(64,6) = "rescue"
        │       │   │   ├── exceptions: (length: 2)
        │       │   │   │   ├── @ ConstantReadNode (location: (64,7)-(64,16))
        │       │   │   │   │   └── name: :SomeError
        │       │   │   │   └── @ SplatNode (location: (64,18)-(64,22))
        │       │   │   │       ├── operator_loc: (64,18)-(64,19) = "*"
        │       │   │   │       └── expression:
        │       │   │   │           @ CallNode (location: (64,19)-(64,22))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :bar
        │       │   │   │           ├── message_loc: (64,19)-(64,22) = "bar"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   ├── operator_loc: (64,23)-(64,25) = "=>"
        │       │   │   ├── reference:
        │       │   │   │   @ LocalVariableTargetNode (location: (64,26)-(64,35))
        │       │   │   │   ├── name: :exception
        │       │   │   │   └── depth: 0
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (65,2)-(65,5))
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (65,2)-(65,5))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (65,2)-(65,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── consequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (66,0)-(66,3) = "end"
        │       ├── opening_loc: (62,2)-(62,4) = "do"
        │       └── closing_loc: (66,0)-(66,3) = "end"
        ├── @ CallNode (location: (67,0)-(71,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (67,0)-(67,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (67,2)-(71,3))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (67,2)-(71,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (68,2)-(68,5))
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (68,2)-(68,5))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (68,2)-(68,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (69,0)-(70,5))
        │       │   │   ├── keyword_loc: (69,0)-(69,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ SplatNode (location: (69,7)-(69,11))
        │       │   │   │       ├── operator_loc: (69,7)-(69,8) = "*"
        │       │   │   │       └── expression:
        │       │   │   │           @ CallNode (location: (69,8)-(69,11))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :bar
        │       │   │   │           ├── message_loc: (69,8)-(69,11) = "bar"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (70,2)-(70,5))
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (70,2)-(70,5))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (70,2)-(70,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── consequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (71,0)-(71,3) = "end"
        │       ├── opening_loc: (67,2)-(67,4) = "do"
        │       └── closing_loc: (71,0)-(71,3) = "end"
        ├── @ CallNode (location: (72,0)-(75,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (72,0)-(72,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (72,2)-(75,3))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (72,2)-(75,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (73,2)-(73,5))
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (73,2)-(73,5))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (73,2)-(73,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (74,0)-(74,16))
        │       │   │   ├── keyword_loc: (74,0)-(74,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ ConstantReadNode (location: (74,7)-(74,16))
        │       │   │   │       └── name: :LoadError
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── statements: ∅
        │       │   │   └── consequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (75,0)-(75,3) = "end"
        │       ├── opening_loc: (72,2)-(72,4) = "do"
        │       └── closing_loc: (75,0)-(75,3) = "end"
        ├── @ CallNode (location: (76,0)-(81,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (76,0)-(76,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (76,2)-(81,3))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (76,2)-(81,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (77,2)-(77,5))
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (77,2)-(77,5))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (77,2)-(77,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (78,0)-(78,6))
        │       │   │   ├── keyword_loc: (78,0)-(78,6) = "rescue"
        │       │   │   ├── exceptions: (length: 0)
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── statements: ∅
        │       │   │   └── consequent: ∅
        │       │   ├── else_clause:
        │       │   │   @ ElseNode (location: (79,0)-(81,3))
        │       │   │   ├── else_keyword_loc: (79,0)-(79,4) = "else"
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (80,2)-(80,5))
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (80,2)-(80,5))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (80,2)-(80,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── end_keyword_loc: (81,0)-(81,3) = "end"
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (81,0)-(81,3) = "end"
        │       ├── opening_loc: (76,2)-(76,4) = "do"
        │       └── closing_loc: (81,0)-(81,3) = "end"
        ├── @ CallNode (location: (82,0)-(86,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (82,0)-(82,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (82,2)-(86,3))
        │       ├── locals: [:exception]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (82,2)-(86,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (83,2)-(83,5))
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (83,2)-(83,5))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (83,2)-(83,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (84,0)-(85,5))
        │       │   │   ├── keyword_loc: (84,0)-(84,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ SplatNode (location: (84,7)-(84,11))
        │       │   │   │       ├── operator_loc: (84,7)-(84,8) = "*"
        │       │   │   │       └── expression:
        │       │   │   │           @ CallNode (location: (84,8)-(84,11))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :bar
        │       │   │   │           ├── message_loc: (84,8)-(84,11) = "bar"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   ├── operator_loc: (84,12)-(84,14) = "=>"
        │       │   │   ├── reference:
        │       │   │   │   @ LocalVariableTargetNode (location: (84,15)-(84,24))
        │       │   │   │   ├── name: :exception
        │       │   │   │   └── depth: 0
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (85,2)-(85,5))
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (85,2)-(85,5))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (85,2)-(85,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── consequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (86,0)-(86,3) = "end"
        │       ├── opening_loc: (82,2)-(82,4) = "do"
        │       └── closing_loc: (86,0)-(86,3) = "end"
        ├── @ CallNode (location: (87,0)-(89,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (87,0)-(87,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (87,2)-(89,3))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (87,2)-(89,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements: ∅
        │       │   ├── rescue_clause: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause:
        │       │   │   @ EnsureNode (location: (88,0)-(89,3))
        │       │   │   ├── ensure_keyword_loc: (88,0)-(88,6) = "ensure"
        │       │   │   ├── statements: ∅
        │       │   │   └── end_keyword_loc: (89,0)-(89,3) = "end"
        │       │   └── end_keyword_loc: (89,0)-(89,3) = "end"
        │       ├── opening_loc: (87,2)-(87,4) = "do"
        │       └── closing_loc: (89,0)-(89,3) = "end"
        ├── @ CallNode (location: (90,0)-(93,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (90,0)-(90,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (90,2)-(93,3))
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (90,2)-(93,3))
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (91,0)-(91,6))
        │       │   │   ├── keyword_loc: (91,0)-(91,6) = "rescue"
        │       │   │   ├── exceptions: (length: 0)
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── statements: ∅
        │       │   │   └── consequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause:
        │       │   │   @ EnsureNode (location: (92,0)-(93,3))
        │       │   │   ├── ensure_keyword_loc: (92,0)-(92,6) = "ensure"
        │       │   │   ├── statements: ∅
        │       │   │   └── end_keyword_loc: (93,0)-(93,3) = "end"
        │       │   └── end_keyword_loc: (93,0)-(93,3) = "end"
        │       ├── opening_loc: (90,2)-(90,4) = "do"
        │       └── closing_loc: (93,0)-(93,3) = "end"
        └── @ CallNode (location: (94,0)-(96,1))
            ├── flags: ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :bar
            ├── message_loc: (94,0)-(94,3) = "bar"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (94,4)-(96,1))
                ├── locals: [:_1, :_2]
                ├── parameters:
                │   @ NumberedParametersNode (location: (94,4)-(96,1))
                │   └── maximum: 2
                ├── body:
                │   @ StatementsNode (location: (95,2)-(95,9))
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (95,2)-(95,9))
                │           ├── flags: ∅
                │           ├── receiver:
                │           │   @ LocalVariableReadNode (location: (95,2)-(95,4))
                │           │   ├── name: :_1
                │           │   └── depth: 0
                │           ├── call_operator_loc: ∅
                │           ├── name: :+
                │           ├── message_loc: (95,5)-(95,6) = "+"
                │           ├── opening_loc: ∅
                │           ├── arguments:
                │           │   @ ArgumentsNode (location: (95,7)-(95,9))
                │           │   ├── flags: ∅
                │           │   └── arguments: (length: 1)
                │           │       └── @ LocalVariableReadNode (location: (95,7)-(95,9))
                │           │           ├── name: :_2
                │           │           └── depth: 0
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (94,4)-(94,5) = "{"
                └── closing_loc: (96,0)-(96,1) = "}"