diff options
Diffstat (limited to 'test/prism/snapshots/constants.txt')
| -rw-r--r-- | test/prism/snapshots/constants.txt | 1225 |
1 files changed, 1225 insertions, 0 deletions
diff --git a/test/prism/snapshots/constants.txt b/test/prism/snapshots/constants.txt new file mode 100644 index 0000000000..1251833663 --- /dev/null +++ b/test/prism/snapshots/constants.txt @@ -0,0 +1,1225 @@ +@ ProgramNode (location: (1,0)-(184,10)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(184,10)) + └── body: (length: 90) + ├── @ ConstantPathNode (location: (1,0)-(1,4)) + │ ├── parent: + │ │ @ ConstantReadNode (location: (1,0)-(1,1)) + │ │ └── name: :A + │ ├── name: :B + │ ├── delimiter_loc: (1,1)-(1,3) = "::" + │ └── name_loc: (1,3)-(1,4) = "B" + ├── @ ConstantPathNode (location: (3,0)-(3,7)) + │ ├── parent: + │ │ @ ConstantPathNode (location: (3,0)-(3,4)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (3,0)-(3,1)) + │ │ │ └── name: :A + │ │ ├── name: :B + │ │ ├── delimiter_loc: (3,1)-(3,3) = "::" + │ │ └── name_loc: (3,3)-(3,4) = "B" + │ ├── name: :C + │ ├── delimiter_loc: (3,4)-(3,6) = "::" + │ └── name_loc: (3,6)-(3,7) = "C" + ├── @ ConstantPathNode (location: (5,0)-(5,4)) + │ ├── parent: + │ │ @ CallNode (location: (5,0)-(5,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (5,0)-(5,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── name: :B + │ ├── delimiter_loc: (5,1)-(5,3) = "::" + │ └── name_loc: (5,3)-(5,4) = "B" + ├── @ ConstantPathWriteNode (location: (7,0)-(7,8)) + │ ├── target: + │ │ @ ConstantPathNode (location: (7,0)-(7,4)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (7,0)-(7,1)) + │ │ │ └── name: :A + │ │ ├── name: :B + │ │ ├── delimiter_loc: (7,1)-(7,3) = "::" + │ │ └── name_loc: (7,3)-(7,4) = "B" + │ ├── operator_loc: (7,5)-(7,6) = "=" + │ └── value: + │ @ IntegerNode (location: (7,7)-(7,8)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ ConstantWriteNode (location: (9,0)-(9,5)) + │ ├── name: :A + │ ├── name_loc: (9,0)-(9,1) = "A" + │ ├── value: + │ │ @ IntegerNode (location: (9,4)-(9,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (9,2)-(9,3) = "=" + ├── @ ConstantReadNode (location: (11,0)-(11,3)) + │ └── name: :ABC + ├── @ CallNode (location: (13,0)-(13,5)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :Foo + │ ├── message_loc: (13,0)-(13,3) = "Foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (13,4)-(13,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (13,4)-(13,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (15,0)-(15,8)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :Foo + │ ├── message_loc: (15,0)-(15,3) = "Foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (15,4)-(15,8)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SplatNode (location: (15,4)-(15,8)) + │ │ ├── operator_loc: (15,4)-(15,5) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (15,5)-(15,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (15,5)-(15,8) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (17,0)-(17,9)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :Foo + │ ├── message_loc: (17,0)-(17,3) = "Foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (17,4)-(17,9)) + │ │ ├── flags: contains_keywords, contains_keyword_splat + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (17,4)-(17,9)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocSplatNode (location: (17,4)-(17,9)) + │ │ ├── value: + │ │ │ @ CallNode (location: (17,6)-(17,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (17,6)-(17,9) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (17,4)-(17,6) = "**" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (19,0)-(19,8)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :Foo + │ ├── message_loc: (19,0)-(19,3) = "Foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockArgumentNode (location: (19,4)-(19,8)) + │ ├── expression: + │ │ @ CallNode (location: (19,5)-(19,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (19,5)-(19,8) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (19,4)-(19,5) = "&" + ├── @ CallNode (location: (21,0)-(21,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (21,0)-(21,3)) + │ │ └── name: :Foo + │ ├── call_operator_loc: (21,3)-(21,5) = "::" + │ ├── name: :Bar + │ ├── message_loc: (21,5)-(21,8) = "Bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (21,9)-(21,13)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SplatNode (location: (21,9)-(21,13)) + │ │ ├── operator_loc: (21,9)-(21,10) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (21,10)-(21,13)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (21,10)-(21,13) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (23,0)-(23,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (23,0)-(23,3)) + │ │ └── name: :Foo + │ ├── call_operator_loc: (23,3)-(23,5) = "::" + │ ├── name: :Bar + │ ├── message_loc: (23,5)-(23,8) = "Bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (23,9)-(23,14)) + │ │ ├── flags: contains_keywords, contains_keyword_splat + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (23,9)-(23,14)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocSplatNode (location: (23,9)-(23,14)) + │ │ ├── value: + │ │ │ @ CallNode (location: (23,11)-(23,14)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (23,11)-(23,14) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (23,9)-(23,11) = "**" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (25,0)-(25,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (25,0)-(25,3)) + │ │ └── name: :Foo + │ ├── call_operator_loc: (25,3)-(25,5) = "::" + │ ├── name: :Bar + │ ├── message_loc: (25,5)-(25,8) = "Bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockArgumentNode (location: (25,9)-(25,13)) + │ ├── expression: + │ │ @ CallNode (location: (25,10)-(25,13)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (25,10)-(25,13) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (25,9)-(25,10) = "&" + ├── @ CallNode (location: (27,0)-(27,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantPathNode (location: (27,0)-(27,3)) + │ │ ├── parent: ∅ + │ │ ├── name: :A + │ │ ├── delimiter_loc: (27,0)-(27,2) = "::" + │ │ └── name_loc: (27,2)-(27,3) = "A" + │ ├── call_operator_loc: (27,3)-(27,5) = "::" + │ ├── name: :foo + │ ├── message_loc: (27,5)-(27,8) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ ConstantPathWriteNode (location: (29,0)-(29,7)) + │ ├── target: + │ │ @ ConstantPathNode (location: (29,0)-(29,3)) + │ │ ├── parent: ∅ + │ │ ├── name: :A + │ │ ├── delimiter_loc: (29,0)-(29,2) = "::" + │ │ └── name_loc: (29,2)-(29,3) = "A" + │ ├── operator_loc: (29,4)-(29,5) = "=" + │ └── value: + │ @ IntegerNode (location: (29,6)-(29,7)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ ConstantPathWriteNode (location: (31,0)-(31,10)) + │ ├── target: + │ │ @ ConstantPathNode (location: (31,0)-(31,6)) + │ │ ├── parent: + │ │ │ @ ConstantPathNode (location: (31,0)-(31,3)) + │ │ │ ├── parent: ∅ + │ │ │ ├── name: :A + │ │ │ ├── delimiter_loc: (31,0)-(31,2) = "::" + │ │ │ └── name_loc: (31,2)-(31,3) = "A" + │ │ ├── name: :B + │ │ ├── delimiter_loc: (31,3)-(31,5) = "::" + │ │ └── name_loc: (31,5)-(31,6) = "B" + │ ├── operator_loc: (31,7)-(31,8) = "=" + │ └── value: + │ @ IntegerNode (location: (31,9)-(31,10)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ ConstantPathNode (location: (33,0)-(33,6)) + │ ├── parent: + │ │ @ ConstantPathNode (location: (33,0)-(33,3)) + │ │ ├── parent: ∅ + │ │ ├── name: :A + │ │ ├── delimiter_loc: (33,0)-(33,2) = "::" + │ │ └── name_loc: (33,2)-(33,3) = "A" + │ ├── name: :B + │ ├── delimiter_loc: (33,3)-(33,5) = "::" + │ └── name_loc: (33,5)-(33,6) = "B" + ├── @ ConstantPathNode (location: (35,0)-(35,3)) + │ ├── parent: ∅ + │ ├── name: :A + │ ├── delimiter_loc: (35,0)-(35,2) = "::" + │ └── name_loc: (35,2)-(35,3) = "A" + ├── @ CallNode (location: (37,0)-(37,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (37,0)-(37,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (37,1)-(37,3) = "::" + │ ├── name: :false + │ ├── message_loc: (37,3)-(37,8) = "false" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (39,0)-(39,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantPathNode (location: (39,0)-(39,4)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (39,0)-(39,1)) + │ │ │ └── name: :A + │ │ ├── name: :B + │ │ ├── delimiter_loc: (39,1)-(39,3) = "::" + │ │ └── name_loc: (39,3)-(39,4) = "B" + │ ├── call_operator_loc: (39,4)-(39,6) = "::" + │ ├── name: :true + │ ├── message_loc: (39,6)-(39,10) = "true" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (41,0)-(41,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (41,0)-(41,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (41,1)-(41,3) = "::" + │ ├── name: :& + │ ├── message_loc: (41,3)-(41,4) = "&" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (43,0)-(43,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (43,0)-(43,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (43,1)-(43,3) = "::" + │ ├── name: :` + │ ├── message_loc: (43,3)-(43,4) = "`" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (45,0)-(45,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (45,0)-(45,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (45,1)-(45,3) = "::" + │ ├── name: :! + │ ├── message_loc: (45,3)-(45,4) = "!" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (47,0)-(47,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (47,0)-(47,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (47,1)-(47,3) = "::" + │ ├── name: :!= + │ ├── message_loc: (47,3)-(47,5) = "!=" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (49,0)-(49,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (49,0)-(49,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (49,1)-(49,3) = "::" + │ ├── name: :^ + │ ├── message_loc: (49,3)-(49,4) = "^" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (51,0)-(51,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (51,0)-(51,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (51,1)-(51,3) = "::" + │ ├── name: :== + │ ├── message_loc: (51,3)-(51,5) = "==" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (53,0)-(53,6)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (53,0)-(53,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (53,1)-(53,3) = "::" + │ ├── name: :=== + │ ├── message_loc: (53,3)-(53,6) = "===" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (55,0)-(55,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (55,0)-(55,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (55,1)-(55,3) = "::" + │ ├── name: :=~ + │ ├── message_loc: (55,3)-(55,5) = "=~" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (57,0)-(57,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (57,0)-(57,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (57,1)-(57,3) = "::" + │ ├── name: :> + │ ├── message_loc: (57,3)-(57,4) = ">" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (59,0)-(59,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (59,0)-(59,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (59,1)-(59,3) = "::" + │ ├── name: :>= + │ ├── message_loc: (59,3)-(59,5) = ">=" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (61,0)-(61,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (61,0)-(61,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (61,1)-(61,3) = "::" + │ ├── name: :>> + │ ├── message_loc: (61,3)-(61,5) = ">>" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (63,0)-(63,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (63,0)-(63,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (63,1)-(63,3) = "::" + │ ├── name: :<< + │ ├── message_loc: (63,3)-(63,5) = "<<" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ ConstantPathNode (location: (65,0)-(67,1)) + │ ├── parent: + │ │ @ ConstantReadNode (location: (65,0)-(65,1)) + │ │ └── name: :A + │ ├── name: :C + │ ├── delimiter_loc: (65,1)-(65,3) = "::" + │ └── name_loc: (67,0)-(67,1) = "C" + ├── @ CallNode (location: (69,0)-(69,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (69,0)-(69,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (69,1)-(69,3) = "::" + │ ├── name: :alias + │ ├── message_loc: (69,3)-(69,8) = "alias" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (71,0)-(71,6)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (71,0)-(71,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (71,1)-(71,3) = "::" + │ ├── name: :and + │ ├── message_loc: (71,3)-(71,6) = "and" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (73,0)-(73,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (73,0)-(73,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (73,1)-(73,3) = "::" + │ ├── name: :begin + │ ├── message_loc: (73,3)-(73,8) = "begin" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ ConstantPathNode (location: (75,0)-(75,8)) + │ ├── parent: + │ │ @ ConstantReadNode (location: (75,0)-(75,1)) + │ │ └── name: :A + │ ├── name: :BEGIN + │ ├── delimiter_loc: (75,1)-(75,3) = "::" + │ └── name_loc: (75,3)-(75,8) = "BEGIN" + ├── @ CallNode (location: (77,0)-(77,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (77,0)-(77,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (77,1)-(77,3) = "::" + │ ├── name: :break + │ ├── message_loc: (77,3)-(77,8) = "break" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (79,0)-(79,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (79,0)-(79,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (79,1)-(79,3) = "::" + │ ├── name: :class + │ ├── message_loc: (79,3)-(79,8) = "class" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (81,0)-(81,6)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (81,0)-(81,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (81,1)-(81,3) = "::" + │ ├── name: :def + │ ├── message_loc: (81,3)-(81,6) = "def" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (83,0)-(83,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (83,0)-(83,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (83,1)-(83,3) = "::" + │ ├── name: :defined + │ ├── message_loc: (83,3)-(83,10) = "defined" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (85,0)-(85,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (85,0)-(85,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (85,1)-(85,3) = "::" + │ ├── name: :do + │ ├── message_loc: (85,3)-(85,5) = "do" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (87,0)-(87,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (87,0)-(87,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (87,1)-(87,3) = "::" + │ ├── name: :else + │ ├── message_loc: (87,3)-(87,7) = "else" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (89,0)-(89,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (89,0)-(89,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (89,1)-(89,3) = "::" + │ ├── name: :elsif + │ ├── message_loc: (89,3)-(89,8) = "elsif" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (91,0)-(91,6)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (91,0)-(91,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (91,1)-(91,3) = "::" + │ ├── name: :end + │ ├── message_loc: (91,3)-(91,6) = "end" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ ConstantPathNode (location: (93,0)-(93,6)) + │ ├── parent: + │ │ @ ConstantReadNode (location: (93,0)-(93,1)) + │ │ └── name: :A + │ ├── name: :END + │ ├── delimiter_loc: (93,1)-(93,3) = "::" + │ └── name_loc: (93,3)-(93,6) = "END" + ├── @ CallNode (location: (95,0)-(95,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (95,0)-(95,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (95,1)-(95,3) = "::" + │ ├── name: :ensure + │ ├── message_loc: (95,3)-(95,9) = "ensure" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (97,0)-(97,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (97,0)-(97,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (97,1)-(97,3) = "::" + │ ├── name: :false + │ ├── message_loc: (97,3)-(97,8) = "false" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (99,0)-(99,6)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (99,0)-(99,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (99,1)-(99,3) = "::" + │ ├── name: :for + │ ├── message_loc: (99,3)-(99,6) = "for" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (101,0)-(101,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (101,0)-(101,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (101,1)-(101,3) = "::" + │ ├── name: :if + │ ├── message_loc: (101,3)-(101,5) = "if" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (103,0)-(103,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (103,0)-(103,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (103,1)-(103,3) = "::" + │ ├── name: :in + │ ├── message_loc: (103,3)-(103,5) = "in" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (105,0)-(105,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (105,0)-(105,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (105,1)-(105,3) = "::" + │ ├── name: :next + │ ├── message_loc: (105,3)-(105,7) = "next" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (107,0)-(107,6)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (107,0)-(107,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (107,1)-(107,3) = "::" + │ ├── name: :nil + │ ├── message_loc: (107,3)-(107,6) = "nil" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (109,0)-(109,6)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (109,0)-(109,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (109,1)-(109,3) = "::" + │ ├── name: :not + │ ├── message_loc: (109,3)-(109,6) = "not" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (111,0)-(111,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (111,0)-(111,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (111,1)-(111,3) = "::" + │ ├── name: :or + │ ├── message_loc: (111,3)-(111,5) = "or" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (113,0)-(113,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (113,0)-(113,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (113,1)-(113,3) = "::" + │ ├── name: :redo + │ ├── message_loc: (113,3)-(113,7) = "redo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (115,0)-(115,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (115,0)-(115,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (115,1)-(115,3) = "::" + │ ├── name: :rescue + │ ├── message_loc: (115,3)-(115,9) = "rescue" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (117,0)-(117,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (117,0)-(117,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (117,1)-(117,3) = "::" + │ ├── name: :retry + │ ├── message_loc: (117,3)-(117,8) = "retry" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (119,0)-(119,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (119,0)-(119,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (119,1)-(119,3) = "::" + │ ├── name: :return + │ ├── message_loc: (119,3)-(119,9) = "return" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (121,0)-(121,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (121,0)-(121,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (121,1)-(121,3) = "::" + │ ├── name: :self + │ ├── message_loc: (121,3)-(121,7) = "self" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (123,0)-(123,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (123,0)-(123,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (123,1)-(123,3) = "::" + │ ├── name: :super + │ ├── message_loc: (123,3)-(123,8) = "super" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (125,0)-(125,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (125,0)-(125,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (125,1)-(125,3) = "::" + │ ├── name: :then + │ ├── message_loc: (125,3)-(125,7) = "then" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (127,0)-(127,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (127,0)-(127,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (127,1)-(127,3) = "::" + │ ├── name: :true + │ ├── message_loc: (127,3)-(127,7) = "true" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (129,0)-(129,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (129,0)-(129,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (129,1)-(129,3) = "::" + │ ├── name: :undef + │ ├── message_loc: (129,3)-(129,8) = "undef" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (131,0)-(131,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (131,0)-(131,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (131,1)-(131,3) = "::" + │ ├── name: :unless + │ ├── message_loc: (131,3)-(131,9) = "unless" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (133,0)-(133,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (133,0)-(133,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (133,1)-(133,3) = "::" + │ ├── name: :until + │ ├── message_loc: (133,3)-(133,8) = "until" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (135,0)-(135,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (135,0)-(135,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (135,1)-(135,3) = "::" + │ ├── name: :when + │ ├── message_loc: (135,3)-(135,7) = "when" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (137,0)-(137,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (137,0)-(137,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (137,1)-(137,3) = "::" + │ ├── name: :while + │ ├── message_loc: (137,3)-(137,8) = "while" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (139,0)-(139,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (139,0)-(139,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (139,1)-(139,3) = "::" + │ ├── name: :yield + │ ├── message_loc: (139,3)-(139,8) = "yield" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (141,0)-(141,15)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (141,0)-(141,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (141,1)-(141,3) = "::" + │ ├── name: :__ENCODING__ + │ ├── message_loc: (141,3)-(141,15) = "__ENCODING__" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (143,0)-(143,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (143,0)-(143,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (143,1)-(143,3) = "::" + │ ├── name: :__FILE__ + │ ├── message_loc: (143,3)-(143,11) = "__FILE__" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (145,0)-(145,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (145,0)-(145,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (145,1)-(145,3) = "::" + │ ├── name: :__LINE__ + │ ├── message_loc: (145,3)-(145,11) = "__LINE__" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (147,0)-(147,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (147,0)-(147,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (147,1)-(147,3) = "::" + │ ├── name: :< + │ ├── message_loc: (147,3)-(147,4) = "<" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (149,0)-(149,6)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (149,0)-(149,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (149,1)-(149,3) = "::" + │ ├── name: :<=> + │ ├── message_loc: (149,3)-(149,6) = "<=>" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (151,0)-(151,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (151,0)-(151,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (151,1)-(151,3) = "::" + │ ├── name: :<< + │ ├── message_loc: (151,3)-(151,5) = "<<" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (153,0)-(153,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (153,0)-(153,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (153,1)-(153,3) = "::" + │ ├── name: :- + │ ├── message_loc: (153,3)-(153,4) = "-" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (155,0)-(155,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (155,0)-(155,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (155,1)-(155,3) = "::" + │ ├── name: :% + │ ├── message_loc: (155,3)-(155,4) = "%" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (157,0)-(157,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (157,0)-(157,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (157,1)-(157,3) = "::" + │ ├── name: :% + │ ├── message_loc: (157,3)-(157,4) = "%" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (157,4)-(157,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (157,4)-(157,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :i + │ │ ├── message_loc: (157,4)-(157,5) = "i" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (159,0)-(159,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (159,0)-(159,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (159,1)-(159,3) = "::" + │ ├── name: :% + │ ├── message_loc: (159,3)-(159,4) = "%" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (159,4)-(159,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (159,4)-(159,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :w + │ │ ├── message_loc: (159,4)-(159,5) = "w" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (161,0)-(161,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (161,0)-(161,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (161,1)-(161,3) = "::" + │ ├── name: :% + │ ├── message_loc: (161,3)-(161,4) = "%" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (161,4)-(161,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (161,4)-(161,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :x + │ │ ├── message_loc: (161,4)-(161,5) = "x" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (163,0)-(163,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (163,0)-(163,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (163,1)-(163,3) = "::" + │ ├── name: :% + │ ├── message_loc: (163,3)-(163,4) = "%" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (163,4)-(163,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ ConstantReadNode (location: (163,4)-(163,5)) + │ │ └── name: :I + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (165,0)-(165,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (165,0)-(165,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (165,1)-(165,3) = "::" + │ ├── name: :% + │ ├── message_loc: (165,3)-(165,4) = "%" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (165,4)-(165,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ ConstantReadNode (location: (165,4)-(165,5)) + │ │ └── name: :W + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (167,0)-(167,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (167,0)-(167,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (167,1)-(167,3) = "::" + │ ├── name: :| + │ ├── message_loc: (167,3)-(167,4) = "|" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (169,0)-(169,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (169,0)-(169,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (169,1)-(169,3) = "::" + │ ├── name: :+ + │ ├── message_loc: (169,3)-(169,4) = "+" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (171,0)-(171,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (171,0)-(171,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (171,1)-(171,3) = "::" + │ ├── name: :/ + │ ├── message_loc: (171,3)-(171,4) = "/" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (173,0)-(173,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (173,0)-(173,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (173,1)-(173,3) = "::" + │ ├── name: :* + │ ├── message_loc: (173,3)-(173,4) = "*" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (175,0)-(175,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (175,0)-(175,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (175,1)-(175,3) = "::" + │ ├── name: :** + │ ├── message_loc: (175,3)-(175,5) = "**" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (177,0)-(177,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (177,0)-(177,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (177,1)-(177,3) = "::" + │ ├── name: :~ + │ ├── message_loc: (177,3)-(177,4) = "~" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ ConstantPathNode (location: (179,0)-(180,1)) + │ ├── parent: + │ │ @ CallNode (location: (179,0)-(179,4)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ ConstantReadNode (location: (179,0)-(179,1)) + │ │ │ └── name: :A + │ │ ├── call_operator_loc: (179,1)-(179,3) = "::" + │ │ ├── name: :_ + │ │ ├── message_loc: (179,3)-(179,4) = "_" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── name: :C + │ ├── delimiter_loc: (179,4)-(179,6) = "::" + │ └── name_loc: (180,0)-(180,1) = "C" + └── @ RangeNode (location: (182,0)-(184,10)) + ├── flags: ∅ + ├── left: + │ @ CallNode (location: (182,0)-(182,4)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (182,0)-(182,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (182,1)-(182,3) = "::" + │ ├── name: :_ + │ ├── message_loc: (182,3)-(182,4) = "_" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── right: + │ @ CallNode (location: (184,0)-(184,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (184,0)-(184,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (184,1)-(184,3) = "::" + │ ├── name: :__END__ + │ ├── message_loc: (184,3)-(184,10) = "__END__" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── operator_loc: (182,4)-(182,6) = ".." |