aboutsummaryrefslogtreecommitdiffstats
path: root/test/yarp/snapshots/tilde_heredocs.txt
blob: 417102ed380d05a27477b3924157fdf0f47730d9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
@ ProgramNode (location: (0...372))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...372))
    └── body: (length: 18)
        ├── @ InterpolatedStringNode (location: (0...6))
        │   ├── opening_loc: (0...6) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (7...11))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (7...11) = "  a\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n"
        │   └── closing_loc: (11...15) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (16...22))
        │   ├── opening_loc: (16...22) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (23...34))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (23...34) = "\ta\n  b\n\t\tc\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\ta\nb\n\t\tc\n"
        │   └── closing_loc: (34...38) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (39...45))
        │   ├── opening_loc: (39...45) = "<<~EOF"
        │   ├── parts: (length: 2)
        │   │   ├── @ EmbeddedStatementsNode (location: (48...52))
        │   │   │   ├── opening_loc: (48...50) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (50...51))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (50...51))
        │   │   │   │           └── flags: decimal
        │   │   │   └── closing_loc: (51...52) = "}"
        │   │   └── @ StringNode (location: (52...55))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (52...55) = " a\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " a\n"
        │   └── closing_loc: (55...59) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (60...66))
        │   ├── opening_loc: (60...66) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (67...71))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (67...71) = "  a "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a "
        │   │   ├── @ EmbeddedStatementsNode (location: (71...75))
        │   │   │   ├── opening_loc: (71...73) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (73...74))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (73...74))
        │   │   │   │           └── flags: decimal
        │   │   │   └── closing_loc: (74...75) = "}"
        │   │   └── @ StringNode (location: (75...76))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (75...76) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (76...80) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (81...87))
        │   ├── opening_loc: (81...87) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (88...93))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (88...93) = "  a\n "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: " a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (93...97))
        │   │   │   ├── opening_loc: (93...95) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (95...96))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (95...96))
        │   │   │   │           └── flags: decimal
        │   │   │   └── closing_loc: (96...97) = "}"
        │   │   └── @ StringNode (location: (97...98))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (97...98) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (98...102) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (103...109))
        │   ├── opening_loc: (103...109) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (110...116))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (110...116) = "  a\n  "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (116...120))
        │   │   │   ├── opening_loc: (116...118) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (118...119))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (118...119))
        │   │   │   │           └── flags: decimal
        │   │   │   └── closing_loc: (119...120) = "}"
        │   │   └── @ StringNode (location: (120...121))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (120...121) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (121...125) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (126...132))
        │   ├── opening_loc: (126...132) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (133...141))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (133...141) = "  a\n  b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\nb\n"
        │   └── closing_loc: (141...145) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (146...152))
        │   ├── opening_loc: (146...152) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (153...162))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (153...162) = "  a\n   b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n b\n"
        │   └── closing_loc: (162...166) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (167...173))
        │   ├── opening_loc: (167...173) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (174...183))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (174...183) = "\t\t\ta\n\t\tb\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\ta\nb\n"
        │   └── closing_loc: (183...187) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (188...196))
        │   ├── opening_loc: (188...196) = "<<~'EOF'"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (197...206))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (197...206) = "  a \#{1}\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a \#{1}\n"
        │   └── closing_loc: (206...210) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (211...217))
        │   ├── opening_loc: (211...217) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (218...225))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (218...225) = "\ta\n\t b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n b\n"
        │   └── closing_loc: (225...229) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (230...236))
        │   ├── opening_loc: (230...236) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (237...244))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (237...244) = "\t a\n\tb\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " a\nb\n"
        │   └── closing_loc: (244...248) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (249...255))
        │   ├── opening_loc: (249...255) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (256...271))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (256...271) = "  \ta\n        b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\nb\n"
        │   └── closing_loc: (271...275) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (276...282))
        │   ├── opening_loc: (276...282) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (283...292))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (283...292) = "  a\n\n  b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n\nb\n"
        │   └── closing_loc: (292...296) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (297...303))
        │   ├── opening_loc: (297...303) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (304...313))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (304...313) = "  a\n\n  b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n\nb\n"
        │   └── closing_loc: (313...317) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (318...324))
        │   ├── opening_loc: (318...324) = "<<~EOF"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (325...336))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (325...336) = "  a\n\n\n\n  b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n\n\n\nb\n"
        │   └── closing_loc: (336...340) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (341...347))
        │   ├── opening_loc: (341...347) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (348...351))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (348...351) = "\n  "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (351...355))
        │   │   │   ├── opening_loc: (351...353) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (353...354))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (353...354))
        │   │   │   │           └── flags: decimal
        │   │   │   └── closing_loc: (354...355) = "}"
        │   │   └── @ StringNode (location: (355...357))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (355...357) = "a\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n"
        │   └── closing_loc: (357...365) = "    EOF\n"
        └── @ InterpolatedStringNode (location: (366...372))
            ├── opening_loc: (366...372) = "<<~EOT"
            ├── parts: (length: 2)
            │   ├── @ EmbeddedStatementsNode (location: (375...379))
            │   │   ├── opening_loc: (375...377) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (377...378))
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ IntegerNode (location: (377...378))
            │   │   │           └── flags: decimal
            │   │   └── closing_loc: (378...379) = "}"
            │   └── @ StringNode (location: (379...383))
            │       ├── opening_loc: ∅
            │       ├── content_loc: (379...383) = "\n\tb\n"
            │       ├── closing_loc: ∅
            │       └── unescaped: "\n\tb\n"
            └── closing_loc: (383...387) = "EOT\n"