@ ProgramNode (location: (1,0)-(84,7)) ├── locals: [] └── statements: @ StatementsNode (location: (1,0)-(84,7)) └── body: (length: 62) ├── @ ModuleNode (location: (1,0)-(3,3)) │ ├── locals: [:foo, :a, :_] │ ├── module_keyword_loc: (1,0)-(1,6) = "module" │ ├── constant_path: │ │ @ ConstantReadNode (location: (1,7)-(1,8)) │ │ └── name: :A │ ├── body: │ │ @ StatementsNode (location: (2,2)-(2,22)) │ │ └── body: (length: 1) │ │ └── @ LocalVariableOrWriteNode (location: (2,2)-(2,22)) │ │ ├── name_loc: (2,2)-(2,5) = "foo" │ │ ├── operator_loc: (2,6)-(2,9) = "||=" │ │ ├── value: │ │ │ @ ParenthesesNode (location: (2,10)-(2,22)) │ │ │ ├── body: │ │ │ │ @ StatementsNode (location: (2,11)-(2,21)) │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ MultiWriteNode (location: (2,11)-(2,21)) │ │ │ │ ├── lefts: (length: 2) │ │ │ │ │ ├── @ LocalVariableTargetNode (location: (2,12)-(2,13)) │ │ │ │ │ │ ├── name: :a │ │ │ │ │ │ └── depth: 0 │ │ │ │ │ └── @ LocalVariableTargetNode (location: (2,15)-(2,16)) │ │ │ │ │ ├── name: :_ │ │ │ │ │ └── depth: 0 │ │ │ │ ├── rest: ∅ │ │ │ │ ├── rights: (length: 0) │ │ │ │ ├── lparen_loc: (2,11)-(2,12) = "(" │ │ │ │ ├── rparen_loc: (2,16)-(2,17) = ")" │ │ │ │ ├── operator_loc: (2,18)-(2,19) = "=" │ │ │ │ └── value: │ │ │ │ @ CallNode (location: (2,20)-(2,21)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :b │ │ │ │ ├── message_loc: (2,20)-(2,21) = "b" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── opening_loc: (2,10)-(2,11) = "(" │ │ │ └── closing_loc: (2,21)-(2,22) = ")" │ │ ├── name: :foo │ │ └── depth: 0 │ ├── end_keyword_loc: (3,0)-(3,3) = "end" │ └── name: :A ├── @ ModuleNode (location: (5,0)-(8,3)) │ ├── locals: [:local] │ ├── module_keyword_loc: (5,0)-(5,6) = "module" │ ├── constant_path: │ │ @ ConstantReadNode (location: (5,7)-(5,8)) │ │ └── name: :A │ ├── body: │ │ @ StatementsNode (location: (6,2)-(7,11)) │ │ └── body: (length: 2) │ │ ├── @ LocalVariableWriteNode (location: (6,2)-(6,11)) │ │ │ ├── name: :local │ │ │ ├── depth: 0 │ │ │ ├── name_loc: (6,2)-(6,7) = "local" │ │ │ ├── value: │ │ │ │ @ IntegerNode (location: (6,10)-(6,11)) │ │ │ │ ├── flags: decimal │ │ │ │ └── value: 1 │ │ │ └── operator_loc: (6,8)-(6,9) = "=" │ │ └── @ CallNode (location: (7,2)-(7,11)) │ │ ├── flags: ∅ │ │ ├── receiver: │ │ │ @ LocalVariableReadNode (location: (7,2)-(7,7)) │ │ │ ├── name: :local │ │ │ └── depth: 0 │ │ ├── call_operator_loc: (7,7)-(7,8) = "." │ │ ├── name: :bar │ │ ├── message_loc: (7,8)-(7,11) = "bar" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── end_keyword_loc: (8,0)-(8,3) = "end" │ └── name: :A ├── @ CallNode (location: (9,0)-(10,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ClassNode (location: (9,0)-(10,3)) │ │ ├── locals: [] │ │ ├── class_keyword_loc: (9,0)-(9,5) = "class" │ │ ├── constant_path: │ │ │ @ ConstantReadNode (location: (9,6)-(9,7)) │ │ │ └── name: :A │ │ ├── inheritance_operator_loc: ∅ │ │ ├── superclass: ∅ │ │ ├── body: ∅ │ │ ├── end_keyword_loc: (10,0)-(10,3) = "end" │ │ └── name: :A │ ├── call_operator_loc: (10,3)-(10,4) = "." │ ├── name: :bar │ ├── message_loc: (10,4)-(10,7) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (11,0)-(12,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ModuleNode (location: (11,0)-(12,3)) │ │ ├── locals: [] │ │ ├── module_keyword_loc: (11,0)-(11,6) = "module" │ │ ├── constant_path: │ │ │ @ ConstantReadNode (location: (11,7)-(11,8)) │ │ │ └── name: :A │ │ ├── body: ∅ │ │ ├── end_keyword_loc: (12,0)-(12,3) = "end" │ │ └── name: :A │ ├── call_operator_loc: (12,3)-(12,4) = "." │ ├── name: :bar │ ├── message_loc: (12,4)-(12,7) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (13,0)-(15,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ BeginNode (location: (13,0)-(15,3)) │ │ ├── begin_keyword_loc: (13,0)-(13,5) = "begin" │ │ ├── statements: ∅ │ │ ├── rescue_clause: │ │ │ @ RescueNode (location: (14,0)-(14,6)) │ │ │ ├── keyword_loc: (14,0)-(14,6) = "rescue" │ │ │ ├── exceptions: (length: 0) │ │ │ ├── operator_loc: ∅ │ │ │ ├── reference: ∅ │ │ │ ├── statements: ∅ │ │ │ └── consequent: ∅ │ │ ├── else_clause: ∅ │ │ ├── ensure_clause: ∅ │ │ └── end_keyword_loc: (15,0)-(15,3) = "end" │ ├── call_operator_loc: (15,3)-(15,4) = "." │ ├── name: :bar │ ├── message_loc: (15,4)-(15,7) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (16,0)-(19,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CaseNode (location: (16,0)-(19,3)) │ │ ├── predicate: │ │ │ @ ParenthesesNode (location: (16,5)-(17,10)) │ │ │ ├── body: │ │ │ │ @ StatementsNode (location: (16,6)-(17,9)) │ │ │ │ └── body: (length: 2) │ │ │ │ ├── @ DefNode (location: (16,6)-(17,3)) │ │ │ │ │ ├── name: :foo │ │ │ │ │ ├── name_loc: (16,10)-(16,13) = "foo" │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── parameters: ∅ │ │ │ │ │ ├── body: ∅ │ │ │ │ │ ├── locals: [] │ │ │ │ │ ├── def_keyword_loc: (16,6)-(16,9) = "def" │ │ │ │ │ ├── operator_loc: ∅ │ │ │ │ │ ├── lparen_loc: ∅ │ │ │ │ │ ├── rparen_loc: ∅ │ │ │ │ │ ├── equal_loc: ∅ │ │ │ │ │ └── end_keyword_loc: (17,0)-(17,3) = "end" │ │ │ │ └── @ SymbolNode (location: (17,5)-(17,9)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: (17,5)-(17,6) = ":" │ │ │ │ ├── value_loc: (17,6)-(17,9) = "bar" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "bar" │ │ │ ├── opening_loc: (16,5)-(16,6) = "(" │ │ │ └── closing_loc: (17,9)-(17,10) = ")" │ │ ├── conditions: (length: 1) │ │ │ └── @ WhenNode (location: (18,0)-(18,8)) │ │ │ ├── keyword_loc: (18,0)-(18,4) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ CallNode (location: (18,5)-(18,8)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (18,5)-(18,8) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── then_keyword_loc: ∅ │ │ │ └── statements: ∅ │ │ ├── consequent: ∅ │ │ ├── case_keyword_loc: (16,0)-(16,4) = "case" │ │ └── end_keyword_loc: (19,0)-(19,3) = "end" │ ├── call_operator_loc: (19,3)-(19,4) = "." │ ├── name: :baz │ ├── message_loc: (19,4)-(19,7) = "baz" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (20,0)-(22,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CaseNode (location: (20,0)-(22,3)) │ │ ├── predicate: │ │ │ @ CallNode (location: (20,5)-(20,8)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (20,5)-(20,8) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── conditions: (length: 1) │ │ │ └── @ WhenNode (location: (21,0)-(21,8)) │ │ │ ├── keyword_loc: (21,0)-(21,4) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ CallNode (location: (21,5)-(21,8)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (21,5)-(21,8) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── then_keyword_loc: ∅ │ │ │ └── statements: ∅ │ │ ├── consequent: ∅ │ │ ├── case_keyword_loc: (20,0)-(20,4) = "case" │ │ └── end_keyword_loc: (22,0)-(22,3) = "end" │ ├── call_operator_loc: (22,3)-(22,4) = "." │ ├── name: :baz │ ├── message_loc: (22,4)-(22,7) = "baz" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (23,0)-(24,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ SingletonClassNode (location: (23,0)-(24,3)) │ │ ├── locals: [] │ │ ├── class_keyword_loc: (23,0)-(23,5) = "class" │ │ ├── operator_loc: (23,6)-(23,8) = "<<" │ │ ├── expression: │ │ │ @ SelfNode (location: (23,9)-(23,13)) │ │ ├── body: ∅ │ │ └── end_keyword_loc: (24,0)-(24,3) = "end" │ ├── call_operator_loc: (24,3)-(24,4) = "." │ ├── name: :bar │ ├── message_loc: (24,4)-(24,7) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (25,0)-(26,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ DefNode (location: (25,0)-(26,3)) │ │ ├── name: :foo │ │ ├── name_loc: (25,9)-(25,12) = "foo" │ │ ├── receiver: │ │ │ @ SelfNode (location: (25,4)-(25,8)) │ │ ├── parameters: ∅ │ │ ├── body: ∅ │ │ ├── locals: [] │ │ ├── def_keyword_loc: (25,0)-(25,3) = "def" │ │ ├── operator_loc: (25,8)-(25,9) = "." │ │ ├── lparen_loc: ∅ │ │ ├── rparen_loc: ∅ │ │ ├── equal_loc: ∅ │ │ └── end_keyword_loc: (26,0)-(26,3) = "end" │ ├── call_operator_loc: (26,3)-(26,4) = "." │ ├── name: :bar │ ├── message_loc: (26,4)-(26,7) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (27,0)-(28,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ DefNode (location: (27,0)-(28,3)) │ │ ├── name: :foo │ │ ├── name_loc: (27,4)-(27,7) = "foo" │ │ ├── receiver: ∅ │ │ ├── parameters: ∅ │ │ ├── body: ∅ │ │ ├── locals: [] │ │ ├── def_keyword_loc: (27,0)-(27,3) = "def" │ │ ├── operator_loc: ∅ │ │ ├── lparen_loc: ∅ │ │ ├── rparen_loc: ∅ │ │ ├── equal_loc: ∅ │ │ └── end_keyword_loc: (28,0)-(28,3) = "end" │ ├── call_operator_loc: (28,3)-(28,4) = "." │ ├── name: :bar │ ├── message_loc: (28,4)-(28,7) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (29,0)-(30,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ UntilNode (location: (29,0)-(30,3)) │ │ ├── flags: ∅ │ │ ├── keyword_loc: (29,0)-(29,5) = "until" │ │ ├── closing_loc: (30,0)-(30,3) = "end" │ │ ├── predicate: │ │ │ @ CallNode (location: (29,6)-(29,9)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (29,6)-(29,9) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── statements: ∅ │ ├── call_operator_loc: (30,3)-(30,4) = "." │ ├── name: :bar │ ├── message_loc: (30,4)-(30,7) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (31,0)-(32,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ WhileNode (location: (31,0)-(32,3)) │ │ ├── flags: ∅ │ │ ├── keyword_loc: (31,0)-(31,5) = "while" │ │ ├── closing_loc: (32,0)-(32,3) = "end" │ │ ├── predicate: │ │ │ @ CallNode (location: (31,6)-(31,9)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (31,6)-(31,9) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── statements: ∅ │ ├── call_operator_loc: (32,3)-(32,4) = "." │ ├── name: :bar │ ├── message_loc: (32,4)-(32,7) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (33,0)-(34,5)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (33,0)-(34,1)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :loop │ │ ├── message_loc: (33,0)-(33,4) = "loop" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: │ │ @ BlockNode (location: (33,5)-(34,1)) │ │ ├── locals: [] │ │ ├── parameters: ∅ │ │ ├── body: ∅ │ │ ├── opening_loc: (33,5)-(33,6) = "{" │ │ └── closing_loc: (34,0)-(34,1) = "}" │ ├── call_operator_loc: (34,1)-(34,2) = "." │ ├── name: :bar │ ├── message_loc: (34,2)-(34,5) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (35,0)-(36,7)) │ ├── flags: ∅ │ ├── receiver: │ │ @ IfNode (location: (35,0)-(36,3)) │ │ ├── if_keyword_loc: (35,0)-(35,2) = "if" │ │ ├── predicate: │ │ │ @ CallNode (location: (35,3)-(35,6)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (35,3)-(35,6) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── then_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── consequent: ∅ │ │ └── end_keyword_loc: (36,0)-(36,3) = "end" │ ├── call_operator_loc: (36,3)-(36,4) = "." │ ├── name: :baz │ ├── message_loc: (36,4)-(36,7) = "baz" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (37,0)-(37,19)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ParenthesesNode (location: (37,0)-(37,15)) │ │ ├── body: │ │ │ @ StatementsNode (location: (37,1)-(37,14)) │ │ │ └── body: (length: 1) │ │ │ └── @ CallNode (location: (37,1)-(37,14)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: │ │ │ │ @ RegularExpressionNode (location: (37,1)-(37,6)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: (37,1)-(37,2) = "/" │ │ │ │ ├── content_loc: (37,2)-(37,5) = "bar" │ │ │ │ ├── closing_loc: (37,5)-(37,6) = "/" │ │ │ │ └── unescaped: "bar" │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :=~ │ │ │ ├── message_loc: (37,7)-(37,9) = "=~" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (37,10)-(37,14)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ SymbolNode (location: (37,10)-(37,14)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: (37,10)-(37,11) = ":" │ │ │ │ ├── value_loc: (37,11)-(37,14) = "foo" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "foo" │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── opening_loc: (37,0)-(37,1) = "(" │ │ └── closing_loc: (37,14)-(37,15) = ")" │ ├── call_operator_loc: (37,15)-(37,16) = "." │ ├── name: :foo │ ├── message_loc: (37,16)-(37,19) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (38,0)-(38,10)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ParenthesesNode (location: (38,0)-(38,6)) │ │ ├── body: │ │ │ @ StatementsNode (location: (38,1)-(38,5)) │ │ │ └── body: (length: 1) │ │ │ └── @ RangeNode (location: (38,1)-(38,5)) │ │ │ ├── flags: ∅ │ │ │ ├── left: │ │ │ │ @ IntegerNode (location: (38,1)-(38,2)) │ │ │ │ ├── flags: decimal │ │ │ │ └── value: 1 │ │ │ ├── right: │ │ │ │ @ IntegerNode (location: (38,4)-(38,5)) │ │ │ │ ├── flags: decimal │ │ │ │ └── value: 2 │ │ │ └── operator_loc: (38,2)-(38,4) = ".." │ │ ├── opening_loc: (38,0)-(38,1) = "(" │ │ └── closing_loc: (38,5)-(38,6) = ")" │ ├── call_operator_loc: (38,6)-(38,7) = "." │ ├── name: :max │ ├── message_loc: (38,7)-(38,10) = "max" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (39,0)-(39,18)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ParenthesesNode (location: (39,0)-(39,14)) │ │ ├── body: │ │ │ @ StatementsNode (location: (39,1)-(39,13)) │ │ │ └── body: (length: 1) │ │ │ └── @ CallNode (location: (39,1)-(39,13)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (39,1)-(39,4)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :foo │ │ │ │ ├── message_loc: (39,1)-(39,4) = "foo" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :=~ │ │ │ ├── message_loc: (39,5)-(39,7) = "=~" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (39,8)-(39,13)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ RegularExpressionNode (location: (39,8)-(39,13)) │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ ├── opening_loc: (39,8)-(39,9) = "/" │ │ │ │ ├── content_loc: (39,9)-(39,12) = "bar" │ │ │ │ ├── closing_loc: (39,12)-(39,13) = "/" │ │ │ │ └── unescaped: "bar" │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── opening_loc: (39,0)-(39,1) = "(" │ │ └── closing_loc: (39,13)-(39,14) = ")" │ ├── call_operator_loc: (39,14)-(39,15) = "." │ ├── name: :foo │ ├── message_loc: (39,15)-(39,18) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (40,0)-(40,13)) │ ├── flags: ∅ │ ├── receiver: │ │ @ RegularExpressionNode (location: (40,0)-(40,5)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (40,0)-(40,1) = "/" │ │ ├── content_loc: (40,1)-(40,4) = "bar" │ │ ├── closing_loc: (40,4)-(40,5) = "/" │ │ └── unescaped: "bar" │ ├── call_operator_loc: ∅ │ ├── name: :=~ │ ├── message_loc: (40,6)-(40,8) = "=~" │ ├── opening_loc: ∅ │ ├── arguments: │ │ @ ArgumentsNode (location: (40,9)-(40,13)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ SymbolNode (location: (40,9)-(40,13)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (40,9)-(40,10) = ":" │ │ ├── value_loc: (40,10)-(40,13) = "foo" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "foo" │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (41,0)-(41,12)) │ ├── flags: ∅ │ ├── receiver: │ │ @ RegularExpressionNode (location: (41,0)-(41,5)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (41,0)-(41,1) = "/" │ │ ├── content_loc: (41,1)-(41,4) = "bar" │ │ ├── closing_loc: (41,4)-(41,5) = "/" │ │ └── unescaped: "bar" │ ├── call_operator_loc: ∅ │ ├── name: :=~ │ ├── message_loc: (41,6)-(41,8) = "=~" │ ├── opening_loc: ∅ │ ├── arguments: │ │ @ ArgumentsNode (location: (41,9)-(41,12)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ CallNode (location: (41,9)-(41,12)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (41,9)-(41,12) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ RangeNode (location: (42,0)-(42,8)) │ ├── flags: ∅ │ ├── left: │ │ @ IntegerNode (location: (42,0)-(42,1)) │ │ ├── flags: decimal │ │ └── value: 1 │ ├── right: │ │ @ CallNode (location: (42,3)-(42,8)) │ │ ├── flags: ∅ │ │ ├── receiver: │ │ │ @ IntegerNode (location: (42,3)-(42,4)) │ │ │ ├── flags: decimal │ │ │ └── value: 2 │ │ ├── call_operator_loc: (42,4)-(42,5) = "." │ │ ├── name: :max │ │ ├── message_loc: (42,5)-(42,8) = "max" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ └── operator_loc: (42,1)-(42,3) = ".." ├── @ CallNode (location: (43,0)-(43,5)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ConstantReadNode (location: (43,0)-(43,1)) │ │ └── name: :A │ ├── call_operator_loc: (43,1)-(43,2) = "." │ ├── name: :foo │ ├── message_loc: (43,2)-(43,5) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (44,0)-(44,5)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :FOO │ ├── message_loc: (44,0)-(44,3) = "FOO" │ ├── opening_loc: (44,3)-(44,4) = "(" │ ├── arguments: ∅ │ ├── closing_loc: (44,4)-(44,5) = ")" │ └── block: ∅ ├── @ CallNode (location: (45,0)-(45,4)) │ ├── flags: safe_navigation │ ├── receiver: │ │ @ CallNode (location: (45,0)-(45,1)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :a │ │ ├── message_loc: (45,0)-(45,1) = "a" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (45,1)-(45,3) = "&." │ ├── name: :b │ ├── message_loc: (45,3)-(45,4) = "b" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (46,0)-(46,5)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (46,0)-(46,1)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :a │ │ ├── message_loc: (46,0)-(46,1) = "a" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (46,1)-(46,2) = "." │ ├── name: :foo │ ├── message_loc: (46,2)-(46,5) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ 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: ∅ ├── @ CallNode (location: (48,0)-(48,18)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (48,0)-(48,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (48,0)-(48,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :<< │ ├── message_loc: (48,4)-(48,6) = "<<" │ ├── opening_loc: ∅ │ ├── arguments: │ │ @ ArgumentsNode (location: (48,7)-(48,18)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ ParenthesesNode (location: (48,7)-(48,18)) │ │ ├── body: │ │ │ @ StatementsNode (location: (48,8)-(48,17)) │ │ │ └── body: (length: 1) │ │ │ └── @ CallNode (location: (48,8)-(48,17)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (48,8)-(48,11)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (48,8)-(48,11) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :* │ │ │ ├── message_loc: (48,12)-(48,13) = "*" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (48,14)-(48,17)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ CallNode (location: (48,14)-(48,17)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :baz │ │ │ │ ├── message_loc: (48,14)-(48,17) = "baz" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── opening_loc: (48,7)-(48,8) = "(" │ │ └── closing_loc: (48,17)-(48,18) = ")" │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (49,0)-(49,12)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (49,0)-(49,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (49,0)-(49,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :=~ │ ├── message_loc: (49,4)-(49,6) = "=~" │ ├── opening_loc: ∅ │ ├── arguments: │ │ @ ArgumentsNode (location: (49,7)-(49,12)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ RegularExpressionNode (location: (49,7)-(49,12)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (49,7)-(49,8) = "/" │ │ ├── content_loc: (49,8)-(49,11) = "bar" │ │ ├── closing_loc: (49,11)-(49,12) = "/" │ │ └── unescaped: "bar" │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (50,0)-(50,17)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (50,0)-(50,3) = "foo" │ ├── opening_loc: (50,3)-(50,4) = "(" │ ├── arguments: ∅ │ ├── closing_loc: (50,17)-(50,18) = ")" │ └── block: │ @ BlockArgumentNode (location: (50,4)-(50,17)) │ ├── expression: │ │ @ ParenthesesNode (location: (50,5)-(50,17)) │ │ ├── body: │ │ │ @ StatementsNode (location: (50,6)-(50,16)) │ │ │ └── body: (length: 1) │ │ │ └── @ OrNode (location: (50,6)-(50,16)) │ │ │ ├── left: │ │ │ │ @ CallNode (location: (50,6)-(50,9)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :foo │ │ │ │ ├── message_loc: (50,6)-(50,9) = "foo" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── right: │ │ │ │ @ CallNode (location: (50,13)-(50,16)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar │ │ │ │ ├── message_loc: (50,13)-(50,16) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ └── operator_loc: (50,10)-(50,12) = "||" │ │ ├── opening_loc: (50,5)-(50,6) = "(" │ │ └── closing_loc: (50,16)-(50,17) = ")" │ └── operator_loc: (50,4)-(50,5) = "&" ├── @ CallNode (location: (51,0)-(51,10)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (51,0)-(51,3) = "foo" │ ├── opening_loc: (51,3)-(51,4) = "(" │ ├── arguments: ∅ │ ├── closing_loc: (51,10)-(51,11) = ")" │ └── block: │ @ BlockArgumentNode (location: (51,4)-(51,10)) │ ├── expression: │ │ @ CallNode (location: (51,5)-(51,10)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :block │ │ ├── message_loc: (51,5)-(51,10) = "block" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ └── operator_loc: (51,4)-(51,5) = "&" ├── @ CallNode (location: (52,0)-(52,17)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (52,0)-(52,3) = "foo" │ ├── opening_loc: (52,3)-(52,4) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (52,4)-(52,9)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ SplatNode (location: (52,4)-(52,9)) │ │ ├── operator_loc: (52,4)-(52,5) = "*" │ │ └── expression: │ │ @ CallNode (location: (52,5)-(52,9)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :args │ │ ├── message_loc: (52,5)-(52,9) = "args" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (52,17)-(52,18) = ")" │ └── block: │ @ BlockArgumentNode (location: (52,11)-(52,17)) │ ├── expression: │ │ @ CallNode (location: (52,12)-(52,17)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :block │ │ ├── message_loc: (52,12)-(52,17) = "block" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ └── operator_loc: (52,11)-(52,12) = "&" ├── @ CallNode (location: (53,0)-(53,15)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (53,0)-(53,3) = "foo" │ ├── opening_loc: (53,3)-(53,4) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (53,4)-(53,14)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ SplatNode (location: (53,4)-(53,14)) │ │ ├── operator_loc: (53,4)-(53,5) = "*" │ │ └── expression: │ │ @ CallNode (location: (53,5)-(53,14)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :arguments │ │ ├── message_loc: (53,5)-(53,14) = "arguments" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (53,14)-(53,15) = ")" │ └── block: ∅ ├── @ CallNode (location: (54,0)-(54,9)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (54,0)-(54,3) = "foo" │ ├── opening_loc: (54,3)-(54,4) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (54,4)-(54,8)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) │ │ ├── @ IntegerNode (location: (54,4)-(54,5)) │ │ │ ├── flags: decimal │ │ │ └── value: 1 │ │ └── @ IntegerNode (location: (54,7)-(54,8)) │ │ ├── flags: decimal │ │ └── value: 2 │ ├── closing_loc: (54,8)-(54,9) = ")" │ └── block: ∅ ├── @ CallNode (location: (55,0)-(55,8)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (55,0)-(55,3) = "foo" │ ├── opening_loc: (55,3)-(55,4) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (55,4)-(55,7)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ CallNode (location: (55,4)-(55,7)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :bar │ │ ├── message_loc: (55,4)-(55,7) = "bar" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (55,7)-(55,8) = ")" │ └── block: ∅ ├── @ CallNode (location: (56,0)-(56,15)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (56,0)-(56,3) = "foo" │ ├── opening_loc: (56,3)-(56,4) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (56,4)-(56,14)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) │ │ ├── @ CallNode (location: (56,4)-(56,7)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar │ │ │ ├── message_loc: (56,4)-(56,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── @ SplatNode (location: (56,9)-(56,14)) │ │ ├── operator_loc: (56,9)-(56,10) = "*" │ │ └── expression: │ │ @ CallNode (location: (56,10)-(56,14)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :args │ │ ├── message_loc: (56,10)-(56,14) = "args" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (56,14)-(56,15) = ")" │ └── block: ∅ ├── @ CallNode (location: (57,0)-(57,17)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (57,0)-(57,3) = "foo" │ ├── opening_loc: (57,3)-(57,4) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (57,4)-(57,16)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ CallNode (location: (57,4)-(57,16)) │ │ ├── flags: ∅ │ │ ├── receiver: │ │ │ @ CallNode (location: (57,4)-(57,7)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (57,4)-(57,7) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :=~ │ │ ├── message_loc: (57,8)-(57,10) = "=~" │ │ ├── opening_loc: ∅ │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (57,11)-(57,16)) │ │ │ ├── flags: ∅ │ │ │ └── arguments: (length: 1) │ │ │ └── @ RegularExpressionNode (location: (57,11)-(57,16)) │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ ├── opening_loc: (57,11)-(57,12) = "/" │ │ │ ├── content_loc: (57,12)-(57,15) = "bar" │ │ │ ├── closing_loc: (57,15)-(57,16) = "/" │ │ │ └── unescaped: "bar" │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (57,16)-(57,17) = ")" │ └── block: ∅ ├── @ CallNode (location: (58,0)-(58,13)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (58,0)-(58,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (58,0)-(58,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (58,3)-(58,4) = "." │ ├── name: :bar │ ├── message_loc: (58,4)-(58,7) = "bar" │ ├── opening_loc: (58,7)-(58,8) = "(" │ ├── arguments: ∅ │ ├── closing_loc: (58,12)-(58,13) = ")" │ └── block: │ @ BlockArgumentNode (location: (58,8)-(58,12)) │ ├── expression: │ │ @ CallNode (location: (58,9)-(58,12)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :baz │ │ ├── message_loc: (58,9)-(58,12) = "baz" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ └── operator_loc: (58,8)-(58,9) = "&" ├── @ CallNode (location: (59,0)-(59,26)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (59,0)-(59,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (59,0)-(59,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (59,3)-(59,4) = "." │ ├── name: :bar │ ├── message_loc: (59,4)-(59,7) = "bar" │ ├── opening_loc: (59,7)-(59,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (59,8)-(59,25)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 3) │ │ ├── @ SplatNode (location: (59,8)-(59,13)) │ │ │ ├── operator_loc: (59,8)-(59,9) = "*" │ │ │ └── expression: │ │ │ @ CallNode (location: (59,9)-(59,13)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :arga │ │ │ ├── message_loc: (59,9)-(59,13) = "arga" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── @ CallNode (location: (59,15)-(59,18)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (59,15)-(59,18) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── @ SplatNode (location: (59,20)-(59,25)) │ │ ├── operator_loc: (59,20)-(59,21) = "*" │ │ └── expression: │ │ @ CallNode (location: (59,21)-(59,25)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :argb │ │ ├── message_loc: (59,21)-(59,25) = "argb" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (59,25)-(59,26) = ")" │ └── block: ∅ ├── @ CallNode (location: (60,0)-(60,14)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (60,0)-(60,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (60,0)-(60,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (60,3)-(60,4) = "." │ ├── name: :bar │ ├── message_loc: (60,4)-(60,7) = "bar" │ ├── opening_loc: (60,7)-(60,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (60,8)-(60,13)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ SplatNode (location: (60,8)-(60,13)) │ │ ├── operator_loc: (60,8)-(60,9) = "*" │ │ └── expression: │ │ @ CallNode (location: (60,9)-(60,13)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :args │ │ ├── message_loc: (60,9)-(60,13) = "args" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (60,13)-(60,14) = ")" │ └── block: ∅ ├── @ CallNode (location: (61,0)-(61,19)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (61,0)-(61,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (61,0)-(61,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (61,3)-(61,4) = "." │ ├── name: :bar │ ├── message_loc: (61,4)-(61,7) = "bar" │ ├── opening_loc: (61,7)-(61,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (61,8)-(61,18)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) │ │ ├── @ SplatNode (location: (61,8)-(61,13)) │ │ │ ├── operator_loc: (61,8)-(61,9) = "*" │ │ │ └── expression: │ │ │ @ CallNode (location: (61,9)-(61,13)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :args │ │ │ ├── message_loc: (61,9)-(61,13) = "args" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── @ CallNode (location: (61,15)-(61,18)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (61,15)-(61,18) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (61,18)-(61,19) = ")" │ └── block: ∅ ├── @ CallNode (location: (62,0)-(62,19)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (62,0)-(62,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (62,0)-(62,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (62,3)-(62,4) = "." │ ├── name: :bar │ ├── message_loc: (62,4)-(62,7) = "bar" │ ├── opening_loc: (62,7)-(62,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (62,8)-(62,12)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ SymbolNode (location: (62,8)-(62,12)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (62,8)-(62,9) = ":" │ │ ├── value_loc: (62,9)-(62,12) = "baz" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "baz" │ ├── closing_loc: (62,18)-(62,19) = ")" │ └── block: │ @ BlockArgumentNode (location: (62,14)-(62,18)) │ ├── expression: │ │ @ CallNode (location: (62,15)-(62,18)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :baz │ │ ├── message_loc: (62,15)-(62,18) = "baz" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ └── operator_loc: (62,14)-(62,15) = "&" ├── @ CallNode (location: (63,0)-(63,17)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (63,0)-(63,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (63,0)-(63,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (63,3)-(63,4) = "." │ ├── name: :bar │ ├── message_loc: (63,4)-(63,7) = "bar" │ ├── opening_loc: (63,7)-(63,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (63,8)-(63,16)) │ │ ├── flags: contains_keywords │ │ └── arguments: (length: 1) │ │ └── @ KeywordHashNode (location: (63,8)-(63,16)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) │ │ └── @ AssocNode (location: (63,8)-(63,16)) │ │ ├── key: │ │ │ @ SymbolNode (location: (63,8)-(63,12)) │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (63,8)-(63,11) = "baz" │ │ │ ├── closing_loc: (63,11)-(63,12) = ":" │ │ │ └── unescaped: "baz" │ │ ├── value: │ │ │ @ CallNode (location: (63,13)-(63,16)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :boz │ │ │ ├── message_loc: (63,13)-(63,16) = "boz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: ∅ │ ├── closing_loc: (63,16)-(63,17) = ")" │ └── block: ∅ ├── @ CallNode (location: (64,0)-(64,26)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (64,0)-(64,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (64,0)-(64,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (64,3)-(64,4) = "." │ ├── name: :bar │ ├── message_loc: (64,4)-(64,7) = "bar" │ ├── opening_loc: (64,7)-(64,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (64,8)-(64,25)) │ │ ├── flags: contains_keywords │ │ └── arguments: (length: 2) │ │ ├── @ CallNode (location: (64,8)-(64,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (64,8)-(64,11) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── @ KeywordHashNode (location: (64,13)-(64,25)) │ │ ├── flags: ∅ │ │ └── elements: (length: 1) │ │ └── @ AssocNode (location: (64,13)-(64,25)) │ │ ├── key: │ │ │ @ StringNode (location: (64,13)-(64,18)) │ │ │ ├── flags: frozen │ │ │ ├── opening_loc: (64,13)-(64,14) = "\"" │ │ │ ├── content_loc: (64,14)-(64,17) = "baz" │ │ │ ├── closing_loc: (64,17)-(64,18) = "\"" │ │ │ └── unescaped: "baz" │ │ ├── value: │ │ │ @ CallNode (location: (64,22)-(64,25)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :boz │ │ │ ├── message_loc: (64,22)-(64,25) = "boz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: (64,19)-(64,21) = "=>" │ ├── closing_loc: (64,25)-(64,26) = ")" │ └── block: ∅ ├── @ CallNode (location: (65,0)-(65,19)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (65,0)-(65,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (65,0)-(65,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (65,3)-(65,4) = "." │ ├── name: :bar │ ├── message_loc: (65,4)-(65,7) = "bar" │ ├── opening_loc: (65,7)-(65,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (65,8)-(65,18)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) │ │ ├── @ CallNode (location: (65,8)-(65,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (65,8)-(65,11) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── @ SplatNode (location: (65,13)-(65,18)) │ │ ├── operator_loc: (65,13)-(65,14) = "*" │ │ └── expression: │ │ @ CallNode (location: (65,14)-(65,18)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :args │ │ ├── message_loc: (65,14)-(65,18) = "args" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (65,18)-(65,19) = ")" │ └── block: ∅ ├── @ CallNode (location: (66,0)-(66,27)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (66,0)-(66,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (66,0)-(66,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (66,3)-(66,4) = "." │ ├── name: :bar │ ├── message_loc: (66,4)-(66,7) = "bar" │ ├── opening_loc: (66,7)-(66,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (66,8)-(66,18)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) │ │ ├── @ CallNode (location: (66,8)-(66,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (66,8)-(66,11) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── @ SplatNode (location: (66,13)-(66,18)) │ │ ├── operator_loc: (66,13)-(66,14) = "*" │ │ └── expression: │ │ @ CallNode (location: (66,14)-(66,18)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :args │ │ ├── message_loc: (66,14)-(66,18) = "args" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (66,26)-(66,27) = ")" │ └── block: │ @ BlockArgumentNode (location: (66,20)-(66,26)) │ ├── expression: │ │ @ CallNode (location: (66,21)-(66,26)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :block │ │ ├── message_loc: (66,21)-(66,26) = "block" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ └── operator_loc: (66,20)-(66,21) = "&" ├── @ CallNode (location: (67,0)-(67,16)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (67,0)-(67,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (67,0)-(67,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (67,3)-(67,4) = "." │ ├── name: :bar │ ├── message_loc: (67,4)-(67,7) = "bar" │ ├── opening_loc: (67,7)-(67,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (67,8)-(67,15)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) │ │ ├── @ CallNode (location: (67,8)-(67,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (67,8)-(67,11) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── @ HashNode (location: (67,13)-(67,15)) │ │ ├── opening_loc: (67,13)-(67,14) = "{" │ │ ├── elements: (length: 0) │ │ └── closing_loc: (67,14)-(67,15) = "}" │ ├── closing_loc: (67,15)-(67,16) = ")" │ └── block: ∅ ├── @ CallNode (location: (68,0)-(68,26)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (68,0)-(68,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (68,0)-(68,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (68,3)-(68,4) = "." │ ├── name: :bar │ ├── message_loc: (68,4)-(68,7) = "bar" │ ├── opening_loc: (68,7)-(68,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (68,8)-(68,25)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) │ │ ├── @ HashNode (location: (68,8)-(68,20)) │ │ │ ├── opening_loc: (68,8)-(68,9) = "{" │ │ │ ├── elements: (length: 1) │ │ │ │ └── @ AssocNode (location: (68,10)-(68,18)) │ │ │ │ ├── key: │ │ │ │ │ @ SymbolNode (location: (68,10)-(68,14)) │ │ │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── value_loc: (68,10)-(68,13) = "foo" │ │ │ │ │ ├── closing_loc: (68,13)-(68,14) = ":" │ │ │ │ │ └── unescaped: "foo" │ │ │ │ ├── value: │ │ │ │ │ @ CallNode (location: (68,15)-(68,18)) │ │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── name: :boz │ │ │ │ │ ├── message_loc: (68,15)-(68,18) = "boz" │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── block: ∅ │ │ │ │ └── operator_loc: ∅ │ │ │ └── closing_loc: (68,19)-(68,20) = "}" │ │ └── @ CallNode (location: (68,22)-(68,25)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :boz │ │ ├── message_loc: (68,22)-(68,25) = "boz" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (68,25)-(68,26) = ")" │ └── block: ∅ ├── @ CallNode (location: (69,0)-(69,12)) │ ├── flags: attribute_write │ ├── receiver: │ │ @ CallNode (location: (69,0)-(69,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (69,0)-(69,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (69,3)-(69,4) = "." │ ├── name: :bar= │ ├── message_loc: (69,4)-(69,7) = "bar" │ ├── opening_loc: ∅ │ ├── arguments: │ │ @ ArgumentsNode (location: (69,8)-(69,12)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ SymbolNode (location: (69,8)-(69,12)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (69,8)-(69,9) = ":" │ │ ├── value_loc: (69,9)-(69,12) = "baz" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "baz" │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (70,0)-(70,9)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo │ ├── message_loc: (70,0)-(70,3) = "foo" │ ├── opening_loc: (70,3)-(70,4) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (70,4)-(70,8)) │ │ ├── flags: contains_keywords │ │ └── arguments: (length: 1) │ │ └── @ KeywordHashNode (location: (70,4)-(70,8)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) │ │ └── @ AssocNode (location: (70,4)-(70,8)) │ │ ├── key: │ │ │ @ SymbolNode (location: (70,4)-(70,6)) │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (70,4)-(70,5) = "a" │ │ │ ├── closing_loc: (70,5)-(70,6) = ":" │ │ │ └── unescaped: "a" │ │ ├── value: │ │ │ @ CallNode (location: (70,7)-(70,8)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :b │ │ │ ├── message_loc: (70,7)-(70,8) = "b" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: ∅ │ ├── closing_loc: (70,8)-(70,9) = ")" │ └── block: ∅ ├── @ CallNode (location: (71,0)-(71,11)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (71,0)-(71,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (71,0)-(71,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (71,3)-(71,4) = "." │ ├── name: :& │ ├── message_loc: (71,4)-(71,5) = "&" │ ├── opening_loc: (71,5)-(71,6) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (71,6)-(71,10)) │ │ ├── flags: contains_keywords │ │ └── arguments: (length: 1) │ │ └── @ KeywordHashNode (location: (71,6)-(71,10)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) │ │ └── @ AssocNode (location: (71,6)-(71,10)) │ │ ├── key: │ │ │ @ SymbolNode (location: (71,6)-(71,8)) │ │ │ ├── flags: forced_us_ascii_encoding │ │ │ ├── opening_loc: ∅ │ │ │ ├── value_loc: (71,6)-(71,7) = "a" │ │ │ ├── closing_loc: (71,7)-(71,8) = ":" │ │ │ └── unescaped: "a" │ │ ├── value: │ │ │ @ CallNode (location: (71,9)-(71,10)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :b │ │ │ ├── message_loc: (71,9)-(71,10) = "b" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: ∅ │ ├── closing_loc: (71,10)-(71,11) = ")" │ └── block: ∅ ├── @ CallNode (location: (72,0)-(72,10)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (72,0)-(72,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (72,0)-(72,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (72,3)-(72,4) = "." │ ├── name: :& │ ├── message_loc: (72,4)-(72,5) = "&" │ ├── opening_loc: (72,5)-(72,6) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (72,6)-(72,9)) │ │ ├── flags: contains_keywords, contains_keyword_splat │ │ └── arguments: (length: 1) │ │ └── @ KeywordHashNode (location: (72,6)-(72,9)) │ │ ├── flags: ∅ │ │ └── elements: (length: 1) │ │ └── @ AssocSplatNode (location: (72,6)-(72,9)) │ │ ├── value: │ │ │ @ CallNode (location: (72,8)-(72,9)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :a │ │ │ ├── message_loc: (72,8)-(72,9) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: (72,6)-(72,8) = "**" │ ├── closing_loc: (72,9)-(72,10) = ")" │ └── block: ∅ ├── @ CallNode (location: (73,0)-(73,9)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (73,0)-(73,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (73,0)-(73,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :[] │ ├── message_loc: (73,3)-(73,9) = "[*baz]" │ ├── opening_loc: (73,3)-(73,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (73,4)-(73,8)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ SplatNode (location: (73,4)-(73,8)) │ │ ├── operator_loc: (73,4)-(73,5) = "*" │ │ └── expression: │ │ @ CallNode (location: (73,5)-(73,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :baz │ │ ├── message_loc: (73,5)-(73,8) = "baz" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (73,8)-(73,9) = "]" │ └── block: ∅ ├── @ CallNode (location: (74,0)-(74,9)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (74,0)-(74,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (74,0)-(74,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :[] │ ├── message_loc: (74,3)-(74,9) = "[1, 2]" │ ├── opening_loc: (74,3)-(74,4) = "[" │ ├── arguments: │ │ @ ArgumentsNode (location: (74,4)-(74,8)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) │ │ ├── @ IntegerNode (location: (74,4)-(74,5)) │ │ │ ├── flags: decimal │ │ │ └── value: 1 │ │ └── @ IntegerNode (location: (74,7)-(74,8)) │ │ ├── flags: decimal │ │ └── value: 2 │ ├── closing_loc: (74,8)-(74,9) = "]" │ └── block: ∅ ├── @ CallNode (location: (75,0)-(75,5)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (75,0)-(75,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (75,0)-(75,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :[] │ ├── message_loc: (75,3)-(75,5) = "[]" │ ├── opening_loc: (75,3)-(75,4) = "[" │ ├── arguments: ∅ │ ├── closing_loc: (75,4)-(75,5) = "]" │ └── block: ∅ ├── @ CallNode (location: (76,0)-(76,8)) │ ├── flags: ignore_visibility │ ├── receiver: │ │ @ SelfNode (location: (76,0)-(76,4)) │ ├── call_operator_loc: (76,4)-(76,5) = "." │ ├── name: :foo │ ├── message_loc: (76,5)-(76,8) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (77,0)-(77,13)) │ ├── flags: attribute_write, ignore_visibility │ ├── receiver: │ │ @ SelfNode (location: (77,0)-(77,4)) │ ├── call_operator_loc: (77,4)-(77,5) = "." │ ├── name: :foo= │ ├── message_loc: (77,5)-(77,8) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: │ │ @ ArgumentsNode (location: (77,9)-(77,13)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ SymbolNode (location: (77,9)-(77,13)) │ │ ├── flags: forced_us_ascii_encoding │ │ ├── opening_loc: (77,9)-(77,10) = ":" │ │ ├── value_loc: (77,10)-(77,13) = "bar" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "bar" │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (78,0)-(78,17)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ParenthesesNode (location: (78,0)-(78,7)) │ │ ├── body: │ │ │ @ StatementsNode (location: (78,1)-(78,6)) │ │ │ └── body: (length: 1) │ │ │ └── @ CallNode (location: (78,1)-(78,6)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (78,1)-(78,2)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :a │ │ │ │ ├── message_loc: (78,1)-(78,2) = "a" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :+ │ │ │ ├── message_loc: (78,3)-(78,4) = "+" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (78,5)-(78,6)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ CallNode (location: (78,5)-(78,6)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :b │ │ │ │ ├── message_loc: (78,5)-(78,6) = "b" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── opening_loc: (78,0)-(78,1) = "(" │ │ └── closing_loc: (78,6)-(78,7) = ")" │ ├── call_operator_loc: ∅ │ ├── name: :/ │ ├── message_loc: (78,8)-(78,9) = "/" │ ├── opening_loc: ∅ │ ├── arguments: │ │ @ ArgumentsNode (location: (78,10)-(78,17)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ ParenthesesNode (location: (78,10)-(78,17)) │ │ ├── body: │ │ │ @ StatementsNode (location: (78,11)-(78,16)) │ │ │ └── body: (length: 1) │ │ │ └── @ CallNode (location: (78,11)-(78,16)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (78,11)-(78,12)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :c │ │ │ │ ├── message_loc: (78,11)-(78,12) = "c" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :- │ │ │ ├── message_loc: (78,13)-(78,14) = "-" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (78,15)-(78,16)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ CallNode (location: (78,15)-(78,16)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :d │ │ │ │ ├── message_loc: (78,15)-(78,16) = "d" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── opening_loc: (78,10)-(78,11) = "(" │ │ └── closing_loc: (78,16)-(78,17) = ")" │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (79,0)-(79,19)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ParenthesesNode (location: (79,0)-(79,7)) │ │ ├── body: │ │ │ @ StatementsNode (location: (79,1)-(79,6)) │ │ │ └── body: (length: 1) │ │ │ └── @ CallNode (location: (79,1)-(79,6)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (79,1)-(79,2)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :a │ │ │ │ ├── message_loc: (79,1)-(79,2) = "a" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :+ │ │ │ ├── message_loc: (79,3)-(79,4) = "+" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (79,5)-(79,6)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ CallNode (location: (79,5)-(79,6)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :b │ │ │ │ ├── message_loc: (79,5)-(79,6) = "b" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── opening_loc: (79,0)-(79,1) = "(" │ │ └── closing_loc: (79,6)-(79,7) = ")" │ ├── call_operator_loc: ∅ │ ├── name: :/ │ ├── message_loc: (79,8)-(79,9) = "/" │ ├── opening_loc: ∅ │ ├── arguments: │ │ @ ArgumentsNode (location: (79,10)-(79,19)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ CallNode (location: (79,10)-(79,19)) │ │ ├── flags: ∅ │ │ ├── receiver: │ │ │ @ CallNode (location: (79,10)-(79,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :c │ │ │ ├── message_loc: (79,10)-(79,11) = "c" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── call_operator_loc: (79,11)-(79,12) = "." │ │ ├── name: :- │ │ ├── message_loc: (79,12)-(79,13) = "-" │ │ ├── opening_loc: (79,13)-(79,14) = "(" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (79,14)-(79,18)) │ │ │ ├── flags: ∅ │ │ │ └── arguments: (length: 2) │ │ │ ├── @ CallNode (location: (79,14)-(79,15)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :e │ │ │ │ ├── message_loc: (79,14)-(79,15) = "e" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ └── @ CallNode (location: (79,17)-(79,18)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :f │ │ │ ├── message_loc: (79,17)-(79,18) = "f" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── closing_loc: (79,18)-(79,19) = ")" │ │ └── block: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (80,0)-(80,17)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ParenthesesNode (location: (80,0)-(80,7)) │ │ ├── body: │ │ │ @ StatementsNode (location: (80,1)-(80,6)) │ │ │ └── body: (length: 1) │ │ │ └── @ CallNode (location: (80,1)-(80,6)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (80,1)-(80,2)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :a │ │ │ │ ├── message_loc: (80,1)-(80,2) = "a" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :+ │ │ │ ├── message_loc: (80,3)-(80,4) = "+" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (80,5)-(80,6)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ CallNode (location: (80,5)-(80,6)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :b │ │ │ │ ├── message_loc: (80,5)-(80,6) = "b" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── opening_loc: (80,0)-(80,1) = "(" │ │ └── closing_loc: (80,6)-(80,7) = ")" │ ├── call_operator_loc: ∅ │ ├── name: :/ │ ├── message_loc: (80,8)-(80,9) = "/" │ ├── opening_loc: ∅ │ ├── arguments: │ │ @ ArgumentsNode (location: (80,10)-(80,17)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ CallNode (location: (80,10)-(80,17)) │ │ ├── flags: ∅ │ │ ├── receiver: │ │ │ @ CallNode (location: (80,10)-(80,11)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :c │ │ │ ├── message_loc: (80,10)-(80,11) = "c" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── call_operator_loc: (80,11)-(80,12) = "." │ │ ├── name: :- │ │ ├── message_loc: (80,12)-(80,13) = "-" │ │ ├── opening_loc: (80,13)-(80,14) = "(" │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (80,14)-(80,16)) │ │ │ ├── flags: ∅ │ │ │ └── arguments: (length: 1) │ │ │ └── @ SplatNode (location: (80,14)-(80,16)) │ │ │ ├── operator_loc: (80,14)-(80,15) = "*" │ │ │ └── expression: │ │ │ @ CallNode (location: (80,15)-(80,16)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :f │ │ │ ├── message_loc: (80,15)-(80,16) = "f" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── closing_loc: (80,16)-(80,17) = ")" │ │ └── block: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (81,0)-(81,8)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :x │ ├── message_loc: (81,0)-(81,1) = "x" │ ├── opening_loc: (81,1)-(81,2) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (81,2)-(81,7)) │ │ ├── flags: contains_keywords, contains_keyword_splat │ │ └── arguments: (length: 1) │ │ └── @ KeywordHashNode (location: (81,2)-(81,7)) │ │ ├── flags: ∅ │ │ └── elements: (length: 1) │ │ └── @ AssocSplatNode (location: (81,2)-(81,7)) │ │ ├── value: │ │ │ @ CallNode (location: (81,4)-(81,7)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :foo │ │ │ ├── message_loc: (81,4)-(81,7) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── operator_loc: (81,2)-(81,4) = "**" │ ├── closing_loc: (81,7)-(81,8) = ")" │ └── block: ∅ ├── @ CallNode (location: (82,0)-(82,6)) │ ├── flags: safe_navigation │ ├── receiver: │ │ @ CallNode (location: (82,0)-(82,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (82,0)-(82,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (82,3)-(82,5) = "&." │ ├── name: :! │ ├── message_loc: (82,5)-(82,6) = "!" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── @ CallNode (location: (83,0)-(83,8)) │ ├── flags: ∅ │ ├── receiver: │ │ @ CallNode (location: (83,0)-(83,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo │ │ ├── message_loc: (83,0)-(83,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: (83,3)-(83,4) = "." │ ├── name: :~ │ ├── message_loc: (83,4)-(83,5) = "~" │ ├── opening_loc: (83,5)-(83,6) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (83,6)-(83,7)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) │ │ └── @ CallNode (location: (83,6)-(83,7)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :b │ │ ├── message_loc: (83,6)-(83,7) = "b" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: (83,7)-(83,8) = ")" │ └── block: ∅ └── @ CallNode (location: (84,0)-(84,7)) ├── flags: safe_navigation ├── receiver: │ @ CallNode (location: (84,0)-(84,1)) │ ├── flags: variable_call, ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :a │ ├── message_loc: (84,0)-(84,1) = "a" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── call_operator_loc: (84,1)-(84,3) = "&." ├── name: :+ ├── message_loc: (84,3)-(84,4) = "+" ├── opening_loc: (84,4)-(84,5) = "(" ├── arguments: │ @ ArgumentsNode (location: (84,5)-(84,6)) │ ├── flags: ∅ │ └── arguments: (length: 1) │ └── @ CallNode (location: (84,5)-(84,6)) │ ├── flags: variable_call, ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :b │ ├── message_loc: (84,5)-(84,6) = "b" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ ├── closing_loc: (84,6)-(84,7) = ")" └── block: ∅