@ ProgramNode (location: (1,0)-(142,32)) ├── locals: [] └── statements: @ StatementsNode (location: (1,0)-(142,32)) └── body: (length: 59) ├── @ ArrayNode (location: (1,0)-(1,4)) │ ├── elements: (length: 1) │ │ └── @ SplatNode (location: (1,1)-(1,3)) │ │ ├── operator_loc: (1,1)-(1,2) = "*" │ │ └── expression: │ │ @ CallNode (location: (1,2)-(1,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :a │ │ ├── message_loc: (1,2)-(1,3) = "a" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── opening_loc: (1,0)-(1,1) = "[" │ ├── closing_loc: (1,3)-(1,4) = "]" │ └── flags: contains_splat ├── @ CallNode (location: (3,0)-(3,23)) │ ├── receiver: │ │ @ CallNode (location: (3,0)-(3,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (3,0)-(3,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── 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)) │ │ ├── arguments: (length: 3) │ │ │ ├── @ CallNode (location: (3,4)-(3,7)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (3,4)-(3,7) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ ├── @ CallNode (location: (3,9)-(3,12)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :baz │ │ │ │ ├── message_loc: (3,9)-(3,12) = "baz" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ └── @ ArrayNode (location: (3,16)-(3,23)) │ │ │ ├── elements: (length: 3) │ │ │ │ ├── @ IntegerNode (location: (3,16)-(3,17)) │ │ │ │ │ └── flags: decimal │ │ │ │ ├── @ IntegerNode (location: (3,19)-(3,20)) │ │ │ │ │ └── flags: decimal │ │ │ │ └── @ IntegerNode (location: (3,22)-(3,23)) │ │ │ │ └── flags: decimal │ │ │ ├── opening_loc: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── flags: ∅ │ │ └── flags: ∅ │ ├── closing_loc: (3,12)-(3,13) = "]" │ ├── block: ∅ │ └── flags: ∅ ├── @ ArrayNode (location: (5,0)-(5,13)) │ ├── elements: (length: 1) │ │ └── @ KeywordHashNode (location: (5,1)-(5,12)) │ │ └── elements: (length: 1) │ │ └── @ AssocNode (location: (5,1)-(5,12)) │ │ ├── key: │ │ │ @ SymbolNode (location: (5,1)-(5,3)) │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (5,1)-(5,2) = "a" │ │ │ ├── closing_loc: (5,2)-(5,3) = ":" │ │ │ └── unescaped: "a" │ │ ├── value: │ │ │ @ ArrayNode (location: (5,4)-(5,12)) │ │ │ ├── elements: (length: 2) │ │ │ │ ├── @ SymbolNode (location: (5,5)-(5,7)) │ │ │ │ │ ├── opening_loc: (5,5)-(5,6) = ":" │ │ │ │ │ ├── value_loc: (5,6)-(5,7) = "b" │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── unescaped: "b" │ │ │ │ └── @ SymbolNode (location: (5,9)-(5,11)) │ │ │ │ ├── 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) = "]" │ │ │ └── flags: ∅ │ │ └── operator_loc: ∅ │ ├── opening_loc: (5,0)-(5,1) = "[" │ ├── closing_loc: (5,12)-(5,13) = "]" │ └── flags: ∅ ├── @ ArrayNode (location: (9,0)-(15,1)) │ ├── elements: (length: 5) │ │ ├── @ SymbolNode (location: (9,1)-(9,3)) │ │ │ ├── opening_loc: (9,1)-(9,2) = ":" │ │ │ ├── value_loc: (9,2)-(9,3) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" │ │ ├── @ SymbolNode (location: (9,5)-(9,7)) │ │ │ ├── opening_loc: (9,5)-(9,6) = ":" │ │ │ ├── value_loc: (9,6)-(9,7) = "b" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "b" │ │ ├── @ SymbolNode (location: (10,0)-(10,2)) │ │ │ ├── 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 │ │ └── @ SymbolNode (location: (14,0)-(14,2)) │ │ ├── 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) = "]" │ └── flags: ∅ ├── @ ArrayNode (location: (18,0)-(26,1)) │ ├── elements: (length: 5) │ │ ├── @ SymbolNode (location: (18,1)-(18,3)) │ │ │ ├── opening_loc: (18,1)-(18,2) = ":" │ │ │ ├── value_loc: (18,2)-(18,3) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" │ │ ├── @ SymbolNode (location: (18,5)-(18,7)) │ │ │ ├── opening_loc: (18,5)-(18,6) = ":" │ │ │ ├── value_loc: (18,6)-(18,7) = "b" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "b" │ │ ├── @ SymbolNode (location: (19,0)-(19,2)) │ │ │ ├── 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 │ │ └── @ SymbolNode (location: (23,0)-(23,2)) │ │ ├── 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) = "]" │ └── flags: ∅ ├── @ ArrayNode (location: (28,0)-(28,12)) │ ├── elements: (length: 1) │ │ └── @ KeywordHashNode (location: (28,1)-(28,11)) │ │ └── elements: (length: 1) │ │ └── @ AssocNode (location: (28,1)-(28,11)) │ │ ├── key: │ │ │ @ CallNode (location: (28,1)-(28,4)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (28,1)-(28,4) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── value: │ │ │ @ CallNode (location: (28,8)-(28,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (28,8)-(28,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (28,5)-(28,7) = "=>" │ ├── opening_loc: (28,0)-(28,1) = "[" │ ├── closing_loc: (28,11)-(28,12) = "]" │ └── flags: ∅ ├── @ CallNode (location: (30,0)-(30,19)) │ ├── receiver: │ │ @ CallNode (location: (30,0)-(30,8)) │ │ ├── receiver: │ │ │ @ CallNode (location: (30,0)-(30,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (30,0)-(30,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── name: :[] │ │ ├── message_loc: (30,3)-(30,8) = "[bar]" │ │ ├── opening_loc: (30,3)-(30,4) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (30,4)-(30,7)) │ │ │ ├── arguments: (length: 1) │ │ │ │ └── @ CallNode (location: (30,4)-(30,7)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (30,4)-(30,7) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ └── flags: ∅ │ │ ├── closing_loc: (30,7)-(30,8) = "]" │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :[]= │ ├── message_loc: (30,8)-(30,13) = "[baz]" │ ├── opening_loc: (30,8)-(30,9) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (30,9)-(30,19)) │ │ ├── arguments: (length: 2) │ │ │ ├── @ CallNode (location: (30,9)-(30,12)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :baz │ │ │ │ ├── message_loc: (30,9)-(30,12) = "baz" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ └── @ CallNode (location: (30,16)-(30,19)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :qux │ │ │ ├── message_loc: (30,16)-(30,19) = "qux" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (30,12)-(30,13) = "]" │ ├── block: ∅ │ └── flags: ∅ ├── @ CallNode (location: (32,0)-(32,13)) │ ├── receiver: │ │ @ CallNode (location: (32,0)-(32,8)) │ │ ├── receiver: │ │ │ @ CallNode (location: (32,0)-(32,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (32,0)-(32,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── name: :[] │ │ ├── message_loc: (32,3)-(32,8) = "[bar]" │ │ ├── opening_loc: (32,3)-(32,4) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (32,4)-(32,7)) │ │ │ ├── arguments: (length: 1) │ │ │ │ └── @ CallNode (location: (32,4)-(32,7)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (32,4)-(32,7) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ └── flags: ∅ │ │ ├── closing_loc: (32,7)-(32,8) = "]" │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :[] │ ├── message_loc: (32,8)-(32,13) = "[baz]" │ ├── opening_loc: (32,8)-(32,9) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (32,9)-(32,12)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (32,9)-(32,12)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz │ │ │ ├── message_loc: (32,9)-(32,12) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (32,12)-(32,13) = "]" │ ├── block: ∅ │ └── flags: ∅ ├── @ ArrayNode (location: (34,0)-(35,1)) │ ├── elements: (length: 0) │ ├── opening_loc: (34,0)-(34,1) = "[" │ ├── closing_loc: (35,0)-(35,1) = "]" │ └── flags: ∅ ├── @ CallNode (location: (37,0)-(37,13)) │ ├── receiver: │ │ @ CallNode (location: (37,0)-(37,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (37,0)-(37,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── 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)) │ │ ├── arguments: (length: 2) │ │ │ ├── @ CallNode (location: (37,4)-(37,7)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (37,4)-(37,7) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ └── @ CallNode (location: (37,9)-(37,12)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz │ │ │ ├── message_loc: (37,9)-(37,12) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (37,12)-(37,13) = "]" │ ├── block: ∅ │ └── flags: ∅ ├── @ CallNode (location: (39,0)-(39,19)) │ ├── receiver: │ │ @ CallNode (location: (39,0)-(39,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (39,0)-(39,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── 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)) │ │ ├── arguments: (length: 3) │ │ │ ├── @ CallNode (location: (39,4)-(39,7)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (39,4)-(39,7) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ ├── @ CallNode (location: (39,9)-(39,12)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :baz │ │ │ │ ├── message_loc: (39,9)-(39,12) = "baz" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ └── @ CallNode (location: (39,16)-(39,19)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :qux │ │ │ ├── message_loc: (39,16)-(39,19) = "qux" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (39,12)-(39,13) = "]" │ ├── block: ∅ │ └── flags: ∅ ├── @ MultiWriteNode (location: (41,0)-(41,21)) │ ├── lefts: (length: 2) │ │ ├── @ CallNode (location: (41,0)-(41,6)) │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (41,0)-(41,3)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :foo │ │ │ │ ├── message_loc: (41,0)-(41,3) = "foo" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :[]= │ │ │ ├── message_loc: (41,3)-(41,6) = "[0]" │ │ │ ├── opening_loc: (41,3)-(41,4) = "[" │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (41,4)-(41,5)) │ │ │ │ ├── arguments: (length: 1) │ │ │ │ │ └── @ IntegerNode (location: (41,4)-(41,5)) │ │ │ │ │ └── flags: decimal │ │ │ │ └── flags: ∅ │ │ │ ├── closing_loc: (41,5)-(41,6) = "]" │ │ │ ├── block: ∅ │ │ │ └── flags: ∅ │ │ └── @ CallNode (location: (41,8)-(41,14)) │ │ ├── receiver: │ │ │ @ CallNode (location: (41,8)-(41,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (41,8)-(41,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── name: :[]= │ │ ├── message_loc: (41,11)-(41,14) = "[0]" │ │ ├── opening_loc: (41,11)-(41,12) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (41,12)-(41,13)) │ │ │ ├── arguments: (length: 1) │ │ │ │ └── @ IntegerNode (location: (41,12)-(41,13)) │ │ │ │ └── flags: decimal │ │ │ └── flags: ∅ │ │ ├── closing_loc: (41,13)-(41,14) = "]" │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── rest: ∅ │ ├── rights: (length: 0) │ ├── lparen_loc: ∅ │ ├── rparen_loc: ∅ │ ├── operator_loc: (41,15)-(41,16) = "=" │ └── value: │ @ ArrayNode (location: (41,17)-(41,21)) │ ├── elements: (length: 2) │ │ ├── @ IntegerNode (location: (41,17)-(41,18)) │ │ │ └── flags: decimal │ │ └── @ IntegerNode (location: (41,20)-(41,21)) │ │ └── flags: decimal │ ├── opening_loc: ∅ │ ├── closing_loc: ∅ │ └── flags: ∅ ├── @ CallNode (location: (43,0)-(43,19)) │ ├── receiver: │ │ @ CallNode (location: (43,0)-(43,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (43,0)-(43,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── 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)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (43,4)-(43,18)) │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (43,4)-(43,7)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (43,4)-(43,7) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :[]= │ │ │ ├── message_loc: (43,7)-(43,12) = "[baz]" │ │ │ ├── opening_loc: (43,7)-(43,8) = "[" │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (43,8)-(43,18)) │ │ │ │ ├── arguments: (length: 2) │ │ │ │ │ ├── @ CallNode (location: (43,8)-(43,11)) │ │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ │ ├── name: :baz │ │ │ │ │ │ ├── message_loc: (43,8)-(43,11) = "baz" │ │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ │ ├── block: ∅ │ │ │ │ │ │ └── flags: variable_call │ │ │ │ │ └── @ CallNode (location: (43,15)-(43,18)) │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── name: :qux │ │ │ │ │ ├── message_loc: (43,15)-(43,18) = "qux" │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ ├── block: ∅ │ │ │ │ │ └── flags: variable_call │ │ │ │ └── flags: ∅ │ │ │ ├── closing_loc: (43,11)-(43,12) = "]" │ │ │ ├── block: ∅ │ │ │ └── flags: ∅ │ │ └── flags: ∅ │ ├── closing_loc: (43,18)-(43,19) = "]" │ ├── block: ∅ │ └── flags: ∅ ├── @ CallNode (location: (45,0)-(45,8)) │ ├── receiver: │ │ @ CallNode (location: (45,0)-(45,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (45,0)-(45,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── name: :[] │ ├── message_loc: (45,3)-(45,8) = "[bar]" │ ├── opening_loc: (45,3)-(45,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (45,4)-(45,7)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (45,4)-(45,7)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (45,4)-(45,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (45,7)-(45,8) = "]" │ ├── block: ∅ │ └── flags: ∅ ├── @ CallNode (location: (47,0)-(47,14)) │ ├── receiver: │ │ @ CallNode (location: (47,0)-(47,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (47,0)-(47,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── name: :[]= │ ├── message_loc: (47,3)-(47,8) = "[bar]" │ ├── opening_loc: (47,3)-(47,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (47,4)-(47,14)) │ │ ├── arguments: (length: 2) │ │ │ ├── @ CallNode (location: (47,4)-(47,7)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (47,4)-(47,7) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ └── @ CallNode (location: (47,11)-(47,14)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz │ │ │ ├── message_loc: (47,11)-(47,14) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (47,7)-(47,8) = "]" │ ├── block: ∅ │ └── flags: ∅ ├── @ ArrayNode (location: (49,0)-(49,6)) │ ├── elements: (length: 1) │ │ └── @ KeywordHashNode (location: (49,1)-(49,5)) │ │ └── 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) = "]" │ └── flags: ∅ ├── @ ArrayNode (location: (51,0)-(51,6)) │ ├── elements: (length: 1) │ │ └── @ KeywordHashNode (location: (51,1)-(51,5)) │ │ └── elements: (length: 1) │ │ └── @ AssocSplatNode (location: (51,1)-(51,5)) │ │ ├── value: │ │ │ @ CallNode (location: (51,3)-(51,5)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :kw │ │ │ ├── message_loc: (51,3)-(51,5) = "kw" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (51,1)-(51,3) = "**" │ ├── opening_loc: (51,0)-(51,1) = "[" │ ├── closing_loc: (51,5)-(51,6) = "]" │ └── flags: ∅ ├── @ ArrayNode (location: (53,0)-(53,9)) │ ├── elements: (length: 2) │ │ ├── @ IntegerNode (location: (53,1)-(53,2)) │ │ │ └── flags: decimal │ │ └── @ KeywordHashNode (location: (53,4)-(53,8)) │ │ └── elements: (length: 1) │ │ └── @ AssocSplatNode (location: (53,4)-(53,8)) │ │ ├── value: │ │ │ @ CallNode (location: (53,6)-(53,8)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :kw │ │ │ ├── message_loc: (53,6)-(53,8) = "kw" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (53,4)-(53,6) = "**" │ ├── opening_loc: (53,0)-(53,1) = "[" │ ├── closing_loc: (53,8)-(53,9) = "]" │ └── flags: ∅ ├── @ ArrayNode (location: (55,0)-(55,21)) │ ├── elements: (length: 2) │ │ ├── @ IntegerNode (location: (55,1)-(55,2)) │ │ │ └── flags: decimal │ │ └── @ KeywordHashNode (location: (55,4)-(55,20)) │ │ └── elements: (length: 3) │ │ ├── @ AssocSplatNode (location: (55,4)-(55,8)) │ │ │ ├── value: │ │ │ │ @ CallNode (location: (55,6)-(55,8)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :kw │ │ │ │ ├── message_loc: (55,6)-(55,8) = "kw" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ └── 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)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :kw │ │ │ ├── message_loc: (55,18)-(55,20) = "kw" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (55,16)-(55,18) = "**" │ ├── opening_loc: (55,0)-(55,1) = "[" │ ├── closing_loc: (55,20)-(55,21) = "]" │ └── flags: ∅ ├── @ ArrayNode (location: (57,0)-(59,1)) │ ├── elements: (length: 1) │ │ └── @ KeywordHashNode (location: (58,2)-(58,12)) │ │ └── elements: (length: 1) │ │ └── @ AssocNode (location: (58,2)-(58,12)) │ │ ├── key: │ │ │ @ CallNode (location: (58,2)-(58,5)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (58,2)-(58,5) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── value: │ │ │ @ CallNode (location: (58,9)-(58,12)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (58,9)-(58,12) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (58,6)-(58,8) = "=>" │ ├── opening_loc: (57,0)-(57,1) = "[" │ ├── closing_loc: (59,0)-(59,1) = "]" │ └── flags: ∅ ├── @ ArrayNode (location: (62,0)-(62,17)) │ ├── elements: (length: 3) │ │ ├── @ SymbolNode (location: (62,3)-(62,6)) │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (62,3)-(62,6) = "one" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "one" │ │ ├── @ SymbolNode (location: (62,7)-(62,10)) │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (62,7)-(62,10) = "two" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "two" │ │ └── @ SymbolNode (location: (62,11)-(62,16)) │ │ ├── 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) = "#" │ └── flags: ∅ ├── @ ArrayNode (location: (64,0)-(64,17)) │ ├── 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) = "#" │ └── flags: ∅ ├── @ 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)) │ ├── elements: (length: 3) │ │ ├── @ SymbolNode (location: (69,3)-(69,6)) │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (69,3)-(69,6) = "one" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "one" │ │ ├── @ SymbolNode (location: (69,7)-(69,10)) │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (69,7)-(69,10) = "two" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "two" │ │ └── @ SymbolNode (location: (69,11)-(69,16)) │ │ ├── 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) = "@" │ └── flags: ∅ ├── @ ArrayNode (location: (71,0)-(71,17)) │ ├── 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) = "@" │ └── flags: ∅ ├── @ 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)) │ ├── elements: (length: 3) │ │ ├── @ SymbolNode (location: (76,3)-(76,6)) │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (76,3)-(76,6) = "one" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "one" │ │ ├── @ SymbolNode (location: (76,7)-(76,10)) │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (76,7)-(76,10) = "two" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "two" │ │ └── @ SymbolNode (location: (76,11)-(76,16)) │ │ ├── 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) = "}" │ └── flags: ∅ ├── @ ArrayNode (location: (78,0)-(78,17)) │ ├── 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) = "}" │ └── flags: ∅ ├── @ 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)) │ ├── 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) = "]" │ └── flags: ∅ ├── @ CallNode (location: (84,0)-(84,13)) │ ├── receiver: │ │ @ CallNode (location: (84,0)-(84,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (84,0)-(84,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── name: :[]= │ ├── message_loc: (84,3)-(84,9) = "[&bar]" │ ├── opening_loc: (84,3)-(84,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (84,12)-(84,13)) │ │ ├── arguments: (length: 1) │ │ │ └── @ IntegerNode (location: (84,12)-(84,13)) │ │ │ └── flags: decimal │ │ └── flags: ∅ │ ├── closing_loc: (84,8)-(84,9) = "]" │ ├── block: │ │ @ BlockArgumentNode (location: (84,4)-(84,8)) │ │ ├── expression: │ │ │ @ CallNode (location: (84,5)-(84,8)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (84,5)-(84,8) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (84,4)-(84,5) = "&" │ └── flags: ∅ ├── @ CallNode (location: (86,0)-(86,17)) │ ├── receiver: │ │ @ CallNode (location: (86,0)-(86,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (86,0)-(86,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (86,0)-(86,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (86,3)-(86,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (86,4)-(86,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :[]= │ ├── message_loc: (86,7)-(86,13) = "[&bar]" │ ├── opening_loc: (86,7)-(86,8) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (86,16)-(86,17)) │ │ ├── arguments: (length: 1) │ │ │ └── @ IntegerNode (location: (86,16)-(86,17)) │ │ │ └── flags: decimal │ │ └── flags: ∅ │ ├── closing_loc: (86,12)-(86,13) = "]" │ ├── block: │ │ @ BlockArgumentNode (location: (86,8)-(86,12)) │ │ ├── expression: │ │ │ @ CallNode (location: (86,9)-(86,12)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (86,9)-(86,12) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (86,8)-(86,9) = "&" │ └── flags: ∅ ├── @ DefNode (location: (88,0)-(90,3)) │ ├── name: :foo │ ├── name_loc: (88,4)-(88,7) = "foo" │ ├── receiver: ∅ │ ├── parameters: │ │ @ ParametersNode (location: (88,8)-(88,9)) │ │ ├── requireds: (length: 0) │ │ ├── optionals: (length: 0) │ │ ├── rest: ∅ │ │ ├── posts: (length: 0) │ │ ├── keywords: (length: 0) │ │ ├── keyword_rest: ∅ │ │ └── block: │ │ @ BlockParameterNode (location: (88,8)-(88,9)) │ │ ├── name: ∅ │ │ ├── name_loc: ∅ │ │ └── operator_loc: (88,8)-(88,9) = "&" │ ├── body: │ │ @ StatementsNode (location: (89,2)-(89,12)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (89,2)-(89,12)) │ │ ├── receiver: │ │ │ @ CallNode (location: (89,2)-(89,5)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (89,2)-(89,5) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── name: :[]= │ │ ├── message_loc: (89,5)-(89,8) = "[&]" │ │ ├── opening_loc: (89,5)-(89,6) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (89,11)-(89,12)) │ │ │ ├── arguments: (length: 1) │ │ │ │ └── @ IntegerNode (location: (89,11)-(89,12)) │ │ │ │ └── flags: decimal │ │ │ └── flags: ∅ │ │ ├── closing_loc: (89,7)-(89,8) = "]" │ │ ├── block: │ │ │ @ BlockArgumentNode (location: (89,6)-(89,7)) │ │ │ ├── expression: ∅ │ │ │ └── operator_loc: (89,6)-(89,7) = "&" │ │ └── flags: ∅ │ ├── locals: [:&] │ ├── locals_body_index: 1 │ ├── def_keyword_loc: (88,0)-(88,3) = "def" │ ├── operator_loc: ∅ │ ├── lparen_loc: (88,7)-(88,8) = "(" │ ├── rparen_loc: (88,9)-(88,10) = ")" │ ├── equal_loc: ∅ │ └── end_keyword_loc: (90,0)-(90,3) = "end" ├── @ IndexOperatorWriteNode (location: (92,0)-(92,10)) │ ├── receiver: │ │ @ CallNode (location: (92,0)-(92,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (92,0)-(92,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── opening_loc: (92,3)-(92,4) = "[" │ ├── arguments: ∅ │ ├── closing_loc: (92,4)-(92,5) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator: :+ │ ├── operator_loc: (92,6)-(92,8) = "+=" │ └── value: │ @ IntegerNode (location: (92,9)-(92,10)) │ └── flags: decimal ├── @ IndexOrWriteNode (location: (94,0)-(94,11)) │ ├── receiver: │ │ @ CallNode (location: (94,0)-(94,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (94,0)-(94,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── opening_loc: (94,3)-(94,4) = "[" │ ├── arguments: ∅ │ ├── closing_loc: (94,4)-(94,5) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator_loc: (94,6)-(94,9) = "||=" │ └── value: │ @ IntegerNode (location: (94,10)-(94,11)) │ └── flags: decimal ├── @ IndexAndWriteNode (location: (96,0)-(96,11)) │ ├── receiver: │ │ @ CallNode (location: (96,0)-(96,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (96,0)-(96,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── opening_loc: (96,3)-(96,4) = "[" │ ├── arguments: ∅ │ ├── closing_loc: (96,4)-(96,5) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator_loc: (96,6)-(96,9) = "&&=" │ └── value: │ @ IntegerNode (location: (96,10)-(96,11)) │ └── flags: decimal ├── @ IndexOperatorWriteNode (location: (98,0)-(98,14)) │ ├── receiver: │ │ @ CallNode (location: (98,0)-(98,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (98,0)-(98,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (98,0)-(98,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (98,3)-(98,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (98,4)-(98,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── opening_loc: (98,7)-(98,8) = "[" │ ├── arguments: ∅ │ ├── closing_loc: (98,8)-(98,9) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator: :+ │ ├── operator_loc: (98,10)-(98,12) = "+=" │ └── value: │ @ IntegerNode (location: (98,13)-(98,14)) │ └── flags: decimal ├── @ IndexOrWriteNode (location: (100,0)-(100,15)) │ ├── receiver: │ │ @ CallNode (location: (100,0)-(100,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (100,0)-(100,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (100,0)-(100,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (100,3)-(100,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (100,4)-(100,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── opening_loc: (100,7)-(100,8) = "[" │ ├── arguments: ∅ │ ├── closing_loc: (100,8)-(100,9) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator_loc: (100,10)-(100,13) = "||=" │ └── value: │ @ IntegerNode (location: (100,14)-(100,15)) │ └── flags: decimal ├── @ IndexAndWriteNode (location: (102,0)-(102,15)) │ ├── receiver: │ │ @ CallNode (location: (102,0)-(102,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (102,0)-(102,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (102,0)-(102,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (102,3)-(102,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (102,4)-(102,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── opening_loc: (102,7)-(102,8) = "[" │ ├── arguments: ∅ │ ├── closing_loc: (102,8)-(102,9) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator_loc: (102,10)-(102,13) = "&&=" │ └── value: │ @ IntegerNode (location: (102,14)-(102,15)) │ └── flags: decimal ├── @ IndexOperatorWriteNode (location: (104,0)-(104,13)) │ ├── receiver: │ │ @ CallNode (location: (104,0)-(104,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (104,0)-(104,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── opening_loc: (104,3)-(104,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (104,4)-(104,7)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (104,4)-(104,7)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (104,4)-(104,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (104,7)-(104,8) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator: :+ │ ├── operator_loc: (104,9)-(104,11) = "+=" │ └── value: │ @ IntegerNode (location: (104,12)-(104,13)) │ └── flags: decimal ├── @ IndexOrWriteNode (location: (106,0)-(106,14)) │ ├── receiver: │ │ @ CallNode (location: (106,0)-(106,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (106,0)-(106,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── opening_loc: (106,3)-(106,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (106,4)-(106,7)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (106,4)-(106,7)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (106,4)-(106,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (106,7)-(106,8) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator_loc: (106,9)-(106,12) = "||=" │ └── value: │ @ IntegerNode (location: (106,13)-(106,14)) │ └── flags: decimal ├── @ IndexAndWriteNode (location: (108,0)-(108,14)) │ ├── receiver: │ │ @ CallNode (location: (108,0)-(108,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (108,0)-(108,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── opening_loc: (108,3)-(108,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (108,4)-(108,7)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (108,4)-(108,7)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (108,4)-(108,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (108,7)-(108,8) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator_loc: (108,9)-(108,12) = "&&=" │ └── value: │ @ IntegerNode (location: (108,13)-(108,14)) │ └── flags: decimal ├── @ IndexOperatorWriteNode (location: (110,0)-(110,17)) │ ├── receiver: │ │ @ CallNode (location: (110,0)-(110,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (110,0)-(110,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (110,0)-(110,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (110,3)-(110,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (110,4)-(110,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── opening_loc: (110,7)-(110,8) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (110,8)-(110,11)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (110,8)-(110,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (110,8)-(110,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (110,11)-(110,12) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator: :+ │ ├── operator_loc: (110,13)-(110,15) = "+=" │ └── value: │ @ IntegerNode (location: (110,16)-(110,17)) │ └── flags: decimal ├── @ IndexOrWriteNode (location: (112,0)-(112,18)) │ ├── receiver: │ │ @ CallNode (location: (112,0)-(112,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (112,0)-(112,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (112,0)-(112,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (112,3)-(112,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (112,4)-(112,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── opening_loc: (112,7)-(112,8) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (112,8)-(112,11)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (112,8)-(112,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (112,8)-(112,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (112,11)-(112,12) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator_loc: (112,13)-(112,16) = "||=" │ └── value: │ @ IntegerNode (location: (112,17)-(112,18)) │ └── flags: decimal ├── @ IndexAndWriteNode (location: (114,0)-(114,18)) │ ├── receiver: │ │ @ CallNode (location: (114,0)-(114,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (114,0)-(114,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (114,0)-(114,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (114,3)-(114,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (114,4)-(114,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── opening_loc: (114,7)-(114,8) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (114,8)-(114,11)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (114,8)-(114,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (114,8)-(114,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (114,11)-(114,12) = "]" │ ├── block: ∅ │ ├── flags: ∅ │ ├── operator_loc: (114,13)-(114,16) = "&&=" │ └── value: │ @ IntegerNode (location: (114,17)-(114,18)) │ └── flags: decimal ├── @ IndexOperatorWriteNode (location: (116,0)-(116,19)) │ ├── receiver: │ │ @ CallNode (location: (116,0)-(116,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (116,0)-(116,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── opening_loc: (116,3)-(116,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (116,4)-(116,7)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (116,4)-(116,7)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (116,4)-(116,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (116,13)-(116,14) = "]" │ ├── block: │ │ @ BlockArgumentNode (location: (116,9)-(116,13)) │ │ ├── expression: │ │ │ @ CallNode (location: (116,10)-(116,13)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz │ │ │ ├── message_loc: (116,10)-(116,13) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (116,9)-(116,10) = "&" │ ├── flags: ∅ │ ├── operator: :+ │ ├── operator_loc: (116,15)-(116,17) = "+=" │ └── value: │ @ IntegerNode (location: (116,18)-(116,19)) │ └── flags: decimal ├── @ IndexOrWriteNode (location: (118,0)-(118,20)) │ ├── receiver: │ │ @ CallNode (location: (118,0)-(118,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (118,0)-(118,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── opening_loc: (118,3)-(118,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (118,4)-(118,7)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (118,4)-(118,7)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (118,4)-(118,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (118,13)-(118,14) = "]" │ ├── block: │ │ @ BlockArgumentNode (location: (118,9)-(118,13)) │ │ ├── expression: │ │ │ @ CallNode (location: (118,10)-(118,13)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz │ │ │ ├── message_loc: (118,10)-(118,13) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (118,9)-(118,10) = "&" │ ├── flags: ∅ │ ├── operator_loc: (118,15)-(118,18) = "||=" │ └── value: │ @ IntegerNode (location: (118,19)-(118,20)) │ └── flags: decimal ├── @ IndexAndWriteNode (location: (120,0)-(120,20)) │ ├── receiver: │ │ @ CallNode (location: (120,0)-(120,3)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (120,0)-(120,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: variable_call │ ├── call_operator_loc: ∅ │ ├── opening_loc: (120,3)-(120,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (120,4)-(120,7)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (120,4)-(120,7)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (120,4)-(120,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (120,13)-(120,14) = "]" │ ├── block: │ │ @ BlockArgumentNode (location: (120,9)-(120,13)) │ │ ├── expression: │ │ │ @ CallNode (location: (120,10)-(120,13)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz │ │ │ ├── message_loc: (120,10)-(120,13) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (120,9)-(120,10) = "&" │ ├── flags: ∅ │ ├── operator_loc: (120,15)-(120,18) = "&&=" │ └── value: │ @ IntegerNode (location: (120,19)-(120,20)) │ └── flags: decimal ├── @ IndexOperatorWriteNode (location: (122,0)-(122,23)) │ ├── receiver: │ │ @ CallNode (location: (122,0)-(122,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (122,0)-(122,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (122,0)-(122,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (122,3)-(122,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (122,4)-(122,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── opening_loc: (122,7)-(122,8) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (122,8)-(122,11)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (122,8)-(122,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (122,8)-(122,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (122,17)-(122,18) = "]" │ ├── block: │ │ @ BlockArgumentNode (location: (122,13)-(122,17)) │ │ ├── expression: │ │ │ @ CallNode (location: (122,14)-(122,17)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz │ │ │ ├── message_loc: (122,14)-(122,17) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (122,13)-(122,14) = "&" │ ├── flags: ∅ │ ├── operator: :+ │ ├── operator_loc: (122,19)-(122,21) = "+=" │ └── value: │ @ IntegerNode (location: (122,22)-(122,23)) │ └── flags: decimal ├── @ IndexOrWriteNode (location: (124,0)-(124,24)) │ ├── receiver: │ │ @ CallNode (location: (124,0)-(124,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (124,0)-(124,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (124,0)-(124,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (124,3)-(124,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (124,4)-(124,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── opening_loc: (124,7)-(124,8) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (124,8)-(124,11)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (124,8)-(124,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (124,8)-(124,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (124,17)-(124,18) = "]" │ ├── block: │ │ @ BlockArgumentNode (location: (124,13)-(124,17)) │ │ ├── expression: │ │ │ @ CallNode (location: (124,14)-(124,17)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz │ │ │ ├── message_loc: (124,14)-(124,17) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (124,13)-(124,14) = "&" │ ├── flags: ∅ │ ├── operator_loc: (124,19)-(124,22) = "||=" │ └── value: │ @ IntegerNode (location: (124,23)-(124,24)) │ └── flags: decimal ├── @ IndexAndWriteNode (location: (126,0)-(126,24)) │ ├── receiver: │ │ @ CallNode (location: (126,0)-(126,7)) │ │ ├── receiver: │ │ │ @ CallNode (location: (126,0)-(126,3)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (126,0)-(126,3) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: (126,3)-(126,4) = "." │ │ ├── name: :foo │ │ ├── message_loc: (126,4)-(126,7) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── call_operator_loc: ∅ │ ├── opening_loc: (126,7)-(126,8) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (126,8)-(126,11)) │ │ ├── arguments: (length: 1) │ │ │ └── @ CallNode (location: (126,8)-(126,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (126,8)-(126,11) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── flags: ∅ │ ├── closing_loc: (126,17)-(126,18) = "]" │ ├── block: │ │ @ BlockArgumentNode (location: (126,13)-(126,17)) │ │ ├── expression: │ │ │ @ CallNode (location: (126,14)-(126,17)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz │ │ │ ├── message_loc: (126,14)-(126,17) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ └── operator_loc: (126,13)-(126,14) = "&" │ ├── flags: ∅ │ ├── operator_loc: (126,19)-(126,22) = "&&=" │ └── value: │ @ IntegerNode (location: (126,23)-(126,24)) │ └── flags: decimal ├── @ DefNode (location: (128,0)-(128,19)) │ ├── name: :f │ ├── name_loc: (128,4)-(128,5) = "f" │ ├── receiver: ∅ │ ├── parameters: │ │ @ ParametersNode (location: (128,6)-(128,7)) │ │ ├── requireds: (length: 0) │ │ ├── optionals: (length: 0) │ │ ├── rest: │ │ │ @ RestParameterNode (location: (128,6)-(128,7)) │ │ │ ├── name: ∅ │ │ │ ├── name_loc: ∅ │ │ │ └── operator_loc: (128,6)-(128,7) = "*" │ │ ├── posts: (length: 0) │ │ ├── keywords: (length: 0) │ │ ├── keyword_rest: ∅ │ │ └── block: ∅ │ ├── body: │ │ @ StatementsNode (location: (128,10)-(128,14)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (128,10)-(128,14)) │ │ ├── receiver: │ │ │ @ CallNode (location: (128,10)-(128,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :a │ │ │ ├── message_loc: (128,10)-(128,11) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── name: :[] │ │ ├── message_loc: (128,11)-(128,14) = "[*]" │ │ ├── opening_loc: (128,11)-(128,12) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (128,12)-(128,13)) │ │ │ ├── arguments: (length: 1) │ │ │ │ └── @ SplatNode (location: (128,12)-(128,13)) │ │ │ │ ├── operator_loc: (128,12)-(128,13) = "*" │ │ │ │ └── expression: ∅ │ │ │ └── flags: ∅ │ │ ├── closing_loc: (128,13)-(128,14) = "]" │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── locals: [:*] │ ├── locals_body_index: 1 │ ├── def_keyword_loc: (128,0)-(128,3) = "def" │ ├── operator_loc: ∅ │ ├── lparen_loc: (128,5)-(128,6) = "(" │ ├── rparen_loc: (128,7)-(128,8) = ")" │ ├── equal_loc: ∅ │ └── end_keyword_loc: (128,16)-(128,19) = "end" ├── @ DefNode (location: (130,0)-(130,22)) │ ├── name: :f │ ├── name_loc: (130,4)-(130,5) = "f" │ ├── receiver: ∅ │ ├── parameters: │ │ @ ParametersNode (location: (130,6)-(130,7)) │ │ ├── requireds: (length: 0) │ │ ├── optionals: (length: 0) │ │ ├── rest: │ │ │ @ RestParameterNode (location: (130,6)-(130,7)) │ │ │ ├── name: ∅ │ │ │ ├── name_loc: ∅ │ │ │ └── operator_loc: (130,6)-(130,7) = "*" │ │ ├── posts: (length: 0) │ │ ├── keywords: (length: 0) │ │ ├── keyword_rest: ∅ │ │ └── block: ∅ │ ├── body: │ │ @ StatementsNode (location: (130,10)-(130,17)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (130,10)-(130,17)) │ │ ├── receiver: │ │ │ @ CallNode (location: (130,10)-(130,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :a │ │ │ ├── message_loc: (130,10)-(130,11) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── name: :[] │ │ ├── message_loc: (130,11)-(130,17) = "[1, *]" │ │ ├── opening_loc: (130,11)-(130,12) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (130,12)-(130,16)) │ │ │ ├── arguments: (length: 2) │ │ │ │ ├── @ IntegerNode (location: (130,12)-(130,13)) │ │ │ │ │ └── flags: decimal │ │ │ │ └── @ SplatNode (location: (130,15)-(130,16)) │ │ │ │ ├── operator_loc: (130,15)-(130,16) = "*" │ │ │ │ └── expression: ∅ │ │ │ └── flags: ∅ │ │ ├── closing_loc: (130,16)-(130,17) = "]" │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── locals: [:*] │ ├── locals_body_index: 1 │ ├── def_keyword_loc: (130,0)-(130,3) = "def" │ ├── operator_loc: ∅ │ ├── lparen_loc: (130,5)-(130,6) = "(" │ ├── rparen_loc: (130,7)-(130,8) = ")" │ ├── equal_loc: ∅ │ └── end_keyword_loc: (130,19)-(130,22) = "end" ├── @ DefNode (location: (132,0)-(132,23)) │ ├── name: :f │ ├── name_loc: (132,4)-(132,5) = "f" │ ├── receiver: ∅ │ ├── parameters: │ │ @ ParametersNode (location: (132,6)-(132,7)) │ │ ├── requireds: (length: 0) │ │ ├── optionals: (length: 0) │ │ ├── rest: │ │ │ @ RestParameterNode (location: (132,6)-(132,7)) │ │ │ ├── name: ∅ │ │ │ ├── name_loc: ∅ │ │ │ └── operator_loc: (132,6)-(132,7) = "*" │ │ ├── posts: (length: 0) │ │ ├── keywords: (length: 0) │ │ ├── keyword_rest: ∅ │ │ └── block: ∅ │ ├── body: │ │ @ StatementsNode (location: (132,10)-(132,18)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (132,10)-(132,18)) │ │ ├── receiver: │ │ │ @ CallNode (location: (132,10)-(132,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :a │ │ │ ├── message_loc: (132,10)-(132,11) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── name: :[]= │ │ ├── message_loc: (132,11)-(132,14) = "[*]" │ │ ├── opening_loc: (132,11)-(132,12) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (132,12)-(132,18)) │ │ │ ├── arguments: (length: 2) │ │ │ │ ├── @ SplatNode (location: (132,12)-(132,13)) │ │ │ │ │ ├── operator_loc: (132,12)-(132,13) = "*" │ │ │ │ │ └── expression: ∅ │ │ │ │ └── @ IntegerNode (location: (132,17)-(132,18)) │ │ │ │ └── flags: decimal │ │ │ └── flags: ∅ │ │ ├── closing_loc: (132,13)-(132,14) = "]" │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── locals: [:*] │ ├── locals_body_index: 1 │ ├── def_keyword_loc: (132,0)-(132,3) = "def" │ ├── operator_loc: ∅ │ ├── lparen_loc: (132,5)-(132,6) = "(" │ ├── rparen_loc: (132,7)-(132,8) = ")" │ ├── equal_loc: ∅ │ └── end_keyword_loc: (132,20)-(132,23) = "end" ├── @ DefNode (location: (134,0)-(134,26)) │ ├── name: :f │ ├── name_loc: (134,4)-(134,5) = "f" │ ├── receiver: ∅ │ ├── parameters: │ │ @ ParametersNode (location: (134,6)-(134,7)) │ │ ├── requireds: (length: 0) │ │ ├── optionals: (length: 0) │ │ ├── rest: │ │ │ @ RestParameterNode (location: (134,6)-(134,7)) │ │ │ ├── name: ∅ │ │ │ ├── name_loc: ∅ │ │ │ └── operator_loc: (134,6)-(134,7) = "*" │ │ ├── posts: (length: 0) │ │ ├── keywords: (length: 0) │ │ ├── keyword_rest: ∅ │ │ └── block: ∅ │ ├── body: │ │ @ StatementsNode (location: (134,10)-(134,21)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (134,10)-(134,21)) │ │ ├── receiver: │ │ │ @ CallNode (location: (134,10)-(134,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :a │ │ │ ├── message_loc: (134,10)-(134,11) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── name: :[]= │ │ ├── message_loc: (134,11)-(134,17) = "[1, *]" │ │ ├── opening_loc: (134,11)-(134,12) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (134,12)-(134,21)) │ │ │ ├── arguments: (length: 3) │ │ │ │ ├── @ IntegerNode (location: (134,12)-(134,13)) │ │ │ │ │ └── flags: decimal │ │ │ │ ├── @ SplatNode (location: (134,15)-(134,16)) │ │ │ │ │ ├── operator_loc: (134,15)-(134,16) = "*" │ │ │ │ │ └── expression: ∅ │ │ │ │ └── @ IntegerNode (location: (134,20)-(134,21)) │ │ │ │ └── flags: decimal │ │ │ └── flags: ∅ │ │ ├── closing_loc: (134,16)-(134,17) = "]" │ │ ├── block: ∅ │ │ └── flags: ∅ │ ├── locals: [:*] │ ├── locals_body_index: 1 │ ├── def_keyword_loc: (134,0)-(134,3) = "def" │ ├── operator_loc: ∅ │ ├── lparen_loc: (134,5)-(134,6) = "(" │ ├── rparen_loc: (134,7)-(134,8) = ")" │ ├── equal_loc: ∅ │ └── end_keyword_loc: (134,23)-(134,26) = "end" ├── @ DefNode (location: (136,0)-(136,24)) │ ├── name: :f │ ├── name_loc: (136,4)-(136,5) = "f" │ ├── receiver: ∅ │ ├── parameters: │ │ @ ParametersNode (location: (136,6)-(136,7)) │ │ ├── requireds: (length: 0) │ │ ├── optionals: (length: 0) │ │ ├── rest: │ │ │ @ RestParameterNode (location: (136,6)-(136,7)) │ │ │ ├── name: ∅ │ │ │ ├── name_loc: ∅ │ │ │ └── operator_loc: (136,6)-(136,7) = "*" │ │ ├── posts: (length: 0) │ │ ├── keywords: (length: 0) │ │ ├── keyword_rest: ∅ │ │ └── block: ∅ │ ├── body: │ │ @ StatementsNode (location: (136,10)-(136,19)) │ │ └── body: (length: 1) │ │ └── @ IndexOperatorWriteNode (location: (136,10)-(136,19)) │ │ ├── receiver: │ │ │ @ CallNode (location: (136,10)-(136,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :a │ │ │ ├── message_loc: (136,10)-(136,11) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── opening_loc: (136,11)-(136,12) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (136,12)-(136,13)) │ │ │ ├── arguments: (length: 1) │ │ │ │ └── @ SplatNode (location: (136,12)-(136,13)) │ │ │ │ ├── operator_loc: (136,12)-(136,13) = "*" │ │ │ │ └── expression: ∅ │ │ │ └── flags: ∅ │ │ ├── closing_loc: (136,13)-(136,14) = "]" │ │ ├── block: ∅ │ │ ├── flags: ∅ │ │ ├── operator: :+ │ │ ├── operator_loc: (136,15)-(136,17) = "+=" │ │ └── value: │ │ @ IntegerNode (location: (136,18)-(136,19)) │ │ └── flags: decimal │ ├── locals: [:*] │ ├── locals_body_index: 1 │ ├── def_keyword_loc: (136,0)-(136,3) = "def" │ ├── operator_loc: ∅ │ ├── lparen_loc: (136,5)-(136,6) = "(" │ ├── rparen_loc: (136,7)-(136,8) = ")" │ ├── equal_loc: ∅ │ └── end_keyword_loc: (136,21)-(136,24) = "end" ├── @ DefNode (location: (138,0)-(138,28)) │ ├── name: :f │ ├── name_loc: (138,4)-(138,5) = "f" │ ├── receiver: ∅ │ ├── parameters: │ │ @ ParametersNode (location: (138,6)-(138,7)) │ │ ├── requireds: (length: 0) │ │ ├── optionals: (length: 0) │ │ ├── rest: │ │ │ @ RestParameterNode (location: (138,6)-(138,7)) │ │ │ ├── name: ∅ │ │ │ ├── name_loc: ∅ │ │ │ └── operator_loc: (138,6)-(138,7) = "*" │ │ ├── posts: (length: 0) │ │ ├── keywords: (length: 0) │ │ ├── keyword_rest: ∅ │ │ └── block: ∅ │ ├── body: │ │ @ StatementsNode (location: (138,10)-(138,23)) │ │ └── body: (length: 1) │ │ └── @ IndexAndWriteNode (location: (138,10)-(138,23)) │ │ ├── receiver: │ │ │ @ CallNode (location: (138,10)-(138,11)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :a │ │ │ ├── message_loc: (138,10)-(138,11) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ └── flags: variable_call │ │ ├── call_operator_loc: ∅ │ │ ├── opening_loc: (138,11)-(138,12) = "[" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (138,12)-(138,16)) │ │ │ ├── arguments: (length: 2) │ │ │ │ ├── @ IntegerNode (location: (138,12)-(138,13)) │ │ │ │ │ └── flags: decimal │ │ │ │ └── @ SplatNode (location: (138,15)-(138,16)) │ │ │ │ ├── operator_loc: (138,15)-(138,16) = "*" │ │ │ │ └── expression: ∅ │ │ │ └── flags: ∅ │ │ ├── closing_loc: (138,16)-(138,17) = "]" │ │ ├── block: ∅ │ │ ├── flags: ∅ │ │ ├── operator_loc: (138,18)-(138,21) = "&&=" │ │ └── value: │ │ @ IntegerNode (location: (138,22)-(138,23)) │ │ └── flags: decimal │ ├── locals: [:*] │ ├── locals_body_index: 1 │ ├── def_keyword_loc: (138,0)-(138,3) = "def" │ ├── operator_loc: ∅ │ ├── lparen_loc: (138,5)-(138,6) = "(" │ ├── rparen_loc: (138,7)-(138,8) = ")" │ ├── equal_loc: ∅ │ └── end_keyword_loc: (138,25)-(138,28) = "end" ├── @ DefNode (location: (140,0)-(140,29)) │ ├── name: :f │ ├── name_loc: (140,4)-(140,5) = "f" │ ├── receiver: ∅ │ ├── parameters: │ │ @ ParametersNode (location: (140,6)-(140,7)) │ │ ├── requireds: (length: 0) │ │ ├── optionals: (length: 0) │ │ ├── rest: │ │ │ @ RestParameterNode (location: (140,6)-(140,7)) │ │ │ ├── name: ∅ │ │ │ ├── name_loc: ∅ │ │ │ └── operator_loc: (140,6)-(140,7) = "*" │ │ ├── posts: (length: 0) │ │ ├── keywords: (length: 0) │ │ ├── keyword_rest: ∅ │ │ └── block: ∅ │ ├── body: │ │ @ BeginNode (location: (140,10)-(140,29)) │ │ ├── begin_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── rescue_clause: │ │ │ @ RescueNode (location: (140,10)-(140,24)) │ │ │ ├── keyword_loc: (140,10)-(140,16) = "rescue" │ │ │ ├── exceptions: (length: 0) │ │ │ ├── operator_loc: (140,17)-(140,19) = "=>" │ │ │ ├── reference: │ │ │ │ @ CallNode (location: (140,20)-(140,24)) │ │ │ │ ├── receiver: │ │ │ │ │ @ CallNode (location: (140,20)-(140,21)) │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── name: :a │ │ │ │ │ ├── message_loc: (140,20)-(140,21) = "a" │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ ├── block: ∅ │ │ │ │ │ └── flags: variable_call │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :[]= │ │ │ │ ├── message_loc: (140,21)-(140,24) = "[*]" │ │ │ │ ├── opening_loc: (140,21)-(140,22) = "[" │ │ │ │ ├── arguments: │ │ │ │ │ @ ArgumentsNode (location: (140,22)-(140,23)) │ │ │ │ │ ├── arguments: (length: 1) │ │ │ │ │ │ └── @ SplatNode (location: (140,22)-(140,23)) │ │ │ │ │ │ ├── operator_loc: (140,22)-(140,23) = "*" │ │ │ │ │ │ └── expression: ∅ │ │ │ │ │ └── flags: ∅ │ │ │ │ ├── closing_loc: (140,23)-(140,24) = "]" │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: ∅ │ │ │ ├── statements: ∅ │ │ │ └── consequent: ∅ │ │ ├── else_clause: ∅ │ │ ├── ensure_clause: ∅ │ │ └── end_keyword_loc: (140,26)-(140,29) = "end" │ ├── locals: [:*] │ ├── locals_body_index: 1 │ ├── def_keyword_loc: (140,0)-(140,3) = "def" │ ├── operator_loc: ∅ │ ├── lparen_loc: (140,5)-(140,6) = "(" │ ├── rparen_loc: (140,7)-(140,8) = ")" │ ├── equal_loc: ∅ │ └── end_keyword_loc: (140,26)-(140,29) = "end" └── @ DefNode (location: (142,0)-(142,32)) ├── name: :f ├── name_loc: (142,4)-(142,5) = "f" ├── receiver: ∅ ├── parameters: │ @ ParametersNode (location: (142,6)-(142,7)) │ ├── requireds: (length: 0) │ ├── optionals: (length: 0) │ ├── rest: │ │ @ RestParameterNode (location: (142,6)-(142,7)) │ │ ├── name: ∅ │ │ ├── name_loc: ∅ │ │ └── operator_loc: (142,6)-(142,7) = "*" │ ├── posts: (length: 0) │ ├── keywords: (length: 0) │ ├── keyword_rest: ∅ │ └── block: ∅ ├── body: │ @ BeginNode (location: (142,10)-(142,32)) │ ├── begin_keyword_loc: ∅ │ ├── statements: ∅ │ ├── rescue_clause: │ │ @ RescueNode (location: (142,10)-(142,27)) │ │ ├── keyword_loc: (142,10)-(142,16) = "rescue" │ │ ├── exceptions: (length: 0) │ │ ├── operator_loc: (142,17)-(142,19) = "=>" │ │ ├── reference: │ │ │ @ CallNode (location: (142,20)-(142,27)) │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (142,20)-(142,21)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :a │ │ │ │ ├── message_loc: (142,20)-(142,21) = "a" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ └── flags: variable_call │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :[]= │ │ │ ├── message_loc: (142,21)-(142,27) = "[1, *]" │ │ │ ├── opening_loc: (142,21)-(142,22) = "[" │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (142,22)-(142,26)) │ │ │ │ ├── arguments: (length: 2) │ │ │ │ │ ├── @ IntegerNode (location: (142,22)-(142,23)) │ │ │ │ │ │ └── flags: decimal │ │ │ │ │ └── @ SplatNode (location: (142,25)-(142,26)) │ │ │ │ │ ├── operator_loc: (142,25)-(142,26) = "*" │ │ │ │ │ └── expression: ∅ │ │ │ │ └── flags: ∅ │ │ │ ├── closing_loc: (142,26)-(142,27) = "]" │ │ │ ├── block: ∅ │ │ │ └── flags: ∅ │ │ ├── statements: ∅ │ │ └── consequent: ∅ │ ├── else_clause: ∅ │ ├── ensure_clause: ∅ │ └── end_keyword_loc: (142,29)-(142,32) = "end" ├── locals: [:*] ├── locals_body_index: 1 ├── def_keyword_loc: (142,0)-(142,3) = "def" ├── operator_loc: ∅ ├── lparen_loc: (142,5)-(142,6) = "(" ├── rparen_loc: (142,7)-(142,8) = ")" ├── equal_loc: ∅ └── end_keyword_loc: (142,29)-(142,32) = "end"