@ ProgramNode (location: (0...913))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...913))
    └── body: (length: 30)
        ├── @ DefNode (location: (0...46))
        │   ├── name: :foo
        │   ├── name_loc: (4...7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (10...46))
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (10...11))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (10...11))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (10...11) = "a"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "a"
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (12...22))
        │   │   │   ├── keyword_loc: (12...18) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (21...22))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (21...22))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (21...22) = "b"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "b"
        │   │   │   └── consequent: ∅
        │   │   ├── else_clause:
        │   │   │   @ ElseNode (location: (23...38))
        │   │   │   ├── else_keyword_loc: (23...27) = "else"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (30...31))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (30...31))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (30...31) = "c"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "c"
        │   │   │   └── end_keyword_loc: (32...38) = "ensure"
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (32...46))
        │   │   │   ├── ensure_keyword_loc: (32...38) = "ensure"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (41...42))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (41...42))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (41...42) = "d"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "d"
        │   │   │   └── end_keyword_loc: (43...46) = "end"
        │   │   └── end_keyword_loc: (43...46) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (0...3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (43...46) = "end"
        ├── @ DefNode (location: (48...103))
        │   ├── name: :foo
        │   ├── name_loc: (52...55) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (58...103))
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (58...68))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ RescueModifierNode (location: (58...68))
        │   │   │           ├── expression:
        │   │   │           │   @ CallNode (location: (58...59))
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── message_loc: (58...59) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   ├── block: ∅
        │   │   │           │   ├── flags: variable_call
        │   │   │           │   └── name: "a"
        │   │   │           ├── keyword_loc: (60...66) = "rescue"
        │   │   │           └── rescue_expression:
        │   │   │               @ CallNode (location: (67...68))
        │   │   │               ├── receiver: ∅
        │   │   │               ├── call_operator_loc: ∅
        │   │   │               ├── message_loc: (67...68) = "b"
        │   │   │               ├── opening_loc: ∅
        │   │   │               ├── arguments: ∅
        │   │   │               ├── closing_loc: ∅
        │   │   │               ├── block: ∅
        │   │   │               ├── flags: variable_call
        │   │   │               └── name: "b"
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (69...79))
        │   │   │   ├── keyword_loc: (69...75) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (78...79))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (78...79))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (78...79) = "b"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "b"
        │   │   │   └── consequent: ∅
        │   │   ├── else_clause:
        │   │   │   @ ElseNode (location: (80...95))
        │   │   │   ├── else_keyword_loc: (80...84) = "else"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (87...88))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (87...88))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (87...88) = "c"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "c"
        │   │   │   └── end_keyword_loc: (89...95) = "ensure"
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (89...103))
        │   │   │   ├── ensure_keyword_loc: (89...95) = "ensure"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (98...99))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (98...99))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (98...99) = "d"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "d"
        │   │   │   └── end_keyword_loc: (100...103) = "end"
        │   │   └── end_keyword_loc: (100...103) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (48...51) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (100...103) = "end"
        ├── @ DefNode (location: (105...128))
        │   ├── name: :foo
        │   ├── name_loc: (109...112) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (113...123))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ KeywordParameterNode (location: (113...117))
        │   │   │   │   ├── name: :bar
        │   │   │   │   ├── name_loc: (113...117) = "bar:"
        │   │   │   │   └── value: ∅
        │   │   │   └── @ KeywordParameterNode (location: (119...123))
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (119...123) = "baz:"
        │   │   │       └── value: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (105...108) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (112...113) = "("
        │   ├── rparen_loc: (123...124) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (125...128) = "end"
        ├── @ DefNode (location: (130...141))
        │   ├── name: :foo
        │   ├── name_loc: (134...137) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (130...133) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (138...141) = "end"
        ├── @ DefNode (location: (143...160))
        │   ├── name: :foo
        │   ├── name_loc: (147...150) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (153...156))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (153...156))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (153...156) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── locals: []
        │   ├── def_keyword_loc: (143...146) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (157...160) = "end"
        ├── @ DefNode (location: (162...205))
        │   ├── name: :foo
        │   ├── name_loc: (166...169) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (172...205))
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (172...175))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (172...175))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (172...175) = "foo"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "foo"
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (176...188))
        │   │   │   ├── keyword_loc: (176...182) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (185...188))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (185...188))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (185...188) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "bar"
        │   │   │   └── consequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (189...205))
        │   │   │   ├── ensure_keyword_loc: (189...195) = "ensure"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (198...201))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (198...201))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (198...201) = "baz"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "baz"
        │   │   │   └── end_keyword_loc: (202...205) = "end"
        │   │   └── end_keyword_loc: (202...205) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (162...165) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (202...205) = "end"
        ├── @ DefNode (location: (207...237))
        │   ├── name: :foo
        │   ├── name_loc: (211...214) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (217...237))
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (217...220))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (217...220))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (217...220) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "bar"
        │   │   ├── rescue_clause: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (221...237))
        │   │   │   ├── ensure_keyword_loc: (221...227) = "ensure"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (230...233))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (230...233))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (230...233) = "baz"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "baz"
        │   │   │   └── end_keyword_loc: (234...237) = "end"
        │   │   └── end_keyword_loc: (234...237) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (207...210) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (234...237) = "end"
        ├── @ DefNode (location: (239...269))
        │   ├── name: :foo
        │   ├── name_loc: (243...246) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (249...269))
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (249...252))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (249...252))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (249...252) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "bar"
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (253...265))
        │   │   │   ├── keyword_loc: (253...259) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (262...265))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (262...265))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (262...265) = "baz"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "baz"
        │   │   │   └── consequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (266...269) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (239...242) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (266...269) = "end"
        ├── @ DefNode (location: (271...293))
        │   ├── name: :foo
        │   ├── name_loc: (275...278) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (279...282))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (279...282))
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (286...289))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (286...289))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (271...274) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (278...279) = "("
        │   ├── rparen_loc: (282...283) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (290...293) = "end"
        ├── @ DefNode (location: (295...322))
        │   ├── name: :foo
        │   ├── name_loc: (299...302) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (303...311))
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ RequiredParameterNode (location: (303...306))
        │   │   │   │   └── name: :bar
        │   │   │   └── @ RequiredParameterNode (location: (308...311))
        │   │   │       └── name: :baz
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (315...318))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (315...318))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (295...298) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (302...303) = "("
        │   ├── rparen_loc: (311...312) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (319...322) = "end"
        ├── @ DefNode (location: (324...351))
        │   ├── name: :foo
        │   ├── name_loc: (328...331) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (332...340))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (332...340))
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (332...335) = "bar"
        │   │   │       ├── operator_loc: (336...337) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (338...340))
        │   │   │           ├── body: ∅
        │   │   │           ├── opening_loc: (338...339) = "("
        │   │   │           └── closing_loc: (339...340) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (344...347))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (344...347))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (324...327) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (331...332) = "("
        │   ├── rparen_loc: (340...341) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (348...351) = "end"
        ├── @ DefNode (location: (353...382))
        │   ├── name: :foo
        │   ├── name_loc: (357...360) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (361...377))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (361...377))
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (361...364) = "bar"
        │   │   │       ├── operator_loc: (365...366) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (367...377))
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (368...376))
        │   │   │           │   └── body: (length: 2)
        │   │   │           │       ├── @ CallNode (location: (368...371))
        │   │   │           │       │   ├── receiver: ∅
        │   │   │           │       │   ├── call_operator_loc: ∅
        │   │   │           │       │   ├── message_loc: (368...371) = "baz"
        │   │   │           │       │   ├── opening_loc: ∅
        │   │   │           │       │   ├── arguments: ∅
        │   │   │           │       │   ├── closing_loc: ∅
        │   │   │           │       │   ├── block: ∅
        │   │   │           │       │   ├── flags: variable_call
        │   │   │           │       │   └── name: "baz"
        │   │   │           │       └── @ NilNode (location: (373...376))
        │   │   │           ├── opening_loc: (367...368) = "("
        │   │   │           └── closing_loc: (376...377) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (353...356) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (360...361) = "("
        │   ├── rparen_loc: (377...378) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (379...382) = "end"
        ├── @ DefNode (location: (384...413))
        │   ├── name: :foo
        │   ├── name_loc: (388...391) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (392...402))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (392...402))
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (392...395) = "bar"
        │   │   │       ├── operator_loc: (396...397) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (398...402))
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (406...409))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (406...409))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (384...387) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (391...392) = "("
        │   ├── rparen_loc: (402...403) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (410...413) = "end"
        ├── @ DefNode (location: (415...449))
        │   ├── name: :foo
        │   ├── name_loc: (419...422) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (423...438))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (423...426))
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (428...438))
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (428...431) = "baz"
        │   │   │       ├── operator_loc: (432...433) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (434...438))
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (442...445))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (442...445))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (415...418) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (422...423) = "("
        │   ├── rparen_loc: (438...439) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (446...449) = "end"
        ├── @ DefNode (location: (451...470))
        │   ├── name: :foo
        │   ├── name_loc: (455...458) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (459...465))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ KeywordParameterNode (location: (459...465))
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (459...463) = "bar:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (464...465))
        │   │   │           └── flags: decimal
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (451...454) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (458...459) = "("
        │   ├── rparen_loc: (465...466) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (467...470) = "end"
        ├── @ DefNode (location: (472...493))
        │   ├── name: :foo
        │   ├── name_loc: (476...479) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (480...488))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ KeywordParameterNode (location: (480...488))
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (480...484) = "bar:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (485...488))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (485...488) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "baz"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (472...475) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (479...480) = "("
        │   ├── rparen_loc: (488...489) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (490...493) = "end"
        ├── @ DefNode (location: (495...518))
        │   ├── name: :foo
        │   ├── name_loc: (499...502) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (503...513))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ KeywordParameterNode (location: (503...513))
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (503...507) = "bar:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (508...513))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (508...511) = "bar"
        │   │   │           ├── opening_loc: (511...512) = "("
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: (512...513) = ")"
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: ∅
        │   │   │           └── name: "bar"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (495...498) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (502...503) = "("
        │   ├── rparen_loc: (513...514) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (515...518) = "end"
        ├── @ DefNode (location: (520...540))
        │   ├── name: :foo
        │   ├── name_loc: (524...527) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (528...529))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (528...529))
        │   │   │   ├── name: nil
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (528...529) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (533...536))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (533...536))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (533...536) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── locals: [:*]
        │   ├── def_keyword_loc: (520...523) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (527...528) = "("
        │   ├── rparen_loc: (529...530) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (537...540) = "end"
        ├── @ DefNode (location: (542...565))
        │   ├── name: :foo
        │   ├── name_loc: (546...549) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (550...554))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (550...554))
        │   │   │   ├── name: :bar
        │   │   │   ├── name_loc: (551...554) = "bar"
        │   │   │   └── operator_loc: (550...551) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (558...561))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (558...561))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (542...545) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (549...550) = "("
        │   ├── rparen_loc: (554...555) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (562...565) = "end"
        ├── @ DefNode (location: (567...595))
        │   ├── name: :foo
        │   ├── name_loc: (571...574) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (575...584))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (575...578))
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (580...584))
        │   │   │   ├── name: :baz
        │   │   │   ├── name_loc: (581...584) = "baz"
        │   │   │   └── operator_loc: (580...581) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (588...591))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (588...591))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (567...570) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (574...575) = "("
        │   ├── rparen_loc: (584...585) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (592...595) = "end"
        ├── @ DefNode (location: (597...632))
        │   ├── name: :foo
        │   ├── name_loc: (601...604) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (605...621))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (605...615))
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (605...608) = "baz"
        │   │   │       ├── operator_loc: (609...610) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (611...615))
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (617...621))
        │   │   │   ├── name: :bor
        │   │   │   ├── name_loc: (618...621) = "bor"
        │   │   │   └── operator_loc: (617...618) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (625...628))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (625...628))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (625...628) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── locals: [:baz, :bor]
        │   ├── def_keyword_loc: (597...600) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (604...605) = "("
        │   ├── rparen_loc: (621...622) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (629...632) = "end"
        ├── @ DefNode (location: (634...677))
        │   ├── name: :foo
        │   ├── name_loc: (638...641) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (642...666))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (642...652))
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (642...645) = "baz"
        │   │   │       ├── operator_loc: (646...647) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (648...652))
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (654...658))
        │   │   │   ├── name: :bor
        │   │   │   ├── name_loc: (655...658) = "bor"
        │   │   │   └── operator_loc: (654...655) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (660...666))
        │   │       ├── name: :block
        │   │       ├── name_loc: (661...666) = "block"
        │   │       └── operator_loc: (660...661) = "&"
        │   ├── body:
        │   │   @ StatementsNode (location: (670...673))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (670...673))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (670...673) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── locals: [:baz, :bor, :block]
        │   ├── def_keyword_loc: (634...637) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (641...642) = "("
        │   ├── rparen_loc: (666...667) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (674...677) = "end"
        ├── @ DefNode (location: (679...719))
        │   ├── name: :foo
        │   ├── name_loc: (683...686) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (687...708))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (687...690))
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (692...702))
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (692...695) = "baz"
        │   │   │       ├── operator_loc: (696...697) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (698...702))
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (704...708))
        │   │   │   ├── name: :bor
        │   │   │   ├── name_loc: (705...708) = "bor"
        │   │   │   └── operator_loc: (704...705) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (712...715))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (712...715))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :baz, :bor]
        │   ├── def_keyword_loc: (679...682) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (686...687) = "("
        │   ├── rparen_loc: (708...709) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (716...719) = "end"
        ├── @ DefNode (location: (721...746))
        │   ├── name: :foo
        │   ├── name_loc: (725...728) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (729...735))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (729...735))
        │   │       ├── name: :block
        │   │       ├── name_loc: (730...735) = "block"
        │   │       └── operator_loc: (729...730) = "&"
        │   ├── body:
        │   │   @ StatementsNode (location: (739...742))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (739...742))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (739...742) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── locals: [:block]
        │   ├── def_keyword_loc: (721...724) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (728...729) = "("
        │   ├── rparen_loc: (735...736) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (743...746) = "end"
        ├── @ DefNode (location: (748...778))
        │   ├── name: :foo
        │   ├── name_loc: (752...755) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (756...767))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (756...759))
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (761...767))
        │   │       ├── name: :block
        │   │       ├── name_loc: (762...767) = "block"
        │   │       └── operator_loc: (761...762) = "&"
        │   ├── body:
        │   │   @ StatementsNode (location: (771...774))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (771...774))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :block]
        │   ├── def_keyword_loc: (748...751) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (755...756) = "("
        │   ├── rparen_loc: (767...768) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (775...778) = "end"
        ├── @ DefNode (location: (780...803))
        │   ├── name: :foo
        │   ├── name_loc: (784...787) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (790...799))
        │   │   └── body: (length: 2)
        │   │       ├── @ CallNode (location: (790...793))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (790...793) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "bar"
        │   │       └── @ CallNode (location: (796...799))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (796...799) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "baz"
        │   ├── locals: []
        │   ├── def_keyword_loc: (780...783) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (800...803) = "end"
        ├── @ DefNode (location: (805...821))
        │   ├── name: :f
        │   ├── name_loc: (809...810) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (811...816))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredDestructuredParameterNode (location: (811...816))
        │   │   │       ├── parameters: (length: 1)
        │   │   │       │   └── @ RequiredDestructuredParameterNode (location: (812...815))
        │   │   │       │       ├── parameters: (length: 1)
        │   │   │       │       │   └── @ RequiredParameterNode (location: (813...814))
        │   │   │       │       │       └── name: :a
        │   │   │       │       ├── opening_loc: (812...813) = "("
        │   │   │       │       └── closing_loc: (814...815) = ")"
        │   │   │       ├── opening_loc: (811...812) = "("
        │   │   │       └── closing_loc: (815...816) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (805...808) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (810...811) = "("
        │   ├── rparen_loc: (816...817) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (818...821) = "end"
        ├── @ DefNode (location: (823...854))
        │   ├── name: :foo
        │   ├── name_loc: (827...830) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (831...849))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ KeywordParameterNode (location: (831...835))
        │   │   │   │   ├── name: :bar
        │   │   │   │   ├── name_loc: (831...835) = "bar:"
        │   │   │   │   └── value: ∅
        │   │   │   └── @ KeywordParameterNode (location: (837...849))
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (837...841) = "baz:"
        │   │   │       └── value:
        │   │   │           @ StringNode (location: (842...849))
        │   │   │           ├── opening_loc: (842...843) = "\""
        │   │   │           ├── content_loc: (843...848) = "value"
        │   │   │           ├── closing_loc: (848...849) = "\""
        │   │   │           └── unescaped: "value"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (823...826) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (830...831) = "("
        │   ├── rparen_loc: (849...850) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (851...854) = "end"
        ├── @ DefNode (location: (856...896))
        │   ├── name: :f
        │   ├── name_loc: (860...861) = "f"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (864...874))
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (864...874))
        │   │           ├── opening_loc: (864...874) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (875...879))
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (875...879) = "    "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "    "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (879...882))
        │   │           │   │   ├── opening_loc: (879...881) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (881...882) = "}"
        │   │           │   └── @ StringNode (location: (882...883))
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (882...883) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (883...893) = "  HEREDOC\n"
        │   ├── locals: []
        │   ├── def_keyword_loc: (856...859) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (893...896) = "end"
        └── @ DefNode (location: (898...913))
            ├── name: :f
            ├── name_loc: (902...903) = "f"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (906...909))
            │   └── body: (length: 1)
            │       └── @ StringNode (location: (906...909))
            │           ├── opening_loc: (906...908) = "%("
            │           ├── content_loc: (908...908) = ""
            │           ├── closing_loc: (908...909) = ")"
            │           └── unescaped: ""
            ├── locals: []
            ├── def_keyword_loc: (898...901) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (910...913) = "end"
