@ ProgramNode (location: (0...292))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...292))
    └── body: (length: 10)
        ├── @ ParenthesesNode (location: (0...28))
        │   ├── body:
        │   │   @ StatementsNode (location: (1...27))
        │   │   └── body: (length: 1)
        │   │       └── @ DefNode (location: (1...27))
        │   │           ├── name: :foo
        │   │           ├── name_loc: (5...8) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters:
        │   │           │   @ ParametersNode (location: (9...12))
        │   │           │   ├── requireds: (length: 0)
        │   │           │   ├── optionals: (length: 0)
        │   │           │   ├── rest: ∅
        │   │           │   ├── posts: (length: 0)
        │   │           │   ├── keywords: (length: 0)
        │   │           │   ├── keyword_rest:
        │   │           │   │   @ ForwardingParameterNode (location: (9...12))
        │   │           │   └── block: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (15...23))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (15...23))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (15...18) = "bar"
        │   │           │           ├── opening_loc: (18...19) = "("
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (19...22))
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ ForwardingArgumentsNode (location: (19...22))
        │   │           │           ├── closing_loc: (22...23) = ")"
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: ∅
        │   │           │           └── name: "bar"
        │   │           ├── locals: [:"..."]
        │   │           ├── def_keyword_loc: (1...4) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── end_keyword_loc: (24...27) = "end"
        │   ├── opening_loc: (0...1) = "("
        │   └── closing_loc: (27...28) = ")"
        ├── @ ParenthesesNode (location: (30...58))
        │   ├── body:
        │   │   @ StatementsNode (location: (31...57))
        │   │   └── body: (length: 1)
        │   │       └── @ DefNode (location: (31...57))
        │   │           ├── name: :foo
        │   │           ├── name_loc: (35...38) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters:
        │   │           │   @ ParametersNode (location: (39...42))
        │   │           │   ├── requireds: (length: 0)
        │   │           │   ├── optionals: (length: 0)
        │   │           │   ├── rest: ∅
        │   │           │   ├── posts: (length: 0)
        │   │           │   ├── keywords: (length: 0)
        │   │           │   ├── keyword_rest:
        │   │           │   │   @ ForwardingParameterNode (location: (39...42))
        │   │           │   └── block: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (44...52))
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (44...52))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (44...47) = "bar"
        │   │           │           ├── opening_loc: (47...48) = "("
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (48...51))
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ ForwardingArgumentsNode (location: (48...51))
        │   │           │           ├── closing_loc: (51...52) = ")"
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: ∅
        │   │           │           └── name: "bar"
        │   │           ├── locals: [:"..."]
        │   │           ├── def_keyword_loc: (31...34) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── end_keyword_loc: (54...57) = "end"
        │   ├── opening_loc: (30...31) = "("
        │   └── closing_loc: (57...58) = ")"
        ├── @ DefNode (location: (60...75))
        │   ├── name: :foo
        │   ├── name_loc: (64...67) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (68...71))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (68...71))
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:"..."]
        │   ├── def_keyword_loc: (60...63) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (72...75) = "end"
        ├── @ DefNode (location: (77...103))
        │   ├── name: :foo
        │   ├── name_loc: (81...84) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (85...88))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (85...88))
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (90...98))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (90...98))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (90...93) = "bar"
        │   │           ├── opening_loc: (93...94) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (94...97))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (94...97))
        │   │           ├── closing_loc: (97...98) = ")"
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "bar"
        │   ├── locals: [:"..."]
        │   ├── def_keyword_loc: (77...80) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (100...103) = "end"
        ├── @ DefNode (location: (105...134))
        │   ├── name: :foo
        │   ├── name_loc: (109...112) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (113...119))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (113...114))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (116...119))
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (122...130))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (122...130))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (122...125) = "bar"
        │   │           ├── opening_loc: (125...126) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (126...129))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (126...129))
        │   │           ├── closing_loc: (129...130) = ")"
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "bar"
        │   ├── locals: [:a, :"..."]
        │   ├── def_keyword_loc: (105...108) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (131...134) = "end"
        ├── @ DefNode (location: (136...165))
        │   ├── name: :foo
        │   ├── name_loc: (140...143) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (144...150))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (144...145))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (147...150))
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (152...160))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (152...160))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (152...155) = "bar"
        │   │           ├── opening_loc: (155...156) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (156...159))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (156...159))
        │   │           ├── closing_loc: (159...160) = ")"
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "bar"
        │   ├── locals: [:a, :"..."]
        │   ├── def_keyword_loc: (136...139) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (162...165) = "end"
        ├── @ DefNode (location: (167...192))
        │   ├── name: :foo
        │   ├── name_loc: (171...174) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (175...188))
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (175...176))
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (178...183))
        │   │   │       ├── name: :b
        │   │   │       ├── name_loc: (178...179) = "b"
        │   │   │       ├── operator_loc: (180...181) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (182...183))
        │   │   │           └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (185...188))
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :b, :"..."]
        │   ├── def_keyword_loc: (167...170) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (189...192) = "end"
        ├── @ DefNode (location: (194...227))
        │   ├── name: :foo
        │   ├── name_loc: (198...201) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (202...212))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (202...207))
        │   │   │       ├── name: :b
        │   │   │       ├── name_loc: (202...203) = "b"
        │   │   │       ├── operator_loc: (204...205) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (206...207))
        │   │   │           └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (209...212))
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (215...223))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (215...223))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (215...218) = "bar"
        │   │           ├── opening_loc: (218...219) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (219...222))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (219...222))
        │   │           ├── closing_loc: (222...223) = ")"
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "bar"
        │   ├── locals: [:b, :"..."]
        │   ├── def_keyword_loc: (194...197) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (224...227) = "end"
        ├── @ DefNode (location: (229...262))
        │   ├── name: :foo
        │   ├── name_loc: (233...236) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (237...247))
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (237...242))
        │   │   │       ├── name: :b
        │   │   │       ├── name_loc: (237...238) = "b"
        │   │   │       ├── operator_loc: (239...240) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (241...242))
        │   │   │           └── flags: decimal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (244...247))
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (249...257))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (249...257))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (249...252) = "bar"
        │   │           ├── opening_loc: (252...253) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (253...256))
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (253...256))
        │   │           ├── closing_loc: (256...257) = ")"
        │   │           ├── block: ∅
        │   │           ├── flags: ∅
        │   │           └── name: "bar"
        │   ├── locals: [:b, :"..."]
        │   ├── def_keyword_loc: (229...232) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (259...262) = "end"
        └── @ DefNode (location: (264...292))
            ├── name: :foo
            ├── name_loc: (268...271) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (272...278))
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (272...273))
            │   │       └── name: :a
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (275...278))
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (280...288))
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (280...288))
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── message_loc: (280...283) = "bar"
            │           ├── opening_loc: (283...284) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (284...287))
            │           │   └── arguments: (length: 1)
            │           │       └── @ ForwardingArgumentsNode (location: (284...287))
            │           ├── closing_loc: (287...288) = ")"
            │           ├── block: ∅
            │           ├── flags: ∅
            │           └── name: "bar"
            ├── locals: [:a, :"..."]
            ├── def_keyword_loc: (264...267) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (271...272) = "("
            ├── rparen_loc: (278...279) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (289...292) = "end"
