Invalid flags in a RegExp literal should be an early SyntaxError
[WebKit-https.git] / JSTests / stress / const-tdz.js
1 "use strict";
2
3 function truth() {
4     return true;
5 }
6 noInline(truth);
7
8 function assert(cond) {
9     if (!cond)
10         throw new Error("broke assertion");
11 }
12 noInline(assert);
13
14 function shouldThrowTDZ(func) {
15     var hasThrown = false;
16     try {
17         func();
18     } catch(e) {
19         if (e.name.indexOf("ReferenceError") !== -1)
20             hasThrown = true;
21     }
22     assert(hasThrown);
23 }
24 noInline(shouldThrowTDZ);
25
26 // Test cases
27
28 const NUM_LOOPS = 1000;
29 const SHORT_LOOPS = 100;
30
31 ;(function() {
32 function foo() {
33     x;
34     const x = 20;
35 }
36 function bar() {
37     const x = x;
38 }
39 function baz() {
40     const {x: prop, y: prop2} = {x: prop};
41 }
42 function jaz() {
43     const {x: prop, y: prop2} = {x: 20, y: prop};
44 }
45 for (var i = 0; i < NUM_LOOPS; i++) {
46     shouldThrowTDZ(foo);
47     shouldThrowTDZ(bar);
48     shouldThrowTDZ(baz);
49     shouldThrowTDZ(jaz);
50 }
51 })();
52
53
54 ;(function() {
55 function foo() {
56     x;
57     const x = 20;
58     function captureX() { return x; }
59 }
60 function bar() {
61     captureX();
62     const x = 20;
63     function captureX() { return x; }
64 }
65
66 for (var i = 0; i < NUM_LOOPS; i++) {
67     shouldThrowTDZ(foo);
68     shouldThrowTDZ(bar);
69 }
70 })();
71
72
73 ;(function() {
74 function foo() {
75     if (truth()) {
76         const x = 20;
77         assert(x === 20);
78     }
79     x;
80     const x = 20;
81 }
82
83 for (var i = 0; i < NUM_LOOPS; i++) {
84     shouldThrowTDZ(foo);
85 }
86 })();
87
88
89
90 ;(function() {
91 function foo() {
92     if (truth()) {
93         const y = 20;
94         const captureY = function() { return y; }
95         assert(y === 20);
96         x;
97     }
98     const x = 20;
99     const y = 40;
100 }
101
102 for (var i = 0; i < NUM_LOOPS; i++) {
103     shouldThrowTDZ(foo);
104 }
105 })();
106
107
108 ;(function() {
109 function foo() {
110     if (truth()) {
111         const y = 20;
112         const x = 40;
113         const captureAll = function() { return x + y; }
114         assert(y === 20);
115         assert(x === 40);
116         assert(captureAll() === 60);
117     }
118     tdz;
119     const tdz = 20;
120 }
121
122 for (var i = 0; i < NUM_LOOPS; i++) {
123     shouldThrowTDZ(foo);
124 }
125 })();
126
127
128 ;(function() {
129 function foo() {
130     if (truth()) {
131         const y = 20;
132         const x = 40;
133         const captureAll = function() { return x + y + tdz; }
134         assert(y === 20);
135         assert(x === 40);
136     }
137     tdz;
138     const tdz = 20;
139 }
140
141 for (var i = 0; i < NUM_LOOPS; i++) {
142     shouldThrowTDZ(foo);
143 }
144 })();
145
146
147 ;(function() {
148 function foo() {
149     x = 10;
150     const x = 20;
151 }
152
153 for (var i = 0; i < NUM_LOOPS; i++) {
154     shouldThrowTDZ(foo);
155 }
156 })();
157
158
159 ;(function() {
160 function foo() {
161     x = 10;
162     const x = 20;
163     function cap() { return x; }
164 }
165 function bar() {
166     captureX();
167     const x = 20;
168     function captureX() { return x; }
169 }
170
171 for (var i = 0; i < NUM_LOOPS; i++) {
172     shouldThrowTDZ(foo);
173     shouldThrowTDZ(bar);
174 }
175 })();
176
177
178 ;(function() {
179 function foo() {
180     if (!truth()) {
181         y;
182         assert(false);
183     }
184     const y = undefined;
185     assert(y === undefined);
186     if (truth()) {
187         x;
188     }
189     const x = undefined;
190 }
191
192 for (var i = 0; i < NUM_LOOPS; i++) {
193     shouldThrowTDZ(foo);
194 }
195 })();
196
197
198 ;(function() {
199 function foo() {
200     eval("x;");
201     const x = 20;
202 }
203 function bar() {
204     function captureX() { return x; }
205     eval("captureX();");
206     const x = 20;
207 }
208 function baz() {
209     function captureX() { return x; }
210     function other() { return captureX; }
211     other()();
212     const x = 20;
213 }
214
215 for (var i = 0; i < SHORT_LOOPS; i++) {
216     shouldThrowTDZ(foo);
217     shouldThrowTDZ(bar);
218     shouldThrowTDZ(baz);
219 }
220 })();
221
222
223 ;(function() {
224 function foo() {
225     const y = 40;
226     eval("y; x;");
227     const x = 20;
228 }
229
230 for (var i = 0; i < 1; i++) {
231     shouldThrowTDZ(foo);
232 }
233 })();
234
235
236 ;(function() {
237 function foo() {
238     const x = 20;
239     const y = 40;
240     assert(eval("x;") === 20);
241     if (truth()) {
242         assert(eval("eval('y');") === 40);
243         eval("eval('x');");
244         const x = 40;
245     }
246 }
247
248 for (var i = 0; i < SHORT_LOOPS; i++) {
249     shouldThrowTDZ(foo);
250 }
251 })();
252
253
254 // FunctionResolveNode
255 ;(function() {
256 function foo() {
257     function captureX() { return x; }
258     x();
259     const x = function() { return 20; };
260 }
261
262 function bar() {
263     x();
264     let x = function() { return 20; };
265 }
266
267 for (var i = 0; i < NUM_LOOPS; i++) {
268     shouldThrowTDZ(foo);
269     shouldThrowTDZ(bar);
270 }
271 })();
272
273
274 // TypeofResolveNode
275 ;(function() {
276 function foo() {
277     function captureX() { return x; }
278     typeof x;
279     const x = function() { return 20; };
280 }
281
282 function bar() {
283     typeof x;
284     const x = function() { return 20; };
285 }
286
287 for (var i = 0; i < NUM_LOOPS; i++) {
288     shouldThrowTDZ(foo);
289     shouldThrowTDZ(bar);
290 }
291 })();
292
293
294 // ReadModifyResolveNode
295 ;(function() {
296 function foo() {
297     function captureX() { return x; }
298     x++;
299     const x = 20;
300 }
301
302 function bar() {
303     x--;
304     const x = 30;
305 }
306
307 function baz() {
308     x *= 40;
309     const x = 30;
310 }
311
312 function kaz() {
313     function captureX() { return x; }
314     x /= 20;
315     const x = 20;
316 }
317
318 function haz() {
319     function captureX() { return x; }
320     --x;
321     const x = 20;
322 }
323
324 function jaz() {
325     --x;
326     const x = 30;
327 }
328
329 for (var i = 0; i < NUM_LOOPS; i++) {
330     shouldThrowTDZ(foo);
331     shouldThrowTDZ(bar);
332     shouldThrowTDZ(baz);
333     shouldThrowTDZ(kaz);
334     shouldThrowTDZ(haz);
335     shouldThrowTDZ(jaz);
336 }
337 })();
338
339
340 ;(function() {
341 function foo(x) {
342     const y = 50;
343     let result = null;
344     switch(x) {
345         case 10:
346             const y = 40;
347             assert(y === 40);
348         case 20:
349             y += 1;
350             assert(y === 41);
351             result = y;
352             break;
353         default:
354             result = x;
355             break;
356     }
357     assert(y === 50);
358     return result;
359 }
360 function bar(x) {
361     const y = 50;
362     let result = null;
363     switch(x) {
364         case 10:
365             const y = 40;
366             assert(y === 40);
367         case 20:
368             const capY = function() { return y; }
369             y += 1;
370             assert(y === 41);
371             result = y;
372             break;
373         default:
374             result = x;
375             break;
376     }
377     assert(y === 50);
378     return result;
379 }
380 function baz(x) {
381     const y = 50;
382     let result = null;
383     switch(x) {
384         case 10:
385             const y = 40;
386             assert(y === 40);
387         case 20:
388             let inc = function() { y += 1; }
389             inc();
390             assert(y === 41);
391             result = y;
392             break;
393         default:
394             result = x;
395             break;
396     }
397     assert(y === 50);
398     return result;
399 }
400
401 for (var i = 0; i < NUM_LOOPS; i++) {
402     shouldThrowTDZ(function() { foo(20); });
403     shouldThrowTDZ(function() { bar(20); });
404     shouldThrowTDZ(function() { baz(20); });
405 }
406 })();
407
408
409 ;(function() {
410 function foo() {
411     [x] = [1];
412     const x = null;
413 }
414
415 function boo() {
416     [x] = [1];
417     const x = 20;
418     function capX() { return x; }
419 }
420
421 function bar() {
422     ({a, p: y} = {a: 100, p: 40});
423     const y = 40;
424 }
425
426 function zar() {
427     ({a, p: y} = {a: 100, p: 40});
428     const y = 10;
429     function capY() { return y; }
430 }
431
432 function baz() {
433     ({a, p: {y}} = {a: 100, p: {p: {y: 40}}});
434     const y = 100;
435 }
436
437 function jaz() {
438     ({y} = {});
439     const y = null;
440 }
441
442 for (var i = 0; i < NUM_LOOPS; i++) {
443     shouldThrowTDZ(foo);
444     shouldThrowTDZ(boo);
445     shouldThrowTDZ(bar);
446     shouldThrowTDZ(zar);
447     shouldThrowTDZ(baz);
448     shouldThrowTDZ(jaz);
449 }
450 })();