@ ProgramNode (location: (0...114))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...114))
    └── body: (length: 6)
        ├── @ CallNode (location: (0...14))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (0...3) = "fun"
        │   ├── opening_loc: (3...4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (4...13))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (4...13))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (4...13))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (4...8))
        │   │                   │   ├── opening_loc: (4...5) = ":"
        │   │                   │   ├── value_loc: (5...8) = "foo"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "foo"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (12...13))
        │   │                   │   └── flags: decimal
        │   │                   └── operator_loc: (9...11) = "=>"
        │   ├── closing_loc: (13...14) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "fun"
        ├── @ CallNode (location: (16...36))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (16...19) = "fun"
        │   ├── opening_loc: (19...20) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (20...35))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ KeywordHashNode (location: (20...29))
        │   │       │   └── elements: (length: 1)
        │   │       │       └── @ AssocNode (location: (20...29))
        │   │       │           ├── key:
        │   │       │           │   @ SymbolNode (location: (20...24))
        │   │       │           │   ├── opening_loc: (20...21) = ":"
        │   │       │           │   ├── value_loc: (21...24) = "foo"
        │   │       │           │   ├── closing_loc: ∅
        │   │       │           │   └── unescaped: "foo"
        │   │       │           ├── value:
        │   │       │           │   @ IntegerNode (location: (28...29))
        │   │       │           │   └── flags: decimal
        │   │       │           └── operator_loc: (25...27) = "=>"
        │   │       └── @ BlockArgumentNode (location: (31...35))
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (32...35))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (32...35) = "baz"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: variable_call
        │   │           │   └── name: "baz"
        │   │           └── operator_loc: (31...32) = "&"
        │   ├── closing_loc: (35...36) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "fun"
        ├── @ CallNode (location: (38...59))
        │   ├── receiver:
        │   │   @ SelfNode (location: (38...42))
        │   ├── call_operator_loc: (42...43) = "."
        │   ├── message_loc: (43...46) = "[]="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (47...59))
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (47...50))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (47...50) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "foo"
        │   │       └── @ KeywordHashNode (location: (52...59))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (52...59))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (52...54))
        │   │                   │   ├── opening_loc: (52...53) = ":"
        │   │                   │   ├── value_loc: (53...54) = "a"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (58...59))
        │   │                   │   └── flags: decimal
        │   │                   └── operator_loc: (55...57) = "=>"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "[]="
        ├── @ CallNode (location: (61...76))
        │   ├── receiver:
        │   │   @ SelfNode (location: (61...65))
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (65...76) = "[:bar => 1]"
        │   ├── opening_loc: (65...66) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (66...75))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (66...75))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (66...75))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (66...70))
        │   │                   │   ├── opening_loc: (66...67) = ":"
        │   │                   │   ├── value_loc: (67...70) = "bar"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "bar"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (74...75))
        │   │                   │   └── flags: decimal
        │   │                   └── operator_loc: (71...73) = "=>"
        │   ├── closing_loc: (75...76) = "]"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "[]"
        ├── @ SuperNode (location: (78...95))
        │   ├── keyword_loc: (78...83) = "super"
        │   ├── lparen_loc: (83...84) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (84...94))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (84...94))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (84...94))
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (84...88))
        │   │                   │   ├── opening_loc: (84...85) = ":"
        │   │                   │   ├── value_loc: (85...88) = "foo"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "foo"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (92...94))
        │   │                   │   └── flags: decimal
        │   │                   └── operator_loc: (89...91) = "=>"
        │   ├── rparen_loc: (94...95) = ")"
        │   └── block: ∅
        └── @ YieldNode (location: (97...114))
            ├── keyword_loc: (97...102) = "yield"
            ├── lparen_loc: (102...103) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (103...113))
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (103...113))
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (103...113))
            │                   ├── key:
            │                   │   @ SymbolNode (location: (103...107))
            │                   │   ├── opening_loc: (103...104) = ":"
            │                   │   ├── value_loc: (104...107) = "foo"
            │                   │   ├── closing_loc: ∅
            │                   │   └── unescaped: "foo"
            │                   ├── value:
            │                   │   @ IntegerNode (location: (111...113))
            │                   │   └── flags: decimal
            │                   └── operator_loc: (108...110) = "=>"
            └── rparen_loc: (113...114) = ")"
