diff options
Diffstat (limited to 'test/prism/snapshots/unparser/corpus/literal/dstr.txt')
| -rw-r--r-- | test/prism/snapshots/unparser/corpus/literal/dstr.txt | 353 |
1 files changed, 353 insertions, 0 deletions
diff --git a/test/prism/snapshots/unparser/corpus/literal/dstr.txt b/test/prism/snapshots/unparser/corpus/literal/dstr.txt new file mode 100644 index 0000000000..8893e8b75d --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/dstr.txt @@ -0,0 +1,353 @@ +@ ProgramNode (location: (1,0)-(37,1)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(37,1)) + └── body: (length: 11) + ├── @ IfNode (location: (1,0)-(3,3)) + │ ├── if_keyword_loc: (1,0)-(1,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (1,3)-(1,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (2,2)-(2,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (2,2)-(2,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (2,2)-(2,3) = "\"" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (2,3)-(2,6)) + │ │ │ │ ├── opening_loc: (2,3)-(2,5) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (2,5)-(2,6) = "}" + │ │ │ └── @ StringNode (location: (2,6)-(2,7)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (2,6)-(2,7) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── closing_loc: (2,7)-(2,8) = "\"" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + ├── @ IfNode (location: (4,0)-(11,3)) + │ ├── if_keyword_loc: (4,0)-(4,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (4,3)-(4,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (5,2)-(10,3)) + │ │ └── body: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (5,2)-(5,12)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (5,2)-(5,12) = "<<-HEREDOC" + │ │ │ ├── parts: (length: 3) + │ │ │ │ ├── @ StringNode (location: (6,0)-(7,0)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (6,0)-(7,0) = "a\n" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a\n" + │ │ │ │ ├── @ EmbeddedStatementsNode (location: (7,0)-(7,3)) + │ │ │ │ │ ├── opening_loc: (7,0)-(7,2) = "\#{" + │ │ │ │ │ ├── statements: ∅ + │ │ │ │ │ └── closing_loc: (7,2)-(7,3) = "}" + │ │ │ │ └── @ StringNode (location: (7,3)-(9,0)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (7,3)-(9,0) = "a\nb\n" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "a\nb\n" + │ │ │ └── closing_loc: (9,0)-(10,0) = " HEREDOC\n" + │ │ └── @ CallNode (location: (10,2)-(10,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :x + │ │ ├── message_loc: (10,2)-(10,3) = "x" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: (11,0)-(11,3) = "end" + ├── @ InterpolatedStringNode (location: (12,0)-(12,10)) + │ ├── flags: ∅ + │ ├── opening_loc: (12,0)-(12,10) = "<<-HEREDOC" + │ ├── parts: (length: 7) + │ │ ├── @ StringNode (location: (13,0)-(14,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (13,0)-(14,0) = "\\\#{}\\\#{}\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\#{}\#{}\n" + │ │ ├── @ EmbeddedStatementsNode (location: (14,0)-(14,3)) + │ │ │ ├── opening_loc: (14,0)-(14,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (14,2)-(14,3) = "}" + │ │ ├── @ StringNode (location: (14,3)-(15,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (14,3)-(15,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ ├── @ EmbeddedStatementsNode (location: (15,0)-(15,3)) + │ │ │ ├── opening_loc: (15,0)-(15,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (15,2)-(15,3) = "}" + │ │ ├── @ StringNode (location: (15,3)-(16,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (15,3)-(16,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ ├── @ EmbeddedStatementsNode (location: (16,0)-(16,3)) + │ │ │ ├── opening_loc: (16,0)-(16,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (16,2)-(16,3) = "}" + │ │ └── @ StringNode (location: (16,3)-(17,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (16,3)-(17,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (17,0)-(18,0) = "HEREDOC\n" + ├── @ RescueModifierNode (location: (18,0)-(18,21)) + │ ├── expression: + │ │ @ InterpolatedStringNode (location: (18,0)-(18,10)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (18,0)-(18,10) = "<<-HEREDOC" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (19,0)-(19,3)) + │ │ │ │ ├── opening_loc: (19,0)-(19,2) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (19,2)-(19,3) = "}" + │ │ │ └── @ StringNode (location: (19,3)-(21,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (19,3)-(21,0) = "\na\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\na\n" + │ │ └── closing_loc: (21,0)-(22,0) = "HEREDOC\n" + │ ├── keyword_loc: (18,11)-(18,17) = "rescue" + │ └── rescue_expression: + │ @ NilNode (location: (18,18)-(18,21)) + ├── @ InterpolatedStringNode (location: (22,0)-(22,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (22,0)-(22,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (22,1)-(22,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (22,1)-(22,2) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ EmbeddedVariableNode (location: (22,2)-(22,5)) + │ │ ├── operator_loc: (22,2)-(22,3) = "#" + │ │ └── variable: + │ │ @ NumberedReferenceReadNode (location: (22,3)-(22,5)) + │ │ └── number: 1 + │ └── closing_loc: (22,5)-(22,6) = "\"" + ├── @ InterpolatedStringNode (location: (23,0)-(23,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (23,0)-(23,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (23,1)-(23,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (23,1)-(23,2) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ EmbeddedVariableNode (location: (23,2)-(23,5)) + │ │ ├── operator_loc: (23,2)-(23,3) = "#" + │ │ └── variable: + │ │ @ GlobalVariableReadNode (location: (23,3)-(23,5)) + │ │ └── name: :$a + │ └── closing_loc: (23,5)-(23,6) = "\"" + ├── @ InterpolatedStringNode (location: (24,0)-(24,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (24,0)-(24,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (24,1)-(24,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (24,1)-(24,2) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ EmbeddedVariableNode (location: (24,2)-(24,5)) + │ │ ├── operator_loc: (24,2)-(24,3) = "#" + │ │ └── variable: + │ │ @ InstanceVariableReadNode (location: (24,3)-(24,5)) + │ │ └── name: :@a + │ └── closing_loc: (24,5)-(24,6) = "\"" + ├── @ InterpolatedStringNode (location: (25,0)-(25,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (25,0)-(25,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (25,1)-(25,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (25,1)-(25,2) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ EmbeddedVariableNode (location: (25,2)-(25,6)) + │ │ ├── operator_loc: (25,2)-(25,3) = "#" + │ │ └── variable: + │ │ @ ClassVariableReadNode (location: (25,3)-(25,6)) + │ │ └── name: :@@a + │ └── closing_loc: (25,6)-(25,7) = "\"" + ├── @ IfNode (location: (26,0)-(30,3)) + │ ├── if_keyword_loc: (26,0)-(26,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (26,3)-(26,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (27,2)-(27,19)) + │ │ └── body: (length: 1) + │ │ └── @ ReturnNode (location: (27,2)-(27,19)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (27,2)-(27,8) = "return" + │ │ └── arguments: + │ │ @ ArgumentsNode (location: (27,9)-(27,19)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (27,9)-(27,19)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (27,9)-(27,19) = "<<-HEREDOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (28,0)-(28,4)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (28,0)-(28,4) = " " + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: " " + │ │ │ ├── @ EmbeddedStatementsNode (location: (28,4)-(28,9)) + │ │ │ │ ├── opening_loc: (28,4)-(28,6) = "\#{" + │ │ │ │ ├── statements: + │ │ │ │ │ @ StatementsNode (location: (28,6)-(28,8)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ IntegerNode (location: (28,6)-(28,8)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 42 + │ │ │ │ └── closing_loc: (28,8)-(28,9) = "}" + │ │ │ └── @ StringNode (location: (28,9)-(29,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (28,9)-(29,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (29,0)-(30,0) = " HEREDOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (30,0)-(30,3) = "end" + ├── @ CallNode (location: (31,0)-(31,15)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (31,0)-(31,3) = "foo" + │ ├── opening_loc: (31,3)-(31,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (31,4)-(31,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (31,4)-(31,14)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (31,4)-(31,14) = "<<-HEREDOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (32,0)-(32,2)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (32,0)-(32,2) = " " + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: " " + │ │ │ ├── @ EmbeddedStatementsNode (location: (32,2)-(32,8)) + │ │ │ │ ├── opening_loc: (32,2)-(32,4) = "\#{" + │ │ │ │ ├── statements: + │ │ │ │ │ @ StatementsNode (location: (32,4)-(32,7)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ CallNode (location: (32,4)-(32,7)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :bar + │ │ │ │ │ ├── message_loc: (32,4)-(32,7) = "bar" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ └── closing_loc: (32,7)-(32,8) = "}" + │ │ │ └── @ StringNode (location: (32,8)-(33,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (32,8)-(33,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (33,0)-(34,0) = "HEREDOC\n" + │ ├── closing_loc: (31,14)-(31,15) = ")" + │ └── block: ∅ + └── @ CallNode (location: (34,0)-(37,1)) + ├── flags: ignore_visibility + ├── receiver: ∅ + ├── call_operator_loc: ∅ + ├── name: :foo + ├── message_loc: (34,0)-(34,3) = "foo" + ├── opening_loc: (34,3)-(34,4) = "(" + ├── arguments: + │ @ ArgumentsNode (location: (34,4)-(34,14)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ InterpolatedStringNode (location: (34,4)-(34,14)) + │ ├── flags: ∅ + │ ├── opening_loc: (34,4)-(34,14) = "<<-HEREDOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (35,0)-(35,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (35,0)-(35,2) = " " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " " + │ │ ├── @ EmbeddedStatementsNode (location: (35,2)-(35,8)) + │ │ │ ├── opening_loc: (35,2)-(35,4) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (35,4)-(35,7)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (35,4)-(35,7)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (35,4)-(35,7) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── closing_loc: (35,7)-(35,8) = "}" + │ │ └── @ StringNode (location: (35,8)-(36,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (35,8)-(36,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (36,0)-(37,0) = "HEREDOC\n" + ├── closing_loc: (34,14)-(34,15) = ")" + └── block: + @ BlockNode (location: (34,16)-(37,1)) + ├── locals: [:x] + ├── parameters: + │ @ BlockParametersNode (location: (34,18)-(34,21)) + │ ├── parameters: + │ │ @ ParametersNode (location: (34,19)-(34,20)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (34,19)-(34,20)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :x + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── locals: (length: 0) + │ ├── opening_loc: (34,18)-(34,19) = "|" + │ └── closing_loc: (34,20)-(34,21) = "|" + ├── body: ∅ + ├── opening_loc: (34,16)-(34,17) = "{" + └── closing_loc: (37,0)-(37,1) = "}" |