summaryrefslogtreecommitdiff
path: root/test/prism/snapshots/unparser/corpus/literal/def.txt
diff options
context:
space:
mode:
Diffstat (limited to 'test/prism/snapshots/unparser/corpus/literal/def.txt')
-rw-r--r--test/prism/snapshots/unparser/corpus/literal/def.txt1204
1 files changed, 1204 insertions, 0 deletions
diff --git a/test/prism/snapshots/unparser/corpus/literal/def.txt b/test/prism/snapshots/unparser/corpus/literal/def.txt
new file mode 100644
index 0000000000..f3ef6c388e
--- /dev/null
+++ b/test/prism/snapshots/unparser/corpus/literal/def.txt
@@ -0,0 +1,1204 @@
+@ ProgramNode (location: (1,0)-(134,3))
+├── locals: []
+└── statements:
+ @ StatementsNode (location: (1,0)-(134,3))
+ └── body: (length: 30)
+ ├── @ DefNode (location: (1,0)-(9,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (1,4)-(1,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters: ∅
+ │ ├── body:
+ │ │ @ BeginNode (location: (1,0)-(9,3))
+ │ │ ├── begin_keyword_loc: ∅
+ │ │ ├── statements:
+ │ │ │ @ StatementsNode (location: (2,2)-(2,3))
+ │ │ │ └── body: (length: 1)
+ │ │ │ └── @ CallNode (location: (2,2)-(2,3))
+ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ ├── receiver: ∅
+ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ ├── name: :a
+ │ │ │ ├── message_loc: (2,2)-(2,3) = "a"
+ │ │ │ ├── opening_loc: ∅
+ │ │ │ ├── arguments: ∅
+ │ │ │ ├── closing_loc: ∅
+ │ │ │ └── block: ∅
+ │ │ ├── rescue_clause:
+ │ │ │ @ RescueNode (location: (3,0)-(4,3))
+ │ │ │ ├── keyword_loc: (3,0)-(3,6) = "rescue"
+ │ │ │ ├── exceptions: (length: 0)
+ │ │ │ ├── operator_loc: ∅
+ │ │ │ ├── reference: ∅
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (4,2)-(4,3))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (4,2)-(4,3))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :b
+ │ │ │ │ ├── message_loc: (4,2)-(4,3) = "b"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── consequent: ∅
+ │ │ ├── else_clause:
+ │ │ │ @ ElseNode (location: (5,0)-(7,6))
+ │ │ │ ├── else_keyword_loc: (5,0)-(5,4) = "else"
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (6,2)-(6,3))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (6,2)-(6,3))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :c
+ │ │ │ │ ├── message_loc: (6,2)-(6,3) = "c"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── end_keyword_loc: (7,0)-(7,6) = "ensure"
+ │ │ ├── ensure_clause:
+ │ │ │ @ EnsureNode (location: (7,0)-(9,3))
+ │ │ │ ├── ensure_keyword_loc: (7,0)-(7,6) = "ensure"
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (8,2)-(8,3))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (8,2)-(8,3))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :d
+ │ │ │ │ ├── message_loc: (8,2)-(8,3) = "d"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── end_keyword_loc: (9,0)-(9,3) = "end"
+ │ │ └── end_keyword_loc: (9,0)-(9,3) = "end"
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (1,0)-(1,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: ∅
+ │ ├── rparen_loc: ∅
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (9,0)-(9,3) = "end"
+ ├── @ DefNode (location: (11,0)-(19,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (11,4)-(11,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters: ∅
+ │ ├── body:
+ │ │ @ BeginNode (location: (11,0)-(19,3))
+ │ │ ├── begin_keyword_loc: ∅
+ │ │ ├── statements:
+ │ │ │ @ StatementsNode (location: (12,2)-(12,12))
+ │ │ │ └── body: (length: 1)
+ │ │ │ └── @ RescueModifierNode (location: (12,2)-(12,12))
+ │ │ │ ├── expression:
+ │ │ │ │ @ CallNode (location: (12,2)-(12,3))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :a
+ │ │ │ │ ├── message_loc: (12,2)-(12,3) = "a"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ ├── keyword_loc: (12,4)-(12,10) = "rescue"
+ │ │ │ └── rescue_expression:
+ │ │ │ @ CallNode (location: (12,11)-(12,12))
+ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ ├── receiver: ∅
+ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ ├── name: :b
+ │ │ │ ├── message_loc: (12,11)-(12,12) = "b"
+ │ │ │ ├── opening_loc: ∅
+ │ │ │ ├── arguments: ∅
+ │ │ │ ├── closing_loc: ∅
+ │ │ │ └── block: ∅
+ │ │ ├── rescue_clause:
+ │ │ │ @ RescueNode (location: (13,0)-(14,3))
+ │ │ │ ├── keyword_loc: (13,0)-(13,6) = "rescue"
+ │ │ │ ├── exceptions: (length: 0)
+ │ │ │ ├── operator_loc: ∅
+ │ │ │ ├── reference: ∅
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (14,2)-(14,3))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (14,2)-(14,3))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :b
+ │ │ │ │ ├── message_loc: (14,2)-(14,3) = "b"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── consequent: ∅
+ │ │ ├── else_clause:
+ │ │ │ @ ElseNode (location: (15,0)-(17,6))
+ │ │ │ ├── else_keyword_loc: (15,0)-(15,4) = "else"
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (16,2)-(16,3))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (16,2)-(16,3))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :c
+ │ │ │ │ ├── message_loc: (16,2)-(16,3) = "c"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── end_keyword_loc: (17,0)-(17,6) = "ensure"
+ │ │ ├── ensure_clause:
+ │ │ │ @ EnsureNode (location: (17,0)-(19,3))
+ │ │ │ ├── ensure_keyword_loc: (17,0)-(17,6) = "ensure"
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (18,2)-(18,3))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (18,2)-(18,3))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :d
+ │ │ │ │ ├── message_loc: (18,2)-(18,3) = "d"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── end_keyword_loc: (19,0)-(19,3) = "end"
+ │ │ └── end_keyword_loc: (19,0)-(19,3) = "end"
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (11,0)-(11,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: ∅
+ │ ├── rparen_loc: ∅
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (19,0)-(19,3) = "end"
+ ├── @ DefNode (location: (21,0)-(22,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (21,4)-(21,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (21,8)-(21,18))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 2)
+ │ │ │ ├── @ RequiredKeywordParameterNode (location: (21,8)-(21,12))
+ │ │ │ │ ├── flags: ∅
+ │ │ │ │ ├── name: :bar
+ │ │ │ │ └── name_loc: (21,8)-(21,12) = "bar:"
+ │ │ │ └── @ RequiredKeywordParameterNode (location: (21,14)-(21,18))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :baz
+ │ │ │ └── name_loc: (21,14)-(21,18) = "baz:"
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body: ∅
+ │ ├── locals: [:bar, :baz]
+ │ ├── def_keyword_loc: (21,0)-(21,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (21,7)-(21,8) = "("
+ │ ├── rparen_loc: (21,18)-(21,19) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (22,0)-(22,3) = "end"
+ ├── @ DefNode (location: (24,0)-(25,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (24,4)-(24,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters: ∅
+ │ ├── body: ∅
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (24,0)-(24,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: ∅
+ │ ├── rparen_loc: ∅
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (25,0)-(25,3) = "end"
+ ├── @ DefNode (location: (27,0)-(29,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (27,4)-(27,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (28,2)-(28,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ CallNode (location: (28,2)-(28,5))
+ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ ├── receiver: ∅
+ │ │ ├── call_operator_loc: ∅
+ │ │ ├── name: :bar
+ │ │ ├── message_loc: (28,2)-(28,5) = "bar"
+ │ │ ├── opening_loc: ∅
+ │ │ ├── arguments: ∅
+ │ │ ├── closing_loc: ∅
+ │ │ └── block: ∅
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (27,0)-(27,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: ∅
+ │ ├── rparen_loc: ∅
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (29,0)-(29,3) = "end"
+ ├── @ DefNode (location: (31,0)-(37,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (31,4)-(31,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters: ∅
+ │ ├── body:
+ │ │ @ BeginNode (location: (31,0)-(37,3))
+ │ │ ├── begin_keyword_loc: ∅
+ │ │ ├── statements:
+ │ │ │ @ StatementsNode (location: (32,2)-(32,5))
+ │ │ │ └── body: (length: 1)
+ │ │ │ └── @ CallNode (location: (32,2)-(32,5))
+ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ ├── receiver: ∅
+ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ ├── name: :foo
+ │ │ │ ├── message_loc: (32,2)-(32,5) = "foo"
+ │ │ │ ├── opening_loc: ∅
+ │ │ │ ├── arguments: ∅
+ │ │ │ ├── closing_loc: ∅
+ │ │ │ └── block: ∅
+ │ │ ├── rescue_clause:
+ │ │ │ @ RescueNode (location: (33,0)-(34,5))
+ │ │ │ ├── keyword_loc: (33,0)-(33,6) = "rescue"
+ │ │ │ ├── exceptions: (length: 0)
+ │ │ │ ├── operator_loc: ∅
+ │ │ │ ├── reference: ∅
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (34,2)-(34,5))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (34,2)-(34,5))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :bar
+ │ │ │ │ ├── message_loc: (34,2)-(34,5) = "bar"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── consequent: ∅
+ │ │ ├── else_clause: ∅
+ │ │ ├── ensure_clause:
+ │ │ │ @ EnsureNode (location: (35,0)-(37,3))
+ │ │ │ ├── ensure_keyword_loc: (35,0)-(35,6) = "ensure"
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (36,2)-(36,5))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (36,2)-(36,5))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :baz
+ │ │ │ │ ├── message_loc: (36,2)-(36,5) = "baz"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── end_keyword_loc: (37,0)-(37,3) = "end"
+ │ │ └── end_keyword_loc: (37,0)-(37,3) = "end"
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (31,0)-(31,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: ∅
+ │ ├── rparen_loc: ∅
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (37,0)-(37,3) = "end"
+ ├── @ DefNode (location: (39,0)-(43,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (39,4)-(39,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters: ∅
+ │ ├── body:
+ │ │ @ BeginNode (location: (39,0)-(43,3))
+ │ │ ├── begin_keyword_loc: ∅
+ │ │ ├── statements:
+ │ │ │ @ StatementsNode (location: (40,2)-(40,5))
+ │ │ │ └── body: (length: 1)
+ │ │ │ └── @ CallNode (location: (40,2)-(40,5))
+ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ ├── receiver: ∅
+ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── message_loc: (40,2)-(40,5) = "bar"
+ │ │ │ ├── opening_loc: ∅
+ │ │ │ ├── arguments: ∅
+ │ │ │ ├── closing_loc: ∅
+ │ │ │ └── block: ∅
+ │ │ ├── rescue_clause: ∅
+ │ │ ├── else_clause: ∅
+ │ │ ├── ensure_clause:
+ │ │ │ @ EnsureNode (location: (41,0)-(43,3))
+ │ │ │ ├── ensure_keyword_loc: (41,0)-(41,6) = "ensure"
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (42,2)-(42,5))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (42,2)-(42,5))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :baz
+ │ │ │ │ ├── message_loc: (42,2)-(42,5) = "baz"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── end_keyword_loc: (43,0)-(43,3) = "end"
+ │ │ └── end_keyword_loc: (43,0)-(43,3) = "end"
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (39,0)-(39,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: ∅
+ │ ├── rparen_loc: ∅
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (43,0)-(43,3) = "end"
+ ├── @ DefNode (location: (45,0)-(49,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (45,4)-(45,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters: ∅
+ │ ├── body:
+ │ │ @ BeginNode (location: (45,0)-(49,3))
+ │ │ ├── begin_keyword_loc: ∅
+ │ │ ├── statements:
+ │ │ │ @ StatementsNode (location: (46,2)-(46,5))
+ │ │ │ └── body: (length: 1)
+ │ │ │ └── @ CallNode (location: (46,2)-(46,5))
+ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ ├── receiver: ∅
+ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── message_loc: (46,2)-(46,5) = "bar"
+ │ │ │ ├── opening_loc: ∅
+ │ │ │ ├── arguments: ∅
+ │ │ │ ├── closing_loc: ∅
+ │ │ │ └── block: ∅
+ │ │ ├── rescue_clause:
+ │ │ │ @ RescueNode (location: (47,0)-(48,5))
+ │ │ │ ├── keyword_loc: (47,0)-(47,6) = "rescue"
+ │ │ │ ├── exceptions: (length: 0)
+ │ │ │ ├── operator_loc: ∅
+ │ │ │ ├── reference: ∅
+ │ │ │ ├── statements:
+ │ │ │ │ @ StatementsNode (location: (48,2)-(48,5))
+ │ │ │ │ └── body: (length: 1)
+ │ │ │ │ └── @ CallNode (location: (48,2)-(48,5))
+ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ ├── name: :baz
+ │ │ │ │ ├── message_loc: (48,2)-(48,5) = "baz"
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── block: ∅
+ │ │ │ └── consequent: ∅
+ │ │ ├── else_clause: ∅
+ │ │ ├── ensure_clause: ∅
+ │ │ └── end_keyword_loc: (49,0)-(49,3) = "end"
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (45,0)-(45,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: ∅
+ │ ├── rparen_loc: ∅
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (49,0)-(49,3) = "end"
+ ├── @ DefNode (location: (51,0)-(53,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (51,4)-(51,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (51,8)-(51,11))
+ │ │ ├── requireds: (length: 1)
+ │ │ │ └── @ RequiredParameterNode (location: (51,8)-(51,11))
+ │ │ │ ├── flags: ∅
+ │ │ │ └── name: :bar
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (52,2)-(52,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ LocalVariableReadNode (location: (52,2)-(52,5))
+ │ │ ├── name: :bar
+ │ │ └── depth: 0
+ │ ├── locals: [:bar]
+ │ ├── def_keyword_loc: (51,0)-(51,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (51,7)-(51,8) = "("
+ │ ├── rparen_loc: (51,11)-(51,12) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (53,0)-(53,3) = "end"
+ ├── @ DefNode (location: (55,0)-(57,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (55,4)-(55,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (55,8)-(55,16))
+ │ │ ├── requireds: (length: 2)
+ │ │ │ ├── @ RequiredParameterNode (location: (55,8)-(55,11))
+ │ │ │ │ ├── flags: ∅
+ │ │ │ │ └── name: :bar
+ │ │ │ └── @ RequiredParameterNode (location: (55,13)-(55,16))
+ │ │ │ ├── flags: ∅
+ │ │ │ └── name: :baz
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (56,2)-(56,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ LocalVariableReadNode (location: (56,2)-(56,5))
+ │ │ ├── name: :bar
+ │ │ └── depth: 0
+ │ ├── locals: [:bar, :baz]
+ │ ├── def_keyword_loc: (55,0)-(55,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (55,7)-(55,8) = "("
+ │ ├── rparen_loc: (55,16)-(55,17) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (57,0)-(57,3) = "end"
+ ├── @ DefNode (location: (59,0)-(61,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (59,4)-(59,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (59,8)-(59,16))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 1)
+ │ │ │ └── @ OptionalParameterNode (location: (59,8)-(59,16))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── name_loc: (59,8)-(59,11) = "bar"
+ │ │ │ ├── operator_loc: (59,12)-(59,13) = "="
+ │ │ │ └── value:
+ │ │ │ @ ParenthesesNode (location: (59,14)-(59,16))
+ │ │ │ ├── body: ∅
+ │ │ │ ├── opening_loc: (59,14)-(59,15) = "("
+ │ │ │ └── closing_loc: (59,15)-(59,16) = ")"
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (60,2)-(60,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ LocalVariableReadNode (location: (60,2)-(60,5))
+ │ │ ├── name: :bar
+ │ │ └── depth: 0
+ │ ├── locals: [:bar]
+ │ ├── def_keyword_loc: (59,0)-(59,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (59,7)-(59,8) = "("
+ │ ├── rparen_loc: (59,16)-(59,17) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (61,0)-(61,3) = "end"
+ ├── @ DefNode (location: (63,0)-(64,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (63,4)-(63,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (63,8)-(63,24))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 1)
+ │ │ │ └── @ OptionalParameterNode (location: (63,8)-(63,24))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── name_loc: (63,8)-(63,11) = "bar"
+ │ │ │ ├── operator_loc: (63,12)-(63,13) = "="
+ │ │ │ └── value:
+ │ │ │ @ ParenthesesNode (location: (63,14)-(63,24))
+ │ │ │ ├── body:
+ │ │ │ │ @ StatementsNode (location: (63,15)-(63,23))
+ │ │ │ │ └── body: (length: 2)
+ │ │ │ │ ├── @ CallNode (location: (63,15)-(63,18))
+ │ │ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ │ │ ├── receiver: ∅
+ │ │ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ │ │ ├── name: :baz
+ │ │ │ │ │ ├── message_loc: (63,15)-(63,18) = "baz"
+ │ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ │ ├── arguments: ∅
+ │ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ │ └── block: ∅
+ │ │ │ │ └── @ NilNode (location: (63,20)-(63,23))
+ │ │ │ ├── opening_loc: (63,14)-(63,15) = "("
+ │ │ │ └── closing_loc: (63,23)-(63,24) = ")"
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body: ∅
+ │ ├── locals: [:bar]
+ │ ├── def_keyword_loc: (63,0)-(63,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (63,7)-(63,8) = "("
+ │ ├── rparen_loc: (63,24)-(63,25) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (64,0)-(64,3) = "end"
+ ├── @ DefNode (location: (66,0)-(68,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (66,4)-(66,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (66,8)-(66,18))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 1)
+ │ │ │ └── @ OptionalParameterNode (location: (66,8)-(66,18))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── name_loc: (66,8)-(66,11) = "bar"
+ │ │ │ ├── operator_loc: (66,12)-(66,13) = "="
+ │ │ │ └── value:
+ │ │ │ @ TrueNode (location: (66,14)-(66,18))
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (67,2)-(67,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ LocalVariableReadNode (location: (67,2)-(67,5))
+ │ │ ├── name: :bar
+ │ │ └── depth: 0
+ │ ├── locals: [:bar]
+ │ ├── def_keyword_loc: (66,0)-(66,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (66,7)-(66,8) = "("
+ │ ├── rparen_loc: (66,18)-(66,19) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (68,0)-(68,3) = "end"
+ ├── @ DefNode (location: (70,0)-(72,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (70,4)-(70,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (70,8)-(70,23))
+ │ │ ├── requireds: (length: 1)
+ │ │ │ └── @ RequiredParameterNode (location: (70,8)-(70,11))
+ │ │ │ ├── flags: ∅
+ │ │ │ └── name: :bar
+ │ │ ├── optionals: (length: 1)
+ │ │ │ └── @ OptionalParameterNode (location: (70,13)-(70,23))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :baz
+ │ │ │ ├── name_loc: (70,13)-(70,16) = "baz"
+ │ │ │ ├── operator_loc: (70,17)-(70,18) = "="
+ │ │ │ └── value:
+ │ │ │ @ TrueNode (location: (70,19)-(70,23))
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (71,2)-(71,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ LocalVariableReadNode (location: (71,2)-(71,5))
+ │ │ ├── name: :bar
+ │ │ └── depth: 0
+ │ ├── locals: [:bar, :baz]
+ │ ├── def_keyword_loc: (70,0)-(70,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (70,7)-(70,8) = "("
+ │ ├── rparen_loc: (70,23)-(70,24) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (72,0)-(72,3) = "end"
+ ├── @ DefNode (location: (74,0)-(75,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (74,4)-(74,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (74,8)-(74,14))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 1)
+ │ │ │ └── @ OptionalKeywordParameterNode (location: (74,8)-(74,14))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── name_loc: (74,8)-(74,12) = "bar:"
+ │ │ │ └── value:
+ │ │ │ @ IntegerNode (location: (74,13)-(74,14))
+ │ │ │ ├── flags: decimal
+ │ │ │ └── value: 1
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body: ∅
+ │ ├── locals: [:bar]
+ │ ├── def_keyword_loc: (74,0)-(74,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (74,7)-(74,8) = "("
+ │ ├── rparen_loc: (74,14)-(74,15) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (75,0)-(75,3) = "end"
+ ├── @ DefNode (location: (77,0)-(78,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (77,4)-(77,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (77,8)-(77,16))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 1)
+ │ │ │ └── @ OptionalKeywordParameterNode (location: (77,8)-(77,16))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── name_loc: (77,8)-(77,12) = "bar:"
+ │ │ │ └── value:
+ │ │ │ @ CallNode (location: (77,13)-(77,16))
+ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ ├── receiver: ∅
+ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ ├── name: :baz
+ │ │ │ ├── message_loc: (77,13)-(77,16) = "baz"
+ │ │ │ ├── opening_loc: ∅
+ │ │ │ ├── arguments: ∅
+ │ │ │ ├── closing_loc: ∅
+ │ │ │ └── block: ∅
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body: ∅
+ │ ├── locals: [:bar]
+ │ ├── def_keyword_loc: (77,0)-(77,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (77,7)-(77,8) = "("
+ │ ├── rparen_loc: (77,16)-(77,17) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (78,0)-(78,3) = "end"
+ ├── @ DefNode (location: (80,0)-(81,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (80,4)-(80,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (80,8)-(80,18))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 1)
+ │ │ │ └── @ OptionalKeywordParameterNode (location: (80,8)-(80,18))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── name_loc: (80,8)-(80,12) = "bar:"
+ │ │ │ └── value:
+ │ │ │ @ CallNode (location: (80,13)-(80,18))
+ │ │ │ ├── flags: ignore_visibility
+ │ │ │ ├── receiver: ∅
+ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── message_loc: (80,13)-(80,16) = "bar"
+ │ │ │ ├── opening_loc: (80,16)-(80,17) = "("
+ │ │ │ ├── arguments: ∅
+ │ │ │ ├── closing_loc: (80,17)-(80,18) = ")"
+ │ │ │ └── block: ∅
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body: ∅
+ │ ├── locals: [:bar]
+ │ ├── def_keyword_loc: (80,0)-(80,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (80,7)-(80,8) = "("
+ │ ├── rparen_loc: (80,18)-(80,19) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (81,0)-(81,3) = "end"
+ ├── @ DefNode (location: (83,0)-(85,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (83,4)-(83,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (83,8)-(83,9))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest:
+ │ │ │ @ RestParameterNode (location: (83,8)-(83,9))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: ∅
+ │ │ │ ├── name_loc: ∅
+ │ │ │ └── operator_loc: (83,8)-(83,9) = "*"
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (84,2)-(84,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ CallNode (location: (84,2)-(84,5))
+ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ ├── receiver: ∅
+ │ │ ├── call_operator_loc: ∅
+ │ │ ├── name: :bar
+ │ │ ├── message_loc: (84,2)-(84,5) = "bar"
+ │ │ ├── opening_loc: ∅
+ │ │ ├── arguments: ∅
+ │ │ ├── closing_loc: ∅
+ │ │ └── block: ∅
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (83,0)-(83,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (83,7)-(83,8) = "("
+ │ ├── rparen_loc: (83,9)-(83,10) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (85,0)-(85,3) = "end"
+ ├── @ DefNode (location: (87,0)-(89,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (87,4)-(87,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (87,8)-(87,12))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest:
+ │ │ │ @ RestParameterNode (location: (87,8)-(87,12))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── name_loc: (87,9)-(87,12) = "bar"
+ │ │ │ └── operator_loc: (87,8)-(87,9) = "*"
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (88,2)-(88,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ LocalVariableReadNode (location: (88,2)-(88,5))
+ │ │ ├── name: :bar
+ │ │ └── depth: 0
+ │ ├── locals: [:bar]
+ │ ├── def_keyword_loc: (87,0)-(87,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (87,7)-(87,8) = "("
+ │ ├── rparen_loc: (87,12)-(87,13) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (89,0)-(89,3) = "end"
+ ├── @ DefNode (location: (91,0)-(93,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (91,4)-(91,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (91,8)-(91,17))
+ │ │ ├── requireds: (length: 1)
+ │ │ │ └── @ RequiredParameterNode (location: (91,8)-(91,11))
+ │ │ │ ├── flags: ∅
+ │ │ │ └── name: :bar
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest:
+ │ │ │ @ RestParameterNode (location: (91,13)-(91,17))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :baz
+ │ │ │ ├── name_loc: (91,14)-(91,17) = "baz"
+ │ │ │ └── operator_loc: (91,13)-(91,14) = "*"
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (92,2)-(92,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ LocalVariableReadNode (location: (92,2)-(92,5))
+ │ │ ├── name: :bar
+ │ │ └── depth: 0
+ │ ├── locals: [:bar, :baz]
+ │ ├── def_keyword_loc: (91,0)-(91,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (91,7)-(91,8) = "("
+ │ ├── rparen_loc: (91,17)-(91,18) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (93,0)-(93,3) = "end"
+ ├── @ DefNode (location: (95,0)-(97,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (95,4)-(95,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (95,8)-(95,24))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 1)
+ │ │ │ └── @ OptionalParameterNode (location: (95,8)-(95,18))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :baz
+ │ │ │ ├── name_loc: (95,8)-(95,11) = "baz"
+ │ │ │ ├── operator_loc: (95,12)-(95,13) = "="
+ │ │ │ └── value:
+ │ │ │ @ TrueNode (location: (95,14)-(95,18))
+ │ │ ├── rest:
+ │ │ │ @ RestParameterNode (location: (95,20)-(95,24))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bor
+ │ │ │ ├── name_loc: (95,21)-(95,24) = "bor"
+ │ │ │ └── operator_loc: (95,20)-(95,21) = "*"
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (96,2)-(96,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ CallNode (location: (96,2)-(96,5))
+ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ ├── receiver: ∅
+ │ │ ├── call_operator_loc: ∅
+ │ │ ├── name: :bar
+ │ │ ├── message_loc: (96,2)-(96,5) = "bar"
+ │ │ ├── opening_loc: ∅
+ │ │ ├── arguments: ∅
+ │ │ ├── closing_loc: ∅
+ │ │ └── block: ∅
+ │ ├── locals: [:baz, :bor]
+ │ ├── def_keyword_loc: (95,0)-(95,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (95,7)-(95,8) = "("
+ │ ├── rparen_loc: (95,24)-(95,25) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (97,0)-(97,3) = "end"
+ ├── @ DefNode (location: (99,0)-(101,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (99,4)-(99,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (99,8)-(99,32))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 1)
+ │ │ │ └── @ OptionalParameterNode (location: (99,8)-(99,18))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :baz
+ │ │ │ ├── name_loc: (99,8)-(99,11) = "baz"
+ │ │ │ ├── operator_loc: (99,12)-(99,13) = "="
+ │ │ │ └── value:
+ │ │ │ @ TrueNode (location: (99,14)-(99,18))
+ │ │ ├── rest:
+ │ │ │ @ RestParameterNode (location: (99,20)-(99,24))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bor
+ │ │ │ ├── name_loc: (99,21)-(99,24) = "bor"
+ │ │ │ └── operator_loc: (99,20)-(99,21) = "*"
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block:
+ │ │ @ BlockParameterNode (location: (99,26)-(99,32))
+ │ │ ├── flags: ∅
+ │ │ ├── name: :block
+ │ │ ├── name_loc: (99,27)-(99,32) = "block"
+ │ │ └── operator_loc: (99,26)-(99,27) = "&"
+ │ ├── body:
+ │ │ @ StatementsNode (location: (100,2)-(100,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ CallNode (location: (100,2)-(100,5))
+ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ ├── receiver: ∅
+ │ │ ├── call_operator_loc: ∅
+ │ │ ├── name: :bar
+ │ │ ├── message_loc: (100,2)-(100,5) = "bar"
+ │ │ ├── opening_loc: ∅
+ │ │ ├── arguments: ∅
+ │ │ ├── closing_loc: ∅
+ │ │ └── block: ∅
+ │ ├── locals: [:baz, :bor, :block]
+ │ ├── def_keyword_loc: (99,0)-(99,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (99,7)-(99,8) = "("
+ │ ├── rparen_loc: (99,32)-(99,33) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (101,0)-(101,3) = "end"
+ ├── @ DefNode (location: (103,0)-(105,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (103,4)-(103,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (103,8)-(103,29))
+ │ │ ├── requireds: (length: 1)
+ │ │ │ └── @ RequiredParameterNode (location: (103,8)-(103,11))
+ │ │ │ ├── flags: ∅
+ │ │ │ └── name: :bar
+ │ │ ├── optionals: (length: 1)
+ │ │ │ └── @ OptionalParameterNode (location: (103,13)-(103,23))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :baz
+ │ │ │ ├── name_loc: (103,13)-(103,16) = "baz"
+ │ │ │ ├── operator_loc: (103,17)-(103,18) = "="
+ │ │ │ └── value:
+ │ │ │ @ TrueNode (location: (103,19)-(103,23))
+ │ │ ├── rest:
+ │ │ │ @ RestParameterNode (location: (103,25)-(103,29))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :bor
+ │ │ │ ├── name_loc: (103,26)-(103,29) = "bor"
+ │ │ │ └── operator_loc: (103,25)-(103,26) = "*"
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (104,2)-(104,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ LocalVariableReadNode (location: (104,2)-(104,5))
+ │ │ ├── name: :bar
+ │ │ └── depth: 0
+ │ ├── locals: [:bar, :baz, :bor]
+ │ ├── def_keyword_loc: (103,0)-(103,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (103,7)-(103,8) = "("
+ │ ├── rparen_loc: (103,29)-(103,30) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (105,0)-(105,3) = "end"
+ ├── @ DefNode (location: (107,0)-(109,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (107,4)-(107,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (107,8)-(107,14))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block:
+ │ │ @ BlockParameterNode (location: (107,8)-(107,14))
+ │ │ ├── flags: ∅
+ │ │ ├── name: :block
+ │ │ ├── name_loc: (107,9)-(107,14) = "block"
+ │ │ └── operator_loc: (107,8)-(107,9) = "&"
+ │ ├── body:
+ │ │ @ StatementsNode (location: (108,2)-(108,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ CallNode (location: (108,2)-(108,5))
+ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ ├── receiver: ∅
+ │ │ ├── call_operator_loc: ∅
+ │ │ ├── name: :bar
+ │ │ ├── message_loc: (108,2)-(108,5) = "bar"
+ │ │ ├── opening_loc: ∅
+ │ │ ├── arguments: ∅
+ │ │ ├── closing_loc: ∅
+ │ │ └── block: ∅
+ │ ├── locals: [:block]
+ │ ├── def_keyword_loc: (107,0)-(107,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (107,7)-(107,8) = "("
+ │ ├── rparen_loc: (107,14)-(107,15) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (109,0)-(109,3) = "end"
+ ├── @ DefNode (location: (111,0)-(113,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (111,4)-(111,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (111,8)-(111,19))
+ │ │ ├── requireds: (length: 1)
+ │ │ │ └── @ RequiredParameterNode (location: (111,8)-(111,11))
+ │ │ │ ├── flags: ∅
+ │ │ │ └── name: :bar
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block:
+ │ │ @ BlockParameterNode (location: (111,13)-(111,19))
+ │ │ ├── flags: ∅
+ │ │ ├── name: :block
+ │ │ ├── name_loc: (111,14)-(111,19) = "block"
+ │ │ └── operator_loc: (111,13)-(111,14) = "&"
+ │ ├── body:
+ │ │ @ StatementsNode (location: (112,2)-(112,5))
+ │ │ └── body: (length: 1)
+ │ │ └── @ LocalVariableReadNode (location: (112,2)-(112,5))
+ │ │ ├── name: :bar
+ │ │ └── depth: 0
+ │ ├── locals: [:bar, :block]
+ │ ├── def_keyword_loc: (111,0)-(111,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (111,7)-(111,8) = "("
+ │ ├── rparen_loc: (111,19)-(111,20) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (113,0)-(113,3) = "end"
+ ├── @ DefNode (location: (115,0)-(118,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (115,4)-(115,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (116,2)-(117,5))
+ │ │ └── body: (length: 2)
+ │ │ ├── @ CallNode (location: (116,2)-(116,5))
+ │ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ │ ├── receiver: ∅
+ │ │ │ ├── call_operator_loc: ∅
+ │ │ │ ├── name: :bar
+ │ │ │ ├── message_loc: (116,2)-(116,5) = "bar"
+ │ │ │ ├── opening_loc: ∅
+ │ │ │ ├── arguments: ∅
+ │ │ │ ├── closing_loc: ∅
+ │ │ │ └── block: ∅
+ │ │ └── @ CallNode (location: (117,2)-(117,5))
+ │ │ ├── flags: variable_call, ignore_visibility
+ │ │ ├── receiver: ∅
+ │ │ ├── call_operator_loc: ∅
+ │ │ ├── name: :baz
+ │ │ ├── message_loc: (117,2)-(117,5) = "baz"
+ │ │ ├── opening_loc: ∅
+ │ │ ├── arguments: ∅
+ │ │ ├── closing_loc: ∅
+ │ │ └── block: ∅
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (115,0)-(115,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: ∅
+ │ ├── rparen_loc: ∅
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (118,0)-(118,3) = "end"
+ ├── @ DefNode (location: (120,0)-(121,3))
+ │ ├── name: :f
+ │ ├── name_loc: (120,4)-(120,5) = "f"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (120,6)-(120,11))
+ │ │ ├── requireds: (length: 1)
+ │ │ │ └── @ MultiTargetNode (location: (120,6)-(120,11))
+ │ │ │ ├── lefts: (length: 1)
+ │ │ │ │ └── @ MultiTargetNode (location: (120,7)-(120,10))
+ │ │ │ │ ├── lefts: (length: 1)
+ │ │ │ │ │ └── @ RequiredParameterNode (location: (120,8)-(120,9))
+ │ │ │ │ │ ├── flags: ∅
+ │ │ │ │ │ └── name: :a
+ │ │ │ │ ├── rest: ∅
+ │ │ │ │ ├── rights: (length: 0)
+ │ │ │ │ ├── lparen_loc: (120,7)-(120,8) = "("
+ │ │ │ │ └── rparen_loc: (120,9)-(120,10) = ")"
+ │ │ │ ├── rest: ∅
+ │ │ │ ├── rights: (length: 0)
+ │ │ │ ├── lparen_loc: (120,6)-(120,7) = "("
+ │ │ │ └── rparen_loc: (120,10)-(120,11) = ")"
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 0)
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body: ∅
+ │ ├── locals: [:a]
+ │ ├── def_keyword_loc: (120,0)-(120,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (120,5)-(120,6) = "("
+ │ ├── rparen_loc: (120,11)-(120,12) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (121,0)-(121,3) = "end"
+ ├── @ DefNode (location: (123,0)-(124,3))
+ │ ├── name: :foo
+ │ ├── name_loc: (123,4)-(123,7) = "foo"
+ │ ├── receiver: ∅
+ │ ├── parameters:
+ │ │ @ ParametersNode (location: (123,8)-(123,26))
+ │ │ ├── requireds: (length: 0)
+ │ │ ├── optionals: (length: 0)
+ │ │ ├── rest: ∅
+ │ │ ├── posts: (length: 0)
+ │ │ ├── keywords: (length: 2)
+ │ │ │ ├── @ RequiredKeywordParameterNode (location: (123,8)-(123,12))
+ │ │ │ │ ├── flags: ∅
+ │ │ │ │ ├── name: :bar
+ │ │ │ │ └── name_loc: (123,8)-(123,12) = "bar:"
+ │ │ │ └── @ OptionalKeywordParameterNode (location: (123,14)-(123,26))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── name: :baz
+ │ │ │ ├── name_loc: (123,14)-(123,18) = "baz:"
+ │ │ │ └── value:
+ │ │ │ @ StringNode (location: (123,19)-(123,26))
+ │ │ │ ├── flags: ∅
+ │ │ │ ├── opening_loc: (123,19)-(123,20) = "\""
+ │ │ │ ├── content_loc: (123,20)-(123,25) = "value"
+ │ │ │ ├── closing_loc: (123,25)-(123,26) = "\""
+ │ │ │ └── unescaped: "value"
+ │ │ ├── keyword_rest: ∅
+ │ │ └── block: ∅
+ │ ├── body: ∅
+ │ ├── locals: [:bar, :baz]
+ │ ├── def_keyword_loc: (123,0)-(123,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: (123,7)-(123,8) = "("
+ │ ├── rparen_loc: (123,26)-(123,27) = ")"
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (124,0)-(124,3) = "end"
+ ├── @ DefNode (location: (126,0)-(130,3))
+ │ ├── name: :f
+ │ ├── name_loc: (126,4)-(126,5) = "f"
+ │ ├── receiver: ∅
+ │ ├── parameters: ∅
+ │ ├── body:
+ │ │ @ StatementsNode (location: (127,2)-(127,12))
+ │ │ └── body: (length: 1)
+ │ │ └── @ InterpolatedStringNode (location: (127,2)-(127,12))
+ │ │ ├── flags: ∅
+ │ │ ├── opening_loc: (127,2)-(127,12) = "<<-HEREDOC"
+ │ │ ├── parts: (length: 3)
+ │ │ │ ├── @ StringNode (location: (128,0)-(128,4))
+ │ │ │ │ ├── flags: frozen
+ │ │ │ │ ├── opening_loc: ∅
+ │ │ │ │ ├── content_loc: (128,0)-(128,4) = " "
+ │ │ │ │ ├── closing_loc: ∅
+ │ │ │ │ └── unescaped: " "
+ │ │ │ ├── @ EmbeddedStatementsNode (location: (128,4)-(128,7))
+ │ │ │ │ ├── opening_loc: (128,4)-(128,6) = "\#{"
+ │ │ │ │ ├── statements: ∅
+ │ │ │ │ └── closing_loc: (128,6)-(128,7) = "}"
+ │ │ │ └── @ StringNode (location: (128,7)-(129,0))
+ │ │ │ ├── flags: frozen
+ │ │ │ ├── opening_loc: ∅
+ │ │ │ ├── content_loc: (128,7)-(129,0) = "\n"
+ │ │ │ ├── closing_loc: ∅
+ │ │ │ └── unescaped: "\n"
+ │ │ └── closing_loc: (129,0)-(130,0) = " HEREDOC\n"
+ │ ├── locals: []
+ │ ├── def_keyword_loc: (126,0)-(126,3) = "def"
+ │ ├── operator_loc: ∅
+ │ ├── lparen_loc: ∅
+ │ ├── rparen_loc: ∅
+ │ ├── equal_loc: ∅
+ │ └── end_keyword_loc: (130,0)-(130,3) = "end"
+ └── @ DefNode (location: (132,0)-(134,3))
+ ├── name: :f
+ ├── name_loc: (132,4)-(132,5) = "f"
+ ├── receiver: ∅
+ ├── parameters: ∅
+ ├── body:
+ │ @ StatementsNode (location: (133,2)-(133,5))
+ │ └── body: (length: 1)
+ │ └── @ StringNode (location: (133,2)-(133,5))
+ │ ├── flags: ∅
+ │ ├── opening_loc: (133,2)-(133,4) = "%("
+ │ ├── content_loc: (133,4)-(133,4) = ""
+ │ ├── closing_loc: (133,4)-(133,5) = ")"
+ │ └── unescaped: ""
+ ├── locals: []
+ ├── def_keyword_loc: (132,0)-(132,3) = "def"
+ ├── operator_loc: ∅
+ ├── lparen_loc: ∅
+ ├── rparen_loc: ∅
+ ├── equal_loc: ∅
+ └── end_keyword_loc: (134,0)-(134,3) = "end"
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-09 02:54:44 +0000