@ ProgramNode (location: (0...402))
├── locals: [:fork]
└── statements:
    @ StatementsNode (location: (0...402))
    └── body: (length: 20)
        ├── @ CallNode (location: (0...16))
        │   ├── receiver:
        │   │   @ CallNode (location: (0...3))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (0...3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (3...8) = "[bar]"
        │   ├── opening_loc: (3...4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (4...7))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (4...7))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (4...7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── closing_loc: (7...8) = "]"
        │   ├── block:
        │   │   @ BlockNode (location: (9...16))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (11...14))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (11...14))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (11...14) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "baz"
        │   │   ├── opening_loc: (9...10) = "{"
        │   │   └── closing_loc: (15...16) = "}"
        │   ├── flags: ∅
        │   └── name: "[]"
        ├── @ CallNode (location: (18...37))
        │   ├── receiver:
        │   │   @ CallNode (location: (18...21))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (18...21) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (21...26) = "[bar]"
        │   ├── opening_loc: (21...22) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (22...25))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (22...25))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (22...25) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── closing_loc: (25...26) = "]"
        │   ├── block:
        │   │   @ BlockNode (location: (27...37))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (30...33))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (30...33))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (30...33) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "baz"
        │   │   ├── opening_loc: (27...29) = "do"
        │   │   └── closing_loc: (34...37) = "end"
        │   ├── flags: ∅
        │   └── name: "[]"
        ├── @ CallNode (location: (39...74))
        │   ├── receiver:
        │   │   @ CallNode (location: (39...40))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (39...40) = "x"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "x"
        │   ├── call_operator_loc: (40...41) = "."
        │   ├── message_loc: (41...47) = "reduce"
        │   ├── opening_loc: (47...48) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (48...49))
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (48...49))
        │   │           └── flags: decimal
        │   ├── closing_loc: (49...50) = ")"
        │   ├── block:
        │   │   @ BlockNode (location: (51...74))
        │   │   ├── locals: [:x, :memo]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (53...62))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (54...61))
        │   │   │   │   ├── requireds: (length: 2)
        │   │   │   │   │   ├── @ RequiredParameterNode (location: (54...55))
        │   │   │   │   │   │   └── name: :x
        │   │   │   │   │   └── @ RequiredParameterNode (location: (57...61))
        │   │   │   │   │       └── name: :memo
        │   │   │   │   ├── optionals: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (53...54) = "|"
        │   │   │   └── closing_loc: (61...62) = "|"
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (63...72))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableOperatorWriteNode (location: (63...72))
        │   │   │           ├── name_loc: (63...67) = "memo"
        │   │   │           ├── operator_loc: (68...70) = "+="
        │   │   │           ├── value:
        │   │   │           │   @ LocalVariableReadNode (location: (71...72))
        │   │   │           │   ├── name: :x
        │   │   │           │   └── depth: 0
        │   │   │           ├── name: :memo
        │   │   │           ├── operator: :+
        │   │   │           └── depth: 0
        │   │   ├── opening_loc: (51...52) = "{"
        │   │   └── closing_loc: (73...74) = "}"
        │   ├── flags: ∅
        │   └── name: "reduce"
        ├── @ CallNode (location: (76...86))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (76...79) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (80...86))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (80...82) = "do"
        │   │   └── closing_loc: (83...86) = "end"
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (88...109))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (88...91) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (92...109))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (92...95))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (92...95) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "bar"
        │   │       └── @ ParenthesesNode (location: (97...109))
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (98...108))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (98...108))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (98...101) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block:
        │   │           │           │   @ BlockNode (location: (102...108))
        │   │           │           │   ├── locals: []
        │   │           │           │   ├── parameters: ∅
        │   │           │           │   ├── body: ∅
        │   │           │           │   ├── opening_loc: (102...104) = "do"
        │   │           │           │   └── closing_loc: (105...108) = "end"
        │   │           │           ├── flags: ∅
        │   │           │           └── name: "baz"
        │   │           ├── opening_loc: (97...98) = "("
        │   │           └── closing_loc: (108...109) = ")"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (111...125))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (111...114) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (115...118))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (115...118))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (115...118) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (119...125))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (119...121) = "do"
        │   │   └── closing_loc: (122...125) = "end"
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (127...145))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (127...130) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (131...138))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (131...138))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (131...134) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (135...138))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ CallNode (location: (135...138))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (135...138) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: variable_call
        │   │           │           └── name: "baz"
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "bar"
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (139...145))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (139...141) = "do"
        │   │   └── closing_loc: (142...145) = "end"
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (147...168))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (147...150) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (151...168))
        │   │   ├── locals: [:a]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (154...164))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (155...163))
        │   │   │   │   ├── requireds: (length: 0)
        │   │   │   │   ├── optionals: (length: 1)
        │   │   │   │   │   └── @ OptionalParameterNode (location: (155...163))
        │   │   │   │   │       ├── name: :a
        │   │   │   │   │       ├── name_loc: (155...156) = "a"
        │   │   │   │   │       ├── operator_loc: (157...158) = "="
        │   │   │   │   │       └── value:
        │   │   │   │   │           @ CallNode (location: (159...163))
        │   │   │   │   │           ├── receiver:
        │   │   │   │   │           │   @ CallNode (location: (159...160))
        │   │   │   │   │           │   ├── receiver: ∅
        │   │   │   │   │           │   ├── call_operator_loc: ∅
        │   │   │   │   │           │   ├── message_loc: (159...160) = "b"
        │   │   │   │   │           │   ├── opening_loc: ∅
        │   │   │   │   │           │   ├── arguments: ∅
        │   │   │   │   │           │   ├── closing_loc: ∅
        │   │   │   │   │           │   ├── block: ∅
        │   │   │   │   │           │   ├── flags: variable_call
        │   │   │   │   │           │   └── name: "b"
        │   │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │   │           ├── message_loc: (160...163) = "[1]"
        │   │   │   │   │           ├── opening_loc: (160...161) = "["
        │   │   │   │   │           ├── arguments:
        │   │   │   │   │           │   @ ArgumentsNode (location: (161...162))
        │   │   │   │   │           │   └── arguments: (length: 1)
        │   │   │   │   │           │       └── @ IntegerNode (location: (161...162))
        │   │   │   │   │           │           └── flags: decimal
        │   │   │   │   │           ├── closing_loc: (162...163) = "]"
        │   │   │   │   │           ├── block: ∅
        │   │   │   │   │           ├── flags: ∅
        │   │   │   │   │           └── name: "[]"
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (154...155) = "|"
        │   │   │   └── closing_loc: (163...164) = "|"
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (151...153) = "do"
        │   │   └── closing_loc: (165...168) = "end"
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (170...187))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (170...173) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (174...187))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ BeginNode (location: (177...187))
        │   │   │   ├── begin_keyword_loc: ∅
        │   │   │   ├── statements: ∅
        │   │   │   ├── rescue_clause:
        │   │   │   │   @ RescueNode (location: (177...183))
        │   │   │   │   ├── keyword_loc: (177...183) = "rescue"
        │   │   │   │   ├── exceptions: (length: 0)
        │   │   │   │   ├── operator_loc: ∅
        │   │   │   │   ├── reference: ∅
        │   │   │   │   ├── statements: ∅
        │   │   │   │   └── consequent: ∅
        │   │   │   ├── else_clause: ∅
        │   │   │   ├── ensure_clause: ∅
        │   │   │   └── end_keyword_loc: (184...187) = "end"
        │   │   ├── opening_loc: (174...176) = "do"
        │   │   └── closing_loc: (184...187) = "end"
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (189...233))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (189...192) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (193...233))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (198...229))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (198...229))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (198...201) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block:
        │   │   │           │   @ BlockNode (location: (202...229))
        │   │   │           │   ├── locals: []
        │   │   │           │   ├── parameters: ∅
        │   │   │           │   ├── body:
        │   │   │           │   │   @ StatementsNode (location: (209...223))
        │   │   │           │   │   └── body: (length: 1)
        │   │   │           │   │       └── @ CallNode (location: (209...223))
        │   │   │           │   │           ├── receiver: ∅
        │   │   │           │   │           ├── call_operator_loc: ∅
        │   │   │           │   │           ├── message_loc: (209...212) = "baz"
        │   │   │           │   │           ├── opening_loc: ∅
        │   │   │           │   │           ├── arguments: ∅
        │   │   │           │   │           ├── closing_loc: ∅
        │   │   │           │   │           ├── block:
        │   │   │           │   │           │   @ BlockNode (location: (213...223))
        │   │   │           │   │           │   ├── locals: []
        │   │   │           │   │           │   ├── parameters: ∅
        │   │   │           │   │           │   ├── body: ∅
        │   │   │           │   │           │   ├── opening_loc: (213...215) = "do"
        │   │   │           │   │           │   └── closing_loc: (220...223) = "end"
        │   │   │           │   │           ├── flags: ∅
        │   │   │           │   │           └── name: "baz"
        │   │   │           │   ├── opening_loc: (202...204) = "do"
        │   │   │           │   └── closing_loc: (226...229) = "end"
        │   │   │           ├── flags: ∅
        │   │   │           └── name: "bar"
        │   │   ├── opening_loc: (193...195) = "do"
        │   │   └── closing_loc: (230...233) = "end"
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (235...251))
        │   ├── receiver:
        │   │   @ CallNode (location: (235...238))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (235...238) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "foo"
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (238...243) = "[bar]"
        │   ├── opening_loc: (238...239) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (239...242))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (239...242))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (239...242) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "bar"
        │   ├── closing_loc: (242...243) = "]"
        │   ├── block:
        │   │   @ BlockNode (location: (244...251))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (246...249))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (246...249))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (246...249) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "baz"
        │   │   ├── opening_loc: (244...245) = "{"
        │   │   └── closing_loc: (250...251) = "}"
        │   ├── flags: ∅
        │   └── name: "[]"
        ├── @ CallNode (location: (253...277))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (253...256) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (257...277))
        │   │   ├── locals: [:x, :y, :z]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (259...273))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (260...272))
        │   │   │   │   ├── requireds: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (260...261))
        │   │   │   │   │       └── name: :x
        │   │   │   │   ├── optionals: (length: 1)
        │   │   │   │   │   └── @ OptionalParameterNode (location: (263...268))
        │   │   │   │   │       ├── name: :y
        │   │   │   │   │       ├── name_loc: (263...264) = "y"
        │   │   │   │   │       ├── operator_loc: (265...266) = "="
        │   │   │   │   │       └── value:
        │   │   │   │   │           @ IntegerNode (location: (267...268))
        │   │   │   │   │           └── flags: decimal
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 1)
        │   │   │   │   │   └── @ KeywordParameterNode (location: (270...272))
        │   │   │   │   │       ├── name: :z
        │   │   │   │   │       ├── name_loc: (270...272) = "z:"
        │   │   │   │   │       └── value: ∅
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (259...260) = "|"
        │   │   │   └── closing_loc: (272...273) = "|"
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (274...275))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableReadNode (location: (274...275))
        │   │   │           ├── name: :x
        │   │   │           └── depth: 0
        │   │   ├── opening_loc: (257...258) = "{"
        │   │   └── closing_loc: (276...277) = "}"
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ CallNode (location: (279...290))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (279...282) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (283...290))
        │   │   ├── locals: [:x]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (285...288))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (286...287))
        │   │   │   │   ├── requireds: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (286...287))
        │   │   │   │   │       └── name: :x
        │   │   │   │   ├── optionals: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (285...286) = "|"
        │   │   │   └── closing_loc: (287...288) = "|"
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (283...284) = "{"
        │   │   └── closing_loc: (289...290) = "}"
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ LocalVariableWriteNode (location: (292...300))
        │   ├── name: :fork
        │   ├── depth: 0
        │   ├── name_loc: (292...296) = "fork"
        │   ├── value:
        │   │   @ IntegerNode (location: (299...300))
        │   │   └── flags: decimal
        │   └── operator_loc: (297...298) = "="
        ├── @ CallNode (location: (301...316))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (301...305) = "fork"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (306...316))
        │   │   ├── locals: [:a]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (309...312))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (310...311))
        │   │   │   │   ├── requireds: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (310...311))
        │   │   │   │   │       └── name: :a
        │   │   │   │   ├── optionals: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (309...310) = "|"
        │   │   │   └── closing_loc: (311...312) = "|"
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (306...308) = "do"
        │   │   └── closing_loc: (313...316) = "end"
        │   ├── flags: ∅
        │   └── name: "fork"
        ├── @ CallNode (location: (318...330))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (318...322) = "fork"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (323...330))
        │   │   ├── locals: [:a]
        │   │   ├── parameters:
        │   │   │   @ BlockParametersNode (location: (325...328))
        │   │   │   ├── parameters:
        │   │   │   │   @ ParametersNode (location: (326...327))
        │   │   │   │   ├── requireds: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (326...327))
        │   │   │   │   │       └── name: :a
        │   │   │   │   ├── optionals: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── keywords: (length: 0)
        │   │   │   │   ├── keyword_rest: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── locals: (length: 0)
        │   │   │   ├── opening_loc: (325...326) = "|"
        │   │   │   └── closing_loc: (327...328) = "|"
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (323...324) = "{"
        │   │   └── closing_loc: (329...330) = "}"
        │   ├── flags: ∅
        │   └── name: "fork"
        ├── @ CallNode (location: (332...340))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (332...333) = "C"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (334...340))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (334...336) = "do"
        │   │   └── closing_loc: (337...340) = "end"
        │   ├── flags: ∅
        │   └── name: "C"
        ├── @ CallNode (location: (342...346))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (342...343) = "C"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockNode (location: (344...346))
        │   │   ├── locals: []
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (344...345) = "{"
        │   │   └── closing_loc: (345...346) = "}"
        │   ├── flags: ∅
        │   └── name: "C"
        ├── @ CallNode (location: (348...383))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (348...351) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (352...383))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (352...383))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (352...358) = "lambda"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block:
        │   │           │   @ BlockNode (location: (359...383))
        │   │           │   ├── locals: [:a, :b]
        │   │           │   ├── parameters:
        │   │           │   │   @ BlockParametersNode (location: (361...381))
        │   │           │   │   ├── parameters:
        │   │           │   │   │   @ ParametersNode (location: (365...377))
        │   │           │   │   │   ├── requireds: (length: 0)
        │   │           │   │   │   ├── optionals: (length: 0)
        │   │           │   │   │   ├── rest: ∅
        │   │           │   │   │   ├── posts: (length: 0)
        │   │           │   │   │   ├── keywords: (length: 2)
        │   │           │   │   │   │   ├── @ KeywordParameterNode (location: (365...369))
        │   │           │   │   │   │   │   ├── name: :a
        │   │           │   │   │   │   │   ├── name_loc: (365...367) = "a:"
        │   │           │   │   │   │   │   └── value:
        │   │           │   │   │   │   │       @ IntegerNode (location: (368...369))
        │   │           │   │   │   │   │       └── flags: decimal
        │   │           │   │   │   │   └── @ KeywordParameterNode (location: (373...377))
        │   │           │   │   │   │       ├── name: :b
        │   │           │   │   │   │       ├── name_loc: (373...375) = "b:"
        │   │           │   │   │   │       └── value:
        │   │           │   │   │   │           @ IntegerNode (location: (376...377))
        │   │           │   │   │   │           └── flags: decimal
        │   │           │   │   │   ├── keyword_rest: ∅
        │   │           │   │   │   └── block: ∅
        │   │           │   │   ├── locals: (length: 0)
        │   │           │   │   ├── opening_loc: (361...362) = "|"
        │   │           │   │   └── closing_loc: (380...381) = "|"
        │   │           │   ├── body: ∅
        │   │           │   ├── opening_loc: (359...360) = "{"
        │   │           │   └── closing_loc: (382...383) = "}"
        │   │           ├── flags: ∅
        │   │           └── name: "lambda"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        └── @ CallNode (location: (385...402))
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── message_loc: (385...388) = "foo"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            ├── block:
            │   @ BlockNode (location: (389...402))
            │   ├── locals: [:bar]
            │   ├── parameters:
            │   │   @ BlockParametersNode (location: (392...398))
            │   │   ├── parameters:
            │   │   │   @ ParametersNode (location: (393...397))
            │   │   │   ├── requireds: (length: 1)
            │   │   │   │   └── @ RequiredParameterNode (location: (393...396))
            │   │   │   │       └── name: :bar
            │   │   │   ├── optionals: (length: 0)
            │   │   │   ├── rest:
            │   │   │   │   @ RestParameterNode (location: (396...397))
            │   │   │   │   ├── name: nil
            │   │   │   │   ├── name_loc: ∅
            │   │   │   │   └── operator_loc: (396...397) = ","
            │   │   │   ├── posts: (length: 0)
            │   │   │   ├── keywords: (length: 0)
            │   │   │   ├── keyword_rest: ∅
            │   │   │   └── block: ∅
            │   │   ├── locals: (length: 0)
            │   │   ├── opening_loc: (392...393) = "|"
            │   │   └── closing_loc: (397...398) = "|"
            │   ├── body: ∅
            │   ├── opening_loc: (389...391) = "do"
            │   └── closing_loc: (399...402) = "end"
            ├── flags: ∅
            └── name: "foo"
