@ ProgramNode (location: (1,0)-(190,3))
├── flags: ∅
├── locals: [:a, :c, :foo]
└── statements:
    @ StatementsNode (location: (1,0)-(190,3))
    ├── flags: ∅
    └── body: (length: 71)
        ├── @ DefNode (location: (1,0)-(2,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,8)-(1,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 2)
        │   │   │       │   ├── @ RequiredParameterNode (location: (1,9)-(1,12))
        │   │   │       │   │   ├── flags: ∅
        │   │   │       │   │   └── name: :bar
        │   │   │       │   └── @ RequiredParameterNode (location: (1,14)-(1,17))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :baz
        │   │   │       ├── rest: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
        │   │   │       └── rparen_loc: (1,17)-(1,18) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,7)-(1,8) = "("
        │   ├── rparen_loc: (1,18)-(1,19) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (2,0)-(2,3) = "end"
        ├── @ DefNode (location: (4,0)-(5,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (4,4)-(4,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (4,8)-(4,44))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (4,8)-(4,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 2)
        │   │   │       │   ├── @ RequiredParameterNode (location: (4,9)-(4,12))
        │   │   │       │   │   ├── flags: ∅
        │   │   │       │   │   └── name: :bar
        │   │   │       │   └── @ RequiredParameterNode (location: (4,14)-(4,17))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :baz
        │   │   │       ├── rest: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (4,8)-(4,9) = "("
        │   │   │       └── rparen_loc: (4,17)-(4,18) = ")"
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (4,20)-(4,32))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :optional
        │   │   │       ├── name_loc: (4,20)-(4,28) = "optional"
        │   │   │       ├── operator_loc: (4,29)-(4,30) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (4,31)-(4,32))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (4,34)-(4,44))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 2)
        │   │   │       │   ├── @ RequiredParameterNode (location: (4,35)-(4,38))
        │   │   │       │   │   ├── flags: ∅
        │   │   │       │   │   └── name: :bin
        │   │   │       │   └── @ RequiredParameterNode (location: (4,40)-(4,43))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :bag
        │   │   │       ├── rest: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (4,34)-(4,35) = "("
        │   │   │       └── rparen_loc: (4,43)-(4,44) = ")"
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar, :baz, :optional, :bin, :bag]
        │   ├── def_keyword_loc: (4,0)-(4,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (4,7)-(4,8) = "("
        │   ├── rparen_loc: (4,44)-(4,45) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ DefNode (location: (8,0)-(8,18))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (8,4)-(8,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (8,0)-(8,18))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (8,7)-(8,18))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (8,7)-(8,13) = "ensure"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (8,15)-(8,18) = "end"
        │   │   └── end_keyword_loc: (8,15)-(8,18) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (8,0)-(8,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (8,15)-(8,18) = "end"
        ├── @ DefNode (location: (10,0)-(11,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (10,8)-(10,9) = "a"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (10,4)-(10,7))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ CallNode (location: (10,5)-(10,6))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :b
        │   │   │   ├── message_loc: (10,5)-(10,6) = "b"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── opening_loc: (10,4)-(10,5) = "("
        │   │   └── closing_loc: (10,6)-(10,7) = ")"
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (10,0)-(10,3) = "def"
        │   ├── operator_loc: (10,7)-(10,8) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ DefNode (location: (13,0)-(14,3))
        │   ├── flags: newline
        │   ├── name: :b
        │   ├── name_loc: (13,9)-(13,10) = "b"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (13,4)-(13,7))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ CallNode (location: (13,5)-(13,6))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── message_loc: (13,5)-(13,6) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── opening_loc: (13,4)-(13,5) = "("
        │   │   └── closing_loc: (13,6)-(13,7) = ")"
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (13,0)-(13,3) = "def"
        │   ├── operator_loc: (13,7)-(13,9) = "::"
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (14,0)-(14,3) = "end"
        ├── @ DefNode (location: (16,0)-(17,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (16,10)-(16,11) = "a"
        │   ├── receiver:
        │   │   @ FalseNode (location: (16,4)-(16,9))
        │   │   └── flags: static_literal
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (16,0)-(16,3) = "def"
        │   ├── operator_loc: (16,9)-(16,10) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (17,0)-(17,3) = "end"
        ├── @ DefNode (location: (19,0)-(20,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (19,4)-(19,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (19,6)-(19,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (19,6)-(19,9))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (19,0)-(19,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (19,5)-(19,6) = "("
        │   ├── rparen_loc: (19,9)-(19,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (20,0)-(20,3) = "end"
        ├── @ DefNode (location: (22,0)-(23,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (22,9)-(22,10) = "a"
        │   ├── receiver:
        │   │   @ GlobalVariableReadNode (location: (22,4)-(22,8))
        │   │   ├── flags: ∅
        │   │   └── name: :$var
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (22,0)-(22,3) = "def"
        │   ├── operator_loc: (22,8)-(22,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (23,0)-(23,3) = "end"
        ├── @ DefNode (location: (25,0)-(26,3))
        │   ├── flags: newline
        │   ├── name: :b
        │   ├── name_loc: (25,6)-(25,7) = "b"
        │   ├── receiver:
        │   │   @ CallNode (location: (25,4)-(25,5))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (25,4)-(25,5) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (25,0)-(25,3) = "def"
        │   ├── operator_loc: (25,5)-(25,6) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (26,0)-(26,3) = "end"
        ├── @ DefNode (location: (28,0)-(29,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (28,9)-(28,10) = "a"
        │   ├── receiver:
        │   │   @ InstanceVariableReadNode (location: (28,4)-(28,8))
        │   │   ├── flags: ∅
        │   │   └── name: :@var
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (28,0)-(28,3) = "def"
        │   ├── operator_loc: (28,8)-(28,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (29,0)-(29,3) = "end"
        ├── @ DefNode (location: (31,0)-(31,13))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (31,4)-(31,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (31,6)-(31,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ RequiredKeywordParameterNode (location: (31,6)-(31,8))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       └── name_loc: (31,6)-(31,8) = "b:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (31,0)-(31,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (31,10)-(31,13) = "end"
        ├── @ StringNode (location: (33,0)-(33,6))
        │   ├── flags: newline
        │   ├── opening_loc: (33,0)-(33,2) = "%,"
        │   ├── content_loc: (33,2)-(33,5) = "abc"
        │   ├── closing_loc: (33,5)-(33,6) = ","
        │   └── unescaped: "abc"
        ├── @ DefNode (location: (35,0)-(36,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (35,4)-(35,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (35,6)-(35,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ RequiredKeywordParameterNode (location: (35,6)-(35,8))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       └── name_loc: (35,6)-(35,8) = "b:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (35,0)-(35,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (35,5)-(35,6) = "("
        │   ├── rparen_loc: (35,8)-(35,9) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (36,0)-(36,3) = "end"
        ├── @ DefNode (location: (38,0)-(39,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (38,4)-(38,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (38,6)-(38,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (38,6)-(38,9))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :b
        │   │   │   ├── name_loc: (38,8)-(38,9) = "b"
        │   │   │   └── operator_loc: (38,6)-(38,8) = "**"
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (38,0)-(38,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (38,5)-(38,6) = "("
        │   ├── rparen_loc: (38,9)-(38,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (39,0)-(39,3) = "end"
        ├── @ DefNode (location: (41,0)-(42,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (41,4)-(41,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (41,6)-(41,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (41,6)-(41,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (41,6)-(41,8) = "**"
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (41,0)-(41,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (41,5)-(41,6) = "("
        │   ├── rparen_loc: (41,8)-(41,9) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (42,0)-(42,3) = "end"
        ├── @ LocalVariableWriteNode (location: (44,0)-(44,5))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (44,0)-(44,1) = "a"
        │   ├── value:
        │   │   @ IntegerNode (location: (44,4)-(44,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (44,2)-(44,3) = "="
        ├── @ DefNode (location: (44,7)-(45,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (44,11)-(44,12) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (44,7)-(44,10) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (45,0)-(45,3) = "end"
        ├── @ DefNode (location: (47,0)-(48,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (47,4)-(47,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (47,6)-(47,13))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ RequiredParameterNode (location: (47,6)-(47,7))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :b
        │   │   │   ├── @ RequiredParameterNode (location: (47,9)-(47,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :c
        │   │   │   └── @ RequiredParameterNode (location: (47,12)-(47,13))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :d
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c, :d]
        │   ├── def_keyword_loc: (47,0)-(47,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (48,0)-(48,3) = "end"
        ├── @ DefNode (location: (50,0)-(51,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (50,8)-(50,9) = "a"
        │   ├── receiver:
        │   │   @ NilNode (location: (50,4)-(50,7))
        │   │   └── flags: static_literal
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (50,0)-(50,3) = "def"
        │   ├── operator_loc: (50,7)-(50,8) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (51,0)-(51,3) = "end"
        ├── @ DefNode (location: (53,0)-(54,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (53,4)-(53,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (53,6)-(53,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ RequiredKeywordParameterNode (location: (53,6)-(53,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   └── name_loc: (53,6)-(53,8) = "b:"
        │   │   │   └── @ OptionalKeywordParameterNode (location: (53,10)-(53,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       ├── name_loc: (53,10)-(53,12) = "c:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (53,13)-(53,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (53,0)-(53,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (54,0)-(54,3) = "end"
        ├── @ DefNode (location: (56,0)-(57,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (56,4)-(56,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (56,6)-(56,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ RequiredKeywordParameterNode (location: (56,6)-(56,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   └── name_loc: (56,6)-(56,8) = "b:"
        │   │   │   └── @ OptionalKeywordParameterNode (location: (56,10)-(56,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       ├── name_loc: (56,10)-(56,12) = "c:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (56,13)-(56,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (56,0)-(56,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (56,5)-(56,6) = "("
        │   ├── rparen_loc: (56,14)-(56,15) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (57,0)-(57,3) = "end"
        ├── @ DefNode (location: (59,0)-(61,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (59,4)-(59,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (59,6)-(60,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ OptionalKeywordParameterNode (location: (59,6)-(60,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── name_loc: (59,6)-(59,8) = "b:"
        │   │   │   │   └── value:
        │   │   │   │       @ IntegerNode (location: (60,2)-(60,3))
        │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │       └── value: 1
        │   │   │   └── @ RequiredKeywordParameterNode (location: (60,5)-(60,7))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       └── name_loc: (60,5)-(60,7) = "c:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (59,0)-(59,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (59,5)-(59,6) = "("
        │   ├── rparen_loc: (60,7)-(60,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (61,0)-(61,3) = "end"
        ├── @ StringNode (location: (63,0)-(63,6))
        │   ├── flags: newline
        │   ├── opening_loc: (63,0)-(63,2) = "%."
        │   ├── content_loc: (63,2)-(63,5) = "abc"
        │   ├── closing_loc: (63,5)-(63,6) = "."
        │   └── unescaped: "abc"
        ├── @ DefNode (location: (65,0)-(66,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (65,4)-(65,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (65,6)-(65,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 2)
        │   │   │   ├── @ OptionalParameterNode (location: (65,6)-(65,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── name_loc: (65,6)-(65,7) = "b"
        │   │   │   │   ├── operator_loc: (65,8)-(65,9) = "="
        │   │   │   │   └── value:
        │   │   │   │       @ IntegerNode (location: (65,10)-(65,11))
        │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │       └── value: 1
        │   │   │   └── @ OptionalParameterNode (location: (65,13)-(65,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       ├── name_loc: (65,13)-(65,14) = "c"
        │   │   │       ├── operator_loc: (65,15)-(65,16) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (65,17)-(65,18))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (65,0)-(65,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (66,0)-(66,3) = "end"
        ├── @ DefNode (location: (68,0)-(69,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (68,4)-(68,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (68,0)-(68,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (68,5)-(68,6) = "("
        │   ├── rparen_loc: (68,6)-(68,7) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (69,0)-(69,3) = "end"
        ├── @ DefNode (location: (71,0)-(72,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (71,4)-(71,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (71,6)-(71,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (71,6)-(71,7))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :b
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (71,9)-(71,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       ├── name_loc: (71,9)-(71,10) = "c"
        │   │   │       ├── operator_loc: (71,11)-(71,12) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (71,13)-(71,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (71,0)-(71,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (72,0)-(72,3) = "end"
        ├── @ DefNode (location: (74,0)-(75,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (74,4)-(74,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (74,6)-(74,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (74,6)-(74,7))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :b
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (74,0)-(74,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (75,0)-(75,3) = "end"
        ├── @ DefNode (location: (77,0)-(77,32))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (77,4)-(77,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (77,0)-(77,32))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (77,7)-(77,13))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (77,7)-(77,13) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause:
        │   │   │   @ ElseNode (location: (77,15)-(77,27))
        │   │   │   ├── flags: ∅
        │   │   │   ├── else_keyword_loc: (77,15)-(77,19) = "else"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (77,21)-(77,27) = "ensure"
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (77,21)-(77,32))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (77,21)-(77,27) = "ensure"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (77,29)-(77,32) = "end"
        │   │   └── end_keyword_loc: (77,29)-(77,32) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (77,0)-(77,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (77,29)-(77,32) = "end"
        ├── @ DefNode (location: (79,0)-(80,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (79,4)-(79,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (79,6)-(79,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (79,6)-(79,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :b
        │   │   │   ├── name_loc: (79,7)-(79,8) = "b"
        │   │   │   └── operator_loc: (79,6)-(79,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (79,0)-(79,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (80,0)-(80,3) = "end"
        ├── @ DefNode (location: (82,0)-(83,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (82,4)-(82,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (82,6)-(82,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (82,6)-(82,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (82,6)-(82,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (82,0)-(82,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (82,5)-(82,6) = "("
        │   ├── rparen_loc: (82,7)-(82,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (83,0)-(83,3) = "end"
        ├── @ DefNode (location: (85,0)-(87,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (85,4)-(85,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (86,0)-(86,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableWriteNode (location: (86,0)-(86,5))
        │   │           ├── flags: newline
        │   │           ├── name: :b
        │   │           ├── depth: 0
        │   │           ├── name_loc: (86,0)-(86,1) = "b"
        │   │           ├── value:
        │   │           │   @ IntegerNode (location: (86,4)-(86,5))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           └── operator_loc: (86,2)-(86,3) = "="
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (85,0)-(85,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (87,0)-(87,3) = "end"
        ├── @ DefNode (location: (89,0)-(90,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (89,9)-(89,10) = "a"
        │   ├── receiver:
        │   │   @ SelfNode (location: (89,4)-(89,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (89,0)-(89,3) = "def"
        │   ├── operator_loc: (89,8)-(89,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (90,0)-(90,3) = "end"
        ├── @ DefNode (location: (92,0)-(93,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (92,9)-(92,10) = "a"
        │   ├── receiver:
        │   │   @ TrueNode (location: (92,4)-(92,8))
        │   │   └── flags: static_literal
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (92,0)-(92,3) = "def"
        │   ├── operator_loc: (92,8)-(92,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (93,0)-(93,3) = "end"
        ├── @ DefNode (location: (95,0)-(96,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (95,4)-(95,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (95,0)-(95,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (96,0)-(96,3) = "end"
        ├── @ DefNode (location: (98,0)-(101,3))
        │   ├── flags: newline
        │   ├── name: :hi
        │   ├── name_loc: (98,4)-(98,6) = "hi"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (99,0)-(100,4))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 2)
        │   │       ├── @ IfNode (location: (99,0)-(99,18))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (99,11)-(99,13) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ TrueNode (location: (99,14)-(99,18))
        │   │       │   │   └── flags: static_literal
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (99,0)-(99,10))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ReturnNode (location: (99,0)-(99,10))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── keyword_loc: (99,0)-(99,6) = "return"
        │   │       │   │           └── arguments:
        │   │       │   │               @ ArgumentsNode (location: (99,7)-(99,10))
        │   │       │   │               ├── flags: ∅
        │   │       │   │               └── arguments: (length: 1)
        │   │       │   │                   └── @ SymbolNode (location: (99,7)-(99,10))
        │   │       │   │                       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │                       ├── opening_loc: (99,7)-(99,8) = ":"
        │   │       │   │                       ├── value_loc: (99,8)-(99,10) = "hi"
        │   │       │   │                       ├── closing_loc: ∅
        │   │       │   │                       └── unescaped: "hi"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       └── @ SymbolNode (location: (100,0)-(100,4))
        │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (100,0)-(100,1) = ":"
        │   │           ├── value_loc: (100,1)-(100,4) = "bye"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "bye"
        │   ├── locals: []
        │   ├── def_keyword_loc: (98,0)-(98,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (101,0)-(101,3) = "end"
        ├── @ DefNode (location: (103,0)-(103,11))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (103,4)-(103,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (103,10)-(103,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (103,10)-(103,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── locals: []
        │   ├── def_keyword_loc: (103,0)-(103,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (103,8)-(103,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (104,0)-(104,11))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (104,4)-(104,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (104,10)-(104,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (104,10)-(104,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── locals: []
        │   ├── def_keyword_loc: (104,0)-(104,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (104,8)-(104,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (106,0)-(106,18))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (106,4)-(106,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (106,8)-(106,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (106,8)-(106,11))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (106,15)-(106,18))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (106,15)-(106,18))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 123
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (106,0)-(106,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (106,7)-(106,8) = "("
        │   ├── rparen_loc: (106,11)-(106,12) = ")"
        │   ├── equal_loc: (106,13)-(106,14) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (108,0)-(108,13))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (108,4)-(108,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (108,10)-(108,13))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (108,10)-(108,13))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 123
        │   ├── locals: []
        │   ├── def_keyword_loc: (108,0)-(108,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (108,8)-(108,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (110,0)-(110,19))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (110,4)-(110,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (110,6)-(110,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (110,6)-(110,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (110,6)-(110,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (110,10)-(110,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (110,10)-(110,14))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (110,10)-(110,11) = "b"
        │   │           ├── opening_loc: (110,11)-(110,12) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (110,12)-(110,13))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ SplatNode (location: (110,12)-(110,13))
        │   │           │           ├── flags: ∅
        │   │           │           ├── operator_loc: (110,12)-(110,13) = "*"
        │   │           │           └── expression: ∅
        │   │           ├── closing_loc: (110,13)-(110,14) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (110,0)-(110,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (110,5)-(110,6) = "("
        │   ├── rparen_loc: (110,7)-(110,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (110,16)-(110,19) = "end"
        ├── @ DefNode (location: (112,0)-(112,33))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (112,4)-(112,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (112,6)-(112,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (112,6)-(112,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (112,6)-(112,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (112,9)-(112,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (112,9)-(112,11) = "**"
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (112,14)-(112,28))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (112,14)-(112,28))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (112,14)-(112,15) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (112,16)-(112,28))
        │   │               ├── flags: ∅
        │   │               ├── locals: []
        │   │               ├── parameters: ∅
        │   │               ├── body:
        │   │               │   @ StatementsNode (location: (112,18)-(112,26))
        │   │               │   ├── flags: ∅
        │   │               │   └── body: (length: 1)
        │   │               │       └── @ CallNode (location: (112,18)-(112,26))
        │   │               │           ├── flags: newline, ignore_visibility
        │   │               │           ├── receiver: ∅
        │   │               │           ├── call_operator_loc: ∅
        │   │               │           ├── name: :c
        │   │               │           ├── message_loc: (112,18)-(112,19) = "c"
        │   │               │           ├── opening_loc: (112,19)-(112,20) = "("
        │   │               │           ├── arguments:
        │   │               │           │   @ ArgumentsNode (location: (112,20)-(112,25))
        │   │               │           │   ├── flags: contains_keywords, contains_keyword_splat, contains_splat
        │   │               │           │   └── arguments: (length: 2)
        │   │               │           │       ├── @ SplatNode (location: (112,20)-(112,21))
        │   │               │           │       │   ├── flags: ∅
        │   │               │           │       │   ├── operator_loc: (112,20)-(112,21) = "*"
        │   │               │           │       │   └── expression: ∅
        │   │               │           │       └── @ KeywordHashNode (location: (112,23)-(112,25))
        │   │               │           │           ├── flags: ∅
        │   │               │           │           └── elements: (length: 1)
        │   │               │           │               └── @ AssocSplatNode (location: (112,23)-(112,25))
        │   │               │           │                   ├── flags: ∅
        │   │               │           │                   ├── value: ∅
        │   │               │           │                   └── operator_loc: (112,23)-(112,25) = "**"
        │   │               │           ├── closing_loc: (112,25)-(112,26) = ")"
        │   │               │           └── block: ∅
        │   │               ├── opening_loc: (112,16)-(112,17) = "{"
        │   │               └── closing_loc: (112,27)-(112,28) = "}"
        │   ├── locals: []
        │   ├── def_keyword_loc: (112,0)-(112,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (112,5)-(112,6) = "("
        │   ├── rparen_loc: (112,11)-(112,12) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (112,30)-(112,33) = "end"
        ├── @ DefNode (location: (114,0)-(114,23))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (114,4)-(114,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (114,6)-(114,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (114,6)-(114,9))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (114,12)-(114,18))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (114,12)-(114,18))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (114,12)-(114,13) = "b"
        │   │           ├── opening_loc: (114,13)-(114,14) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (114,14)-(114,17))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (114,14)-(114,17))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (114,17)-(114,18) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (114,0)-(114,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (114,5)-(114,6) = "("
        │   ├── rparen_loc: (114,9)-(114,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (114,20)-(114,23) = "end"
        ├── @ DefNode (location: (116,0)-(116,29))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (116,4)-(116,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (116,6)-(116,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (116,6)-(116,9))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (116,12)-(116,24))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (116,12)-(116,24))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (116,12)-(116,13) = "b"
        │   │           ├── opening_loc: (116,13)-(116,14) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (116,14)-(116,23))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 3)
        │   │           │       ├── @ IntegerNode (location: (116,14)-(116,15))
        │   │           │       │   ├── flags: static_literal, decimal
        │   │           │       │   └── value: 1
        │   │           │       ├── @ IntegerNode (location: (116,17)-(116,18))
        │   │           │       │   ├── flags: static_literal, decimal
        │   │           │       │   └── value: 2
        │   │           │       └── @ ForwardingArgumentsNode (location: (116,20)-(116,23))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (116,23)-(116,24) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (116,0)-(116,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (116,5)-(116,6) = "("
        │   ├── rparen_loc: (116,9)-(116,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (116,26)-(116,29) = "end"
        ├── @ DefNode (location: (118,0)-(119,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (118,12)-(118,13) = "a"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (118,4)-(118,11))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ LocalVariableWriteNode (location: (118,5)-(118,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :c
        │   │   │   ├── depth: 0
        │   │   │   ├── name_loc: (118,5)-(118,6) = "c"
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (118,9)-(118,10))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── message_loc: (118,9)-(118,10) = "b"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (118,7)-(118,8) = "="
        │   │   ├── opening_loc: (118,4)-(118,5) = "("
        │   │   └── closing_loc: (118,10)-(118,11) = ")"
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (118,0)-(118,3) = "def"
        │   ├── operator_loc: (118,11)-(118,12) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (119,0)-(119,3) = "end"
        ├── @ DefNode (location: (121,0)-(122,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (121,4)-(121,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (121,6)-(121,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (121,6)-(121,8))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       ├── name_loc: (121,7)-(121,8) = "b"
        │   │       └── operator_loc: (121,6)-(121,7) = "&"
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (121,0)-(121,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (122,0)-(122,3) = "end"
        ├── @ DefNode (location: (124,0)-(125,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (124,4)-(124,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (124,6)-(124,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (124,6)-(124,7))
        │   │       ├── flags: ∅
        │   │       ├── name: ∅
        │   │       ├── name_loc: ∅
        │   │       └── operator_loc: (124,6)-(124,7) = "&"
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (124,0)-(124,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (124,5)-(124,6) = "("
        │   ├── rparen_loc: (124,7)-(124,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (125,0)-(125,3) = "end"
        ├── @ DefNode (location: (127,0)-(128,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (127,10)-(127,11) = "a"
        │   ├── receiver:
        │   │   @ ClassVariableReadNode (location: (127,4)-(127,9))
        │   │   ├── flags: ∅
        │   │   └── name: :@@var
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (127,0)-(127,3) = "def"
        │   ├── operator_loc: (127,9)-(127,10) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (128,0)-(128,3) = "end"
        ├── @ DefNode (location: (130,0)-(131,3))
        │   ├── flags: newline
        │   ├── name: :C
        │   ├── name_loc: (130,12)-(130,13) = "C"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (130,4)-(130,11))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ LocalVariableWriteNode (location: (130,5)-(130,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── depth: 0
        │   │   │   ├── name_loc: (130,5)-(130,6) = "a"
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (130,9)-(130,10))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── message_loc: (130,9)-(130,10) = "b"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (130,7)-(130,8) = "="
        │   │   ├── opening_loc: (130,4)-(130,5) = "("
        │   │   └── closing_loc: (130,10)-(130,11) = ")"
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (130,0)-(130,3) = "def"
        │   ├── operator_loc: (130,11)-(130,12) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (131,0)-(131,3) = "end"
        ├── @ DefNode (location: (133,0)-(133,28))
        │   ├── flags: newline
        │   ├── name: :Array_function
        │   ├── name_loc: (133,9)-(133,23) = "Array_function"
        │   ├── receiver:
        │   │   @ SelfNode (location: (133,4)-(133,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (133,0)-(133,3) = "def"
        │   ├── operator_loc: (133,8)-(133,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (133,25)-(133,28) = "end"
        ├── @ ConstantWriteNode (location: (135,0)-(135,9))
        │   ├── flags: newline
        │   ├── name: :Const
        │   ├── name_loc: (135,0)-(135,5) = "Const"
        │   ├── value:
        │   │   @ IntegerNode (location: (135,8)-(135,9))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (135,6)-(135,7) = "="
        ├── @ DefNode (location: (135,11)-(136,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (135,21)-(135,22) = "a"
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (135,15)-(135,20))
        │   │   ├── flags: ∅
        │   │   └── name: :Const
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (135,11)-(135,14) = "def"
        │   ├── operator_loc: (135,20)-(135,21) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (136,0)-(136,3) = "end"
        ├── @ DefNode (location: (138,0)-(138,31))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (138,4)-(138,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (138,6)-(138,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (138,6)-(138,9))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (138,12)-(138,26))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (138,12)-(138,26))
        │   │           ├── flags: newline
        │   │           ├── opening_loc: (138,12)-(138,13) = "\""
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ StringNode (location: (138,13)-(138,16))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (138,13)-(138,16) = "foo"
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "foo"
        │   │           │   └── @ EmbeddedStatementsNode (location: (138,16)-(138,25))
        │   │           │       ├── flags: ∅
        │   │           │       ├── opening_loc: (138,16)-(138,18) = "\#{"
        │   │           │       ├── statements:
        │   │           │       │   @ StatementsNode (location: (138,18)-(138,24))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   └── body: (length: 1)
        │   │           │       │       └── @ CallNode (location: (138,18)-(138,24))
        │   │           │       │           ├── flags: ignore_visibility
        │   │           │       │           ├── receiver: ∅
        │   │           │       │           ├── call_operator_loc: ∅
        │   │           │       │           ├── name: :b
        │   │           │       │           ├── message_loc: (138,18)-(138,19) = "b"
        │   │           │       │           ├── opening_loc: (138,19)-(138,20) = "("
        │   │           │       │           ├── arguments:
        │   │           │       │           │   @ ArgumentsNode (location: (138,20)-(138,23))
        │   │           │       │           │   ├── flags: contains_forwarding
        │   │           │       │           │   └── arguments: (length: 1)
        │   │           │       │           │       └── @ ForwardingArgumentsNode (location: (138,20)-(138,23))
        │   │           │       │           │           └── flags: ∅
        │   │           │       │           ├── closing_loc: (138,23)-(138,24) = ")"
        │   │           │       │           └── block: ∅
        │   │           │       └── closing_loc: (138,24)-(138,25) = "}"
        │   │           └── closing_loc: (138,25)-(138,26) = "\""
        │   ├── locals: []
        │   ├── def_keyword_loc: (138,0)-(138,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (138,5)-(138,6) = "("
        │   ├── rparen_loc: (138,9)-(138,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (138,28)-(138,31) = "end"
        ├── @ DefNode (location: (140,0)-(142,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (140,4)-(140,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (141,2)-(141,30))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (141,2)-(141,30))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ HashNode (location: (141,2)-(141,4))
        │   │           │   ├── flags: static_literal
        │   │           │   ├── opening_loc: (141,2)-(141,3) = "{"
        │   │           │   ├── elements: (length: 0)
        │   │           │   └── closing_loc: (141,3)-(141,4) = "}"
        │   │           ├── call_operator_loc: (141,4)-(141,5) = "."
        │   │           ├── name: :merge
        │   │           ├── message_loc: (141,5)-(141,10) = "merge"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (141,11)-(141,30))
        │   │           │   ├── flags: contains_keywords, contains_keyword_splat
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ KeywordHashNode (location: (141,11)-(141,30))
        │   │           │           ├── flags: ∅
        │   │           │           └── elements: (length: 3)
        │   │           │               ├── @ AssocSplatNode (location: (141,11)-(141,16))
        │   │           │               │   ├── flags: ∅
        │   │           │               │   ├── value:
        │   │           │               │   │   @ CallNode (location: (141,13)-(141,16))
        │   │           │               │   │   ├── flags: variable_call, ignore_visibility
        │   │           │               │   │   ├── receiver: ∅
        │   │           │               │   │   ├── call_operator_loc: ∅
        │   │           │               │   │   ├── name: :bar
        │   │           │               │   │   ├── message_loc: (141,13)-(141,16) = "bar"
        │   │           │               │   │   ├── opening_loc: ∅
        │   │           │               │   │   ├── arguments: ∅
        │   │           │               │   │   ├── closing_loc: ∅
        │   │           │               │   │   └── block: ∅
        │   │           │               │   └── operator_loc: (141,11)-(141,13) = "**"
        │   │           │               ├── @ AssocSplatNode (location: (141,18)-(141,23))
        │   │           │               │   ├── flags: ∅
        │   │           │               │   ├── value:
        │   │           │               │   │   @ CallNode (location: (141,20)-(141,23))
        │   │           │               │   │   ├── flags: variable_call, ignore_visibility
        │   │           │               │   │   ├── receiver: ∅
        │   │           │               │   │   ├── call_operator_loc: ∅
        │   │           │               │   │   ├── name: :baz
        │   │           │               │   │   ├── message_loc: (141,20)-(141,23) = "baz"
        │   │           │               │   │   ├── opening_loc: ∅
        │   │           │               │   │   ├── arguments: ∅
        │   │           │               │   │   ├── closing_loc: ∅
        │   │           │               │   │   └── block: ∅
        │   │           │               │   └── operator_loc: (141,18)-(141,20) = "**"
        │   │           │               └── @ AssocSplatNode (location: (141,25)-(141,30))
        │   │           │                   ├── flags: ∅
        │   │           │                   ├── value:
        │   │           │                   │   @ CallNode (location: (141,27)-(141,30))
        │   │           │                   │   ├── flags: variable_call, ignore_visibility
        │   │           │                   │   ├── receiver: ∅
        │   │           │                   │   ├── call_operator_loc: ∅
        │   │           │                   │   ├── name: :qux
        │   │           │                   │   ├── message_loc: (141,27)-(141,30) = "qux"
        │   │           │                   │   ├── opening_loc: ∅
        │   │           │                   │   ├── arguments: ∅
        │   │           │                   │   ├── closing_loc: ∅
        │   │           │                   │   └── block: ∅
        │   │           │                   └── operator_loc: (141,25)-(141,27) = "**"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (140,0)-(140,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (142,0)-(142,3) = "end"
        ├── @ DefNode (location: (144,0)-(145,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (144,4)-(144,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (144,8)-(144,19))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (144,8)-(144,19))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (144,8)-(144,10) = "a:"
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (144,11)-(144,19))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (144,12)-(144,18))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (144,12)-(144,18))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left:
        │   │   │           │           │   @ IntegerNode (location: (144,12)-(144,13))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 1
        │   │   │           │           ├── right:
        │   │   │           │           │   @ IntegerNode (location: (144,16)-(144,18))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 10
        │   │   │           │           └── operator_loc: (144,13)-(144,16) = "..."
        │   │   │           ├── opening_loc: (144,11)-(144,12) = "("
        │   │   │           └── closing_loc: (144,18)-(144,19) = ")"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (144,0)-(144,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (144,7)-(144,8) = "("
        │   ├── rparen_loc: (144,19)-(144,20) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (145,0)-(145,3) = "end"
        ├── @ DefNode (location: (147,0)-(148,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (147,4)-(147,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (147,8)-(147,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (147,8)-(147,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (147,8)-(147,10) = "a:"
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (147,11)-(147,18))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (147,12)-(147,17))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (147,12)-(147,17))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left: ∅
        │   │   │           │           ├── right:
        │   │   │           │           │   @ IntegerNode (location: (147,15)-(147,17))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 10
        │   │   │           │           └── operator_loc: (147,12)-(147,15) = "..."
        │   │   │           ├── opening_loc: (147,11)-(147,12) = "("
        │   │   │           └── closing_loc: (147,17)-(147,18) = ")"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (147,0)-(147,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (147,7)-(147,8) = "("
        │   ├── rparen_loc: (147,18)-(147,19) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (148,0)-(148,3) = "end"
        ├── @ DefNode (location: (150,0)-(151,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (150,4)-(150,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (150,8)-(150,17))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (150,8)-(150,17))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (150,8)-(150,10) = "a:"
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (150,11)-(150,17))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (150,12)-(150,16))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (150,12)-(150,16))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left:
        │   │   │           │           │   @ IntegerNode (location: (150,12)-(150,13))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 1
        │   │   │           │           ├── right: ∅
        │   │   │           │           └── operator_loc: (150,13)-(150,16) = "..."
        │   │   │           ├── opening_loc: (150,11)-(150,12) = "("
        │   │   │           └── closing_loc: (150,16)-(150,17) = ")"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (150,0)-(150,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (150,7)-(150,8) = "("
        │   ├── rparen_loc: (150,17)-(150,18) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (151,0)-(151,3) = "end"
        ├── @ DefNode (location: (153,0)-(154,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (153,4)-(153,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (153,8)-(153,20))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (153,8)-(153,20))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (153,8)-(153,9) = "a"
        │   │   │       ├── operator_loc: (153,10)-(153,11) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (153,12)-(153,20))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (153,13)-(153,19))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (153,13)-(153,19))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left:
        │   │   │           │           │   @ IntegerNode (location: (153,13)-(153,14))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 1
        │   │   │           │           ├── right:
        │   │   │           │           │   @ IntegerNode (location: (153,17)-(153,19))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 10
        │   │   │           │           └── operator_loc: (153,14)-(153,17) = "..."
        │   │   │           ├── opening_loc: (153,12)-(153,13) = "("
        │   │   │           └── closing_loc: (153,19)-(153,20) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (153,0)-(153,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (153,7)-(153,8) = "("
        │   ├── rparen_loc: (153,20)-(153,21) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (154,0)-(154,3) = "end"
        ├── @ DefNode (location: (156,0)-(157,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (156,4)-(156,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (156,8)-(156,19))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (156,8)-(156,19))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (156,8)-(156,9) = "a"
        │   │   │       ├── operator_loc: (156,10)-(156,11) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (156,12)-(156,19))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (156,13)-(156,18))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (156,13)-(156,18))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left: ∅
        │   │   │           │           ├── right:
        │   │   │           │           │   @ IntegerNode (location: (156,16)-(156,18))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 10
        │   │   │           │           └── operator_loc: (156,13)-(156,16) = "..."
        │   │   │           ├── opening_loc: (156,12)-(156,13) = "("
        │   │   │           └── closing_loc: (156,18)-(156,19) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (156,0)-(156,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (156,7)-(156,8) = "("
        │   ├── rparen_loc: (156,19)-(156,20) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (157,0)-(157,3) = "end"
        ├── @ DefNode (location: (159,0)-(160,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (159,4)-(159,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (159,8)-(159,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (159,8)-(159,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (159,8)-(159,9) = "a"
        │   │   │       ├── operator_loc: (159,10)-(159,11) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (159,12)-(159,18))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (159,13)-(159,17))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (159,13)-(159,17))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left:
        │   │   │           │           │   @ IntegerNode (location: (159,13)-(159,14))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 1
        │   │   │           │           ├── right: ∅
        │   │   │           │           └── operator_loc: (159,14)-(159,17) = "..."
        │   │   │           ├── opening_loc: (159,12)-(159,13) = "("
        │   │   │           └── closing_loc: (159,17)-(159,18) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (159,0)-(159,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (159,7)-(159,8) = "("
        │   ├── rparen_loc: (159,18)-(159,19) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (160,0)-(160,3) = "end"
        ├── @ DefNode (location: (162,0)-(164,3))
        │   ├── flags: newline
        │   ├── name: :method
        │   ├── name_loc: (162,4)-(162,10) = "method"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (162,11)-(162,12))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (162,11)-(162,12))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (163,2)-(163,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (163,2)-(163,14))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (163,2)-(163,6))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :item
        │   │           │   ├── message_loc: (163,2)-(163,6) = "item"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :>>
        │   │           ├── message_loc: (163,7)-(163,9) = ">>"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (163,10)-(163,14))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ CallNode (location: (163,10)-(163,14))
        │   │           │           ├── flags: ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :a
        │   │           │           ├── message_loc: (163,10)-(163,11) = "a"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (163,12)-(163,14))
        │   │           │               ├── flags: ∅
        │   │           │               ├── locals: []
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body: ∅
        │   │           │               ├── opening_loc: (163,12)-(163,13) = "{"
        │   │           │               └── closing_loc: (163,13)-(163,14) = "}"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (162,0)-(162,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (162,10)-(162,11) = "("
        │   ├── rparen_loc: (162,12)-(162,13) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (164,0)-(164,3) = "end"
        ├── @ LocalVariableWriteNode (location: (166,0)-(166,7))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (166,0)-(166,3) = "foo"
        │   ├── value:
        │   │   @ IntegerNode (location: (166,6)-(166,7))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (166,4)-(166,5) = "="
        ├── @ DefNode (location: (167,0)-(167,16))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (167,8)-(167,11) = "bar"
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (167,4)-(167,7))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (167,0)-(167,3) = "def"
        │   ├── operator_loc: (167,7)-(167,8) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (167,13)-(167,16) = "end"
        ├── @ DefNode (location: (169,0)-(169,18))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (169,4)-(169,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (169,6)-(169,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (169,6)-(169,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (169,6)-(169,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (169,10)-(169,13))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ArrayNode (location: (169,10)-(169,13))
        │   │           ├── flags: newline, contains_splat
        │   │           ├── elements: (length: 1)
        │   │           │   └── @ SplatNode (location: (169,11)-(169,12))
        │   │           │       ├── flags: ∅
        │   │           │       ├── operator_loc: (169,11)-(169,12) = "*"
        │   │           │       └── expression: ∅
        │   │           ├── opening_loc: (169,10)-(169,11) = "["
        │   │           └── closing_loc: (169,12)-(169,13) = "]"
        │   ├── locals: []
        │   ├── def_keyword_loc: (169,0)-(169,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (169,5)-(169,6) = "("
        │   ├── rparen_loc: (169,7)-(169,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (169,15)-(169,18) = "end"
        ├── @ DefNode (location: (171,0)-(171,15))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (171,4)-(171,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (171,6)-(171,10))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (171,6)-(171,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (171,6)-(171,8) = "x:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (171,8)-(171,10))
        │   │   │           ├── flags: ∅
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (171,9)-(171,10))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (171,9)-(171,10) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :-@
        │   │   │           ├── message_loc: (171,8)-(171,9) = "-"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (171,0)-(171,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (171,12)-(171,15) = "end"
        ├── @ DefNode (location: (173,0)-(173,15))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (173,4)-(173,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (173,6)-(173,10))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (173,6)-(173,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (173,6)-(173,8) = "x:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (173,8)-(173,10))
        │   │   │           ├── flags: ∅
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (173,9)-(173,10))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (173,9)-(173,10) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :+@
        │   │   │           ├── message_loc: (173,8)-(173,9) = "+"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (173,0)-(173,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (173,12)-(173,15) = "end"
        ├── @ DefNode (location: (175,0)-(175,15))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (175,4)-(175,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (175,6)-(175,10))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (175,6)-(175,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (175,6)-(175,8) = "x:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (175,8)-(175,10))
        │   │   │           ├── flags: ∅
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (175,9)-(175,10))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (175,9)-(175,10) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :!
        │   │   │           ├── message_loc: (175,8)-(175,9) = "!"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (175,0)-(175,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (175,12)-(175,15) = "end"
        ├── @ DefNode (location: (177,0)-(177,20))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (177,4)-(177,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (177,8)-(177,15))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (177,8)-(177,15))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (177,8)-(177,10) = "x:"
        │   │   │       └── value:
        │   │   │           @ StringNode (location: (177,10)-(177,15))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (177,10)-(177,12) = "%("
        │   │   │           ├── content_loc: (177,12)-(177,14) = "xx"
        │   │   │           ├── closing_loc: (177,14)-(177,15) = ")"
        │   │   │           └── unescaped: "xx"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (177,0)-(177,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (177,17)-(177,20) = "end"
        ├── @ DefNode (location: (179,0)-(181,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (179,4)-(179,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (179,8)-(179,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (179,8)-(179,11))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (180,2)-(180,10))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (180,2)-(180,10))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (180,2)-(180,5) = "bar"
        │   │           ├── opening_loc: (180,5)-(180,6) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (180,6)-(180,9))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (180,6)-(180,9))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (180,9)-(180,10) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (179,0)-(179,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (179,7)-(179,8) = "("
        │   ├── rparen_loc: (179,11)-(179,12) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (181,0)-(181,3) = "end"
        ├── @ DefNode (location: (183,0)-(183,42))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (183,4)-(183,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (183,8)-(183,37))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (183,8)-(183,37))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (183,8)-(183,11) = "bar"
        │   │   │       ├── operator_loc: (183,12)-(183,13) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (183,14)-(183,37))
        │   │   │           ├── flags: multiple_statements
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (183,15)-(183,36))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 2)
        │   │   │           │       ├── @ DefNode (location: (183,15)-(183,33))
        │   │   │           │       │   ├── flags: newline
        │   │   │           │       │   ├── name: :baz
        │   │   │           │       │   ├── name_loc: (183,19)-(183,22) = "baz"
        │   │   │           │       │   ├── receiver: ∅
        │   │   │           │       │   ├── parameters:
        │   │   │           │       │   │   @ ParametersNode (location: (183,23)-(183,26))
        │   │   │           │       │   │   ├── flags: ∅
        │   │   │           │       │   │   ├── requireds: (length: 1)
        │   │   │           │       │   │   │   └── @ RequiredParameterNode (location: (183,23)-(183,26))
        │   │   │           │       │   │   │       ├── flags: ∅
        │   │   │           │       │   │   │       └── name: :bar
        │   │   │           │       │   │   ├── optionals: (length: 0)
        │   │   │           │       │   │   ├── rest: ∅
        │   │   │           │       │   │   ├── posts: (length: 0)
        │   │   │           │       │   │   ├── keywords: (length: 0)
        │   │   │           │       │   │   ├── keyword_rest: ∅
        │   │   │           │       │   │   └── block: ∅
        │   │   │           │       │   ├── body:
        │   │   │           │       │   │   @ StatementsNode (location: (183,30)-(183,33))
        │   │   │           │       │   │   ├── flags: ∅
        │   │   │           │       │   │   └── body: (length: 1)
        │   │   │           │       │   │       └── @ LocalVariableReadNode (location: (183,30)-(183,33))
        │   │   │           │       │   │           ├── flags: ∅
        │   │   │           │       │   │           ├── name: :bar
        │   │   │           │       │   │           └── depth: 0
        │   │   │           │       │   ├── locals: [:bar]
        │   │   │           │       │   ├── def_keyword_loc: (183,15)-(183,18) = "def"
        │   │   │           │       │   ├── operator_loc: ∅
        │   │   │           │       │   ├── lparen_loc: (183,22)-(183,23) = "("
        │   │   │           │       │   ├── rparen_loc: (183,26)-(183,27) = ")"
        │   │   │           │       │   ├── equal_loc: (183,28)-(183,29) = "="
        │   │   │           │       │   └── end_keyword_loc: ∅
        │   │   │           │       └── @ IntegerNode (location: (183,35)-(183,36))
        │   │   │           │           ├── flags: newline, static_literal, decimal
        │   │   │           │           └── value: 1
        │   │   │           ├── opening_loc: (183,14)-(183,15) = "("
        │   │   │           └── closing_loc: (183,36)-(183,37) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (183,41)-(183,42))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (183,41)-(183,42))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (183,0)-(183,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (183,7)-(183,8) = "("
        │   ├── rparen_loc: (183,37)-(183,38) = ")"
        │   ├── equal_loc: (183,39)-(183,40) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (185,0)-(185,37))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (185,21)-(185,24) = "foo"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (185,4)-(185,20))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ ClassNode (location: (185,5)-(185,19))
        │   │   │   ├── flags: ∅
        │   │   │   ├── locals: []
        │   │   │   ├── class_keyword_loc: (185,5)-(185,10) = "class"
        │   │   │   ├── constant_path:
        │   │   │   │   @ ConstantReadNode (location: (185,11)-(185,14))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :Foo
        │   │   │   ├── inheritance_operator_loc: ∅
        │   │   │   ├── superclass: ∅
        │   │   │   ├── body: ∅
        │   │   │   ├── end_keyword_loc: (185,16)-(185,19) = "end"
        │   │   │   └── name: :Foo
        │   │   ├── opening_loc: (185,4)-(185,5) = "("
        │   │   └── closing_loc: (185,19)-(185,20) = ")"
        │   ├── parameters:
        │   │   @ ParametersNode (location: (185,25)-(185,32))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (185,25)-(185,32))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (185,25)-(185,28) = "bar"
        │   │   │       ├── operator_loc: (185,29)-(185,30) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (185,31)-(185,32))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (185,36)-(185,37))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (185,36)-(185,37))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (185,0)-(185,3) = "def"
        │   ├── operator_loc: (185,20)-(185,21) = "."
        │   ├── lparen_loc: (185,24)-(185,25) = "("
        │   ├── rparen_loc: (185,32)-(185,33) = ")"
        │   ├── equal_loc: (185,34)-(185,35) = "="
        │   └── end_keyword_loc: ∅
        └── @ ModuleNode (location: (187,0)-(190,3))
            ├── flags: newline
            ├── locals: []
            ├── module_keyword_loc: (187,0)-(187,6) = "module"
            ├── constant_path:
            │   @ ConstantReadNode (location: (187,7)-(187,10))
            │   ├── flags: ∅
            │   └── name: :Foo
            ├── body:
            │   @ StatementsNode (location: (188,2)-(189,5))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ DefNode (location: (188,2)-(189,5))
            │           ├── flags: newline
            │           ├── name: :clone
            │           ├── name_loc: (188,6)-(188,11) = "clone"
            │           ├── receiver: ∅
            │           ├── parameters:
            │           │   @ ParametersNode (location: (188,12)-(188,39))
            │           │   ├── flags: ∅
            │           │   ├── requireds: (length: 0)
            │           │   ├── optionals: (length: 1)
            │           │   │   └── @ OptionalParameterNode (location: (188,12)-(188,39))
            │           │   │       ├── flags: ∅
            │           │   │       ├── name: :opts
            │           │   │       ├── name_loc: (188,12)-(188,16) = "opts"
            │           │   │       ├── operator_loc: (188,17)-(188,18) = "="
            │           │   │       └── value:
            │           │   │           @ OrNode (location: (188,19)-(188,39))
            │           │   │           ├── flags: ∅
            │           │   │           ├── left:
            │           │   │           │   @ NilNode (location: (188,19)-(188,22))
            │           │   │           │   └── flags: static_literal
            │           │   │           ├── right:
            │           │   │           │   @ ParenthesesNode (location: (188,26)-(188,39))
            │           │   │           │   ├── flags: ∅
            │           │   │           │   ├── body:
            │           │   │           │   │   @ StatementsNode (location: (188,27)-(188,38))
            │           │   │           │   │   ├── flags: ∅
            │           │   │           │   │   └── body: (length: 1)
            │           │   │           │   │       └── @ ReturnNode (location: (188,27)-(188,38))
            │           │   │           │   │           ├── flags: newline
            │           │   │           │   │           ├── keyword_loc: (188,27)-(188,33) = "return"
            │           │   │           │   │           └── arguments:
            │           │   │           │   │               @ ArgumentsNode (location: (188,34)-(188,38))
            │           │   │           │   │               ├── flags: ∅
            │           │   │           │   │               └── arguments: (length: 1)
            │           │   │           │   │                   └── @ SelfNode (location: (188,34)-(188,38))
            │           │   │           │   │                       └── flags: ∅
            │           │   │           │   ├── opening_loc: (188,26)-(188,27) = "("
            │           │   │           │   └── closing_loc: (188,38)-(188,39) = ")"
            │           │   │           └── operator_loc: (188,23)-(188,25) = "||"
            │           │   ├── rest: ∅
            │           │   ├── posts: (length: 0)
            │           │   ├── keywords: (length: 0)
            │           │   ├── keyword_rest: ∅
            │           │   └── block: ∅
            │           ├── body: ∅
            │           ├── locals: [:opts]
            │           ├── def_keyword_loc: (188,2)-(188,5) = "def"
            │           ├── operator_loc: ∅
            │           ├── lparen_loc: (188,11)-(188,12) = "("
            │           ├── rparen_loc: (188,39)-(188,40) = ")"
            │           ├── equal_loc: ∅
            │           └── end_keyword_loc: (189,2)-(189,5) = "end"
            ├── end_keyword_loc: (190,0)-(190,3) = "end"
            └── name: :Foo
