diff options
Diffstat (limited to 'test/prism/snapshots/command_method_call.txt')
| -rw-r--r-- | test/prism/snapshots/command_method_call.txt | 755 |
1 files changed, 755 insertions, 0 deletions
diff --git a/test/prism/snapshots/command_method_call.txt b/test/prism/snapshots/command_method_call.txt new file mode 100644 index 0000000000..7fd6341304 --- /dev/null +++ b/test/prism/snapshots/command_method_call.txt @@ -0,0 +1,755 @@ +@ ProgramNode (location: (1,0)-(41,10)) +├── locals: [:foo, :bar] +└── statements: + @ StatementsNode (location: (1,0)-(41,10)) + └── body: (length: 21) + ├── @ CallNode (location: (1,0)-(1,5)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (1,0)-(1,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (1,4)-(1,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (1,4)-(1,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (3,0)-(3,9)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (3,0)-(3,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (3,4)-(3,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (3,4)-(3,9)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (3,4)-(3,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (3,8)-(3,9)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (3,8)-(3,9)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ IfNode (location: (5,0)-(5,14)) + │ ├── if_keyword_loc: (5,6)-(5,8) = "if" + │ ├── predicate: + │ │ @ CallNode (location: (5,9)-(5,14)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (5,9)-(5,12) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (5,13)-(5,14)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (5,13)-(5,14)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (5,0)-(5,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (5,0)-(5,5)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (5,0)-(5,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (5,4)-(5,5)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (5,4)-(5,5)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: ∅ + ├── @ UnlessNode (location: (7,0)-(7,18)) + │ ├── keyword_loc: (7,6)-(7,12) = "unless" + │ ├── predicate: + │ │ @ CallNode (location: (7,13)-(7,18)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (7,13)-(7,16) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (7,17)-(7,18)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (7,17)-(7,18)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (7,0)-(7,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (7,0)-(7,5)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (7,0)-(7,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (7,4)-(7,5)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (7,4)-(7,5)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: ∅ + ├── @ WhileNode (location: (9,0)-(9,17)) + │ ├── flags: ∅ + │ ├── keyword_loc: (9,6)-(9,11) = "while" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ CallNode (location: (9,12)-(9,17)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (9,12)-(9,15) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (9,16)-(9,17)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (9,16)-(9,17)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── statements: + │ @ StatementsNode (location: (9,0)-(9,5)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (9,0)-(9,5)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (9,0)-(9,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (9,4)-(9,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (9,4)-(9,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ UntilNode (location: (11,0)-(11,17)) + │ ├── flags: ∅ + │ ├── keyword_loc: (11,6)-(11,11) = "until" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ CallNode (location: (11,12)-(11,17)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (11,12)-(11,15) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (11,16)-(11,17)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (11,16)-(11,17)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── statements: + │ @ StatementsNode (location: (11,0)-(11,5)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (11,0)-(11,5)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (11,0)-(11,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (11,4)-(11,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (11,4)-(11,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ RescueModifierNode (location: (13,0)-(13,18)) + │ ├── expression: + │ │ @ CallNode (location: (13,0)-(13,5)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (13,0)-(13,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (13,4)-(13,5)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (13,4)-(13,5)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── keyword_loc: (13,6)-(13,12) = "rescue" + │ └── rescue_expression: + │ @ CallNode (location: (13,13)-(13,18)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :bar + │ ├── message_loc: (13,13)-(13,16) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (13,17)-(13,18)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (13,17)-(13,18)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (15,0)-(15,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (15,0)-(15,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (15,0)-(15,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (15,3)-(15,10) = "[bar 1]" + │ ├── opening_loc: (15,3)-(15,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (15,4)-(15,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (15,4)-(15,9)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (15,4)-(15,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (15,8)-(15,9)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (15,8)-(15,9)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (15,9)-(15,10) = "]" + │ └── block: ∅ + ├── @ AndNode (location: (17,0)-(17,15)) + │ ├── left: + │ │ @ CallNode (location: (17,0)-(17,5)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (17,0)-(17,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (17,4)-(17,5)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (17,4)-(17,5)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── right: + │ │ @ CallNode (location: (17,10)-(17,15)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (17,10)-(17,13) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (17,14)-(17,15)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (17,14)-(17,15)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (17,6)-(17,9) = "and" + ├── @ OrNode (location: (19,0)-(19,14)) + │ ├── left: + │ │ @ CallNode (location: (19,0)-(19,5)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (19,0)-(19,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (19,4)-(19,5)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (19,4)-(19,5)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── right: + │ │ @ CallNode (location: (19,9)-(19,14)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (19,9)-(19,12) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (19,13)-(19,14)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (19,13)-(19,14)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (19,6)-(19,8) = "or" + ├── @ CallNode (location: (21,0)-(21,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (21,4)-(21,9)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (21,4)-(21,7) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (21,8)-(21,9)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (21,8)-(21,9)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :! + │ ├── message_loc: (21,0)-(21,3) = "not" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ LocalVariableWriteNode (location: (23,0)-(23,17)) + │ ├── name: :foo + │ ├── depth: 0 + │ ├── name_loc: (23,0)-(23,3) = "foo" + │ ├── value: + │ │ @ LocalVariableWriteNode (location: (23,6)-(23,17)) + │ │ ├── name: :bar + │ │ ├── depth: 0 + │ │ ├── name_loc: (23,6)-(23,9) = "bar" + │ │ ├── value: + │ │ │ @ CallNode (location: (23,12)-(23,17)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (23,12)-(23,15) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (23,16)-(23,17)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (23,16)-(23,17)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (23,10)-(23,11) = "=" + │ └── operator_loc: (23,4)-(23,5) = "=" + ├── @ DefNode (location: (25,0)-(25,15)) + │ ├── name: :foo + │ ├── name_loc: (25,4)-(25,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (25,10)-(25,15)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (25,10)-(25,15)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (25,10)-(25,13) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (25,14)-(25,15)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (25,14)-(25,15)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (25,0)-(25,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: (25,8)-(25,9) = "=" + │ └── end_keyword_loc: ∅ + ├── @ CallNode (location: (27,0)-(27,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ IntegerNode (location: (27,0)-(27,1)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── call_operator_loc: (27,1)-(27,2) = "." + │ ├── name: :foo + │ ├── message_loc: (27,2)-(27,5) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (27,6)-(27,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (27,6)-(27,7)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (29,0)-(29,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (29,0)-(29,5)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ IntegerNode (location: (29,0)-(29,1)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── call_operator_loc: (29,1)-(29,2) = "." + │ │ ├── name: :foo + │ │ ├── message_loc: (29,2)-(29,5) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (29,5)-(29,6) = "." + │ ├── name: :bar + │ ├── message_loc: (29,6)-(29,9) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (29,10)-(29,11)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (29,10)-(29,11)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (31,0)-(31,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (31,0)-(31,8)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (31,0)-(31,5)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ IntegerNode (location: (31,0)-(31,1)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── call_operator_loc: (31,1)-(31,2) = "." + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (31,2)-(31,5) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :[] + │ │ ├── message_loc: (31,5)-(31,8) = "[2]" + │ │ ├── opening_loc: (31,5)-(31,6) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (31,6)-(31,7)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (31,6)-(31,7)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── closing_loc: (31,7)-(31,8) = "]" + │ │ └── block: ∅ + │ ├── call_operator_loc: (31,8)-(31,9) = "." + │ ├── name: :bar + │ ├── message_loc: (31,9)-(31,12) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (31,13)-(31,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (31,13)-(31,14)) + │ │ ├── flags: decimal + │ │ └── value: 3 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (33,0)-(33,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (33,0)-(33,8)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ IntegerNode (location: (33,0)-(33,1)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── call_operator_loc: (33,1)-(33,2) = "." + │ │ ├── name: :foo + │ │ ├── message_loc: (33,2)-(33,5) = "foo" + │ │ ├── opening_loc: (33,5)-(33,6) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (33,6)-(33,7)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (33,6)-(33,7)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── closing_loc: (33,7)-(33,8) = ")" + │ │ └── block: ∅ + │ ├── call_operator_loc: (33,8)-(33,9) = "." + │ ├── name: :bar + │ ├── message_loc: (33,9)-(33,12) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (33,13)-(33,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (33,13)-(33,14)) + │ │ ├── flags: decimal + │ │ └── value: 3 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (35,0)-(35,15)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (35,0)-(35,9)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ IntegerNode (location: (35,0)-(35,1)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── call_operator_loc: (35,1)-(35,2) = "." + │ │ ├── name: :foo + │ │ ├── message_loc: (35,2)-(35,5) = "foo" + │ │ ├── opening_loc: (35,5)-(35,6) = "(" + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: (35,8)-(35,9) = ")" + │ │ └── block: + │ │ @ BlockArgumentNode (location: (35,6)-(35,8)) + │ │ ├── expression: + │ │ │ @ IntegerNode (location: (35,7)-(35,8)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── operator_loc: (35,6)-(35,7) = "&" + │ ├── call_operator_loc: (35,9)-(35,10) = "." + │ ├── name: :bar + │ ├── message_loc: (35,10)-(35,13) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (35,14)-(35,15)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (35,14)-(35,15)) + │ │ ├── flags: decimal + │ │ └── value: 3 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ AndNode (location: (37,0)-(37,17)) + │ ├── left: + │ │ @ CallNode (location: (37,0)-(37,6)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (37,1)-(37,6)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (37,1)-(37,4) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (37,5)-(37,6)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (37,5)-(37,6)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :! + │ │ ├── message_loc: (37,0)-(37,1) = "!" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── right: + │ │ @ CallNode (location: (37,11)-(37,17)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (37,12)-(37,17)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (37,12)-(37,15) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (37,16)-(37,17)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (37,16)-(37,17)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :! + │ │ ├── message_loc: (37,11)-(37,12) = "!" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (37,7)-(37,10) = "and" + ├── @ OrNode (location: (39,0)-(39,16)) + │ ├── left: + │ │ @ CallNode (location: (39,0)-(39,6)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (39,1)-(39,6)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (39,1)-(39,4) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (39,5)-(39,6)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (39,5)-(39,6)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :! + │ │ ├── message_loc: (39,0)-(39,1) = "!" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── right: + │ │ @ CallNode (location: (39,10)-(39,16)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (39,11)-(39,16)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (39,11)-(39,14) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (39,15)-(39,16)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (39,15)-(39,16)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :! + │ │ ├── message_loc: (39,10)-(39,11) = "!" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (39,7)-(39,9) = "or" + └── @ CallNode (location: (41,0)-(41,10)) + ├── flags: ∅ + ├── receiver: + │ @ CallNode (location: (41,4)-(41,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (41,5)-(41,10)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (41,5)-(41,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (41,9)-(41,10)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (41,9)-(41,10)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :! + │ ├── message_loc: (41,4)-(41,5) = "!" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── call_operator_loc: ∅ + ├── name: :! + ├── message_loc: (41,0)-(41,3) = "not" + ├── opening_loc: ∅ + ├── arguments: ∅ + ├── closing_loc: ∅ + └── block: ∅ |