@ ProgramNode (location: (1,0)-(32,25)) ├── locals: [] └── statements: @ StatementsNode (location: (1,0)-(32,25)) └── body: (length: 9) ├── @ CaseNode (location: (1,0)-(3,3)) │ ├── predicate: │ │ @ SymbolNode (location: (1,5)-(1,8)) │ │ ├── opening_loc: (1,5)-(1,6) = ":" │ │ ├── value_loc: (1,6)-(1,8) = "hi" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "hi" │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (2,0)-(2,8)) │ │ ├── keyword_loc: (2,0)-(2,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SymbolNode (location: (2,5)-(2,8)) │ │ │ ├── opening_loc: (2,5)-(2,6) = ":" │ │ │ ├── value_loc: (2,6)-(2,8) = "hi" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "hi" │ │ └── statements: ∅ │ ├── consequent: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (3,0)-(3,3) = "end" ├── @ CaseNode (location: (5,0)-(5,58)) │ ├── predicate: │ │ @ TrueNode (location: (5,5)-(5,9)) │ ├── conditions: (length: 2) │ │ ├── @ WhenNode (location: (5,11)-(5,30)) │ │ │ ├── keyword_loc: (5,11)-(5,15) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ TrueNode (location: (5,16)-(5,20)) │ │ │ └── statements: │ │ │ @ StatementsNode (location: (5,22)-(5,30)) │ │ │ └── body: (length: 1) │ │ │ └── @ CallNode (location: (5,22)-(5,30)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── message_loc: (5,22)-(5,26) = "puts" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (5,27)-(5,30)) │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ SymbolNode (location: (5,27)-(5,30)) │ │ │ │ ├── opening_loc: (5,27)-(5,28) = ":" │ │ │ │ ├── value_loc: (5,28)-(5,30) = "hi" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "hi" │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ ├── flags: ∅ │ │ │ └── name: "puts" │ │ └── @ WhenNode (location: (5,32)-(5,53)) │ │ ├── keyword_loc: (5,32)-(5,36) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ FalseNode (location: (5,37)-(5,42)) │ │ └── statements: │ │ @ StatementsNode (location: (5,44)-(5,53)) │ │ └── body: (length: 1) │ │ └── @ CallNode (location: (5,44)-(5,53)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── message_loc: (5,44)-(5,48) = "puts" │ │ ├── opening_loc: ∅ │ │ ├── arguments: │ │ │ @ ArgumentsNode (location: (5,49)-(5,53)) │ │ │ └── arguments: (length: 1) │ │ │ └── @ SymbolNode (location: (5,49)-(5,53)) │ │ │ ├── opening_loc: (5,49)-(5,50) = ":" │ │ │ ├── value_loc: (5,50)-(5,53) = "bye" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "bye" │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ ├── flags: ∅ │ │ └── name: "puts" │ ├── consequent: ∅ │ ├── case_keyword_loc: (5,0)-(5,4) = "case" │ └── end_keyword_loc: (5,55)-(5,58) = "end" ├── @ CaseNode (location: (7,0)-(7,20)) │ ├── predicate: ∅ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (7,6)-(7,15)) │ │ ├── keyword_loc: (7,6)-(7,10) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SplatNode (location: (7,11)-(7,15)) │ │ │ ├── operator_loc: (7,11)-(7,12) = "*" │ │ │ └── expression: │ │ │ @ CallNode (location: (7,12)-(7,15)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── message_loc: (7,12)-(7,15) = "foo" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ ├── flags: variable_call │ │ │ └── name: "foo" │ │ └── statements: ∅ │ ├── consequent: ∅ │ ├── case_keyword_loc: (7,0)-(7,4) = "case" │ └── end_keyword_loc: (7,17)-(7,20) = "end" ├── @ CaseNode (location: (9,0)-(13,3)) │ ├── predicate: │ │ @ SymbolNode (location: (9,5)-(9,8)) │ │ ├── opening_loc: (9,5)-(9,6) = ":" │ │ ├── value_loc: (9,6)-(9,8) = "hi" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "hi" │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (10,0)-(10,8)) │ │ ├── keyword_loc: (10,0)-(10,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SymbolNode (location: (10,5)-(10,8)) │ │ │ ├── opening_loc: (10,5)-(10,6) = ":" │ │ │ ├── value_loc: (10,6)-(10,8) = "hi" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "hi" │ │ └── statements: ∅ │ ├── consequent: │ │ @ ElseNode (location: (11,0)-(13,3)) │ │ ├── else_keyword_loc: (11,0)-(11,4) = "else" │ │ ├── statements: │ │ │ @ StatementsNode (location: (12,0)-(12,2)) │ │ │ └── body: (length: 1) │ │ │ └── @ SymbolNode (location: (12,0)-(12,2)) │ │ │ ├── opening_loc: (12,0)-(12,1) = ":" │ │ │ ├── value_loc: (12,1)-(12,2) = "b" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "b" │ │ └── end_keyword_loc: (13,0)-(13,3) = "end" │ ├── case_keyword_loc: (9,0)-(9,4) = "case" │ └── end_keyword_loc: (13,0)-(13,3) = "end" ├── @ CaseNode (location: (15,0)-(15,36)) │ ├── predicate: │ │ @ CallNode (location: (15,5)-(15,9)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── message_loc: (15,5)-(15,9) = "this" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ ├── flags: variable_call │ │ └── name: "this" │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (15,11)-(15,31)) │ │ ├── keyword_loc: (15,11)-(15,15) = "when" │ │ ├── conditions: (length: 2) │ │ │ ├── @ ConstantReadNode (location: (15,16)-(15,22)) │ │ │ │ └── name: :FooBar │ │ │ └── @ ConstantReadNode (location: (15,24)-(15,31)) │ │ │ └── name: :BazBonk │ │ └── statements: ∅ │ ├── consequent: ∅ │ ├── case_keyword_loc: (15,0)-(15,4) = "case" │ └── end_keyword_loc: (15,33)-(15,36) = "end" ├── @ CaseNode (location: (17,0)-(19,3)) │ ├── predicate: ∅ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (18,0)-(18,15)) │ │ ├── keyword_loc: (18,0)-(18,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ CallNode (location: (18,5)-(18,15)) │ │ │ ├── receiver: │ │ │ │ @ CallNode (location: (18,5)-(18,8)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── message_loc: (18,5)-(18,8) = "foo" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ ├── flags: variable_call │ │ │ │ └── name: "foo" │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── message_loc: (18,9)-(18,11) = "==" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: │ │ │ │ @ ArgumentsNode (location: (18,12)-(18,15)) │ │ │ │ └── arguments: (length: 1) │ │ │ │ └── @ CallNode (location: (18,12)-(18,15)) │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── message_loc: (18,12)-(18,15) = "bar" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── block: ∅ │ │ │ │ ├── flags: variable_call │ │ │ │ └── name: "bar" │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ ├── flags: ∅ │ │ │ └── name: "==" │ │ └── statements: ∅ │ ├── consequent: ∅ │ ├── case_keyword_loc: (17,0)-(17,4) = "case" │ └── end_keyword_loc: (19,0)-(19,3) = "end" ├── @ CaseNode (location: (21,0)-(25,3)) │ ├── predicate: ∅ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (22,0)-(22,6)) │ │ ├── keyword_loc: (22,0)-(22,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ CallNode (location: (22,5)-(22,6)) │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── message_loc: (22,5)-(22,6) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ ├── block: ∅ │ │ │ ├── flags: variable_call │ │ │ └── name: "a" │ │ └── statements: ∅ │ ├── consequent: │ │ @ ElseNode (location: (23,0)-(25,3)) │ │ ├── else_keyword_loc: (23,0)-(23,4) = "else" │ │ ├── statements: ∅ │ │ └── end_keyword_loc: (25,0)-(25,3) = "end" │ ├── case_keyword_loc: (21,0)-(21,4) = "case" │ └── end_keyword_loc: (25,0)-(25,3) = "end" ├── @ CaseNode (location: (27,0)-(30,6)) │ ├── predicate: │ │ @ CallNode (location: (27,5)-(27,9)) │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── message_loc: (27,5)-(27,9) = "type" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ ├── block: ∅ │ │ ├── flags: variable_call │ │ └── name: "type" │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (28,3)-(28,10)) │ │ ├── keyword_loc: (28,3)-(28,7) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SymbolNode (location: (28,8)-(28,10)) │ │ │ ├── opening_loc: (28,8)-(28,9) = ":" │ │ │ ├── value_loc: (28,9)-(28,10) = "b" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "b" │ │ └── statements: ∅ │ ├── consequent: │ │ @ ElseNode (location: (29,5)-(30,6)) │ │ ├── else_keyword_loc: (29,5)-(29,9) = "else" │ │ ├── statements: ∅ │ │ └── end_keyword_loc: (30,3)-(30,6) = "end" │ ├── case_keyword_loc: (27,0)-(27,4) = "case" │ └── end_keyword_loc: (30,3)-(30,6) = "end" └── @ CaseNode (location: (32,0)-(32,25)) ├── predicate: ∅ ├── conditions: (length: 1) │ └── @ WhenNode (location: (32,14)-(32,20)) │ ├── keyword_loc: (32,14)-(32,18) = "when" │ ├── conditions: (length: 1) │ │ └── @ IntegerNode (location: (32,19)-(32,20)) │ │ └── flags: decimal │ └── statements: ∅ ├── consequent: ∅ ├── case_keyword_loc: (32,0)-(32,4) = "case" └── end_keyword_loc: (32,22)-(32,25) = "end"