diff options
Diffstat (limited to 'test/prism/snapshots/methods.txt')
| -rw-r--r-- | test/prism/snapshots/methods.txt | 2054 |
1 files changed, 2054 insertions, 0 deletions
diff --git a/test/prism/snapshots/methods.txt b/test/prism/snapshots/methods.txt new file mode 100644 index 0000000000..76c0361827 --- /dev/null +++ b/test/prism/snapshots/methods.txt @@ -0,0 +1,2054 @@ +@ ProgramNode (location: (1,0)-(183,37)) +├── locals: [:a, :c, :foo] +└── statements: + @ StatementsNode (location: (1,0)-(183,37)) + └── body: (length: 69) + ├── @ DefNode (location: (1,0)-(2,3)) + │ ├── name: :foo + │ ├── name_loc: (1,4)-(1,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (1,8)-(1,18)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ MultiTargetNode (location: (1,8)-(1,18)) + │ │ │ ├── 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)) + │ ├── name: :foo + │ ├── name_loc: (4,4)-(4,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (4,8)-(4,44)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ MultiTargetNode (location: (4,8)-(4,18)) + │ │ │ ├── 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: decimal + │ │ │ └── value: 1 + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 1) + │ │ │ └── @ MultiTargetNode (location: (4,34)-(4,44)) + │ │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (8,4)-(8,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (8,0)-(8,18)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: + │ │ │ @ EnsureNode (location: (8,7)-(8,18)) + │ │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (10,8)-(10,9) = "a" + │ ├── receiver: + │ │ @ ParenthesesNode (location: (10,4)-(10,7)) + │ │ ├── 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)) + │ ├── name: :b + │ ├── name_loc: (13,9)-(13,10) = "b" + │ ├── receiver: + │ │ @ ParenthesesNode (location: (13,4)-(13,7)) + │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (16,10)-(16,11) = "a" + │ ├── receiver: + │ │ @ FalseNode (location: (16,4)-(16,9)) + │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (19,4)-(19,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (19,6)-(19,9)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: + │ │ │ @ ForwardingParameterNode (location: (19,6)-(19,9)) + │ │ └── 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)) + │ ├── name: :a + │ ├── name_loc: (22,9)-(22,10) = "a" + │ ├── receiver: + │ │ @ GlobalVariableReadNode (location: (22,4)-(22,8)) + │ │ └── 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)) + │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (28,9)-(28,10) = "a" + │ ├── receiver: + │ │ @ InstanceVariableReadNode (location: (28,4)-(28,8)) + │ │ └── 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)) + │ ├── name: :a + │ ├── name_loc: (31,4)-(31,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (31,6)-(31,8)) + │ │ ├── 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: ∅ + │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (35,4)-(35,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (35,6)-(35,8)) + │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (38,4)-(38,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (38,6)-(38,9)) + │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (41,4)-(41,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (41,6)-(41,8)) + │ │ ├── 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)) + │ ├── name: :a + │ ├── depth: 0 + │ ├── name_loc: (44,0)-(44,1) = "a" + │ ├── value: + │ │ @ IntegerNode (location: (44,4)-(44,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (44,2)-(44,3) = "=" + ├── @ DefNode (location: (44,7)-(45,3)) + │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (47,4)-(47,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (47,6)-(47,13)) + │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (50,8)-(50,9) = "a" + │ ├── receiver: + │ │ @ NilNode (location: (50,4)-(50,7)) + │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (53,4)-(53,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (53,6)-(53,14)) + │ │ ├── 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: 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)) + │ ├── name: :a + │ ├── name_loc: (56,4)-(56,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (56,6)-(56,14)) + │ │ ├── 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: 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)) + │ ├── name: :a + │ ├── name_loc: (59,4)-(59,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (59,6)-(60,7)) + │ │ ├── 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: 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: ∅ + │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (65,4)-(65,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (65,6)-(65,18)) + │ │ ├── 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: 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: 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)) + │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (71,4)-(71,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (71,6)-(71,14)) + │ │ ├── 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: 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)) + │ ├── name: :a + │ ├── name_loc: (74,4)-(74,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (74,6)-(74,7)) + │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (77,4)-(77,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (77,0)-(77,32)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (77,7)-(77,13)) + │ │ │ ├── keyword_loc: (77,7)-(77,13) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: + │ │ │ @ ElseNode (location: (77,15)-(77,27)) + │ │ │ ├── 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)) + │ │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (79,4)-(79,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (79,6)-(79,8)) + │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (82,4)-(82,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (82,6)-(82,7)) + │ │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (85,4)-(85,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (86,0)-(86,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableWriteNode (location: (86,0)-(86,5)) + │ │ ├── name: :b + │ │ ├── depth: 0 + │ │ ├── name_loc: (86,0)-(86,1) = "b" + │ │ ├── value: + │ │ │ @ IntegerNode (location: (86,4)-(86,5)) + │ │ │ ├── flags: 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)) + │ ├── name: :a + │ ├── name_loc: (89,9)-(89,10) = "a" + │ ├── receiver: + │ │ @ SelfNode (location: (89,4)-(89,8)) + │ ├── 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)) + │ ├── name: :a + │ ├── name_loc: (92,9)-(92,10) = "a" + │ ├── receiver: + │ │ @ TrueNode (location: (92,4)-(92,8)) + │ ├── 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)) + │ ├── 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)) + │ ├── name: :hi + │ ├── name_loc: (98,4)-(98,6) = "hi" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (99,0)-(100,4)) + │ │ └── body: (length: 2) + │ │ ├── @ IfNode (location: (99,0)-(99,18)) + │ │ │ ├── if_keyword_loc: (99,11)-(99,13) = "if" + │ │ │ ├── predicate: + │ │ │ │ @ TrueNode (location: (99,14)-(99,18)) + │ │ │ ├── then_keyword_loc: ∅ + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (99,0)-(99,10)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ ReturnNode (location: (99,0)-(99,10)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── 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: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (99,7)-(99,8) = ":" + │ │ │ │ ├── value_loc: (99,8)-(99,10) = "hi" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "hi" + │ │ │ ├── consequent: ∅ + │ │ │ └── end_keyword_loc: ∅ + │ │ └── @ SymbolNode (location: (100,0)-(100,4)) + │ │ ├── flags: 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)) + │ ├── name: :foo + │ ├── name_loc: (103,4)-(103,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (103,10)-(103,11)) + │ │ └── body: (length: 1) + │ │ └── @ IntegerNode (location: (103,10)-(103,11)) + │ │ ├── flags: 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)) + │ ├── name: :bar + │ ├── name_loc: (104,4)-(104,7) = "bar" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (104,10)-(104,11)) + │ │ └── body: (length: 1) + │ │ └── @ IntegerNode (location: (104,10)-(104,11)) + │ │ ├── flags: 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)) + │ ├── name: :foo + │ ├── name_loc: (106,4)-(106,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (106,8)-(106,11)) + │ │ ├── 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)) + │ │ └── body: (length: 1) + │ │ └── @ IntegerNode (location: (106,15)-(106,18)) + │ │ ├── flags: 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)) + │ ├── name: :foo + │ ├── name_loc: (108,4)-(108,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (108,10)-(108,13)) + │ │ └── body: (length: 1) + │ │ └── @ IntegerNode (location: (108,10)-(108,13)) + │ │ ├── flags: 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)) + │ ├── name: :a + │ ├── name_loc: (110,4)-(110,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (110,6)-(110,7)) + │ │ ├── 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)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (110,10)-(110,14)) + │ │ ├── flags: 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: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ SplatNode (location: (110,12)-(110,13)) + │ │ │ ├── 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,23)) + │ ├── name: :a + │ ├── name_loc: (112,4)-(112,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (112,6)-(112,9)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: + │ │ │ @ ForwardingParameterNode (location: (112,6)-(112,9)) + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (112,12)-(112,18)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (112,12)-(112,18)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (112,12)-(112,13) = "b" + │ │ ├── opening_loc: (112,13)-(112,14) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (112,14)-(112,17)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ ForwardingArgumentsNode (location: (112,14)-(112,17)) + │ │ ├── closing_loc: (112,17)-(112,18) = ")" + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (112,0)-(112,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (112,5)-(112,6) = "(" + │ ├── rparen_loc: (112,9)-(112,10) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (112,20)-(112,23) = "end" + ├── @ DefNode (location: (114,0)-(114,29)) + │ ├── name: :a + │ ├── name_loc: (114,4)-(114,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (114,6)-(114,9)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: + │ │ │ @ ForwardingParameterNode (location: (114,6)-(114,9)) + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (114,12)-(114,24)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (114,12)-(114,24)) + │ │ ├── flags: 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,23)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 3) + │ │ │ ├── @ IntegerNode (location: (114,14)-(114,15)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── @ IntegerNode (location: (114,17)-(114,18)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ └── @ ForwardingArgumentsNode (location: (114,20)-(114,23)) + │ │ ├── closing_loc: (114,23)-(114,24) = ")" + │ │ └── 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,26)-(114,29) = "end" + ├── @ DefNode (location: (116,0)-(117,3)) + │ ├── name: :a + │ ├── name_loc: (116,12)-(116,13) = "a" + │ ├── receiver: + │ │ @ ParenthesesNode (location: (116,4)-(116,11)) + │ │ ├── body: + │ │ │ @ LocalVariableWriteNode (location: (116,5)-(116,10)) + │ │ │ ├── name: :c + │ │ │ ├── depth: 0 + │ │ │ ├── name_loc: (116,5)-(116,6) = "c" + │ │ │ ├── value: + │ │ │ │ @ CallNode (location: (116,9)-(116,10)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (116,9)-(116,10) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (116,7)-(116,8) = "=" + │ │ ├── opening_loc: (116,4)-(116,5) = "(" + │ │ └── closing_loc: (116,10)-(116,11) = ")" + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (116,0)-(116,3) = "def" + │ ├── operator_loc: (116,11)-(116,12) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (117,0)-(117,3) = "end" + ├── @ DefNode (location: (119,0)-(120,3)) + │ ├── name: :a + │ ├── name_loc: (119,4)-(119,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (119,6)-(119,8)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: + │ │ @ BlockParameterNode (location: (119,6)-(119,8)) + │ │ ├── flags: ∅ + │ │ ├── name: :b + │ │ ├── name_loc: (119,7)-(119,8) = "b" + │ │ └── operator_loc: (119,6)-(119,7) = "&" + │ ├── body: ∅ + │ ├── locals: [:b] + │ ├── def_keyword_loc: (119,0)-(119,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (120,0)-(120,3) = "end" + ├── @ DefNode (location: (122,0)-(123,3)) + │ ├── name: :a + │ ├── name_loc: (122,4)-(122,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (122,6)-(122,7)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: + │ │ @ BlockParameterNode (location: (122,6)-(122,7)) + │ │ ├── flags: ∅ + │ │ ├── name: ∅ + │ │ ├── name_loc: ∅ + │ │ └── operator_loc: (122,6)-(122,7) = "&" + │ ├── body: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (122,0)-(122,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (122,5)-(122,6) = "(" + │ ├── rparen_loc: (122,7)-(122,8) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (123,0)-(123,3) = "end" + ├── @ DefNode (location: (125,0)-(126,3)) + │ ├── name: :a + │ ├── name_loc: (125,10)-(125,11) = "a" + │ ├── receiver: + │ │ @ ClassVariableReadNode (location: (125,4)-(125,9)) + │ │ └── name: :@@var + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (125,0)-(125,3) = "def" + │ ├── operator_loc: (125,9)-(125,10) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (126,0)-(126,3) = "end" + ├── @ DefNode (location: (128,0)-(129,3)) + │ ├── name: :C + │ ├── name_loc: (128,12)-(128,13) = "C" + │ ├── receiver: + │ │ @ ParenthesesNode (location: (128,4)-(128,11)) + │ │ ├── body: + │ │ │ @ LocalVariableWriteNode (location: (128,5)-(128,10)) + │ │ │ ├── name: :a + │ │ │ ├── depth: 0 + │ │ │ ├── name_loc: (128,5)-(128,6) = "a" + │ │ │ ├── value: + │ │ │ │ @ CallNode (location: (128,9)-(128,10)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (128,9)-(128,10) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (128,7)-(128,8) = "=" + │ │ ├── opening_loc: (128,4)-(128,5) = "(" + │ │ └── closing_loc: (128,10)-(128,11) = ")" + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (128,0)-(128,3) = "def" + │ ├── operator_loc: (128,11)-(128,12) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (129,0)-(129,3) = "end" + ├── @ DefNode (location: (131,0)-(131,28)) + │ ├── name: :Array_function + │ ├── name_loc: (131,9)-(131,23) = "Array_function" + │ ├── receiver: + │ │ @ SelfNode (location: (131,4)-(131,8)) + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (131,0)-(131,3) = "def" + │ ├── operator_loc: (131,8)-(131,9) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (131,25)-(131,28) = "end" + ├── @ ConstantWriteNode (location: (133,0)-(133,9)) + │ ├── name: :Const + │ ├── name_loc: (133,0)-(133,5) = "Const" + │ ├── value: + │ │ @ IntegerNode (location: (133,8)-(133,9)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (133,6)-(133,7) = "=" + ├── @ DefNode (location: (133,11)-(134,3)) + │ ├── name: :a + │ ├── name_loc: (133,21)-(133,22) = "a" + │ ├── receiver: + │ │ @ ConstantReadNode (location: (133,15)-(133,20)) + │ │ └── name: :Const + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (133,11)-(133,14) = "def" + │ ├── operator_loc: (133,20)-(133,21) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (134,0)-(134,3) = "end" + ├── @ DefNode (location: (136,0)-(136,31)) + │ ├── name: :a + │ ├── name_loc: (136,4)-(136,5) = "a" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (136,6)-(136,9)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: + │ │ │ @ ForwardingParameterNode (location: (136,6)-(136,9)) + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (136,12)-(136,26)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (136,12)-(136,26)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (136,12)-(136,13) = "\"" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ StringNode (location: (136,13)-(136,16)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (136,13)-(136,16) = "foo" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "foo" + │ │ │ └── @ EmbeddedStatementsNode (location: (136,16)-(136,25)) + │ │ │ ├── opening_loc: (136,16)-(136,18) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (136,18)-(136,24)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (136,18)-(136,24)) + │ │ │ │ ├── flags: ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (136,18)-(136,19) = "b" + │ │ │ │ ├── opening_loc: (136,19)-(136,20) = "(" + │ │ │ │ ├── arguments: + │ │ │ │ │ @ ArgumentsNode (location: (136,20)-(136,23)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ └── @ ForwardingArgumentsNode (location: (136,20)-(136,23)) + │ │ │ │ ├── closing_loc: (136,23)-(136,24) = ")" + │ │ │ │ └── block: ∅ + │ │ │ └── closing_loc: (136,24)-(136,25) = "}" + │ │ └── closing_loc: (136,25)-(136,26) = "\"" + │ ├── locals: [] + │ ├── def_keyword_loc: (136,0)-(136,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (136,5)-(136,6) = "(" + │ ├── rparen_loc: (136,9)-(136,10) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (136,28)-(136,31) = "end" + ├── @ DefNode (location: (138,0)-(140,3)) + │ ├── name: :foo + │ ├── name_loc: (138,4)-(138,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (139,2)-(139,30)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (139,2)-(139,30)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ HashNode (location: (139,2)-(139,4)) + │ │ │ ├── opening_loc: (139,2)-(139,3) = "{" + │ │ │ ├── elements: (length: 0) + │ │ │ └── closing_loc: (139,3)-(139,4) = "}" + │ │ ├── call_operator_loc: (139,4)-(139,5) = "." + │ │ ├── name: :merge + │ │ ├── message_loc: (139,5)-(139,10) = "merge" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (139,11)-(139,30)) + │ │ │ ├── flags: contains_keyword_splat + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ KeywordHashNode (location: (139,11)-(139,30)) + │ │ │ ├── flags: ∅ + │ │ │ └── elements: (length: 3) + │ │ │ ├── @ AssocSplatNode (location: (139,11)-(139,16)) + │ │ │ │ ├── value: + │ │ │ │ │ @ CallNode (location: (139,13)-(139,16)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :bar + │ │ │ │ │ ├── message_loc: (139,13)-(139,16) = "bar" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ └── operator_loc: (139,11)-(139,13) = "**" + │ │ │ ├── @ AssocSplatNode (location: (139,18)-(139,23)) + │ │ │ │ ├── value: + │ │ │ │ │ @ CallNode (location: (139,20)-(139,23)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :baz + │ │ │ │ │ ├── message_loc: (139,20)-(139,23) = "baz" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ └── operator_loc: (139,18)-(139,20) = "**" + │ │ │ └── @ AssocSplatNode (location: (139,25)-(139,30)) + │ │ │ ├── value: + │ │ │ │ @ CallNode (location: (139,27)-(139,30)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :qux + │ │ │ │ ├── message_loc: (139,27)-(139,30) = "qux" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (139,25)-(139,27) = "**" + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (138,0)-(138,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (140,0)-(140,3) = "end" + ├── @ DefNode (location: (142,0)-(143,3)) + │ ├── name: :bar + │ ├── name_loc: (142,4)-(142,7) = "bar" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (142,8)-(142,19)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 1) + │ │ │ └── @ OptionalKeywordParameterNode (location: (142,8)-(142,19)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :a + │ │ │ ├── name_loc: (142,8)-(142,10) = "a:" + │ │ │ └── value: + │ │ │ @ ParenthesesNode (location: (142,11)-(142,19)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (142,12)-(142,18)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ RangeNode (location: (142,12)-(142,18)) + │ │ │ │ ├── flags: exclude_end + │ │ │ │ ├── left: + │ │ │ │ │ @ IntegerNode (location: (142,12)-(142,13)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ ├── right: + │ │ │ │ │ @ IntegerNode (location: (142,16)-(142,18)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 10 + │ │ │ │ └── operator_loc: (142,13)-(142,16) = "..." + │ │ │ ├── opening_loc: (142,11)-(142,12) = "(" + │ │ │ └── closing_loc: (142,18)-(142,19) = ")" + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:a] + │ ├── def_keyword_loc: (142,0)-(142,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (142,7)-(142,8) = "(" + │ ├── rparen_loc: (142,19)-(142,20) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (143,0)-(143,3) = "end" + ├── @ DefNode (location: (145,0)-(146,3)) + │ ├── name: :bar + │ ├── name_loc: (145,4)-(145,7) = "bar" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (145,8)-(145,18)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 1) + │ │ │ └── @ OptionalKeywordParameterNode (location: (145,8)-(145,18)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :a + │ │ │ ├── name_loc: (145,8)-(145,10) = "a:" + │ │ │ └── value: + │ │ │ @ ParenthesesNode (location: (145,11)-(145,18)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (145,12)-(145,17)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ RangeNode (location: (145,12)-(145,17)) + │ │ │ │ ├── flags: exclude_end + │ │ │ │ ├── left: ∅ + │ │ │ │ ├── right: + │ │ │ │ │ @ IntegerNode (location: (145,15)-(145,17)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 10 + │ │ │ │ └── operator_loc: (145,12)-(145,15) = "..." + │ │ │ ├── opening_loc: (145,11)-(145,12) = "(" + │ │ │ └── closing_loc: (145,17)-(145,18) = ")" + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:a] + │ ├── def_keyword_loc: (145,0)-(145,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (145,7)-(145,8) = "(" + │ ├── rparen_loc: (145,18)-(145,19) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (146,0)-(146,3) = "end" + ├── @ DefNode (location: (148,0)-(149,3)) + │ ├── name: :bar + │ ├── name_loc: (148,4)-(148,7) = "bar" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (148,8)-(148,17)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 1) + │ │ │ └── @ OptionalKeywordParameterNode (location: (148,8)-(148,17)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :a + │ │ │ ├── name_loc: (148,8)-(148,10) = "a:" + │ │ │ └── value: + │ │ │ @ ParenthesesNode (location: (148,11)-(148,17)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (148,12)-(148,16)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ RangeNode (location: (148,12)-(148,16)) + │ │ │ │ ├── flags: exclude_end + │ │ │ │ ├── left: + │ │ │ │ │ @ IntegerNode (location: (148,12)-(148,13)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ ├── right: ∅ + │ │ │ │ └── operator_loc: (148,13)-(148,16) = "..." + │ │ │ ├── opening_loc: (148,11)-(148,12) = "(" + │ │ │ └── closing_loc: (148,16)-(148,17) = ")" + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:a] + │ ├── def_keyword_loc: (148,0)-(148,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (148,7)-(148,8) = "(" + │ ├── rparen_loc: (148,17)-(148,18) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (149,0)-(149,3) = "end" + ├── @ DefNode (location: (151,0)-(152,3)) + │ ├── name: :bar + │ ├── name_loc: (151,4)-(151,7) = "bar" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (151,8)-(151,20)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (151,8)-(151,20)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :a + │ │ │ ├── name_loc: (151,8)-(151,9) = "a" + │ │ │ ├── operator_loc: (151,10)-(151,11) = "=" + │ │ │ └── value: + │ │ │ @ ParenthesesNode (location: (151,12)-(151,20)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (151,13)-(151,19)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ RangeNode (location: (151,13)-(151,19)) + │ │ │ │ ├── flags: exclude_end + │ │ │ │ ├── left: + │ │ │ │ │ @ IntegerNode (location: (151,13)-(151,14)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ ├── right: + │ │ │ │ │ @ IntegerNode (location: (151,17)-(151,19)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 10 + │ │ │ │ └── operator_loc: (151,14)-(151,17) = "..." + │ │ │ ├── opening_loc: (151,12)-(151,13) = "(" + │ │ │ └── closing_loc: (151,19)-(151,20) = ")" + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:a] + │ ├── def_keyword_loc: (151,0)-(151,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (151,7)-(151,8) = "(" + │ ├── rparen_loc: (151,20)-(151,21) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (152,0)-(152,3) = "end" + ├── @ DefNode (location: (154,0)-(155,3)) + │ ├── name: :bar + │ ├── name_loc: (154,4)-(154,7) = "bar" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (154,8)-(154,19)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (154,8)-(154,19)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :a + │ │ │ ├── name_loc: (154,8)-(154,9) = "a" + │ │ │ ├── operator_loc: (154,10)-(154,11) = "=" + │ │ │ └── value: + │ │ │ @ ParenthesesNode (location: (154,12)-(154,19)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (154,13)-(154,18)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ RangeNode (location: (154,13)-(154,18)) + │ │ │ │ ├── flags: exclude_end + │ │ │ │ ├── left: ∅ + │ │ │ │ ├── right: + │ │ │ │ │ @ IntegerNode (location: (154,16)-(154,18)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 10 + │ │ │ │ └── operator_loc: (154,13)-(154,16) = "..." + │ │ │ ├── opening_loc: (154,12)-(154,13) = "(" + │ │ │ └── closing_loc: (154,18)-(154,19) = ")" + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:a] + │ ├── def_keyword_loc: (154,0)-(154,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (154,7)-(154,8) = "(" + │ ├── rparen_loc: (154,19)-(154,20) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (155,0)-(155,3) = "end" + ├── @ DefNode (location: (157,0)-(158,3)) + │ ├── name: :bar + │ ├── name_loc: (157,4)-(157,7) = "bar" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (157,8)-(157,18)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (157,8)-(157,18)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :a + │ │ │ ├── name_loc: (157,8)-(157,9) = "a" + │ │ │ ├── operator_loc: (157,10)-(157,11) = "=" + │ │ │ └── value: + │ │ │ @ ParenthesesNode (location: (157,12)-(157,18)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (157,13)-(157,17)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ RangeNode (location: (157,13)-(157,17)) + │ │ │ │ ├── flags: exclude_end + │ │ │ │ ├── left: + │ │ │ │ │ @ IntegerNode (location: (157,13)-(157,14)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ ├── right: ∅ + │ │ │ │ └── operator_loc: (157,14)-(157,17) = "..." + │ │ │ ├── opening_loc: (157,12)-(157,13) = "(" + │ │ │ └── closing_loc: (157,17)-(157,18) = ")" + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:a] + │ ├── def_keyword_loc: (157,0)-(157,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (157,7)-(157,8) = "(" + │ ├── rparen_loc: (157,18)-(157,19) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (158,0)-(158,3) = "end" + ├── @ DefNode (location: (160,0)-(162,3)) + │ ├── name: :method + │ ├── name_loc: (160,4)-(160,10) = "method" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (160,11)-(160,12)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (160,11)-(160,12)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :a + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (161,2)-(161,14)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (161,2)-(161,14)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (161,2)-(161,6)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :item + │ │ │ ├── message_loc: (161,2)-(161,6) = "item" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :>> + │ │ ├── message_loc: (161,7)-(161,9) = ">>" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (161,10)-(161,14)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ CallNode (location: (161,10)-(161,14)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (161,10)-(161,11) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (161,12)-(161,14)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (161,12)-(161,13) = "{" + │ │ │ └── closing_loc: (161,13)-(161,14) = "}" + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [:a] + │ ├── def_keyword_loc: (160,0)-(160,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (160,10)-(160,11) = "(" + │ ├── rparen_loc: (160,12)-(160,13) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (162,0)-(162,3) = "end" + ├── @ LocalVariableWriteNode (location: (164,0)-(164,7)) + │ ├── name: :foo + │ ├── depth: 0 + │ ├── name_loc: (164,0)-(164,3) = "foo" + │ ├── value: + │ │ @ IntegerNode (location: (164,6)-(164,7)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (164,4)-(164,5) = "=" + ├── @ DefNode (location: (165,0)-(165,16)) + │ ├── name: :bar + │ ├── name_loc: (165,8)-(165,11) = "bar" + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (165,4)-(165,7)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (165,0)-(165,3) = "def" + │ ├── operator_loc: (165,7)-(165,8) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (165,13)-(165,16) = "end" + ├── @ DefNode (location: (167,0)-(167,18)) + │ ├── name: :f + │ ├── name_loc: (167,4)-(167,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (167,6)-(167,7)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (167,6)-(167,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (167,6)-(167,7) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (167,10)-(167,13)) + │ │ └── body: (length: 1) + │ │ └── @ ArrayNode (location: (167,10)-(167,13)) + │ │ ├── flags: contains_splat + │ │ ├── elements: (length: 1) + │ │ │ └── @ SplatNode (location: (167,11)-(167,12)) + │ │ │ ├── operator_loc: (167,11)-(167,12) = "*" + │ │ │ └── expression: ∅ + │ │ ├── opening_loc: (167,10)-(167,11) = "[" + │ │ └── closing_loc: (167,12)-(167,13) = "]" + │ ├── locals: [] + │ ├── def_keyword_loc: (167,0)-(167,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (167,5)-(167,6) = "(" + │ ├── rparen_loc: (167,7)-(167,8) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (167,15)-(167,18) = "end" + ├── @ DefNode (location: (169,0)-(169,15)) + │ ├── name: :f + │ ├── name_loc: (169,4)-(169,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (169,6)-(169,10)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 1) + │ │ │ └── @ OptionalKeywordParameterNode (location: (169,6)-(169,10)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :x + │ │ │ ├── name_loc: (169,6)-(169,8) = "x:" + │ │ │ └── value: + │ │ │ @ CallNode (location: (169,8)-(169,10)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (169,9)-(169,10)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (169,9)-(169,10) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :-@ + │ │ │ ├── message_loc: (169,8)-(169,9) = "-" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:x] + │ ├── def_keyword_loc: (169,0)-(169,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (169,12)-(169,15) = "end" + ├── @ DefNode (location: (171,0)-(171,15)) + │ ├── name: :f + │ ├── name_loc: (171,4)-(171,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (171,6)-(171,10)) + │ │ ├── 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)) + │ ├── name: :f + │ ├── name_loc: (173,4)-(173,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (173,6)-(173,10)) + │ │ ├── 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,20)) + │ ├── name: :foo + │ ├── name_loc: (175,4)-(175,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (175,8)-(175,15)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 1) + │ │ │ └── @ OptionalKeywordParameterNode (location: (175,8)-(175,15)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :x + │ │ │ ├── name_loc: (175,8)-(175,10) = "x:" + │ │ │ └── value: + │ │ │ @ StringNode (location: (175,10)-(175,15)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (175,10)-(175,12) = "%(" + │ │ │ ├── content_loc: (175,12)-(175,14) = "xx" + │ │ │ ├── closing_loc: (175,14)-(175,15) = ")" + │ │ │ └── unescaped: "xx" + │ │ ├── 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,17)-(175,20) = "end" + ├── @ DefNode (location: (177,0)-(179,3)) + │ ├── name: :foo + │ ├── name_loc: (177,4)-(177,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (177,8)-(177,11)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: + │ │ │ @ ForwardingParameterNode (location: (177,8)-(177,11)) + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (178,2)-(178,10)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (178,2)-(178,10)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (178,2)-(178,5) = "bar" + │ │ ├── opening_loc: (178,5)-(178,6) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (178,6)-(178,9)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ ForwardingArgumentsNode (location: (178,6)-(178,9)) + │ │ ├── closing_loc: (178,9)-(178,10) = ")" + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (177,0)-(177,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (177,7)-(177,8) = "(" + │ ├── rparen_loc: (177,11)-(177,12) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (179,0)-(179,3) = "end" + ├── @ DefNode (location: (181,0)-(181,42)) + │ ├── name: :foo + │ ├── name_loc: (181,4)-(181,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (181,8)-(181,37)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (181,8)-(181,37)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── name_loc: (181,8)-(181,11) = "bar" + │ │ │ ├── operator_loc: (181,12)-(181,13) = "=" + │ │ │ └── value: + │ │ │ @ ParenthesesNode (location: (181,14)-(181,37)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (181,15)-(181,36)) + │ │ │ │ └── body: (length: 2) + │ │ │ │ ├── @ DefNode (location: (181,15)-(181,33)) + │ │ │ │ │ ├── name: :baz + │ │ │ │ │ ├── name_loc: (181,19)-(181,22) = "baz" + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── parameters: + │ │ │ │ │ │ @ ParametersNode (location: (181,23)-(181,26)) + │ │ │ │ │ │ ├── requireds: (length: 1) + │ │ │ │ │ │ │ └── @ RequiredParameterNode (location: (181,23)-(181,26)) + │ │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ │ └── name: :bar + │ │ │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ │ │ ├── rest: ∅ + │ │ │ │ │ │ ├── posts: (length: 0) + │ │ │ │ │ │ ├── keywords: (length: 0) + │ │ │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ │ │ └── block: ∅ + │ │ │ │ │ ├── body: + │ │ │ │ │ │ @ StatementsNode (location: (181,30)-(181,33)) + │ │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ │ └── @ LocalVariableReadNode (location: (181,30)-(181,33)) + │ │ │ │ │ │ ├── name: :bar + │ │ │ │ │ │ └── depth: 0 + │ │ │ │ │ ├── locals: [:bar] + │ │ │ │ │ ├── def_keyword_loc: (181,15)-(181,18) = "def" + │ │ │ │ │ ├── operator_loc: ∅ + │ │ │ │ │ ├── lparen_loc: (181,22)-(181,23) = "(" + │ │ │ │ │ ├── rparen_loc: (181,26)-(181,27) = ")" + │ │ │ │ │ ├── equal_loc: (181,28)-(181,29) = "=" + │ │ │ │ │ └── end_keyword_loc: ∅ + │ │ │ │ └── @ IntegerNode (location: (181,35)-(181,36)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── opening_loc: (181,14)-(181,15) = "(" + │ │ │ └── closing_loc: (181,36)-(181,37) = ")" + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (181,41)-(181,42)) + │ │ └── body: (length: 1) + │ │ └── @ IntegerNode (location: (181,41)-(181,42)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── locals: [:bar] + │ ├── def_keyword_loc: (181,0)-(181,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (181,7)-(181,8) = "(" + │ ├── rparen_loc: (181,37)-(181,38) = ")" + │ ├── equal_loc: (181,39)-(181,40) = "=" + │ └── end_keyword_loc: ∅ + └── @ DefNode (location: (183,0)-(183,37)) + ├── name: :foo + ├── name_loc: (183,21)-(183,24) = "foo" + ├── receiver: + │ @ ParenthesesNode (location: (183,4)-(183,20)) + │ ├── body: + │ │ @ ClassNode (location: (183,5)-(183,19)) + │ │ ├── locals: [] + │ │ ├── class_keyword_loc: (183,5)-(183,10) = "class" + │ │ ├── constant_path: + │ │ │ @ ConstantReadNode (location: (183,11)-(183,14)) + │ │ │ └── name: :Foo + │ │ ├── inheritance_operator_loc: ∅ + │ │ ├── superclass: ∅ + │ │ ├── body: ∅ + │ │ ├── end_keyword_loc: (183,16)-(183,19) = "end" + │ │ └── name: :Foo + │ ├── opening_loc: (183,4)-(183,5) = "(" + │ └── closing_loc: (183,19)-(183,20) = ")" + ├── parameters: + │ @ ParametersNode (location: (183,25)-(183,32)) + │ ├── requireds: (length: 0) + │ ├── optionals: (length: 1) + │ │ └── @ OptionalParameterNode (location: (183,25)-(183,32)) + │ │ ├── flags: ∅ + │ │ ├── name: :bar + │ │ ├── name_loc: (183,25)-(183,28) = "bar" + │ │ ├── operator_loc: (183,29)-(183,30) = "=" + │ │ └── value: + │ │ @ IntegerNode (location: (183,31)-(183,32)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── rest: ∅ + │ ├── posts: (length: 0) + │ ├── keywords: (length: 0) + │ ├── keyword_rest: ∅ + │ └── block: ∅ + ├── body: + │ @ StatementsNode (location: (183,36)-(183,37)) + │ └── body: (length: 1) + │ └── @ IntegerNode (location: (183,36)-(183,37)) + │ ├── flags: decimal + │ └── value: 2 + ├── locals: [:bar] + ├── def_keyword_loc: (183,0)-(183,3) = "def" + ├── operator_loc: (183,20)-(183,21) = "." + ├── lparen_loc: (183,24)-(183,25) = "(" + ├── rparen_loc: (183,32)-(183,33) = ")" + ├── equal_loc: (183,34)-(183,35) = "=" + └── end_keyword_loc: ∅ |