diff options
Diffstat (limited to 'test/prism/snapshots/case.txt')
| -rw-r--r-- | test/prism/snapshots/case.txt | 495 |
1 files changed, 495 insertions, 0 deletions
diff --git a/test/prism/snapshots/case.txt b/test/prism/snapshots/case.txt new file mode 100644 index 0000000000..417bf9492a --- /dev/null +++ b/test/prism/snapshots/case.txt @@ -0,0 +1,495 @@ +@ ProgramNode (location: (1,0)-(55,3)) +├── locals: [:b] +└── statements: + @ StatementsNode (location: (1,0)-(55,3)) + └── body: (length: 15) + ├── @ CaseNode (location: (1,0)-(3,3)) + │ ├── predicate: + │ │ @ SymbolNode (location: (1,5)-(1,8)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── 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)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (2,5)-(2,6) = ":" + │ │ │ ├── value_loc: (2,6)-(2,8) = "hi" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "hi" + │ │ ├── then_keyword_loc: ∅ + │ │ └── 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)) + │ │ │ ├── then_keyword_loc: ∅ + │ │ │ └── statements: + │ │ │ @ StatementsNode (location: (5,22)-(5,30)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (5,22)-(5,30)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :puts + │ │ │ ├── message_loc: (5,22)-(5,26) = "puts" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (5,27)-(5,30)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ SymbolNode (location: (5,27)-(5,30)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (5,27)-(5,28) = ":" + │ │ │ │ ├── value_loc: (5,28)-(5,30) = "hi" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "hi" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ WhenNode (location: (5,32)-(5,53)) + │ │ ├── keyword_loc: (5,32)-(5,36) = "when" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ FalseNode (location: (5,37)-(5,42)) + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (5,44)-(5,53)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (5,44)-(5,53)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :puts + │ │ ├── message_loc: (5,44)-(5,48) = "puts" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (5,49)-(5,53)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ SymbolNode (location: (5,49)-(5,53)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (5,49)-(5,50) = ":" + │ │ │ ├── value_loc: (5,50)-(5,53) = "bye" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "bye" + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── 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)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (7,12)-(7,15) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── 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)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── 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)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (10,5)-(10,6) = ":" + │ │ │ ├── value_loc: (10,6)-(10,8) = "hi" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "hi" + │ │ ├── then_keyword_loc: ∅ + │ │ └── 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)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── 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)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :this + │ │ ├── message_loc: (15,5)-(15,9) = "this" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── 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 + │ │ ├── then_keyword_loc: ∅ + │ │ └── 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)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (18,5)-(18,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :foo + │ │ │ │ ├── message_loc: (18,5)-(18,8) = "foo" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :== + │ │ │ ├── message_loc: (18,9)-(18,11) = "==" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (18,12)-(18,15)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (18,12)-(18,15)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (18,12)-(18,15) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── 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)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (22,5)-(22,6) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── 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)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :type + │ │ ├── message_loc: (27,5)-(27,9) = "type" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── 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)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (28,8)-(28,9) = ":" + │ │ │ ├── value_loc: (28,9)-(28,10) = "b" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "b" + │ │ ├── then_keyword_loc: ∅ + │ │ └── 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 + │ │ │ └── value: 1 + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (32,0)-(32,4) = "case" + │ └── end_keyword_loc: (32,22)-(32,25) = "end" + ├── @ CaseNode (location: (34,0)-(36,3)) + │ ├── predicate: + │ │ @ MatchPredicateNode (location: (34,5)-(34,11)) + │ │ ├── value: + │ │ │ @ IntegerNode (location: (34,5)-(34,6)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── pattern: + │ │ │ @ IntegerNode (location: (34,10)-(34,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── operator_loc: (34,7)-(34,9) = "in" + │ ├── conditions: (length: 1) + │ │ └── @ WhenNode (location: (35,0)-(35,6)) + │ │ ├── keyword_loc: (35,0)-(35,4) = "when" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ IntegerNode (location: (35,5)-(35,6)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 3 + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (34,0)-(34,4) = "case" + │ └── end_keyword_loc: (36,0)-(36,3) = "end" + ├── @ CaseNode (location: (38,0)-(38,24)) + │ ├── predicate: + │ │ @ MatchPredicateNode (location: (38,5)-(38,11)) + │ │ ├── value: + │ │ │ @ IntegerNode (location: (38,5)-(38,6)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── pattern: + │ │ │ @ IntegerNode (location: (38,10)-(38,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── operator_loc: (38,7)-(38,9) = "in" + │ ├── conditions: (length: 1) + │ │ └── @ WhenNode (location: (38,13)-(38,19)) + │ │ ├── keyword_loc: (38,13)-(38,17) = "when" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ IntegerNode (location: (38,18)-(38,19)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 3 + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (38,0)-(38,4) = "case" + │ └── end_keyword_loc: (38,21)-(38,24) = "end" + ├── @ CaseMatchNode (location: (40,0)-(42,3)) + │ ├── predicate: + │ │ @ MatchPredicateNode (location: (40,5)-(40,11)) + │ │ ├── value: + │ │ │ @ IntegerNode (location: (40,5)-(40,6)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── pattern: + │ │ │ @ IntegerNode (location: (40,10)-(40,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── operator_loc: (40,7)-(40,9) = "in" + │ ├── conditions: (length: 1) + │ │ └── @ InNode (location: (41,0)-(41,4)) + │ │ ├── pattern: + │ │ │ @ IntegerNode (location: (41,3)-(41,4)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 3 + │ │ ├── statements: ∅ + │ │ ├── in_loc: (41,0)-(41,2) = "in" + │ │ └── then_loc: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (40,0)-(40,4) = "case" + │ └── end_keyword_loc: (42,0)-(42,3) = "end" + ├── @ CaseMatchNode (location: (44,0)-(44,22)) + │ ├── predicate: + │ │ @ MatchPredicateNode (location: (44,5)-(44,11)) + │ │ ├── value: + │ │ │ @ IntegerNode (location: (44,5)-(44,6)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── pattern: + │ │ │ @ IntegerNode (location: (44,10)-(44,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── operator_loc: (44,7)-(44,9) = "in" + │ ├── conditions: (length: 1) + │ │ └── @ InNode (location: (44,13)-(44,17)) + │ │ ├── pattern: + │ │ │ @ IntegerNode (location: (44,16)-(44,17)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 3 + │ │ ├── statements: ∅ + │ │ ├── in_loc: (44,13)-(44,15) = "in" + │ │ └── then_loc: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (44,0)-(44,4) = "case" + │ └── end_keyword_loc: (44,19)-(44,22) = "end" + ├── @ CaseMatchNode (location: (46,0)-(49,3)) + │ ├── predicate: + │ │ @ CallNode (location: (46,5)-(46,6)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (46,5)-(46,6) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 1) + │ │ └── @ InNode (location: (47,0)-(48,3)) + │ │ ├── pattern: + │ │ │ @ IfNode (location: (47,3)-(47,15)) + │ │ │ ├── if_keyword_loc: (47,5)-(47,7) = "if" + │ │ │ ├── predicate: + │ │ │ │ @ AndNode (location: (47,8)-(47,15)) + │ │ │ │ ├── left: + │ │ │ │ │ @ CallNode (location: (47,8)-(47,9)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :c + │ │ │ │ │ ├── message_loc: (47,8)-(47,9) = "c" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── right: + │ │ │ │ │ @ CallNode (location: (47,14)-(47,15)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :d + │ │ │ │ │ ├── message_loc: (47,14)-(47,15) = "d" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ └── operator_loc: (47,10)-(47,13) = "and" + │ │ │ ├── then_keyword_loc: ∅ + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (47,3)-(47,4)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ LocalVariableTargetNode (location: (47,3)-(47,4)) + │ │ │ │ ├── name: :b + │ │ │ │ └── depth: 0 + │ │ │ ├── consequent: ∅ + │ │ │ └── end_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (48,2)-(48,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (48,2)-(48,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :e + │ │ │ ├── message_loc: (48,2)-(48,3) = "e" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── in_loc: (47,0)-(47,2) = "in" + │ │ └── then_loc: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (46,0)-(46,4) = "case" + │ └── end_keyword_loc: (49,0)-(49,3) = "end" + └── @ CallNode (location: (51,0)-(55,3)) + ├── flags: ∅ + ├── receiver: + │ @ IntegerNode (location: (51,0)-(51,1)) + │ ├── flags: decimal + │ └── value: 1 + ├── call_operator_loc: (51,1)-(51,2) = "." + ├── name: :then + ├── message_loc: (51,2)-(51,6) = "then" + ├── opening_loc: ∅ + ├── arguments: ∅ + ├── closing_loc: ∅ + └── block: + @ BlockNode (location: (51,7)-(55,3)) + ├── locals: [:_1] + ├── parameters: + │ @ NumberedParametersNode (location: (51,7)-(55,3)) + │ └── maximum: 1 + ├── body: + │ @ StatementsNode (location: (52,2)-(54,5)) + │ └── body: (length: 1) + │ └── @ CaseMatchNode (location: (52,2)-(54,5)) + │ ├── predicate: + │ │ @ IntegerNode (location: (52,7)-(52,8)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── conditions: (length: 1) + │ │ └── @ InNode (location: (53,2)-(53,8)) + │ │ ├── pattern: + │ │ │ @ PinnedVariableNode (location: (53,5)-(53,8)) + │ │ │ ├── variable: + │ │ │ │ @ LocalVariableReadNode (location: (53,6)-(53,8)) + │ │ │ │ ├── name: :_1 + │ │ │ │ └── depth: 0 + │ │ │ └── operator_loc: (53,5)-(53,6) = "^" + │ │ ├── statements: ∅ + │ │ ├── in_loc: (53,2)-(53,4) = "in" + │ │ └── then_loc: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (52,2)-(52,6) = "case" + │ └── end_keyword_loc: (54,2)-(54,5) = "end" + ├── opening_loc: (51,7)-(51,9) = "do" + └── closing_loc: (55,0)-(55,3) = "end" |