diff options
Diffstat (limited to 'test/prism/snapshots/unparser/corpus/semantic')
10 files changed, 2013 insertions, 0 deletions
diff --git a/test/prism/snapshots/unparser/corpus/semantic/and.txt b/test/prism/snapshots/unparser/corpus/semantic/and.txt new file mode 100644 index 0000000000..bc9d674e44 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/and.txt @@ -0,0 +1,235 @@ +@ ProgramNode (location: (1,0)-(8,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(8,3)) + └── body: (length: 4) + ├── @ OrNode (location: (1,0)-(1,14)) + │ ├── left: + │ │ @ RangeNode (location: (1,0)-(1,5)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (1,0)-(1,1)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (1,0)-(1,1) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (1,4)-(1,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (1,4)-(1,5) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (1,1)-(1,4) = "..." + │ ├── right: + │ │ @ RangeNode (location: (1,9)-(1,14)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (1,9)-(1,10)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (1,9)-(1,10) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (1,13)-(1,14)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :d + │ │ │ ├── message_loc: (1,13)-(1,14) = "d" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (1,10)-(1,13) = "..." + │ └── operator_loc: (1,6)-(1,8) = "or" + ├── @ AndNode (location: (2,0)-(2,15)) + │ ├── left: + │ │ @ RangeNode (location: (2,0)-(2,5)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (2,0)-(2,1)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (2,0)-(2,1) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (2,4)-(2,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (2,4)-(2,5) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (2,1)-(2,4) = "..." + │ ├── right: + │ │ @ RangeNode (location: (2,10)-(2,15)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (2,10)-(2,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (2,10)-(2,11) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (2,14)-(2,15)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :d + │ │ │ ├── message_loc: (2,14)-(2,15) = "d" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (2,11)-(2,14) = "..." + │ └── operator_loc: (2,6)-(2,9) = "and" + ├── @ IfNode (location: (4,0)-(5,3)) + │ ├── if_keyword_loc: (4,0)-(4,2) = "if" + │ ├── predicate: + │ │ @ OrNode (location: (4,3)-(4,17)) + │ │ ├── left: + │ │ │ @ FlipFlopNode (location: (4,3)-(4,8)) + │ │ │ ├── flags: exclude_end + │ │ │ ├── left: + │ │ │ │ @ CallNode (location: (4,3)-(4,4)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (4,3)-(4,4) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── right: + │ │ │ │ @ CallNode (location: (4,7)-(4,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (4,7)-(4,8) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (4,4)-(4,7) = "..." + │ │ ├── right: + │ │ │ @ FlipFlopNode (location: (4,12)-(4,17)) + │ │ │ ├── flags: exclude_end + │ │ │ ├── left: + │ │ │ │ @ CallNode (location: (4,12)-(4,13)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :c + │ │ │ │ ├── message_loc: (4,12)-(4,13) = "c" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── right: + │ │ │ │ @ CallNode (location: (4,16)-(4,17)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :d + │ │ │ │ ├── message_loc: (4,16)-(4,17) = "d" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (4,13)-(4,16) = "..." + │ │ └── operator_loc: (4,9)-(4,11) = "or" + │ ├── then_keyword_loc: ∅ + │ ├── statements: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: (5,0)-(5,3) = "end" + └── @ IfNode (location: (7,0)-(8,3)) + ├── if_keyword_loc: (7,0)-(7,2) = "if" + ├── predicate: + │ @ AndNode (location: (7,3)-(7,18)) + │ ├── left: + │ │ @ FlipFlopNode (location: (7,3)-(7,8)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (7,3)-(7,4)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (7,3)-(7,4) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (7,7)-(7,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (7,7)-(7,8) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (7,4)-(7,7) = "..." + │ ├── right: + │ │ @ FlipFlopNode (location: (7,13)-(7,18)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (7,13)-(7,14)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (7,13)-(7,14) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (7,17)-(7,18)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :d + │ │ │ ├── message_loc: (7,17)-(7,18) = "d" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (7,14)-(7,17) = "..." + │ └── operator_loc: (7,9)-(7,12) = "and" + ├── then_keyword_loc: ∅ + ├── statements: ∅ + ├── consequent: ∅ + └── end_keyword_loc: (8,0)-(8,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/semantic/block.txt b/test/prism/snapshots/unparser/corpus/semantic/block.txt new file mode 100644 index 0000000000..b9aa6b2184 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/block.txt @@ -0,0 +1,191 @@ +@ ProgramNode (location: (1,0)-(26,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(26,3)) + └── body: (length: 6) + ├── @ CallNode (location: (1,0)-(2,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (1,0)-(1,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (1,4)-(2,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (1,4)-(1,6) = "do" + │ └── closing_loc: (2,0)-(2,3) = "end" + ├── @ CallNode (location: (4,0)-(6,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (4,0)-(4,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (4,4)-(6,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (4,4)-(6,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (5,0)-(5,6)) + │ │ │ ├── keyword_loc: (5,0)-(5,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (6,0)-(6,3) = "end" + │ ├── opening_loc: (4,4)-(4,6) = "do" + │ └── closing_loc: (6,0)-(6,3) = "end" + ├── @ CallNode (location: (8,0)-(11,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (8,0)-(8,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (8,4)-(11,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (9,2)-(10,5)) + │ │ └── body: (length: 2) + │ │ ├── @ RescueModifierNode (location: (9,2)-(9,16)) + │ │ │ ├── expression: + │ │ │ │ @ NilNode (location: (9,2)-(9,5)) + │ │ │ ├── keyword_loc: (9,6)-(9,12) = "rescue" + │ │ │ └── rescue_expression: + │ │ │ @ NilNode (location: (9,13)-(9,16)) + │ │ └── @ NilNode (location: (10,2)-(10,5)) + │ ├── opening_loc: (8,4)-(8,6) = "do" + │ └── closing_loc: (11,0)-(11,3) = "end" + ├── @ CallNode (location: (13,0)-(14,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (13,0)-(13,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (13,4)-(14,3)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (13,7)-(13,10)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (13,8)-(13,9)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (13,8)-(13,9)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (13,7)-(13,8) = "|" + │ │ └── closing_loc: (13,9)-(13,10) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (13,4)-(13,6) = "do" + │ └── closing_loc: (14,0)-(14,3) = "end" + ├── @ CallNode (location: (16,0)-(20,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (16,0)-(16,3) = "foo" + │ ├── opening_loc: (16,3)-(16,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (16,4)-(16,10)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ StringNode (location: (16,4)-(16,10)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (16,4)-(16,10) = "<<-DOC" + │ │ ├── content_loc: (17,0)-(18,0) = " b\n" + │ │ ├── closing_loc: (18,0)-(19,0) = "DOC\n" + │ │ └── unescaped: " b\n" + │ ├── closing_loc: (16,10)-(16,11) = ")" + │ └── block: + │ @ BlockNode (location: (16,12)-(20,3)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (16,15)-(16,18)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (16,16)-(16,17)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (16,16)-(16,17)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (16,15)-(16,16) = "|" + │ │ └── closing_loc: (16,17)-(16,18) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (19,2)-(19,3)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (19,2)-(19,3)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── opening_loc: (16,12)-(16,14) = "do" + │ └── closing_loc: (20,0)-(20,3) = "end" + └── @ CallNode (location: (22,0)-(26,3)) + ├── flags: ignore_visibility + ├── receiver: ∅ + ├── call_operator_loc: ∅ + ├── name: :foo + ├── message_loc: (22,0)-(22,3) = "foo" + ├── opening_loc: (22,3)-(22,4) = "(" + ├── arguments: + │ @ ArgumentsNode (location: (22,4)-(22,10)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ StringNode (location: (22,4)-(22,10)) + │ ├── flags: ∅ + │ ├── opening_loc: (22,4)-(22,10) = "<<-DOC" + │ ├── content_loc: (23,0)-(24,0) = " b\n" + │ ├── closing_loc: (24,0)-(25,0) = "DOC\n" + │ └── unescaped: " b\n" + ├── closing_loc: (22,10)-(22,11) = ")" + └── block: + @ BlockNode (location: (22,12)-(26,3)) + ├── locals: [] + ├── parameters: ∅ + ├── body: + │ @ StatementsNode (location: (25,2)-(25,3)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (25,2)-(25,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (25,2)-(25,3) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── opening_loc: (22,12)-(22,14) = "do" + └── closing_loc: (26,0)-(26,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/semantic/def.txt b/test/prism/snapshots/unparser/corpus/semantic/def.txt new file mode 100644 index 0000000000..b44983c2f3 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/def.txt @@ -0,0 +1,90 @@ +@ ProgramNode (location: (1,0)-(7,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(7,3)) + └── body: (length: 2) + ├── @ DefNode (location: (1,0)-(3,3)) + │ ├── name: :foo + │ ├── name_loc: (1,4)-(1,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (2,2)-(2,9)) + │ │ └── body: (length: 1) + │ │ └── @ ParenthesesNode (location: (2,2)-(2,9)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (2,3)-(2,8)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (2,3)-(2,8)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (2,3)-(2,4)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (2,3)-(2,4) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :- + │ │ │ ├── message_loc: (2,5)-(2,6) = "-" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (2,7)-(2,8)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (2,7)-(2,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (2,7)-(2,8) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (2,2)-(2,3) = "(" + │ │ └── closing_loc: (2,8)-(2,9) = ")" + │ ├── locals: [] + │ ├── def_keyword_loc: (1,0)-(1,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + └── @ DefNode (location: (5,0)-(7,3)) + ├── name: :foo + ├── name_loc: (5,4)-(5,7) = "foo" + ├── receiver: ∅ + ├── parameters: ∅ + ├── body: + │ @ StatementsNode (location: (6,2)-(6,20)) + │ └── body: (length: 1) + │ └── @ RescueModifierNode (location: (6,2)-(6,20)) + │ ├── expression: + │ │ @ CallNode (location: (6,2)-(6,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (6,2)-(6,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── keyword_loc: (6,4)-(6,10) = "rescue" + │ └── rescue_expression: + │ @ ConstantReadNode (location: (6,11)-(6,20)) + │ └── name: :Exception + ├── locals: [] + ├── def_keyword_loc: (5,0)-(5,3) = "def" + ├── operator_loc: ∅ + ├── lparen_loc: ∅ + ├── rparen_loc: ∅ + ├── equal_loc: ∅ + └── end_keyword_loc: (7,0)-(7,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/semantic/dstr.txt b/test/prism/snapshots/unparser/corpus/semantic/dstr.txt new file mode 100644 index 0000000000..499bf59d1a --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/dstr.txt @@ -0,0 +1,598 @@ +@ ProgramNode (location: (1,0)-(127,11)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(127,11)) + └── body: (length: 33) + ├── @ StringNode (location: (1,0)-(1,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (1,0)-(1,5) = "<<DOC" + │ ├── content_loc: (2,0)-(2,0) = "" + │ ├── closing_loc: (2,0)-(3,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (4,0)-(4,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (4,0)-(4,7) = "<<'DOC'" + │ ├── content_loc: (5,0)-(5,0) = "" + │ ├── closing_loc: (5,0)-(6,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (7,0)-(7,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (7,0)-(7,6) = "<<~DOC" + │ ├── content_loc: (8,0)-(8,0) = "" + │ ├── closing_loc: (8,0)-(9,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (10,0)-(10,8)) + │ ├── flags: ∅ + │ ├── opening_loc: (10,0)-(10,8) = "<<~'DOC'" + │ ├── content_loc: (11,0)-(11,0) = "" + │ ├── closing_loc: (11,0)-(12,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (13,0)-(13,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (13,0)-(13,5) = "<<DOC" + │ ├── content_loc: (14,0)-(15,0) = " a\n" + │ ├── closing_loc: (15,0)-(16,0) = "DOC\n" + │ └── unescaped: " a\n" + ├── @ StringNode (location: (17,0)-(17,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (17,0)-(17,7) = "<<'DOC'" + │ ├── content_loc: (18,0)-(19,0) = " a\n" + │ ├── closing_loc: (19,0)-(20,0) = "DOC\n" + │ └── unescaped: " a\n" + ├── @ InterpolatedStringNode (location: (21,0)-(21,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (21,0)-(21,5) = "<<DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (22,0)-(23,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (22,0)-(23,2) = " a\n " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " a\n " + │ │ ├── @ EmbeddedStatementsNode (location: (23,2)-(23,5)) + │ │ │ ├── opening_loc: (23,2)-(23,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (23,4)-(23,5) = "}" + │ │ └── @ StringNode (location: (23,5)-(24,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (23,5)-(24,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (24,0)-(25,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (26,0)-(26,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (26,0)-(26,6) = "<<~DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (27,0)-(28,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (27,0)-(28,0) = " a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (28,2)-(28,5)) + │ │ │ ├── opening_loc: (28,2)-(28,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (28,4)-(28,5) = "}" + │ │ └── @ StringNode (location: (28,5)-(29,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (28,5)-(29,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (29,0)-(30,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (31,0)-(31,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (31,0)-(31,6) = "<<~DOC" + │ ├── parts: (length: 4) + │ │ ├── @ StringNode (location: (32,0)-(33,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (32,0)-(33,0) = " a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (33,2)-(33,5)) + │ │ │ ├── opening_loc: (33,2)-(33,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (33,4)-(33,5) = "}" + │ │ ├── @ StringNode (location: (33,5)-(34,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (33,5)-(34,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── @ StringNode (location: (34,0)-(35,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (34,0)-(35,0) = " b\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "b\n" + │ └── closing_loc: (35,0)-(36,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (37,0)-(37,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (37,0)-(37,6) = "<<~DOC" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (38,0)-(39,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (38,0)-(39,0) = " a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ └── @ StringNode (location: (39,0)-(40,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (39,0)-(40,0) = " b\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: " b\n" + │ └── closing_loc: (40,0)-(41,0) = "DOC\n" + ├── @ StringNode (location: (42,0)-(42,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (42,0)-(42,7) = "<<'DOC'" + │ ├── content_loc: (43,0)-(46,0) = "a\n\nb\n" + │ ├── closing_loc: (46,0)-(47,0) = "DOC\n" + │ └── unescaped: "a\n\nb\n" + ├── @ StringNode (location: (48,0)-(48,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (48,0)-(48,7) = "<<'DOC'" + │ ├── content_loc: (49,0)-(52,0) = " a\n\n b\n" + │ ├── closing_loc: (52,0)-(53,0) = "DOC\n" + │ └── unescaped: " a\n\n b\n" + ├── @ StringNode (location: (54,0)-(54,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (54,0)-(54,7) = "<<'DOC'" + │ ├── content_loc: (55,0)-(56,0) = " a\\nb\n" + │ ├── closing_loc: (56,0)-(57,0) = "DOC\n" + │ └── unescaped: " a\\nb\n" + ├── @ InterpolatedStringNode (location: (58,0)-(58,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (58,0)-(58,5) = "<<DOC" + │ ├── parts: (length: 4) + │ │ ├── @ EmbeddedStatementsNode (location: (59,0)-(59,3)) + │ │ │ ├── opening_loc: (59,0)-(59,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (59,2)-(59,3) = "}" + │ │ ├── @ StringNode (location: (59,3)-(60,1)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (59,3)-(60,1) = "a\n " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n " + │ │ ├── @ EmbeddedStatementsNode (location: (60,1)-(60,4)) + │ │ │ ├── opening_loc: (60,1)-(60,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (60,3)-(60,4) = "}" + │ │ └── @ StringNode (location: (60,4)-(61,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (60,4)-(61,0) = "a\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "a\n" + │ └── closing_loc: (61,0)-(62,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (63,0)-(63,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (63,0)-(63,5) = "<<DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (64,0)-(64,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (64,0)-(64,2) = " " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " " + │ │ ├── @ EmbeddedStatementsNode (location: (64,2)-(64,5)) + │ │ │ ├── opening_loc: (64,2)-(64,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (64,4)-(64,5) = "}" + │ │ └── @ StringNode (location: (64,5)-(66,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (64,5)-(66,0) = "\n \\\#{}\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n \#{}\n" + │ └── closing_loc: (66,0)-(67,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (68,0)-(68,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (68,0)-(68,5) = "<<DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (69,0)-(69,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (69,0)-(69,2) = " a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " a" + │ │ ├── @ EmbeddedStatementsNode (location: (69,2)-(69,5)) + │ │ │ ├── opening_loc: (69,2)-(69,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (69,4)-(69,5) = "}" + │ │ └── @ StringNode (location: (69,5)-(71,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (69,5)-(71,0) = "b\n c\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "b\n c\n" + │ └── closing_loc: (71,0)-(72,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (73,0)-(73,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (73,0)-(73,6) = "<<~DOC" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (74,2)-(74,5)) + │ │ │ ├── opening_loc: (74,2)-(74,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (74,4)-(74,5) = "}" + │ │ └── @ StringNode (location: (74,5)-(75,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (74,5)-(75,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (75,0)-(76,0) = "DOC\n" + ├── @ IfNode (location: (77,0)-(81,3)) + │ ├── if_keyword_loc: (77,0)-(77,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (77,3)-(77,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (78,2)-(78,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (78,2)-(78,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (78,2)-(78,8) = "<<~DOC" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (79,4)-(79,7)) + │ │ │ │ ├── opening_loc: (79,4)-(79,6) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (79,6)-(79,7) = "}" + │ │ │ └── @ StringNode (location: (79,7)-(80,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (79,7)-(80,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (80,0)-(81,0) = " DOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (81,0)-(81,3) = "end" + ├── @ IfNode (location: (83,0)-(87,3)) + │ ├── if_keyword_loc: (83,0)-(83,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (83,3)-(83,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (84,2)-(84,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (84,2)-(84,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (84,2)-(84,8) = "<<~DOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (85,0)-(85,5)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (85,0)-(85,5) = " b" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "b" + │ │ │ ├── @ EmbeddedStatementsNode (location: (85,5)-(85,8)) + │ │ │ │ ├── opening_loc: (85,5)-(85,7) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (85,7)-(85,8) = "}" + │ │ │ └── @ StringNode (location: (85,8)-(86,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (85,8)-(86,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (86,0)-(87,0) = " DOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (87,0)-(87,3) = "end" + ├── @ IfNode (location: (89,0)-(93,3)) + │ ├── if_keyword_loc: (89,0)-(89,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (89,3)-(89,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (90,2)-(90,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (90,2)-(90,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (90,2)-(90,8) = "<<~DOC" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (91,4)-(91,7)) + │ │ │ │ ├── opening_loc: (91,4)-(91,6) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (91,6)-(91,7) = "}" + │ │ │ └── @ StringNode (location: (91,7)-(92,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (91,7)-(92,0) = "a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ └── closing_loc: (92,0)-(93,0) = " DOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (93,0)-(93,3) = "end" + ├── @ IfNode (location: (95,0)-(101,3)) + │ ├── if_keyword_loc: (95,0)-(95,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (95,3)-(95,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (96,2)-(96,10)) + │ │ └── body: (length: 1) + │ │ └── @ StringNode (location: (96,2)-(96,10)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (96,2)-(96,10) = "<<-'DOC'" + │ │ ├── content_loc: (97,0)-(100,0) = " a\n\n b\n" + │ │ ├── closing_loc: (100,0)-(101,0) = " DOC\n" + │ │ └── unescaped: " a\n\n b\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (101,0)-(101,3) = "end" + ├── @ InterpolatedStringNode (location: (103,0)-(103,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (103,0)-(103,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (103,1)-(103,4)) + │ │ │ ├── opening_loc: (103,1)-(103,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (103,3)-(103,4) = "}" + │ │ └── @ StringNode (location: (103,4)-(103,5)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (103,4)-(103,5) = "a" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "a" + │ └── closing_loc: (103,5)-(103,6) = "\"" + ├── @ InterpolatedStringNode (location: (105,0)-(105,12)) + │ ├── flags: ∅ + │ ├── opening_loc: (105,0)-(105,2) = "%(" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (105,2)-(105,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (105,2)-(105,5) = "\\n\"" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n\"" + │ │ ├── @ EmbeddedStatementsNode (location: (105,5)-(105,8)) + │ │ │ ├── opening_loc: (105,5)-(105,7) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (105,7)-(105,8) = "}" + │ │ └── @ StringNode (location: (105,8)-(105,11)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (105,8)-(105,11) = "\"\\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\"\n" + │ └── closing_loc: (105,11)-(105,12) = ")" + ├── @ InterpolatedStringNode (location: (107,0)-(107,14)) + │ ├── flags: ∅ + │ ├── opening_loc: (107,0)-(107,3) = "%Q(" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (107,3)-(107,7)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (107,3)-(107,7) = "-\\n\"" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "-\n\"" + │ │ ├── @ EmbeddedStatementsNode (location: (107,7)-(107,10)) + │ │ │ ├── opening_loc: (107,7)-(107,9) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (107,9)-(107,10) = "}" + │ │ └── @ StringNode (location: (107,10)-(107,13)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (107,10)-(107,13) = "\"\\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\"\n" + │ └── closing_loc: (107,13)-(107,14) = ")" + ├── @ InterpolatedStringNode (location: (109,0)-(111,2)) + │ ├── flags: ∅ + │ ├── opening_loc: (109,0)-(109,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (109,1)-(110,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (109,1)-(110,0) = "a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (110,0)-(110,3)) + │ │ │ ├── opening_loc: (110,0)-(110,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (110,2)-(110,3) = "}" + │ │ └── @ StringNode (location: (110,3)-(111,1)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (110,3)-(111,1) = "\nb" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\nb" + │ └── closing_loc: (111,1)-(111,2) = "\"" + ├── @ InterpolatedStringNode (location: (113,0)-(114,2)) + │ ├── flags: ∅ + │ ├── opening_loc: (113,0)-(113,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (113,1)-(113,4)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (113,1)-(113,4) = "a\\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (113,4)-(113,7)) + │ │ │ ├── opening_loc: (113,4)-(113,6) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (113,6)-(113,7) = "}" + │ │ └── @ StringNode (location: (113,7)-(114,1)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (113,7)-(114,1) = "\nb" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\nb" + │ └── closing_loc: (114,1)-(114,2) = "\"" + ├── @ InterpolatedStringNode (location: (116,0)-(117,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (116,0)-(116,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (116,1)-(117,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (116,1)-(117,0) = "a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (117,0)-(117,3)) + │ │ │ ├── opening_loc: (117,0)-(117,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (117,2)-(117,3) = "}" + │ │ └── @ StringNode (location: (117,3)-(117,6)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (117,3)-(117,6) = "\\nb" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\nb" + │ └── closing_loc: (117,6)-(117,7) = "\"" + ├── @ InterpolatedStringNode (location: (119,0)-(120,5)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (119,0)-(119,3)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (119,0)-(119,1) = "'" + │ │ │ ├── content_loc: (119,1)-(119,2) = "a" + │ │ │ ├── closing_loc: (119,2)-(119,3) = "'" + │ │ │ └── unescaped: "a" + │ │ └── @ InterpolatedStringNode (location: (120,0)-(120,5)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (120,0)-(120,1) = "\"" + │ │ ├── parts: (length: 1) + │ │ │ └── @ EmbeddedStatementsNode (location: (120,1)-(120,4)) + │ │ │ ├── opening_loc: (120,1)-(120,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (120,3)-(120,4) = "}" + │ │ └── closing_loc: (120,4)-(120,5) = "\"" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (122,0)-(122,8)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (122,0)-(122,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (122,0)-(122,1) = "\"" + │ │ │ ├── content_loc: (122,1)-(122,1) = "" + │ │ │ ├── closing_loc: (122,1)-(122,2) = "\"" + │ │ │ └── unescaped: "" + │ │ ├── @ StringNode (location: (122,3)-(122,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (122,3)-(122,4) = "\"" + │ │ │ ├── content_loc: (122,4)-(122,4) = "" + │ │ │ ├── closing_loc: (122,4)-(122,5) = "\"" + │ │ │ └── unescaped: "" + │ │ └── @ StringNode (location: (122,6)-(122,8)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (122,6)-(122,7) = "\"" + │ │ ├── content_loc: (122,7)-(122,7) = "" + │ │ ├── closing_loc: (122,7)-(122,8) = "\"" + │ │ └── unescaped: "" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (124,0)-(124,12)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (124,0)-(124,8)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (124,0)-(124,1) = "\"" + │ │ │ ├── parts: (length: 2) + │ │ │ │ ├── @ StringNode (location: (124,1)-(124,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (124,1)-(124,2) = "a" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ └── @ EmbeddedStatementsNode (location: (124,2)-(124,7)) + │ │ │ │ ├── opening_loc: (124,2)-(124,4) = "\#{" + │ │ │ │ ├── statements: + │ │ │ │ │ @ StatementsNode (location: (124,4)-(124,6)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ InstanceVariableReadNode (location: (124,4)-(124,6)) + │ │ │ │ │ └── name: :@a + │ │ │ │ └── closing_loc: (124,6)-(124,7) = "}" + │ │ │ └── closing_loc: (124,7)-(124,8) = "\"" + │ │ └── @ StringNode (location: (124,9)-(124,12)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (124,9)-(124,10) = "\"" + │ │ ├── content_loc: (124,10)-(124,11) = "b" + │ │ ├── closing_loc: (124,11)-(124,12) = "\"" + │ │ └── unescaped: "b" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (125,0)-(125,10)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (125,0)-(125,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (125,0)-(125,1) = "\"" + │ │ │ ├── parts: (length: 2) + │ │ │ │ ├── @ StringNode (location: (125,1)-(125,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (125,1)-(125,2) = "a" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ └── @ EmbeddedVariableNode (location: (125,2)-(125,5)) + │ │ │ │ ├── operator_loc: (125,2)-(125,3) = "#" + │ │ │ │ └── variable: + │ │ │ │ @ InstanceVariableReadNode (location: (125,3)-(125,5)) + │ │ │ │ └── name: :@a + │ │ │ └── closing_loc: (125,5)-(125,6) = "\"" + │ │ └── @ StringNode (location: (125,7)-(125,10)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (125,7)-(125,8) = "\"" + │ │ ├── content_loc: (125,8)-(125,9) = "b" + │ │ ├── closing_loc: (125,9)-(125,10) = "\"" + │ │ └── unescaped: "b" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (126,0)-(126,10)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (126,0)-(126,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (126,0)-(126,1) = "\"" + │ │ │ ├── parts: (length: 2) + │ │ │ │ ├── @ StringNode (location: (126,1)-(126,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (126,1)-(126,2) = "a" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ └── @ EmbeddedVariableNode (location: (126,2)-(126,5)) + │ │ │ │ ├── operator_loc: (126,2)-(126,3) = "#" + │ │ │ │ └── variable: + │ │ │ │ @ GlobalVariableReadNode (location: (126,3)-(126,5)) + │ │ │ │ └── name: :$a + │ │ │ └── closing_loc: (126,5)-(126,6) = "\"" + │ │ └── @ StringNode (location: (126,7)-(126,10)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (126,7)-(126,8) = "\"" + │ │ ├── content_loc: (126,8)-(126,9) = "b" + │ │ ├── closing_loc: (126,9)-(126,10) = "\"" + │ │ └── unescaped: "b" + │ └── closing_loc: ∅ + └── @ InterpolatedStringNode (location: (127,0)-(127,11)) + ├── flags: ∅ + ├── opening_loc: ∅ + ├── parts: (length: 2) + │ ├── @ InterpolatedStringNode (location: (127,0)-(127,7)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (127,0)-(127,1) = "\"" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ StringNode (location: (127,1)-(127,2)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (127,1)-(127,2) = "a" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "a" + │ │ │ └── @ EmbeddedVariableNode (location: (127,2)-(127,6)) + │ │ │ ├── operator_loc: (127,2)-(127,3) = "#" + │ │ │ └── variable: + │ │ │ @ ClassVariableReadNode (location: (127,3)-(127,6)) + │ │ │ └── name: :@@a + │ │ └── closing_loc: (127,6)-(127,7) = "\"" + │ └── @ StringNode (location: (127,8)-(127,11)) + │ ├── flags: frozen + │ ├── opening_loc: (127,8)-(127,9) = "\"" + │ ├── content_loc: (127,9)-(127,10) = "b" + │ ├── closing_loc: (127,10)-(127,11) = "\"" + │ └── unescaped: "b" + └── closing_loc: ∅ diff --git a/test/prism/snapshots/unparser/corpus/semantic/kwbegin.txt b/test/prism/snapshots/unparser/corpus/semantic/kwbegin.txt new file mode 100644 index 0000000000..38486ddc12 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/kwbegin.txt @@ -0,0 +1,259 @@ +@ ProgramNode (location: (1,0)-(42,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(42,3)) + └── body: (length: 8) + ├── @ BeginNode (location: (1,0)-(3,3)) + │ ├── begin_keyword_loc: (1,0)-(1,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (2,0)-(2,6)) + │ │ ├── keyword_loc: (2,0)-(2,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + ├── @ BeginNode (location: (5,0)-(8,3)) + │ ├── begin_keyword_loc: (5,0)-(5,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (6,0)-(6,6)) + │ │ ├── keyword_loc: (6,0)-(6,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: + │ │ @ ElseNode (location: (7,0)-(8,3)) + │ │ ├── else_keyword_loc: (7,0)-(7,4) = "else" + │ │ ├── statements: ∅ + │ │ └── end_keyword_loc: (8,0)-(8,3) = "end" + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (8,0)-(8,3) = "end" + ├── @ BeginNode (location: (10,0)-(12,3)) + │ ├── begin_keyword_loc: (10,0)-(10,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (11,2)-(11,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (11,2)-(11,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (11,2)-(11,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (12,0)-(12,3) = "end" + ├── @ BeginNode (location: (14,0)-(18,3)) + │ ├── begin_keyword_loc: (14,0)-(14,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (15,2)-(15,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (15,2)-(15,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (15,2)-(15,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (16,0)-(17,3)) + │ │ ├── keyword_loc: (16,0)-(16,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (17,2)-(17,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (17,2)-(17,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (17,2)-(17,3) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (18,0)-(18,3) = "end" + ├── @ BeginNode (location: (20,0)-(25,3)) + │ ├── begin_keyword_loc: (20,0)-(20,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (21,2)-(22,3)) + │ │ └── body: (length: 2) + │ │ ├── @ CallNode (location: (21,2)-(21,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (21,2)-(21,3) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (22,2)-(22,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (22,2)-(22,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (23,0)-(24,3)) + │ │ ├── keyword_loc: (23,0)-(23,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (24,2)-(24,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (24,2)-(24,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (24,2)-(24,3) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (25,0)-(25,3) = "end" + ├── @ BeginNode (location: (27,0)-(30,3)) + │ ├── begin_keyword_loc: (27,0)-(27,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (28,0)-(28,8)) + │ │ ├── keyword_loc: (28,0)-(28,6) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ ConstantReadNode (location: (28,7)-(28,8)) + │ │ │ └── name: :A + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: + │ │ @ ElseNode (location: (29,0)-(30,3)) + │ │ ├── else_keyword_loc: (29,0)-(29,4) = "else" + │ │ ├── statements: ∅ + │ │ └── end_keyword_loc: (30,0)-(30,3) = "end" + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (30,0)-(30,3) = "end" + ├── @ BeginNode (location: (32,0)-(32,26)) + │ ├── begin_keyword_loc: (32,0)-(32,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (32,7)-(32,15)) + │ │ ├── keyword_loc: (32,7)-(32,13) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ ConstantReadNode (location: (32,14)-(32,15)) + │ │ │ └── name: :A + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: + │ │ @ ElseNode (location: (32,17)-(32,26)) + │ │ ├── else_keyword_loc: (32,17)-(32,21) = "else" + │ │ ├── statements: ∅ + │ │ └── end_keyword_loc: (32,23)-(32,26) = "end" + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (32,23)-(32,26) = "end" + └── @ BeginNode (location: (34,0)-(42,3)) + ├── begin_keyword_loc: (34,0)-(34,5) = "begin" + ├── statements: + │ @ StatementsNode (location: (35,2)-(35,3)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (35,2)-(35,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (35,2)-(35,3) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── rescue_clause: + │ @ RescueNode (location: (36,0)-(39,3)) + │ ├── keyword_loc: (36,0)-(36,6) = "rescue" + │ ├── exceptions: (length: 1) + │ │ └── @ ConstantReadNode (location: (36,7)-(36,8)) + │ │ └── name: :A + │ ├── operator_loc: ∅ + │ ├── reference: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (37,2)-(37,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (37,2)-(37,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (37,2)-(37,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── consequent: + │ @ RescueNode (location: (38,0)-(39,3)) + │ ├── keyword_loc: (38,0)-(38,6) = "rescue" + │ ├── exceptions: (length: 1) + │ │ └── @ ConstantReadNode (location: (38,7)-(38,8)) + │ │ └── name: :B + │ ├── operator_loc: ∅ + │ ├── reference: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (39,2)-(39,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (39,2)-(39,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :c + │ │ ├── message_loc: (39,2)-(39,3) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── consequent: ∅ + ├── else_clause: ∅ + ├── ensure_clause: + │ @ EnsureNode (location: (40,0)-(42,3)) + │ ├── ensure_keyword_loc: (40,0)-(40,6) = "ensure" + │ ├── statements: + │ │ @ StatementsNode (location: (41,2)-(41,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (41,2)-(41,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (41,2)-(41,3) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── end_keyword_loc: (42,0)-(42,3) = "end" + └── end_keyword_loc: (42,0)-(42,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/semantic/literal.txt b/test/prism/snapshots/unparser/corpus/semantic/literal.txt new file mode 100644 index 0000000000..448207f5d3 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/literal.txt @@ -0,0 +1,102 @@ +@ ProgramNode (location: (1,0)-(14,10)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(14,10)) + └── body: (length: 14) + ├── @ RationalNode (location: (1,0)-(1,4)) + │ ├── flags: decimal + │ ├── numerator: 1 + │ └── denominator: 1 + ├── @ RationalNode (location: (2,0)-(2,3)) + │ ├── flags: decimal + │ ├── numerator: 0 + │ └── denominator: 1 + ├── @ IntegerNode (location: (3,0)-(3,3)) + │ ├── flags: hexadecimal + │ └── value: 1 + ├── @ IntegerNode (location: (4,0)-(4,5)) + │ ├── flags: decimal + │ └── value: 1000 + ├── @ FloatNode (location: (5,0)-(5,4)) + │ └── value: 10000000000.0 + ├── @ FloatNode (location: (6,0)-(6,14)) + │ └── value: Infinity + ├── @ FloatNode (location: (7,0)-(7,15)) + │ └── value: -Infinity + ├── @ StringNode (location: (8,0)-(8,2)) + │ ├── flags: ∅ + │ ├── opening_loc: (8,0)-(8,1) = "?" + │ ├── content_loc: (8,1)-(8,2) = "c" + │ ├── closing_loc: ∅ + │ └── unescaped: "c" + ├── @ RegularExpressionNode (location: (9,0)-(9,5)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (9,0)-(9,3) = "%r(" + │ ├── content_loc: (9,3)-(9,4) = "/" + │ ├── closing_loc: (9,4)-(9,5) = ")" + │ └── unescaped: "/" + ├── @ RegularExpressionNode (location: (10,0)-(10,6)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (10,0)-(10,3) = "%r(" + │ ├── content_loc: (10,3)-(10,5) = "\\)" + │ ├── closing_loc: (10,5)-(10,6) = ")" + │ └── unescaped: "\\)" + ├── @ InterpolatedRegularExpressionNode (location: (11,0)-(11,14)) + │ ├── flags: ∅ + │ ├── opening_loc: (11,0)-(11,3) = "%r(" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (11,3)-(11,10)) + │ │ │ ├── opening_loc: (11,3)-(11,5) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (11,5)-(11,9)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ InstanceVariableReadNode (location: (11,5)-(11,9)) + │ │ │ │ └── name: :@bar + │ │ │ └── closing_loc: (11,9)-(11,10) = "}" + │ │ └── @ StringNode (location: (11,10)-(11,13)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (11,10)-(11,13) = "baz" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "baz" + │ └── closing_loc: (11,13)-(11,14) = ")" + ├── @ FloatNode (location: (12,0)-(12,16)) + │ └── value: Infinity + ├── @ FloatNode (location: (13,0)-(13,17)) + │ └── value: -Infinity + └── @ CallNode (location: (14,0)-(14,10)) + ├── flags: ignore_visibility + ├── receiver: ∅ + ├── call_operator_loc: ∅ + ├── name: :w + ├── message_loc: (14,0)-(14,1) = "w" + ├── opening_loc: (14,1)-(14,2) = "(" + ├── arguments: + │ @ ArgumentsNode (location: (14,2)-(14,9)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ CallNode (location: (14,2)-(14,9)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (14,2)-(14,5) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (14,6)-(14,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (14,6)-(14,9)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (14,6)-(14,9) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── closing_loc: (14,9)-(14,10) = ")" + └── block: ∅ diff --git a/test/prism/snapshots/unparser/corpus/semantic/opasgn.txt b/test/prism/snapshots/unparser/corpus/semantic/opasgn.txt new file mode 100644 index 0000000000..7dd26a38dc --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/opasgn.txt @@ -0,0 +1,69 @@ +@ ProgramNode (location: (1,0)-(1,25)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(1,25)) + └── body: (length: 1) + └── @ IndexOperatorWriteNode (location: (1,0)-(1,25)) + ├── flags: ∅ + ├── receiver: + │ @ CallNode (location: (1,0)-(1,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :y + │ ├── message_loc: (1,0)-(1,1) = "y" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── call_operator_loc: ∅ + ├── opening_loc: (1,1)-(1,2) = "[" + ├── arguments: + │ @ ArgumentsNode (location: (1,2)-(1,11)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ InterpolatedStringNode (location: (1,2)-(1,11)) + │ ├── flags: ∅ + │ ├── opening_loc: (1,2)-(1,3) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (1,3)-(1,8)) + │ │ │ ├── opening_loc: (1,3)-(1,5) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (1,5)-(1,7)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (1,5)-(1,7)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 42 + │ │ │ └── closing_loc: (1,7)-(1,8) = "}" + │ │ └── @ StringNode (location: (1,8)-(1,10)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (1,8)-(1,10) = "\\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (1,10)-(1,11) = "\"" + ├── closing_loc: (1,11)-(1,12) = "]" + ├── block: ∅ + ├── binary_operator: :+ + ├── binary_operator_loc: (1,13)-(1,15) = "+=" + └── value: + @ InterpolatedStringNode (location: (1,16)-(1,25)) + ├── flags: ∅ + ├── opening_loc: (1,16)-(1,17) = "\"" + ├── parts: (length: 2) + │ ├── @ EmbeddedStatementsNode (location: (1,17)-(1,22)) + │ │ ├── opening_loc: (1,17)-(1,19) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (1,19)-(1,21)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ IntegerNode (location: (1,19)-(1,21)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 42 + │ │ └── closing_loc: (1,21)-(1,22) = "}" + │ └── @ StringNode (location: (1,22)-(1,24)) + │ ├── flags: frozen + │ ├── opening_loc: ∅ + │ ├── content_loc: (1,22)-(1,24) = "\\n" + │ ├── closing_loc: ∅ + │ └── unescaped: "\n" + └── closing_loc: (1,24)-(1,25) = "\"" diff --git a/test/prism/snapshots/unparser/corpus/semantic/send.txt b/test/prism/snapshots/unparser/corpus/semantic/send.txt new file mode 100644 index 0000000000..7c152c3bfb --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/send.txt @@ -0,0 +1,163 @@ +@ ProgramNode (location: (1,0)-(6,15)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(6,15)) + └── body: (length: 4) + ├── @ CallNode (location: (1,0)-(1,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (1,0)-(1,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (2,0)-(2,6)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (2,0)-(2,3) = "foo" + │ ├── opening_loc: (2,3)-(2,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (2,4)-(2,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (2,4)-(2,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── closing_loc: (2,5)-(2,6) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (4,0)-(4,15)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (4,0)-(4,10)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (4,0)-(4,8)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (4,0)-(4,1)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (4,0)-(4,1) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: (4,1)-(4,2) = "." + │ │ │ ├── name: :=== + │ │ │ ├── message_loc: (4,2)-(4,5) = "===" + │ │ │ ├── opening_loc: (4,5)-(4,6) = "(" + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (4,6)-(4,7)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (4,6)-(4,7)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (4,6)-(4,7) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: (4,7)-(4,8) = ")" + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (4,8)-(4,9) = "." + │ │ ├── name: :c + │ │ ├── message_loc: (4,9)-(4,10) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :== + │ ├── message_loc: (4,11)-(4,13) = "==" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (4,14)-(4,15)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (4,14)-(4,15)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (4,14)-(4,15) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── @ CallNode (location: (6,0)-(6,15)) + ├── flags: ∅ + ├── receiver: + │ @ CallNode (location: (6,0)-(6,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (6,0)-(6,1) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── call_operator_loc: ∅ + ├── name: :== + ├── message_loc: (6,2)-(6,4) = "==" + ├── opening_loc: ∅ + ├── arguments: + │ @ ArgumentsNode (location: (6,5)-(6,15)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ CallNode (location: (6,5)-(6,15)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (6,5)-(6,8)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (6,5)-(6,6)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :d + │ │ │ ├── message_loc: (6,5)-(6,6) = "d" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (6,6)-(6,7) = "." + │ │ ├── name: :c + │ │ ├── message_loc: (6,7)-(6,8) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (6,8)-(6,9) = "." + │ ├── name: :=== + │ ├── message_loc: (6,9)-(6,12) = "===" + │ ├── opening_loc: (6,12)-(6,13) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (6,13)-(6,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (6,13)-(6,14)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :c + │ │ ├── message_loc: (6,13)-(6,14) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (6,14)-(6,15) = ")" + │ └── block: ∅ + ├── closing_loc: ∅ + └── block: ∅ diff --git a/test/prism/snapshots/unparser/corpus/semantic/undef.txt b/test/prism/snapshots/unparser/corpus/semantic/undef.txt new file mode 100644 index 0000000000..ecb073148d --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/undef.txt @@ -0,0 +1,29 @@ +@ ProgramNode (location: (1,0)-(2,14)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(2,14)) + └── body: (length: 2) + ├── @ UndefNode (location: (1,0)-(1,9)) + │ ├── names: (length: 1) + │ │ └── @ SymbolNode (location: (1,6)-(1,9)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: ∅ + │ │ ├── value_loc: (1,6)-(1,9) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ └── keyword_loc: (1,0)-(1,5) = "undef" + └── @ UndefNode (location: (2,0)-(2,14)) + ├── names: (length: 2) + │ ├── @ SymbolNode (location: (2,6)-(2,9)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: ∅ + │ │ ├── value_loc: (2,6)-(2,9) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ └── @ SymbolNode (location: (2,11)-(2,14)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: ∅ + │ ├── value_loc: (2,11)-(2,14) = "bar" + │ ├── closing_loc: ∅ + │ └── unescaped: "bar" + └── keyword_loc: (2,0)-(2,5) = "undef" diff --git a/test/prism/snapshots/unparser/corpus/semantic/while.txt b/test/prism/snapshots/unparser/corpus/semantic/while.txt new file mode 100644 index 0000000000..36bfba5be6 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/while.txt @@ -0,0 +1,277 @@ +@ ProgramNode (location: (1,0)-(25,3)) +├── locals: [:foo, :a] +└── statements: + @ StatementsNode (location: (1,0)-(25,3)) + └── body: (length: 7) + ├── @ UntilNode (location: (1,0)-(1,13)) + │ ├── flags: ∅ + │ ├── keyword_loc: (1,2)-(1,7) = "until" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ CallNode (location: (1,8)-(1,13)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b? + │ │ ├── message_loc: (1,8)-(1,10) = "b?" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (1,11)-(1,13)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (1,11)-(1,12) = "{" + │ │ └── closing_loc: (1,12)-(1,13) = "}" + │ └── statements: + │ @ StatementsNode (location: (1,0)-(1,1)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (1,0)-(1,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (1,0)-(1,1) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ UntilNode (location: (3,0)-(5,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (3,0)-(3,5) = "until" + │ ├── closing_loc: (5,0)-(5,3) = "end" + │ ├── predicate: + │ │ @ CallNode (location: (3,6)-(3,11)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b? + │ │ ├── message_loc: (3,6)-(3,8) = "b?" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (3,9)-(3,11)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (3,9)-(3,10) = "{" + │ │ └── closing_loc: (3,10)-(3,11) = "}" + │ └── statements: + │ @ StatementsNode (location: (4,2)-(4,3)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (4,2)-(4,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (4,2)-(4,3) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ WhileNode (location: (7,0)-(7,19)) + │ ├── flags: ∅ + │ ├── keyword_loc: (7,10)-(7,15) = "while" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ LocalVariableReadNode (location: (7,16)-(7,19)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ └── statements: + │ @ StatementsNode (location: (7,0)-(7,9)) + │ └── body: (length: 1) + │ └── @ LocalVariableWriteNode (location: (7,0)-(7,9)) + │ ├── name: :foo + │ ├── depth: 0 + │ ├── name_loc: (7,0)-(7,3) = "foo" + │ ├── value: + │ │ @ CallNode (location: (7,6)-(7,9)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (7,6)-(7,9) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (7,4)-(7,5) = "=" + ├── @ UntilNode (location: (9,0)-(9,18)) + │ ├── flags: ∅ + │ ├── keyword_loc: (9,2)-(9,7) = "until" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ AndNode (location: (9,8)-(9,18)) + │ │ ├── left: + │ │ │ @ CallNode (location: (9,8)-(9,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (9,8)-(9,9) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (9,13)-(9,18)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (9,13)-(9,14) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (9,15)-(9,18)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (9,15)-(9,16) = "{" + │ │ │ └── closing_loc: (9,17)-(9,18) = "}" + │ │ └── operator_loc: (9,10)-(9,12) = "&&" + │ └── statements: + │ @ StatementsNode (location: (9,0)-(9,1)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (9,0)-(9,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (9,0)-(9,1) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ WhileNode (location: (11,0)-(13,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (11,0)-(11,5) = "while" + │ ├── closing_loc: (13,0)-(13,3) = "end" + │ ├── predicate: + │ │ @ LocalVariableWriteNode (location: (11,6)-(11,11)) + │ │ ├── name: :a + │ │ ├── depth: 0 + │ │ ├── name_loc: (11,6)-(11,7) = "a" + │ │ ├── value: + │ │ │ @ CallNode (location: (11,10)-(11,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (11,10)-(11,11) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (11,8)-(11,9) = "=" + │ └── statements: + │ @ StatementsNode (location: (12,2)-(12,3)) + │ └── body: (length: 1) + │ └── @ LocalVariableReadNode (location: (12,2)-(12,3)) + │ ├── name: :a + │ └── depth: 0 + ├── @ UntilNode (location: (15,0)-(18,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (15,2)-(15,7) = "until" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ CallNode (location: (15,8)-(18,3)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (15,8)-(15,9) = "b" + │ │ ├── opening_loc: (15,9)-(15,10) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (15,10)-(15,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ StringNode (location: (15,10)-(15,16)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (15,10)-(15,16) = "<<-FOO" + │ │ │ ├── content_loc: (16,0)-(16,0) = "" + │ │ │ ├── closing_loc: (16,0)-(17,0) = "FOO\n" + │ │ │ └── unescaped: "" + │ │ ├── closing_loc: (15,16)-(15,17) = ")" + │ │ └── block: + │ │ @ BlockNode (location: (15,18)-(18,3)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: + │ │ │ @ StatementsNode (location: (17,2)-(17,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (17,2)-(17,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (17,2)-(17,3) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (15,18)-(15,20) = "do" + │ │ └── closing_loc: (18,0)-(18,3) = "end" + │ └── statements: + │ @ StatementsNode (location: (15,0)-(15,1)) + │ └── body: (length: 1) + │ └── @ LocalVariableReadNode (location: (15,0)-(15,1)) + │ ├── name: :a + │ └── depth: 0 + └── @ ModuleNode (location: (20,0)-(25,3)) + ├── locals: [:foo] + ├── module_keyword_loc: (20,0)-(20,6) = "module" + ├── constant_path: + │ @ ConstantReadNode (location: (20,7)-(20,8)) + │ └── name: :A + ├── body: + │ @ StatementsNode (location: (21,2)-(24,5)) + │ └── body: (length: 2) + │ ├── @ LocalVariableWriteNode (location: (21,2)-(21,11)) + │ │ ├── name: :foo + │ │ ├── depth: 0 + │ │ ├── name_loc: (21,2)-(21,5) = "foo" + │ │ ├── value: + │ │ │ @ CallNode (location: (21,8)-(21,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :exp + │ │ │ ├── message_loc: (21,8)-(21,11) = "exp" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (21,6)-(21,7) = "=" + │ └── @ WhileNode (location: (22,2)-(24,5)) + │ ├── flags: ∅ + │ ├── keyword_loc: (22,2)-(22,7) = "while" + │ ├── closing_loc: (24,2)-(24,5) = "end" + │ ├── predicate: + │ │ @ LocalVariableReadNode (location: (22,8)-(22,11)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ └── statements: + │ @ StatementsNode (location: (23,4)-(23,13)) + │ └── body: (length: 1) + │ └── @ LocalVariableWriteNode (location: (23,4)-(23,13)) + │ ├── name: :foo + │ ├── depth: 0 + │ ├── name_loc: (23,4)-(23,7) = "foo" + │ ├── value: + │ │ @ CallNode (location: (23,10)-(23,13)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (23,10)-(23,13) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (23,8)-(23,9) = "=" + ├── end_keyword_loc: (25,0)-(25,3) = "end" + └── name: :A |