diff options
Diffstat (limited to 'test/prism/snapshots/arrays.txt')
| -rw-r--r-- | test/prism/snapshots/arrays.txt | 1837 |
1 files changed, 1837 insertions, 0 deletions
diff --git a/test/prism/snapshots/arrays.txt b/test/prism/snapshots/arrays.txt new file mode 100644 index 0000000000..e8e53aacb9 --- /dev/null +++ b/test/prism/snapshots/arrays.txt @@ -0,0 +1,1837 @@ +@ ProgramNode (location: (1,0)-(122,32)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(122,32)) + └── body: (length: 50) + ├── @ ArrayNode (location: (1,0)-(1,4)) + │ ├── flags: contains_splat + │ ├── elements: (length: 1) + │ │ └── @ SplatNode (location: (1,1)-(1,3)) + │ │ ├── operator_loc: (1,1)-(1,2) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (1,2)-(1,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (1,2)-(1,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (1,0)-(1,1) = "[" + │ └── closing_loc: (1,3)-(1,4) = "]" + ├── @ CallNode (location: (3,0)-(3,23)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ CallNode (location: (3,0)-(3,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (3,0)-(3,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (3,3)-(3,13) = "[bar, baz]" + │ ├── opening_loc: (3,3)-(3,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (3,4)-(3,23)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 3) + │ │ ├── @ CallNode (location: (3,4)-(3,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (3,4)-(3,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── @ CallNode (location: (3,9)-(3,12)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (3,9)-(3,12) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ ArrayNode (location: (3,16)-(3,23)) + │ │ ├── flags: ∅ + │ │ ├── elements: (length: 3) + │ │ │ ├── @ IntegerNode (location: (3,16)-(3,17)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── @ IntegerNode (location: (3,19)-(3,20)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ └── @ IntegerNode (location: (3,22)-(3,23)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 3 + │ │ ├── opening_loc: ∅ + │ │ └── closing_loc: ∅ + │ ├── closing_loc: (3,12)-(3,13) = "]" + │ └── block: ∅ + ├── @ ArrayNode (location: (5,0)-(5,13)) + │ ├── flags: ∅ + │ ├── elements: (length: 1) + │ │ └── @ KeywordHashNode (location: (5,1)-(5,12)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (5,1)-(5,12)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (5,1)-(5,3)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (5,1)-(5,2) = "a" + │ │ │ ├── closing_loc: (5,2)-(5,3) = ":" + │ │ │ └── unescaped: "a" + │ │ ├── value: + │ │ │ @ ArrayNode (location: (5,4)-(5,12)) + │ │ │ ├── flags: ∅ + │ │ │ ├── elements: (length: 2) + │ │ │ │ ├── @ SymbolNode (location: (5,5)-(5,7)) + │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ ├── opening_loc: (5,5)-(5,6) = ":" + │ │ │ │ │ ├── value_loc: (5,6)-(5,7) = "b" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "b" + │ │ │ │ └── @ SymbolNode (location: (5,9)-(5,11)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (5,9)-(5,10) = ":" + │ │ │ │ ├── value_loc: (5,10)-(5,11) = "c" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "c" + │ │ │ ├── opening_loc: (5,4)-(5,5) = "[" + │ │ │ └── closing_loc: (5,11)-(5,12) = "]" + │ │ └── operator_loc: ∅ + │ ├── opening_loc: (5,0)-(5,1) = "[" + │ └── closing_loc: (5,12)-(5,13) = "]" + ├── @ ArrayNode (location: (9,0)-(15,1)) + │ ├── flags: ∅ + │ ├── elements: (length: 5) + │ │ ├── @ SymbolNode (location: (9,1)-(9,3)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (9,1)-(9,2) = ":" + │ │ │ ├── value_loc: (9,2)-(9,3) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ ├── @ SymbolNode (location: (9,5)-(9,7)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (9,5)-(9,6) = ":" + │ │ │ ├── value_loc: (9,6)-(9,7) = "b" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "b" + │ │ ├── @ SymbolNode (location: (10,0)-(10,2)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (10,0)-(10,1) = ":" + │ │ │ ├── value_loc: (10,1)-(10,2) = "c" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "c" + │ │ ├── @ IntegerNode (location: (10,3)-(10,4)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ SymbolNode (location: (14,0)-(14,2)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (14,0)-(14,1) = ":" + │ │ ├── value_loc: (14,1)-(14,2) = "d" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "d" + │ ├── opening_loc: (9,0)-(9,1) = "[" + │ └── closing_loc: (15,0)-(15,1) = "]" + ├── @ ArrayNode (location: (18,0)-(26,1)) + │ ├── flags: ∅ + │ ├── elements: (length: 5) + │ │ ├── @ SymbolNode (location: (18,1)-(18,3)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (18,1)-(18,2) = ":" + │ │ │ ├── value_loc: (18,2)-(18,3) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ ├── @ SymbolNode (location: (18,5)-(18,7)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (18,5)-(18,6) = ":" + │ │ │ ├── value_loc: (18,6)-(18,7) = "b" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "b" + │ │ ├── @ SymbolNode (location: (19,0)-(19,2)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (19,0)-(19,1) = ":" + │ │ │ ├── value_loc: (19,1)-(19,2) = "c" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "c" + │ │ ├── @ IntegerNode (location: (19,3)-(19,4)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ SymbolNode (location: (23,0)-(23,2)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (23,0)-(23,1) = ":" + │ │ ├── value_loc: (23,1)-(23,2) = "d" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "d" + │ ├── opening_loc: (18,0)-(18,1) = "[" + │ └── closing_loc: (26,0)-(26,1) = "]" + ├── @ ArrayNode (location: (28,0)-(28,12)) + │ ├── flags: ∅ + │ ├── elements: (length: 1) + │ │ └── @ KeywordHashNode (location: (28,1)-(28,11)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (28,1)-(28,11)) + │ │ ├── key: + │ │ │ @ CallNode (location: (28,1)-(28,4)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (28,1)-(28,4) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── value: + │ │ │ @ CallNode (location: (28,8)-(28,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (28,8)-(28,11) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (28,5)-(28,7) = "=>" + │ ├── opening_loc: (28,0)-(28,1) = "[" + │ └── closing_loc: (28,11)-(28,12) = "]" + ├── @ CallNode (location: (30,0)-(30,19)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ CallNode (location: (30,0)-(30,8)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (30,0)-(30,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (30,0)-(30,3) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :[] + │ │ ├── message_loc: (30,3)-(30,8) = "[bar]" + │ │ ├── opening_loc: (30,3)-(30,4) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (30,4)-(30,7)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ CallNode (location: (30,4)-(30,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (30,4)-(30,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── closing_loc: (30,7)-(30,8) = "]" + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (30,8)-(30,13) = "[baz]" + │ ├── opening_loc: (30,8)-(30,9) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (30,9)-(30,19)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (30,9)-(30,12)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (30,9)-(30,12) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (30,16)-(30,19)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :qux + │ │ ├── message_loc: (30,16)-(30,19) = "qux" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (30,12)-(30,13) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (32,0)-(32,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (32,0)-(32,8)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (32,0)-(32,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (32,0)-(32,3) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :[] + │ │ ├── message_loc: (32,3)-(32,8) = "[bar]" + │ │ ├── opening_loc: (32,3)-(32,4) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (32,4)-(32,7)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ CallNode (location: (32,4)-(32,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (32,4)-(32,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── closing_loc: (32,7)-(32,8) = "]" + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (32,8)-(32,13) = "[baz]" + │ ├── opening_loc: (32,8)-(32,9) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (32,9)-(32,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (32,9)-(32,12)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (32,9)-(32,12) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (32,12)-(32,13) = "]" + │ └── block: ∅ + ├── @ ArrayNode (location: (34,0)-(35,1)) + │ ├── flags: ∅ + │ ├── elements: (length: 0) + │ ├── opening_loc: (34,0)-(34,1) = "[" + │ └── closing_loc: (35,0)-(35,1) = "]" + ├── @ CallNode (location: (37,0)-(37,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (37,0)-(37,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (37,0)-(37,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (37,3)-(37,13) = "[bar, baz]" + │ ├── opening_loc: (37,3)-(37,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (37,4)-(37,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (37,4)-(37,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (37,4)-(37,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (37,9)-(37,12)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (37,9)-(37,12) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (37,12)-(37,13) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (39,0)-(39,19)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ CallNode (location: (39,0)-(39,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (39,0)-(39,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (39,3)-(39,13) = "[bar, baz]" + │ ├── opening_loc: (39,3)-(39,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (39,4)-(39,19)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 3) + │ │ ├── @ CallNode (location: (39,4)-(39,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (39,4)-(39,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── @ CallNode (location: (39,9)-(39,12)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (39,9)-(39,12) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (39,16)-(39,19)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :qux + │ │ ├── message_loc: (39,16)-(39,19) = "qux" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (39,12)-(39,13) = "]" + │ └── block: ∅ + ├── @ MultiWriteNode (location: (41,0)-(41,21)) + │ ├── lefts: (length: 2) + │ │ ├── @ IndexTargetNode (location: (41,0)-(41,6)) + │ │ │ ├── flags: attribute_write + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (41,0)-(41,3)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :foo + │ │ │ │ ├── message_loc: (41,0)-(41,3) = "foo" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── opening_loc: (41,3)-(41,4) = "[" + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (41,4)-(41,5)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (41,4)-(41,5)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 0 + │ │ │ ├── closing_loc: (41,5)-(41,6) = "]" + │ │ │ └── block: ∅ + │ │ └── @ IndexTargetNode (location: (41,8)-(41,14)) + │ │ ├── flags: attribute_write + │ │ ├── receiver: + │ │ │ @ CallNode (location: (41,8)-(41,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (41,8)-(41,11) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (41,11)-(41,12) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (41,12)-(41,13)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (41,12)-(41,13)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 0 + │ │ ├── closing_loc: (41,13)-(41,14) = "]" + │ │ └── block: ∅ + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── operator_loc: (41,15)-(41,16) = "=" + │ └── value: + │ @ ArrayNode (location: (41,17)-(41,21)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (41,17)-(41,18)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (41,20)-(41,21)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: ∅ + │ └── closing_loc: ∅ + ├── @ CallNode (location: (43,0)-(43,19)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (43,0)-(43,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (43,0)-(43,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (43,3)-(43,19) = "[bar[baz] = qux]" + │ ├── opening_loc: (43,3)-(43,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (43,4)-(43,18)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (43,4)-(43,18)) + │ │ ├── flags: attribute_write + │ │ ├── receiver: + │ │ │ @ CallNode (location: (43,4)-(43,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (43,4)-(43,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :[]= + │ │ ├── message_loc: (43,7)-(43,12) = "[baz]" + │ │ ├── opening_loc: (43,7)-(43,8) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (43,8)-(43,18)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 2) + │ │ │ ├── @ CallNode (location: (43,8)-(43,11)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (43,8)-(43,11) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── @ CallNode (location: (43,15)-(43,18)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :qux + │ │ │ ├── message_loc: (43,15)-(43,18) = "qux" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── closing_loc: (43,11)-(43,12) = "]" + │ │ └── block: ∅ + │ ├── closing_loc: (43,18)-(43,19) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (45,0)-(45,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (45,0)-(45,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (45,0)-(45,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (45,3)-(45,8) = "[bar]" + │ ├── opening_loc: (45,3)-(45,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (45,4)-(45,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (45,4)-(45,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (45,4)-(45,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (45,7)-(45,8) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (47,0)-(47,14)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ CallNode (location: (47,0)-(47,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (47,0)-(47,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (47,3)-(47,8) = "[bar]" + │ ├── opening_loc: (47,3)-(47,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (47,4)-(47,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (47,4)-(47,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (47,4)-(47,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (47,11)-(47,14)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (47,11)-(47,14) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (47,7)-(47,8) = "]" + │ └── block: ∅ + ├── @ ArrayNode (location: (49,0)-(49,6)) + │ ├── flags: ∅ + │ ├── elements: (length: 1) + │ │ └── @ KeywordHashNode (location: (49,1)-(49,5)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocSplatNode (location: (49,1)-(49,5)) + │ │ ├── value: + │ │ │ @ HashNode (location: (49,3)-(49,5)) + │ │ │ ├── opening_loc: (49,3)-(49,4) = "{" + │ │ │ ├── elements: (length: 0) + │ │ │ └── closing_loc: (49,4)-(49,5) = "}" + │ │ └── operator_loc: (49,1)-(49,3) = "**" + │ ├── opening_loc: (49,0)-(49,1) = "[" + │ └── closing_loc: (49,5)-(49,6) = "]" + ├── @ ArrayNode (location: (51,0)-(51,6)) + │ ├── flags: ∅ + │ ├── elements: (length: 1) + │ │ └── @ KeywordHashNode (location: (51,1)-(51,5)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocSplatNode (location: (51,1)-(51,5)) + │ │ ├── value: + │ │ │ @ CallNode (location: (51,3)-(51,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :kw + │ │ │ ├── message_loc: (51,3)-(51,5) = "kw" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (51,1)-(51,3) = "**" + │ ├── opening_loc: (51,0)-(51,1) = "[" + │ └── closing_loc: (51,5)-(51,6) = "]" + ├── @ ArrayNode (location: (53,0)-(53,9)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (53,1)-(53,2)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ KeywordHashNode (location: (53,4)-(53,8)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocSplatNode (location: (53,4)-(53,8)) + │ │ ├── value: + │ │ │ @ CallNode (location: (53,6)-(53,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :kw + │ │ │ ├── message_loc: (53,6)-(53,8) = "kw" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (53,4)-(53,6) = "**" + │ ├── opening_loc: (53,0)-(53,1) = "[" + │ └── closing_loc: (53,8)-(53,9) = "]" + ├── @ ArrayNode (location: (55,0)-(55,21)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (55,1)-(55,2)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ KeywordHashNode (location: (55,4)-(55,20)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 3) + │ │ ├── @ AssocSplatNode (location: (55,4)-(55,8)) + │ │ │ ├── value: + │ │ │ │ @ CallNode (location: (55,6)-(55,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :kw + │ │ │ │ ├── message_loc: (55,6)-(55,8) = "kw" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (55,4)-(55,6) = "**" + │ │ ├── @ AssocSplatNode (location: (55,10)-(55,14)) + │ │ │ ├── value: + │ │ │ │ @ HashNode (location: (55,12)-(55,14)) + │ │ │ │ ├── opening_loc: (55,12)-(55,13) = "{" + │ │ │ │ ├── elements: (length: 0) + │ │ │ │ └── closing_loc: (55,13)-(55,14) = "}" + │ │ │ └── operator_loc: (55,10)-(55,12) = "**" + │ │ └── @ AssocSplatNode (location: (55,16)-(55,20)) + │ │ ├── value: + │ │ │ @ CallNode (location: (55,18)-(55,20)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :kw + │ │ │ ├── message_loc: (55,18)-(55,20) = "kw" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (55,16)-(55,18) = "**" + │ ├── opening_loc: (55,0)-(55,1) = "[" + │ └── closing_loc: (55,20)-(55,21) = "]" + ├── @ ArrayNode (location: (57,0)-(59,1)) + │ ├── flags: ∅ + │ ├── elements: (length: 1) + │ │ └── @ KeywordHashNode (location: (58,2)-(58,12)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (58,2)-(58,12)) + │ │ ├── key: + │ │ │ @ CallNode (location: (58,2)-(58,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (58,2)-(58,5) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── value: + │ │ │ @ CallNode (location: (58,9)-(58,12)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (58,9)-(58,12) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (58,6)-(58,8) = "=>" + │ ├── opening_loc: (57,0)-(57,1) = "[" + │ └── closing_loc: (59,0)-(59,1) = "]" + ├── @ ArrayNode (location: (62,0)-(62,17)) + │ ├── flags: ∅ + │ ├── elements: (length: 3) + │ │ ├── @ SymbolNode (location: (62,3)-(62,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (62,3)-(62,6) = "one" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "one" + │ │ ├── @ SymbolNode (location: (62,7)-(62,10)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (62,7)-(62,10) = "two" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "two" + │ │ └── @ SymbolNode (location: (62,11)-(62,16)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: ∅ + │ │ ├── value_loc: (62,11)-(62,16) = "three" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "three" + │ ├── opening_loc: (62,0)-(62,3) = "%i#" + │ └── closing_loc: (62,16)-(62,17) = "#" + ├── @ ArrayNode (location: (64,0)-(64,17)) + │ ├── flags: ∅ + │ ├── elements: (length: 3) + │ │ ├── @ StringNode (location: (64,3)-(64,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (64,3)-(64,6) = "one" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "one" + │ │ ├── @ StringNode (location: (64,7)-(64,10)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (64,7)-(64,10) = "two" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "two" + │ │ └── @ StringNode (location: (64,11)-(64,16)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (64,11)-(64,16) = "three" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "three" + │ ├── opening_loc: (64,0)-(64,3) = "%w#" + │ └── closing_loc: (64,16)-(64,17) = "#" + ├── @ XStringNode (location: (66,0)-(66,17)) + │ ├── flags: ∅ + │ ├── opening_loc: (66,0)-(66,3) = "%x#" + │ ├── content_loc: (66,3)-(66,16) = "one two three" + │ ├── closing_loc: (66,16)-(66,17) = "#" + │ └── unescaped: "one two three" + ├── @ ArrayNode (location: (69,0)-(69,17)) + │ ├── flags: ∅ + │ ├── elements: (length: 3) + │ │ ├── @ SymbolNode (location: (69,3)-(69,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (69,3)-(69,6) = "one" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "one" + │ │ ├── @ SymbolNode (location: (69,7)-(69,10)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (69,7)-(69,10) = "two" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "two" + │ │ └── @ SymbolNode (location: (69,11)-(69,16)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: ∅ + │ │ ├── value_loc: (69,11)-(69,16) = "three" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "three" + │ ├── opening_loc: (69,0)-(69,3) = "%i@" + │ └── closing_loc: (69,16)-(69,17) = "@" + ├── @ ArrayNode (location: (71,0)-(71,17)) + │ ├── flags: ∅ + │ ├── elements: (length: 3) + │ │ ├── @ StringNode (location: (71,3)-(71,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (71,3)-(71,6) = "one" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "one" + │ │ ├── @ StringNode (location: (71,7)-(71,10)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (71,7)-(71,10) = "two" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "two" + │ │ └── @ StringNode (location: (71,11)-(71,16)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (71,11)-(71,16) = "three" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "three" + │ ├── opening_loc: (71,0)-(71,3) = "%w@" + │ └── closing_loc: (71,16)-(71,17) = "@" + ├── @ XStringNode (location: (73,0)-(73,17)) + │ ├── flags: ∅ + │ ├── opening_loc: (73,0)-(73,3) = "%x@" + │ ├── content_loc: (73,3)-(73,16) = "one two three" + │ ├── closing_loc: (73,16)-(73,17) = "@" + │ └── unescaped: "one two three" + ├── @ ArrayNode (location: (76,0)-(76,17)) + │ ├── flags: ∅ + │ ├── elements: (length: 3) + │ │ ├── @ SymbolNode (location: (76,3)-(76,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (76,3)-(76,6) = "one" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "one" + │ │ ├── @ SymbolNode (location: (76,7)-(76,10)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (76,7)-(76,10) = "two" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "two" + │ │ └── @ SymbolNode (location: (76,11)-(76,16)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: ∅ + │ │ ├── value_loc: (76,11)-(76,16) = "three" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "three" + │ ├── opening_loc: (76,0)-(76,3) = "%i{" + │ └── closing_loc: (76,16)-(76,17) = "}" + ├── @ ArrayNode (location: (78,0)-(78,17)) + │ ├── flags: ∅ + │ ├── elements: (length: 3) + │ │ ├── @ StringNode (location: (78,3)-(78,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (78,3)-(78,6) = "one" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "one" + │ │ ├── @ StringNode (location: (78,7)-(78,10)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (78,7)-(78,10) = "two" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "two" + │ │ └── @ StringNode (location: (78,11)-(78,16)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (78,11)-(78,16) = "three" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "three" + │ ├── opening_loc: (78,0)-(78,3) = "%w{" + │ └── closing_loc: (78,16)-(78,17) = "}" + ├── @ XStringNode (location: (80,0)-(80,17)) + │ ├── flags: ∅ + │ ├── opening_loc: (80,0)-(80,3) = "%x{" + │ ├── content_loc: (80,3)-(80,16) = "one two three" + │ ├── closing_loc: (80,16)-(80,17) = "}" + │ └── unescaped: "one two three" + ├── @ ArrayNode (location: (82,0)-(82,7)) + │ ├── flags: ∅ + │ ├── elements: (length: 1) + │ │ └── @ StringNode (location: (82,3)-(82,6)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (82,3)-(82,6) = "\\C:" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\\C:" + │ ├── opening_loc: (82,0)-(82,3) = "%w[" + │ └── closing_loc: (82,6)-(82,7) = "]" + ├── @ IndexOperatorWriteNode (location: (84,0)-(84,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (84,0)-(84,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (84,0)-(84,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (84,3)-(84,4) = "[" + │ ├── arguments: ∅ + │ ├── closing_loc: (84,4)-(84,5) = "]" + │ ├── block: ∅ + │ ├── operator: :+ + │ ├── operator_loc: (84,6)-(84,8) = "+=" + │ └── value: + │ @ IntegerNode (location: (84,9)-(84,10)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexOrWriteNode (location: (86,0)-(86,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (86,0)-(86,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (86,0)-(86,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (86,3)-(86,4) = "[" + │ ├── arguments: ∅ + │ ├── closing_loc: (86,4)-(86,5) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (86,6)-(86,9) = "||=" + │ └── value: + │ @ IntegerNode (location: (86,10)-(86,11)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexAndWriteNode (location: (88,0)-(88,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (88,0)-(88,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (88,0)-(88,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (88,3)-(88,4) = "[" + │ ├── arguments: ∅ + │ ├── closing_loc: (88,4)-(88,5) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (88,6)-(88,9) = "&&=" + │ └── value: + │ @ IntegerNode (location: (88,10)-(88,11)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexOperatorWriteNode (location: (90,0)-(90,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (90,0)-(90,7)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (90,0)-(90,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (90,0)-(90,3) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (90,3)-(90,4) = "." + │ │ ├── name: :foo + │ │ ├── message_loc: (90,4)-(90,7) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (90,7)-(90,8) = "[" + │ ├── arguments: ∅ + │ ├── closing_loc: (90,8)-(90,9) = "]" + │ ├── block: ∅ + │ ├── operator: :+ + │ ├── operator_loc: (90,10)-(90,12) = "+=" + │ └── value: + │ @ IntegerNode (location: (90,13)-(90,14)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexOrWriteNode (location: (92,0)-(92,15)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (92,0)-(92,7)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (92,0)-(92,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (92,0)-(92,3) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (92,3)-(92,4) = "." + │ │ ├── name: :foo + │ │ ├── message_loc: (92,4)-(92,7) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (92,7)-(92,8) = "[" + │ ├── arguments: ∅ + │ ├── closing_loc: (92,8)-(92,9) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (92,10)-(92,13) = "||=" + │ └── value: + │ @ IntegerNode (location: (92,14)-(92,15)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexAndWriteNode (location: (94,0)-(94,15)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (94,0)-(94,7)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (94,0)-(94,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (94,0)-(94,3) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (94,3)-(94,4) = "." + │ │ ├── name: :foo + │ │ ├── message_loc: (94,4)-(94,7) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (94,7)-(94,8) = "[" + │ ├── arguments: ∅ + │ ├── closing_loc: (94,8)-(94,9) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (94,10)-(94,13) = "&&=" + │ └── value: + │ @ IntegerNode (location: (94,14)-(94,15)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexOperatorWriteNode (location: (96,0)-(96,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (96,0)-(96,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (96,0)-(96,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (96,3)-(96,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (96,4)-(96,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (96,4)-(96,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (96,4)-(96,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (96,7)-(96,8) = "]" + │ ├── block: ∅ + │ ├── operator: :+ + │ ├── operator_loc: (96,9)-(96,11) = "+=" + │ └── value: + │ @ IntegerNode (location: (96,12)-(96,13)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexOrWriteNode (location: (98,0)-(98,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (98,0)-(98,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (98,0)-(98,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (98,3)-(98,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (98,4)-(98,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (98,4)-(98,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (98,4)-(98,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (98,7)-(98,8) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (98,9)-(98,12) = "||=" + │ └── value: + │ @ IntegerNode (location: (98,13)-(98,14)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexAndWriteNode (location: (100,0)-(100,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (100,0)-(100,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (100,0)-(100,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (100,3)-(100,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (100,4)-(100,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (100,4)-(100,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (100,4)-(100,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (100,7)-(100,8) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (100,9)-(100,12) = "&&=" + │ └── value: + │ @ IntegerNode (location: (100,13)-(100,14)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexOperatorWriteNode (location: (102,0)-(102,17)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (102,0)-(102,7)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (102,0)-(102,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (102,0)-(102,3) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (102,3)-(102,4) = "." + │ │ ├── name: :foo + │ │ ├── message_loc: (102,4)-(102,7) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (102,7)-(102,8) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (102,8)-(102,11)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (102,8)-(102,11)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (102,8)-(102,11) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (102,11)-(102,12) = "]" + │ ├── block: ∅ + │ ├── operator: :+ + │ ├── operator_loc: (102,13)-(102,15) = "+=" + │ └── value: + │ @ IntegerNode (location: (102,16)-(102,17)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexOrWriteNode (location: (104,0)-(104,18)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (104,0)-(104,7)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (104,0)-(104,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (104,0)-(104,3) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (104,3)-(104,4) = "." + │ │ ├── name: :foo + │ │ ├── message_loc: (104,4)-(104,7) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (104,7)-(104,8) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (104,8)-(104,11)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (104,8)-(104,11)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (104,8)-(104,11) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (104,11)-(104,12) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (104,13)-(104,16) = "||=" + │ └── value: + │ @ IntegerNode (location: (104,17)-(104,18)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IndexAndWriteNode (location: (106,0)-(106,18)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (106,0)-(106,7)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (106,0)-(106,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (106,0)-(106,3) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (106,3)-(106,4) = "." + │ │ ├── name: :foo + │ │ ├── message_loc: (106,4)-(106,7) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (106,7)-(106,8) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (106,8)-(106,11)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (106,8)-(106,11)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (106,8)-(106,11) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (106,11)-(106,12) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (106,13)-(106,16) = "&&=" + │ └── value: + │ @ IntegerNode (location: (106,17)-(106,18)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ DefNode (location: (108,0)-(108,19)) + │ ├── name: :f + │ ├── name_loc: (108,4)-(108,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (108,6)-(108,7)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (108,6)-(108,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (108,6)-(108,7) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (108,10)-(108,14)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (108,10)-(108,14)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (108,10)-(108,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (108,10)-(108,11) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :[] + │ │ ├── message_loc: (108,11)-(108,14) = "[*]" + │ │ ├── opening_loc: (108,11)-(108,12) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (108,12)-(108,13)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ SplatNode (location: (108,12)-(108,13)) + │ │ │ ├── operator_loc: (108,12)-(108,13) = "*" + │ │ │ └── expression: ∅ + │ │ ├── closing_loc: (108,13)-(108,14) = "]" + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (108,0)-(108,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (108,5)-(108,6) = "(" + │ ├── rparen_loc: (108,7)-(108,8) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (108,16)-(108,19) = "end" + ├── @ DefNode (location: (110,0)-(110,22)) + │ ├── name: :f + │ ├── name_loc: (110,4)-(110,5) = "f" + │ ├── 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,17)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (110,10)-(110,17)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (110,10)-(110,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (110,10)-(110,11) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :[] + │ │ ├── message_loc: (110,11)-(110,17) = "[1, *]" + │ │ ├── opening_loc: (110,11)-(110,12) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (110,12)-(110,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 2) + │ │ │ ├── @ IntegerNode (location: (110,12)-(110,13)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ └── @ SplatNode (location: (110,15)-(110,16)) + │ │ │ ├── operator_loc: (110,15)-(110,16) = "*" + │ │ │ └── expression: ∅ + │ │ ├── closing_loc: (110,16)-(110,17) = "]" + │ │ └── 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,19)-(110,22) = "end" + ├── @ DefNode (location: (112,0)-(112,23)) + │ ├── name: :f + │ ├── name_loc: (112,4)-(112,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (112,6)-(112,7)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (112,6)-(112,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (112,6)-(112,7) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (112,10)-(112,18)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (112,10)-(112,18)) + │ │ ├── flags: attribute_write + │ │ ├── receiver: + │ │ │ @ CallNode (location: (112,10)-(112,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (112,10)-(112,11) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :[]= + │ │ ├── message_loc: (112,11)-(112,14) = "[*]" + │ │ ├── opening_loc: (112,11)-(112,12) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (112,12)-(112,18)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 2) + │ │ │ ├── @ SplatNode (location: (112,12)-(112,13)) + │ │ │ │ ├── operator_loc: (112,12)-(112,13) = "*" + │ │ │ │ └── expression: ∅ + │ │ │ └── @ IntegerNode (location: (112,17)-(112,18)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: (112,13)-(112,14) = "]" + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (112,0)-(112,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (112,5)-(112,6) = "(" + │ ├── rparen_loc: (112,7)-(112,8) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (112,20)-(112,23) = "end" + ├── @ DefNode (location: (114,0)-(114,26)) + │ ├── name: :f + │ ├── name_loc: (114,4)-(114,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (114,6)-(114,7)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (114,6)-(114,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (114,6)-(114,7) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (114,10)-(114,21)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (114,10)-(114,21)) + │ │ ├── flags: attribute_write + │ │ ├── receiver: + │ │ │ @ CallNode (location: (114,10)-(114,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (114,10)-(114,11) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :[]= + │ │ ├── message_loc: (114,11)-(114,17) = "[1, *]" + │ │ ├── opening_loc: (114,11)-(114,12) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (114,12)-(114,21)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 3) + │ │ │ ├── @ IntegerNode (location: (114,12)-(114,13)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── @ SplatNode (location: (114,15)-(114,16)) + │ │ │ │ ├── operator_loc: (114,15)-(114,16) = "*" + │ │ │ │ └── expression: ∅ + │ │ │ └── @ IntegerNode (location: (114,20)-(114,21)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: (114,16)-(114,17) = "]" + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (114,0)-(114,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (114,5)-(114,6) = "(" + │ ├── rparen_loc: (114,7)-(114,8) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (114,23)-(114,26) = "end" + ├── @ DefNode (location: (116,0)-(116,24)) + │ ├── name: :f + │ ├── name_loc: (116,4)-(116,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (116,6)-(116,7)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (116,6)-(116,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (116,6)-(116,7) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (116,10)-(116,19)) + │ │ └── body: (length: 1) + │ │ └── @ IndexOperatorWriteNode (location: (116,10)-(116,19)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (116,10)-(116,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (116,10)-(116,11) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── opening_loc: (116,11)-(116,12) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (116,12)-(116,13)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ SplatNode (location: (116,12)-(116,13)) + │ │ │ ├── operator_loc: (116,12)-(116,13) = "*" + │ │ │ └── expression: ∅ + │ │ ├── closing_loc: (116,13)-(116,14) = "]" + │ │ ├── block: ∅ + │ │ ├── operator: :+ + │ │ ├── operator_loc: (116,15)-(116,17) = "+=" + │ │ └── value: + │ │ @ IntegerNode (location: (116,18)-(116,19)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── locals: [] + │ ├── def_keyword_loc: (116,0)-(116,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (116,5)-(116,6) = "(" + │ ├── rparen_loc: (116,7)-(116,8) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (116,21)-(116,24) = "end" + ├── @ DefNode (location: (118,0)-(118,28)) + │ ├── name: :f + │ ├── name_loc: (118,4)-(118,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (118,6)-(118,7)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (118,6)-(118,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (118,6)-(118,7) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (118,10)-(118,23)) + │ │ └── body: (length: 1) + │ │ └── @ IndexAndWriteNode (location: (118,10)-(118,23)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (118,10)-(118,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (118,10)-(118,11) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── opening_loc: (118,11)-(118,12) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (118,12)-(118,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 2) + │ │ │ ├── @ IntegerNode (location: (118,12)-(118,13)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ └── @ SplatNode (location: (118,15)-(118,16)) + │ │ │ ├── operator_loc: (118,15)-(118,16) = "*" + │ │ │ └── expression: ∅ + │ │ ├── closing_loc: (118,16)-(118,17) = "]" + │ │ ├── block: ∅ + │ │ ├── operator_loc: (118,18)-(118,21) = "&&=" + │ │ └── value: + │ │ @ IntegerNode (location: (118,22)-(118,23)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── locals: [] + │ ├── def_keyword_loc: (118,0)-(118,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (118,5)-(118,6) = "(" + │ ├── rparen_loc: (118,7)-(118,8) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (118,25)-(118,28) = "end" + ├── @ DefNode (location: (120,0)-(120,29)) + │ ├── name: :f + │ ├── name_loc: (120,4)-(120,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (120,6)-(120,7)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (120,6)-(120,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (120,6)-(120,7) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ BeginNode (location: (120,0)-(120,29)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (120,10)-(120,24)) + │ │ │ ├── keyword_loc: (120,10)-(120,16) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: (120,17)-(120,19) = "=>" + │ │ │ ├── reference: + │ │ │ │ @ IndexTargetNode (location: (120,20)-(120,24)) + │ │ │ │ ├── flags: attribute_write + │ │ │ │ ├── receiver: + │ │ │ │ │ @ CallNode (location: (120,20)-(120,21)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :a + │ │ │ │ │ ├── message_loc: (120,20)-(120,21) = "a" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── opening_loc: (120,21)-(120,22) = "[" + │ │ │ │ ├── arguments: + │ │ │ │ │ @ ArgumentsNode (location: (120,22)-(120,23)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ └── @ SplatNode (location: (120,22)-(120,23)) + │ │ │ │ │ ├── operator_loc: (120,22)-(120,23) = "*" + │ │ │ │ │ └── expression: ∅ + │ │ │ │ ├── closing_loc: (120,23)-(120,24) = "]" + │ │ │ │ └── block: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (120,26)-(120,29) = "end" + │ ├── locals: [] + │ ├── def_keyword_loc: (120,0)-(120,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (120,5)-(120,6) = "(" + │ ├── rparen_loc: (120,7)-(120,8) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (120,26)-(120,29) = "end" + └── @ DefNode (location: (122,0)-(122,32)) + ├── name: :f + ├── name_loc: (122,4)-(122,5) = "f" + ├── receiver: ∅ + ├── parameters: + │ @ ParametersNode (location: (122,6)-(122,7)) + │ ├── requireds: (length: 0) + │ ├── optionals: (length: 0) + │ ├── rest: + │ │ @ RestParameterNode (location: (122,6)-(122,7)) + │ │ ├── flags: ∅ + │ │ ├── name: ∅ + │ │ ├── name_loc: ∅ + │ │ └── operator_loc: (122,6)-(122,7) = "*" + │ ├── posts: (length: 0) + │ ├── keywords: (length: 0) + │ ├── keyword_rest: ∅ + │ └── block: ∅ + ├── body: + │ @ BeginNode (location: (122,0)-(122,32)) + │ ├── begin_keyword_loc: ∅ + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (122,10)-(122,27)) + │ │ ├── keyword_loc: (122,10)-(122,16) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: (122,17)-(122,19) = "=>" + │ │ ├── reference: + │ │ │ @ IndexTargetNode (location: (122,20)-(122,27)) + │ │ │ ├── flags: attribute_write + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (122,20)-(122,21)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (122,20)-(122,21) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── opening_loc: (122,21)-(122,22) = "[" + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (122,22)-(122,26)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 2) + │ │ │ │ ├── @ IntegerNode (location: (122,22)-(122,23)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ └── @ SplatNode (location: (122,25)-(122,26)) + │ │ │ │ ├── operator_loc: (122,25)-(122,26) = "*" + │ │ │ │ └── expression: ∅ + │ │ │ ├── closing_loc: (122,26)-(122,27) = "]" + │ │ │ └── block: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (122,29)-(122,32) = "end" + ├── 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: (122,29)-(122,32) = "end" |