javascript - ast_statement_test.go
1 package javascript
2
3 import (
4 "testing"
5 )
6
7 func TestStatementOld(t *testing.T) {
8 doTests(t, []sourceFn{
9 {`{}`, func(t *test, tk Tokens) { // 1
10 t.Output = StatementListItem{
11 Statement: &Statement{
12 BlockStatement: &Block{
13 Tokens: tk[:2],
14 },
15 Tokens: tk[:2],
16 },
17 Tokens: tk[:2],
18 }
19 }},
20 {`var a;`, func(t *test, tk Tokens) { // 2
21 t.Output = StatementListItem{
22 Statement: &Statement{
23 VariableStatement: &VariableStatement{
24 VariableDeclarationList: []VariableDeclaration{
25 {
26 BindingIdentifier: &tk[2],
27 Tokens: tk[2:3],
28 },
29 },
30 Tokens: tk[:4],
31 },
32 Tokens: tk[:4],
33 },
34 Tokens: tk[:4],
35 }
36 }},
37 {`var a = 1;`, func(t *test, tk Tokens) { // 3
38 litA := makeConditionLiteral(tk, 6)
39 t.Output = StatementListItem{
40 Statement: &Statement{
41 VariableStatement: &VariableStatement{
42 VariableDeclarationList: []VariableDeclaration{
43 {
44 BindingIdentifier: &tk[2],
45 Initializer: &AssignmentExpression{
46 ConditionalExpression: &litA,
47 Tokens: tk[6:7],
48 },
49 Tokens: tk[2:7],
50 },
51 },
52 Tokens: tk[:8],
53 },
54 Tokens: tk[:8],
55 },
56 Tokens: tk[:8],
57 }
58 }},
59 {`var a = 1, b;`, func(t *test, tk Tokens) { // 4
60 litA := makeConditionLiteral(tk, 6)
61 t.Output = StatementListItem{
62 Statement: &Statement{
63 VariableStatement: &VariableStatement{
64 VariableDeclarationList: []VariableDeclaration{
65 {
66 BindingIdentifier: &tk[2],
67 Initializer: &AssignmentExpression{
68 ConditionalExpression: &litA,
69 Tokens: tk[6:7],
70 },
71 Tokens: tk[2:7],
72 },
73 {
74 BindingIdentifier: &tk[9],
75 Tokens: tk[9:10],
76 },
77 },
78 Tokens: tk[:11],
79 },
80 Tokens: tk[:11],
81 },
82 Tokens: tk[:11],
83 }
84 }},
85 {`var a = 1, b = 2;`, func(t *test, tk Tokens) { // 5
86 litA := makeConditionLiteral(tk, 6)
87 litB := makeConditionLiteral(tk, 13)
88 t.Output = StatementListItem{
89 Statement: &Statement{
90 VariableStatement: &VariableStatement{
91 VariableDeclarationList: []VariableDeclaration{
92 {
93 BindingIdentifier: &tk[2],
94 Initializer: &AssignmentExpression{
95 ConditionalExpression: &litA,
96 Tokens: tk[6:7],
97 },
98 Tokens: tk[2:7],
99 },
100 {
101 BindingIdentifier: &tk[9],
102 Initializer: &AssignmentExpression{
103 ConditionalExpression: &litB,
104 Tokens: tk[13:14],
105 },
106 Tokens: tk[9:14],
107 },
108 },
109 Tokens: tk[:15],
110 },
111 Tokens: tk[:15],
112 },
113 Tokens: tk[:15],
114 }
115 }},
116 {`var a, b = 1;`, func(t *test, tk Tokens) { // 6
117 litB := makeConditionLiteral(tk, 9)
118 t.Output = StatementListItem{
119 Statement: &Statement{
120 VariableStatement: &VariableStatement{
121 VariableDeclarationList: []VariableDeclaration{
122 {
123 BindingIdentifier: &tk[2],
124 Tokens: tk[2:3],
125 },
126 {
127 BindingIdentifier: &tk[5],
128 Initializer: &AssignmentExpression{
129 ConditionalExpression: &litB,
130 Tokens: tk[9:10],
131 },
132 Tokens: tk[5:10],
133 },
134 },
135 Tokens: tk[:11],
136 },
137 Tokens: tk[:11],
138 },
139 Tokens: tk[:11],
140 }
141 }},
142 {`var [a, b] = [1, 2];`, func(t *test, tk Tokens) { // 7
143 litA := makeConditionLiteral(tk, 12)
144 litB := makeConditionLiteral(tk, 15)
145 arr := wrapConditional(UpdateExpression{
146 LeftHandSideExpression: &LeftHandSideExpression{
147 NewExpression: &NewExpression{
148 MemberExpression: MemberExpression{
149 PrimaryExpression: &PrimaryExpression{
150 ArrayLiteral: &ArrayLiteral{
151 ElementList: []ArrayElement{
152 {
153 AssignmentExpression: AssignmentExpression{
154 ConditionalExpression: &litA,
155 Tokens: tk[12:13],
156 },
157 Tokens: tk[12:13],
158 },
159 {
160 AssignmentExpression: AssignmentExpression{
161 ConditionalExpression: &litB,
162 Tokens: tk[15:16],
163 },
164 Tokens: tk[15:16],
165 },
166 },
167 Tokens: tk[11:17],
168 },
169 Tokens: tk[11:17],
170 },
171 Tokens: tk[11:17],
172 },
173 Tokens: tk[11:17],
174 },
175 Tokens: tk[11:17],
176 },
177 Tokens: tk[11:17],
178 })
179 t.Output = StatementListItem{
180 Statement: &Statement{
181 VariableStatement: &VariableStatement{
182 VariableDeclarationList: []VariableDeclaration{
183 {
184 ArrayBindingPattern: &ArrayBindingPattern{
185 BindingElementList: []BindingElement{
186 {
187 SingleNameBinding: &tk[3],
188 Tokens: tk[3:4],
189 },
190 {
191 SingleNameBinding: &tk[6],
192 Tokens: tk[6:7],
193 },
194 },
195 Tokens: tk[2:8],
196 },
197 Initializer: &AssignmentExpression{
198 ConditionalExpression: &arr,
199 Tokens: tk[11:17],
200 },
201 Tokens: tk[2:17],
202 },
203 },
204 Tokens: tk[:18],
205 },
206 Tokens: tk[:18],
207 },
208 Tokens: tk[:18],
209 }
210 }},
211 {`var {a, b} = {c, d};`, func(t *test, tk Tokens) { // 8
212 litC := makeConditionLiteral(tk, 12)
213 litD := makeConditionLiteral(tk, 15)
214 obj := wrapConditional(UpdateExpression{
215 LeftHandSideExpression: &LeftHandSideExpression{
216 NewExpression: &NewExpression{
217 MemberExpression: MemberExpression{
218 PrimaryExpression: &PrimaryExpression{
219 ObjectLiteral: &ObjectLiteral{
220 PropertyDefinitionList: []PropertyDefinition{
221 {
222 PropertyName: &PropertyName{
223 LiteralPropertyName: &tk[12],
224 Tokens: tk[12:13],
225 },
226 AssignmentExpression: &AssignmentExpression{
227 ConditionalExpression: &litC,
228 Tokens: tk[12:13],
229 },
230 Tokens: tk[12:13],
231 },
232 {
233 PropertyName: &PropertyName{
234 LiteralPropertyName: &tk[15],
235 Tokens: tk[15:16],
236 },
237 AssignmentExpression: &AssignmentExpression{
238 ConditionalExpression: &litD,
239 Tokens: tk[15:16],
240 },
241 Tokens: tk[15:16],
242 },
243 },
244 Tokens: tk[11:17],
245 },
246 Tokens: tk[11:17],
247 },
248 Tokens: tk[11:17],
249 },
250 Tokens: tk[11:17],
251 },
252 Tokens: tk[11:17],
253 },
254 Tokens: tk[11:17],
255 })
256 t.Output = StatementListItem{
257 Statement: &Statement{
258 VariableStatement: &VariableStatement{
259 VariableDeclarationList: []VariableDeclaration{
260 {
261 ObjectBindingPattern: &ObjectBindingPattern{
262 BindingPropertyList: []BindingProperty{
263 {
264 PropertyName: PropertyName{
265 LiteralPropertyName: &tk[3],
266 Tokens: tk[3:4],
267 },
268 BindingElement: BindingElement{
269 SingleNameBinding: &tk[3],
270 Tokens: tk[3:4],
271 },
272 Tokens: tk[3:4],
273 },
274 {
275 PropertyName: PropertyName{
276 LiteralPropertyName: &tk[6],
277 Tokens: tk[6:7],
278 },
279 BindingElement: BindingElement{
280 SingleNameBinding: &tk[6],
281 Tokens: tk[6:7],
282 },
283 Tokens: tk[6:7],
284 },
285 },
286 Tokens: tk[2:8],
287 },
288 Initializer: &AssignmentExpression{
289 ConditionalExpression: &obj,
290 Tokens: tk[11:17],
291 },
292 Tokens: tk[2:17],
293 },
294 },
295 Tokens: tk[:18],
296 },
297 Tokens: tk[:18],
298 },
299 Tokens: tk[:18],
300 }
301 }},
302 {`;`, func(t *test, tk Tokens) { // 9
303 t.Output = StatementListItem{
304 Statement: &Statement{
305 Tokens: tk[:1],
306 },
307 Tokens: tk[:1],
308 }
309 }},
310 {`if (1) {}`, func(t *test, tk Tokens) { // 10
311 litA := makeConditionLiteral(tk, 3)
312 t.Output = StatementListItem{
313 Statement: &Statement{
314 IfStatement: &IfStatement{
315 Expression: Expression{
316 Expressions: []AssignmentExpression{
317 {
318 ConditionalExpression: &litA,
319 Tokens: tk[3:4],
320 },
321 },
322 Tokens: tk[3:4],
323 },
324 Statement: Statement{
325 BlockStatement: &Block{
326 Tokens: tk[6:8],
327 },
328 Tokens: tk[6:8],
329 },
330 Tokens: tk[:8],
331 },
332 Tokens: tk[:8],
333 },
334 Tokens: tk[:8],
335 }
336 }},
337 {`if (1) {} else {}`, func(t *test, tk Tokens) { // 11
338 litA := makeConditionLiteral(tk, 3)
339 t.Output = StatementListItem{
340 Statement: &Statement{
341 IfStatement: &IfStatement{
342 Expression: Expression{
343 Expressions: []AssignmentExpression{
344 {
345 ConditionalExpression: &litA,
346 Tokens: tk[3:4],
347 },
348 },
349 Tokens: tk[3:4],
350 },
351 Statement: Statement{
352 BlockStatement: &Block{
353 Tokens: tk[6:8],
354 },
355 Tokens: tk[6:8],
356 },
357 ElseStatement: &Statement{
358 BlockStatement: &Block{
359 Tokens: tk[11:13],
360 },
361 Tokens: tk[11:13],
362 },
363 Tokens: tk[:13],
364 },
365 Tokens: tk[:13],
366 },
367 Tokens: tk[:13],
368 }
369 }},
370 {`do {} while(1);`, func(t *test, tk Tokens) { // 12
371 litA := makeConditionLiteral(tk, 7)
372 t.Output = StatementListItem{
373 Statement: &Statement{
374 IterationStatementDo: &IterationStatementDo{
375 Statement: Statement{
376 BlockStatement: &Block{
377 Tokens: tk[2:4],
378 },
379 Tokens: tk[2:4],
380 },
381 Expression: Expression{
382 Expressions: []AssignmentExpression{
383 {
384 ConditionalExpression: &litA,
385 Tokens: tk[7:8],
386 },
387 },
388 Tokens: tk[7:8],
389 },
390 Tokens: tk[:10],
391 },
392 Tokens: tk[:10],
393 },
394 Tokens: tk[:10],
395 }
396 }},
397 {`while(1){}`, func(t *test, tk Tokens) { // 13
398 litA := makeConditionLiteral(tk, 2)
399 t.Output = StatementListItem{
400 Statement: &Statement{
401 IterationStatementWhile: &IterationStatementWhile{
402 Expression: Expression{
403 Expressions: []AssignmentExpression{
404 {
405 ConditionalExpression: &litA,
406 Tokens: tk[2:3],
407 },
408 },
409 Tokens: tk[2:3],
410 },
411 Statement: Statement{
412 BlockStatement: &Block{
413 Tokens: tk[4:6],
414 },
415 Tokens: tk[4:6],
416 },
417 Tokens: tk[:6],
418 },
419 Tokens: tk[:6],
420 },
421 Tokens: tk[:6],
422 }
423 }},
424 {`for(;;) {}`, func(t *test, tk Tokens) { // 14
425 t.Output = StatementListItem{
426 Statement: &Statement{
427 IterationStatementFor: &IterationStatementFor{
428 Statement: Statement{
429 BlockStatement: &Block{
430 Tokens: tk[6:8],
431 },
432 Tokens: tk[6:8],
433 },
434 Tokens: tk[:8],
435 },
436 Tokens: tk[:8],
437 },
438 Tokens: tk[:8],
439 }
440 }},
441 {`for(i = a; b < c; d++) {}`, func(t *test, tk Tokens) { // 15
442 litA := makeConditionLiteral(tk, 6)
443 litB := makeConditionLiteral(tk, 9)
444 litC := makeConditionLiteral(tk, 13)
445 litD := makeConditionLiteral(tk, 16)
446 t.Output = StatementListItem{
447 Statement: &Statement{
448 IterationStatementFor: &IterationStatementFor{
449 Type: ForNormalExpression,
450 InitExpression: &Expression{
451 Expressions: []AssignmentExpression{
452 {
453 LeftHandSideExpression: &LeftHandSideExpression{
454 NewExpression: &NewExpression{
455 MemberExpression: MemberExpression{
456 PrimaryExpression: &PrimaryExpression{
457 IdentifierReference: &tk[2],
458 Tokens: tk[2:3],
459 },
460 Tokens: tk[2:3],
461 },
462 Tokens: tk[2:3],
463 },
464 Tokens: tk[2:3],
465 },
466 AssignmentOperator: AssignmentAssign,
467 AssignmentExpression: &AssignmentExpression{
468 ConditionalExpression: &litA,
469 Tokens: tk[6:7],
470 },
471 Tokens: tk[2:7],
472 },
473 },
474 Tokens: tk[2:7],
475 },
476 Conditional: &Expression{
477 Expressions: []AssignmentExpression{
478 {
479 ConditionalExpression: &ConditionalExpression{
480 LogicalORExpression: wrapConditional(RelationalExpression{
481 RelationalExpression: &litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
482 RelationshipOperator: RelationshipLessThan,
483 ShiftExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
484 Tokens: tk[9:14],
485 }).LogicalORExpression,
486 Tokens: tk[9:14],
487 },
488 Tokens: tk[9:14],
489 },
490 },
491 Tokens: tk[9:14],
492 },
493 Afterthought: &Expression{
494 Expressions: []AssignmentExpression{
495 {
496 ConditionalExpression: &ConditionalExpression{
497 LogicalORExpression: wrapConditional(UpdateExpression{
498 LeftHandSideExpression: litD.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression,
499 UpdateOperator: UpdatePostIncrement,
500 Tokens: tk[16:18],
501 }).LogicalORExpression,
502 Tokens: tk[16:18],
503 },
504 Tokens: tk[16:18],
505 },
506 },
507 Tokens: tk[16:18],
508 },
509 Statement: Statement{
510 BlockStatement: &Block{
511 Tokens: tk[20:22],
512 },
513 Tokens: tk[20:22],
514 },
515 Tokens: tk[:22],
516 },
517 Tokens: tk[:22],
518 },
519 Tokens: tk[:22],
520 }
521 }},
522 {`for(var i = a; b > c; d--) {}`, func(t *test, tk Tokens) { // 16
523 litA := makeConditionLiteral(tk, 8)
524 litB := makeConditionLiteral(tk, 11)
525 litC := makeConditionLiteral(tk, 15)
526 litD := makeConditionLiteral(tk, 18)
527 t.Output = StatementListItem{
528 Statement: &Statement{
529 IterationStatementFor: &IterationStatementFor{
530 Type: ForNormalVar,
531 InitVar: []VariableDeclaration{
532 {
533 BindingIdentifier: &tk[4],
534 Initializer: &AssignmentExpression{
535 ConditionalExpression: &litA,
536 Tokens: tk[8:9],
537 },
538 Tokens: tk[4:9],
539 },
540 },
541 Conditional: &Expression{
542 Expressions: []AssignmentExpression{
543 {
544 ConditionalExpression: &ConditionalExpression{
545 LogicalORExpression: wrapConditional(RelationalExpression{
546 RelationalExpression: &litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
547 RelationshipOperator: RelationshipGreaterThan,
548 ShiftExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
549 Tokens: tk[11:16],
550 }).LogicalORExpression,
551 Tokens: tk[11:16],
552 },
553 Tokens: tk[11:16],
554 },
555 },
556 Tokens: tk[11:16],
557 },
558 Afterthought: &Expression{
559 Expressions: []AssignmentExpression{
560 {
561 ConditionalExpression: &ConditionalExpression{
562 LogicalORExpression: wrapConditional(UpdateExpression{
563 LeftHandSideExpression: litD.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression.UpdateExpression.LeftHandSideExpression,
564 UpdateOperator: UpdatePostDecrement,
565 Tokens: tk[18:20],
566 }).LogicalORExpression,
567 Tokens: tk[18:20],
568 },
569 Tokens: tk[18:20],
570 },
571 },
572 Tokens: tk[18:20],
573 },
574 Statement: Statement{
575 BlockStatement: &Block{
576 Tokens: tk[22:24],
577 },
578 Tokens: tk[22:24],
579 },
580 Tokens: tk[:24],
581 },
582 Tokens: tk[:24],
583 },
584 Tokens: tk[:24],
585 }
586 }},
587 {`for(let i = a; b <= c; ++d) {}`, func(t *test, tk Tokens) { // 17
588 litA := makeConditionLiteral(tk, 8)
589 litB := makeConditionLiteral(tk, 11)
590 litC := makeConditionLiteral(tk, 15)
591 litD := makeConditionLiteral(tk, 19)
592 t.Output = StatementListItem{
593 Statement: &Statement{
594 IterationStatementFor: &IterationStatementFor{
595 Type: ForNormalLexicalDeclaration,
596 InitLexical: &LexicalDeclaration{
597 LetOrConst: Let,
598 BindingList: []LexicalBinding{
599 {
600 BindingIdentifier: &tk[4],
601 Initializer: &AssignmentExpression{
602 ConditionalExpression: &litA,
603 Tokens: tk[8:9],
604 },
605 Tokens: tk[4:9],
606 },
607 },
608 Tokens: tk[2:10],
609 },
610 Conditional: &Expression{
611 Expressions: []AssignmentExpression{
612 {
613 ConditionalExpression: &ConditionalExpression{
614 LogicalORExpression: wrapConditional(RelationalExpression{
615 RelationalExpression: &litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
616 RelationshipOperator: RelationshipLessThanEqual,
617 ShiftExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
618 Tokens: tk[11:16],
619 }).LogicalORExpression,
620 Tokens: tk[11:16],
621 },
622 Tokens: tk[11:16],
623 },
624 },
625 Tokens: tk[11:16],
626 },
627 Afterthought: &Expression{
628 Expressions: []AssignmentExpression{
629 {
630 ConditionalExpression: &ConditionalExpression{
631 LogicalORExpression: wrapConditional(UpdateExpression{
632 UpdateOperator: UpdatePreIncrement,
633 UnaryExpression: &litD.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression,
634 Tokens: tk[18:20],
635 }).LogicalORExpression,
636 Tokens: tk[18:20],
637 },
638 Tokens: tk[18:20],
639 },
640 },
641 Tokens: tk[18:20],
642 },
643 Statement: Statement{
644 BlockStatement: &Block{
645 Tokens: tk[22:24],
646 },
647 Tokens: tk[22:24],
648 },
649 Tokens: tk[:24],
650 },
651 Tokens: tk[:24],
652 },
653 Tokens: tk[:24],
654 }
655 }},
656 {`for(const i = a; b >= c; ++d) {}`, func(t *test, tk Tokens) { // 18
657 litA := makeConditionLiteral(tk, 8)
658 litB := makeConditionLiteral(tk, 11)
659 litC := makeConditionLiteral(tk, 16)
660 litD := makeConditionLiteral(tk, 20)
661 t.Output = StatementListItem{
662 Statement: &Statement{
663 IterationStatementFor: &IterationStatementFor{
664 Type: ForNormalLexicalDeclaration,
665 InitLexical: &LexicalDeclaration{
666 LetOrConst: Const,
667 BindingList: []LexicalBinding{
668 {
669 BindingIdentifier: &tk[4],
670 Initializer: &AssignmentExpression{
671 ConditionalExpression: &litA,
672 Tokens: tk[8:9],
673 },
674 Tokens: tk[4:9],
675 },
676 },
677 Tokens: tk[2:10],
678 },
679 Conditional: &Expression{
680 Expressions: []AssignmentExpression{
681 {
682 ConditionalExpression: &ConditionalExpression{
683 LogicalORExpression: wrapConditional(RelationalExpression{
684 RelationalExpression: &litB.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression,
685 RelationshipOperator: RelationshipGreaterThanEqual,
686 ShiftExpression: litC.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression,
687 Tokens: tk[11:17],
688 }).LogicalORExpression,
689 Tokens: tk[11:17],
690 },
691 Tokens: tk[11:17],
692 },
693 },
694 Tokens: tk[11:17],
695 },
696 Afterthought: &Expression{
697 Expressions: []AssignmentExpression{
698 {
699 ConditionalExpression: &ConditionalExpression{
700 LogicalORExpression: wrapConditional(UpdateExpression{
701 UpdateOperator: UpdatePreIncrement,
702 UnaryExpression: &litD.LogicalORExpression.LogicalANDExpression.BitwiseORExpression.BitwiseXORExpression.BitwiseANDExpression.EqualityExpression.RelationalExpression.ShiftExpression.AdditiveExpression.MultiplicativeExpression.ExponentiationExpression.UnaryExpression,
703 Tokens: tk[19:21],
704 }).LogicalORExpression,
705 Tokens: tk[19:21],
706 },
707 Tokens: tk[19:21],
708 },
709 },
710 Tokens: tk[19:21],
711 },
712 Statement: Statement{
713 BlockStatement: &Block{
714 Tokens: tk[23:25],
715 },
716 Tokens: tk[23:25],
717 },
718 Tokens: tk[:25],
719 },
720 Tokens: tk[:25],
721 },
722 Tokens: tk[:25],
723 }
724 }},
725 {`for(a in b) {}`, func(t *test, tk Tokens) { // 19
726 litB := makeConditionLiteral(tk, 6)
727 t.Output = StatementListItem{
728 Statement: &Statement{
729 IterationStatementFor: &IterationStatementFor{
730 Type: ForInLeftHandSide,
731 LeftHandSideExpression: &LeftHandSideExpression{
732 NewExpression: &NewExpression{
733 MemberExpression: MemberExpression{
734 PrimaryExpression: &PrimaryExpression{
735 IdentifierReference: &tk[2],
736 Tokens: tk[2:3],
737 },
738 Tokens: tk[2:3],
739 },
740 Tokens: tk[2:3],
741 },
742 Tokens: tk[2:3],
743 },
744 In: &Expression{
745 Expressions: []AssignmentExpression{
746 {
747 ConditionalExpression: &litB,
748 Tokens: tk[6:7],
749 },
750 },
751 Tokens: tk[6:7],
752 },
753 Tokens: tk[:11],
754 Statement: Statement{
755 BlockStatement: &Block{
756 Tokens: tk[9:11],
757 },
758 Tokens: tk[9:11],
759 },
760 },
761 Tokens: tk[:11],
762 },
763 Tokens: tk[:11],
764 }
765 }},
766 {`for(var a in b) {}`, func(t *test, tk Tokens) { // 20
767 litB := makeConditionLiteral(tk, 8)
768 t.Output = StatementListItem{
769 Statement: &Statement{
770 IterationStatementFor: &IterationStatementFor{
771 Type: ForInVar,
772 ForBindingIdentifier: &tk[4],
773 In: &Expression{
774 Expressions: []AssignmentExpression{
775 {
776 ConditionalExpression: &litB,
777 Tokens: tk[8:9],
778 },
779 },
780 Tokens: tk[8:9],
781 },
782 Statement: Statement{
783 BlockStatement: &Block{
784 Tokens: tk[11:13],
785 },
786 Tokens: tk[11:13],
787 },
788 Tokens: tk[:13],
789 },
790 Tokens: tk[:13],
791 },
792 Tokens: tk[:13],
793 }
794 }},
795 {`for(let {a} in b) {}`, func(t *test, tk Tokens) { // 21
796 litB := makeConditionLiteral(tk, 10)
797 t.Output = StatementListItem{
798 Statement: &Statement{
799 IterationStatementFor: &IterationStatementFor{
800 Type: ForInLet,
801 ForBindingPatternObject: &ObjectBindingPattern{
802 BindingPropertyList: []BindingProperty{
803 {
804 PropertyName: PropertyName{
805 LiteralPropertyName: &tk[5],
806 Tokens: tk[5:6],
807 },
808 BindingElement: BindingElement{
809 SingleNameBinding: &tk[5],
810 Tokens: tk[5:6],
811 },
812 Tokens: tk[5:6],
813 },
814 },
815 Tokens: tk[4:7],
816 },
817 In: &Expression{
818 Expressions: []AssignmentExpression{
819 {
820 ConditionalExpression: &litB,
821 Tokens: tk[10:11],
822 },
823 },
824 Tokens: tk[10:11],
825 },
826 Statement: Statement{
827 BlockStatement: &Block{
828 Tokens: tk[13:15],
829 },
830 Tokens: tk[13:15],
831 },
832 Tokens: tk[:15],
833 },
834 Tokens: tk[:15],
835 },
836 Tokens: tk[:15],
837 }
838 }},
839 {`for(const [a] in b) {}`, func(t *test, tk Tokens) { // 22
840 litB := makeConditionLiteral(tk, 10)
841 t.Output = StatementListItem{
842 Statement: &Statement{
843 IterationStatementFor: &IterationStatementFor{
844 Type: ForInConst,
845 ForBindingPatternArray: &ArrayBindingPattern{
846 BindingElementList: []BindingElement{
847 {
848 SingleNameBinding: &tk[5],
849 Tokens: tk[5:6],
850 },
851 },
852 Tokens: tk[4:7],
853 },
854 In: &Expression{
855 Expressions: []AssignmentExpression{
856 {
857 ConditionalExpression: &litB,
858 Tokens: tk[10:11],
859 },
860 },
861 Tokens: tk[10:11],
862 },
863 Statement: Statement{
864 BlockStatement: &Block{
865 Tokens: tk[13:15],
866 },
867 Tokens: tk[13:15],
868 },
869 Tokens: tk[:15],
870 },
871 Tokens: tk[:15],
872 },
873 Tokens: tk[:15],
874 }
875 }},
876 {`for(a of b) {}`, func(t *test, tk Tokens) { // 23
877 litB := makeConditionLiteral(tk, 6)
878 t.Output = StatementListItem{
879 Statement: &Statement{
880 IterationStatementFor: &IterationStatementFor{
881 Type: ForOfLeftHandSide,
882 LeftHandSideExpression: &LeftHandSideExpression{
883 NewExpression: &NewExpression{
884 MemberExpression: MemberExpression{
885 PrimaryExpression: &PrimaryExpression{
886 IdentifierReference: &tk[2],
887 Tokens: tk[2:3],
888 },
889 Tokens: tk[2:3],
890 },
891 Tokens: tk[2:3],
892 },
893 Tokens: tk[2:3],
894 },
895 Of: &AssignmentExpression{
896 ConditionalExpression: &litB,
897 Tokens: tk[6:7],
898 },
899 Statement: Statement{
900 BlockStatement: &Block{
901 Tokens: tk[9:11],
902 },
903 Tokens: tk[9:11],
904 },
905 Tokens: tk[:11],
906 },
907 Tokens: tk[:11],
908 },
909 Tokens: tk[:11],
910 }
911 }},
912 {`for(var a of b) {}`, func(t *test, tk Tokens) { // 24
913 litB := makeConditionLiteral(tk, 8)
914 t.Output = StatementListItem{
915 Statement: &Statement{
916 IterationStatementFor: &IterationStatementFor{
917 Type: ForOfVar,
918 ForBindingIdentifier: &tk[4],
919 Of: &AssignmentExpression{
920 ConditionalExpression: &litB,
921 Tokens: tk[8:9],
922 },
923 Statement: Statement{
924 BlockStatement: &Block{
925 Tokens: tk[11:13],
926 },
927 Tokens: tk[11:13],
928 },
929 Tokens: tk[:13],
930 },
931 Tokens: tk[:13],
932 },
933 Tokens: tk[:13],
934 }
935 }},
936 {`for(let {a} of b) {}`, func(t *test, tk Tokens) { // 25
937 litB := makeConditionLiteral(tk, 10)
938 t.Output = StatementListItem{
939 Statement: &Statement{
940 IterationStatementFor: &IterationStatementFor{
941 Type: ForOfLet,
942 ForBindingPatternObject: &ObjectBindingPattern{
943 BindingPropertyList: []BindingProperty{
944 {
945 PropertyName: PropertyName{
946 LiteralPropertyName: &tk[5],
947 Tokens: tk[5:6],
948 },
949 BindingElement: BindingElement{
950 SingleNameBinding: &tk[5],
951 Tokens: tk[5:6],
952 },
953 Tokens: tk[5:6],
954 },
955 },
956 Tokens: tk[4:7],
957 },
958 Of: &AssignmentExpression{
959 ConditionalExpression: &litB,
960 Tokens: tk[10:11],
961 },
962 Statement: Statement{
963 BlockStatement: &Block{
964 Tokens: tk[13:15],
965 },
966 Tokens: tk[13:15],
967 },
968 Tokens: tk[:15],
969 },
970 Tokens: tk[:15],
971 },
972 Tokens: tk[:15],
973 }
974 }},
975 {`for(const [a] of b) {}`, func(t *test, tk Tokens) { // 26
976 litB := makeConditionLiteral(tk, 10)
977 t.Output = StatementListItem{
978 Statement: &Statement{
979 IterationStatementFor: &IterationStatementFor{
980 Type: ForOfConst,
981 ForBindingPatternArray: &ArrayBindingPattern{
982 BindingElementList: []BindingElement{
983 {
984 SingleNameBinding: &tk[5],
985 Tokens: tk[5:6],
986 },
987 },
988 Tokens: tk[4:7],
989 },
990 Of: &AssignmentExpression{
991 ConditionalExpression: &litB,
992 Tokens: tk[10:11],
993 },
994 Statement: Statement{
995 BlockStatement: &Block{
996 Tokens: tk[13:15],
997 },
998 Tokens: tk[13:15],
999 },
1000 Tokens: tk[:15],
1001 },
1002 Tokens: tk[:15],
1003 },
1004 Tokens: tk[:15],
1005 }
1006 }},
1007 {`switch(true){}`, func(t *test, tk Tokens) { // 27
1008 litA := makeConditionLiteral(tk, 2)
1009 t.Output = StatementListItem{
1010 Statement: &Statement{
1011 SwitchStatement: &SwitchStatement{
1012 Expression: Expression{
1013 Expressions: []AssignmentExpression{
1014 {
1015 ConditionalExpression: &litA,
1016 Tokens: tk[2:3],
1017 },
1018 },
1019 Tokens: tk[2:3],
1020 },
1021 Tokens: tk[:6],
1022 },
1023 Tokens: tk[:6],
1024 },
1025 Tokens: tk[:6],
1026 }
1027 }},
1028 {`switch(a){case 0:case 1:}`, func(t *test, tk Tokens) { // 28
1029 litA := makeConditionLiteral(tk, 2)
1030 litB := makeConditionLiteral(tk, 7)
1031 litC := makeConditionLiteral(tk, 11)
1032 t.Output = StatementListItem{
1033 Statement: &Statement{
1034 SwitchStatement: &SwitchStatement{
1035 Expression: Expression{
1036 Expressions: []AssignmentExpression{
1037 {
1038 ConditionalExpression: &litA,
1039 Tokens: tk[2:3],
1040 },
1041 },
1042 Tokens: tk[2:3],
1043 },
1044 CaseClauses: []CaseClause{
1045 {
1046 Expression: Expression{
1047 Expressions: []AssignmentExpression{
1048 {
1049 ConditionalExpression: &litB,
1050 Tokens: tk[7:8],
1051 },
1052 },
1053 Tokens: tk[7:8],
1054 },
1055 Tokens: tk[5:9],
1056 },
1057 {
1058 Expression: Expression{
1059 Expressions: []AssignmentExpression{
1060 {
1061 ConditionalExpression: &litC,
1062 Tokens: tk[11:12],
1063 },
1064 },
1065 Tokens: tk[11:12],
1066 },
1067 Tokens: tk[9:13],
1068 },
1069 },
1070 Tokens: tk[:14],
1071 },
1072 Tokens: tk[:14],
1073 },
1074 Tokens: tk[:14],
1075 }
1076 }},
1077 {`switch(a){default:case 0:case 1:}`, func(t *test, tk Tokens) { // 29
1078 litA := makeConditionLiteral(tk, 2)
1079 litB := makeConditionLiteral(tk, 9)
1080 litC := makeConditionLiteral(tk, 13)
1081 t.Output = StatementListItem{
1082 Statement: &Statement{
1083 SwitchStatement: &SwitchStatement{
1084 Expression: Expression{
1085 Expressions: []AssignmentExpression{
1086 {
1087 ConditionalExpression: &litA,
1088 Tokens: tk[2:3],
1089 },
1090 },
1091 Tokens: tk[2:3],
1092 },
1093 DefaultClause: []StatementListItem{},
1094 PostDefaultCaseClauses: []CaseClause{
1095 {
1096 Expression: Expression{
1097 Expressions: []AssignmentExpression{
1098 {
1099 ConditionalExpression: &litB,
1100 Tokens: tk[9:10],
1101 },
1102 },
1103 Tokens: tk[9:10],
1104 },
1105 Tokens: tk[7:11],
1106 },
1107 {
1108 Expression: Expression{
1109 Expressions: []AssignmentExpression{
1110 {
1111 ConditionalExpression: &litC,
1112 Tokens: tk[13:14],
1113 },
1114 },
1115 Tokens: tk[13:14],
1116 },
1117 Tokens: tk[11:15],
1118 },
1119 },
1120 Tokens: tk[:16],
1121 },
1122 Tokens: tk[:16],
1123 },
1124 Tokens: tk[:16],
1125 }
1126 }},
1127 {`switch(a){case 0:default:case 1:}`, func(t *test, tk Tokens) { // 30
1128 litA := makeConditionLiteral(tk, 2)
1129 litB := makeConditionLiteral(tk, 7)
1130 litC := makeConditionLiteral(tk, 13)
1131 t.Output = StatementListItem{
1132 Statement: &Statement{
1133 SwitchStatement: &SwitchStatement{
1134 Expression: Expression{
1135 Expressions: []AssignmentExpression{
1136 {
1137 ConditionalExpression: &litA,
1138 Tokens: tk[2:3],
1139 },
1140 },
1141 Tokens: tk[2:3],
1142 },
1143 CaseClauses: []CaseClause{
1144 {
1145 Expression: Expression{
1146 Expressions: []AssignmentExpression{
1147 {
1148 ConditionalExpression: &litB,
1149 Tokens: tk[7:8],
1150 },
1151 },
1152 Tokens: tk[7:8],
1153 },
1154 Tokens: tk[5:9],
1155 },
1156 },
1157 DefaultClause: []StatementListItem{},
1158 PostDefaultCaseClauses: []CaseClause{
1159 {
1160 Expression: Expression{
1161 Expressions: []AssignmentExpression{
1162 {
1163 ConditionalExpression: &litC,
1164 Tokens: tk[13:14],
1165 },
1166 },
1167 Tokens: tk[13:14],
1168 },
1169 Tokens: tk[11:15],
1170 },
1171 },
1172 Tokens: tk[:16],
1173 },
1174 Tokens: tk[:16],
1175 },
1176 Tokens: tk[:16],
1177 }
1178 }},
1179 {`switch(a){case 0:case 1:default:}`, func(t *test, tk Tokens) { // 31
1180 litA := makeConditionLiteral(tk, 2)
1181 litB := makeConditionLiteral(tk, 7)
1182 litC := makeConditionLiteral(tk, 11)
1183 t.Output = StatementListItem{
1184 Statement: &Statement{
1185 SwitchStatement: &SwitchStatement{
1186 Expression: Expression{
1187 Expressions: []AssignmentExpression{
1188 {
1189 ConditionalExpression: &litA,
1190 Tokens: tk[2:3],
1191 },
1192 },
1193 Tokens: tk[2:3],
1194 },
1195 CaseClauses: []CaseClause{
1196 {
1197 Expression: Expression{
1198 Expressions: []AssignmentExpression{
1199 {
1200 ConditionalExpression: &litB,
1201 Tokens: tk[7:8],
1202 },
1203 },
1204 Tokens: tk[7:8],
1205 },
1206 Tokens: tk[5:9],
1207 },
1208 {
1209 Expression: Expression{
1210 Expressions: []AssignmentExpression{
1211 {
1212 ConditionalExpression: &litC,
1213 Tokens: tk[11:12],
1214 },
1215 },
1216 Tokens: tk[11:12],
1217 },
1218 Tokens: tk[9:13],
1219 },
1220 },
1221 DefaultClause: []StatementListItem{},
1222 Tokens: tk[:16],
1223 },
1224 Tokens: tk[:16],
1225 },
1226 Tokens: tk[:16],
1227 }
1228 }},
1229 {`switch(a){case b:case c:d;default:e;f;case g:h;}`, func(t *test, tk Tokens) { // 32
1230 litA := makeConditionLiteral(tk, 2)
1231 litB := makeConditionLiteral(tk, 7)
1232 litC := makeConditionLiteral(tk, 11)
1233 litD := makeConditionLiteral(tk, 13)
1234 litE := makeConditionLiteral(tk, 17)
1235 litF := makeConditionLiteral(tk, 19)
1236 litG := makeConditionLiteral(tk, 23)
1237 litH := makeConditionLiteral(tk, 25)
1238 t.Output = StatementListItem{
1239 Statement: &Statement{
1240 SwitchStatement: &SwitchStatement{
1241 Expression: Expression{
1242 Expressions: []AssignmentExpression{
1243 {
1244 ConditionalExpression: &litA,
1245 Tokens: tk[2:3],
1246 },
1247 },
1248 Tokens: tk[2:3],
1249 },
1250 CaseClauses: []CaseClause{
1251 {
1252 Expression: Expression{
1253 Expressions: []AssignmentExpression{
1254 {
1255 ConditionalExpression: &litB,
1256 Tokens: tk[7:8],
1257 },
1258 },
1259 Tokens: tk[7:8],
1260 },
1261 Tokens: tk[5:9],
1262 },
1263 {
1264 Expression: Expression{
1265 Expressions: []AssignmentExpression{
1266 {
1267 ConditionalExpression: &litC,
1268 Tokens: tk[11:12],
1269 },
1270 },
1271 Tokens: tk[11:12],
1272 },
1273 StatementList: []StatementListItem{
1274 {
1275 Statement: &Statement{
1276 ExpressionStatement: &Expression{
1277 Expressions: []AssignmentExpression{
1278 {
1279 ConditionalExpression: &litD,
1280 Tokens: tk[13:14],
1281 },
1282 },
1283 Tokens: tk[13:14],
1284 },
1285 Tokens: tk[13:15],
1286 },
1287 Tokens: tk[13:15],
1288 },
1289 },
1290 Tokens: tk[9:15],
1291 },
1292 },
1293 DefaultClause: []StatementListItem{
1294 {
1295 Statement: &Statement{
1296 ExpressionStatement: &Expression{
1297 Expressions: []AssignmentExpression{
1298 {
1299 ConditionalExpression: &litE,
1300 Tokens: tk[17:18],
1301 },
1302 },
1303 Tokens: tk[17:18],
1304 },
1305 Tokens: tk[17:19],
1306 },
1307 Tokens: tk[17:19],
1308 },
1309 {
1310 Statement: &Statement{
1311 ExpressionStatement: &Expression{
1312 Expressions: []AssignmentExpression{
1313 {
1314 ConditionalExpression: &litF,
1315 Tokens: tk[19:20],
1316 },
1317 },
1318 Tokens: tk[19:20],
1319 },
1320 Tokens: tk[19:21],
1321 },
1322 Tokens: tk[19:21],
1323 },
1324 },
1325 PostDefaultCaseClauses: []CaseClause{
1326 {
1327 Expression: Expression{
1328 Expressions: []AssignmentExpression{
1329 {
1330 ConditionalExpression: &litG,
1331 Tokens: tk[23:24],
1332 },
1333 },
1334 Tokens: tk[23:24],
1335 },
1336 StatementList: []StatementListItem{
1337 {
1338 Statement: &Statement{
1339 ExpressionStatement: &Expression{
1340 Expressions: []AssignmentExpression{
1341 {
1342 ConditionalExpression: &litH,
1343 Tokens: tk[25:26],
1344 },
1345 },
1346 Tokens: tk[25:26],
1347 },
1348 Tokens: tk[25:27],
1349 },
1350 Tokens: tk[25:27],
1351 },
1352 },
1353 Tokens: tk[21:27],
1354 },
1355 },
1356 Tokens: tk[:28],
1357 },
1358 Tokens: tk[:28],
1359 },
1360 Tokens: tk[:28],
1361 }
1362 }},
1363 {`continue;`, func(t *test, tk Tokens) { // 33
1364 t.Output = StatementListItem{
1365 Statement: &Statement{
1366 Type: StatementContinue,
1367 Tokens: tk[:2],
1368 },
1369 Tokens: tk[:2],
1370 }
1371 }},
1372 {`continue ;`, func(t *test, tk Tokens) { // 34
1373 t.Output = StatementListItem{
1374 Statement: &Statement{
1375 Type: StatementContinue,
1376 Tokens: tk[:3],
1377 },
1378 Tokens: tk[:3],
1379 }
1380 }},
1381 {`continue Name;`, func(t *test, tk Tokens) { // 35
1382 t.Output = StatementListItem{
1383 Statement: &Statement{
1384 Type: StatementContinue,
1385 LabelIdentifier: &tk[2],
1386 Tokens: tk[:4],
1387 },
1388 Tokens: tk[:4],
1389 }
1390 }},
1391 {`break;`, func(t *test, tk Tokens) { // 36
1392 t.Output = StatementListItem{
1393 Statement: &Statement{
1394 Type: StatementBreak,
1395 Tokens: tk[:2],
1396 },
1397 Tokens: tk[:2],
1398 }
1399 }},
1400 {`break ;`, func(t *test, tk Tokens) { // 37
1401 t.Output = StatementListItem{
1402 Statement: &Statement{
1403 Type: StatementBreak,
1404 Tokens: tk[:3],
1405 },
1406 Tokens: tk[:3],
1407 }
1408 }},
1409 {`break Name;`, func(t *test, tk Tokens) { // 38
1410 t.Output = StatementListItem{
1411 Statement: &Statement{
1412 Type: StatementBreak,
1413 LabelIdentifier: &tk[2],
1414 Tokens: tk[:4],
1415 },
1416 Tokens: tk[:4],
1417 }
1418 }},
1419 {`return;`, func(t *test, tk Tokens) { // 39
1420 t.Err = Error{
1421 Err: Error{
1422 Err: ErrInvalidStatement,
1423 Parsing: "Statement",
1424 Token: tk[0],
1425 },
1426 Parsing: "StatementListItem",
1427 Token: tk[0],
1428 }
1429 }},
1430 {`return;`, func(t *test, tk Tokens) { // 40
1431 t.Ret = true
1432 t.Output = StatementListItem{
1433 Statement: &Statement{
1434 Type: StatementReturn,
1435 Tokens: tk[:2],
1436 },
1437 Tokens: tk[:2],
1438 }
1439 }},
1440 {`return 1;`, func(t *test, tk Tokens) { // 41
1441 t.Ret = true
1442 litA := makeConditionLiteral(tk, 2)
1443 t.Output = StatementListItem{
1444 Statement: &Statement{
1445 Type: StatementReturn,
1446 ExpressionStatement: &Expression{
1447 Expressions: []AssignmentExpression{
1448 {
1449 ConditionalExpression: &litA,
1450 Tokens: tk[2:3],
1451 },
1452 },
1453 Tokens: tk[2:3],
1454 },
1455 Tokens: tk[:4],
1456 },
1457 Tokens: tk[:4],
1458 }
1459 }},
1460 {`with(a){}`, func(t *test, tk Tokens) { // 42
1461 litA := makeConditionLiteral(tk, 2)
1462 t.Output = StatementListItem{
1463 Statement: &Statement{
1464 WithStatement: &WithStatement{
1465 Expression: Expression{
1466 Expressions: []AssignmentExpression{
1467 {
1468 ConditionalExpression: &litA,
1469 Tokens: tk[2:3],
1470 },
1471 },
1472 Tokens: tk[2:3],
1473 },
1474 Statement: Statement{
1475 BlockStatement: &Block{
1476 Tokens: tk[4:6],
1477 },
1478 Tokens: tk[4:6],
1479 },
1480 Tokens: tk[:6],
1481 },
1482 Tokens: tk[:6],
1483 },
1484 Tokens: tk[:6],
1485 }
1486 }},
1487 {`throw a;`, func(t *test, tk Tokens) { // 43
1488 litA := makeConditionLiteral(tk, 2)
1489 t.Output = StatementListItem{
1490 Statement: &Statement{
1491 Type: StatementThrow,
1492 ExpressionStatement: &Expression{
1493 Expressions: []AssignmentExpression{
1494 {
1495 ConditionalExpression: &litA,
1496 Tokens: tk[2:3],
1497 },
1498 },
1499 Tokens: tk[2:3],
1500 },
1501 Tokens: tk[0:4],
1502 },
1503 Tokens: tk[0:4],
1504 }
1505 }},
1506 {`try{a;}catch(e){b;}`, func(t *test, tk Tokens) { // 44
1507 litA := makeConditionLiteral(tk, 2)
1508 litB := makeConditionLiteral(tk, 10)
1509 t.Output = StatementListItem{
1510 Statement: &Statement{
1511 TryStatement: &TryStatement{
1512 TryBlock: Block{
1513 StatementList: []StatementListItem{
1514 {
1515 Statement: &Statement{
1516 ExpressionStatement: &Expression{
1517 Expressions: []AssignmentExpression{
1518 {
1519 ConditionalExpression: &litA,
1520 Tokens: tk[2:3],
1521 },
1522 },
1523 Tokens: tk[2:3],
1524 },
1525 Tokens: tk[2:4],
1526 },
1527 Tokens: tk[2:4],
1528 },
1529 },
1530 Tokens: tk[1:5],
1531 },
1532 CatchParameterBindingIdentifier: &tk[7],
1533 CatchBlock: &Block{
1534 StatementList: []StatementListItem{
1535 {
1536 Statement: &Statement{
1537 ExpressionStatement: &Expression{
1538 Expressions: []AssignmentExpression{
1539 {
1540 ConditionalExpression: &litB,
1541 Tokens: tk[10:11],
1542 },
1543 },
1544 Tokens: tk[10:11],
1545 },
1546 Tokens: tk[10:12],
1547 },
1548 Tokens: tk[10:12],
1549 },
1550 },
1551 Tokens: tk[9:13],
1552 },
1553 Tokens: tk[:13],
1554 },
1555 Tokens: tk[:13],
1556 },
1557 Tokens: tk[:13],
1558 }
1559 }},
1560 {`try{a;}catch({e}){b;}`, func(t *test, tk Tokens) { // 45
1561 litA := makeConditionLiteral(tk, 2)
1562 litB := makeConditionLiteral(tk, 12)
1563 t.Output = StatementListItem{
1564 Statement: &Statement{
1565 TryStatement: &TryStatement{
1566 TryBlock: Block{
1567 StatementList: []StatementListItem{
1568 {
1569 Statement: &Statement{
1570 ExpressionStatement: &Expression{
1571 Expressions: []AssignmentExpression{
1572 {
1573 ConditionalExpression: &litA,
1574 Tokens: tk[2:3],
1575 },
1576 },
1577 Tokens: tk[2:3],
1578 },
1579 Tokens: tk[2:4],
1580 },
1581 Tokens: tk[2:4],
1582 },
1583 },
1584 Tokens: tk[1:5],
1585 },
1586 CatchParameterObjectBindingPattern: &ObjectBindingPattern{
1587 BindingPropertyList: []BindingProperty{
1588 {
1589 PropertyName: PropertyName{
1590 LiteralPropertyName: &tk[8],
1591 Tokens: tk[8:9],
1592 },
1593 BindingElement: BindingElement{
1594 SingleNameBinding: &tk[8],
1595 Tokens: tk[8:9],
1596 },
1597 Tokens: tk[8:9],
1598 },
1599 },
1600 Tokens: tk[7:10],
1601 },
1602 CatchBlock: &Block{
1603 StatementList: []StatementListItem{
1604 {
1605 Statement: &Statement{
1606 ExpressionStatement: &Expression{
1607 Expressions: []AssignmentExpression{
1608 {
1609 ConditionalExpression: &litB,
1610 Tokens: tk[12:13],
1611 },
1612 },
1613 Tokens: tk[12:13],
1614 },
1615 Tokens: tk[12:14],
1616 },
1617 Tokens: tk[12:14],
1618 },
1619 },
1620 Tokens: tk[11:15],
1621 },
1622 Tokens: tk[:15],
1623 },
1624 Tokens: tk[:15],
1625 },
1626 Tokens: tk[:15],
1627 }
1628 }},
1629 {`try{a;}finally{b;}`, func(t *test, tk Tokens) { // 46
1630 litA := makeConditionLiteral(tk, 2)
1631 litB := makeConditionLiteral(tk, 7)
1632 t.Output = StatementListItem{
1633 Statement: &Statement{
1634 TryStatement: &TryStatement{
1635 TryBlock: Block{
1636 StatementList: []StatementListItem{
1637 {
1638 Statement: &Statement{
1639 ExpressionStatement: &Expression{
1640 Expressions: []AssignmentExpression{
1641 {
1642 ConditionalExpression: &litA,
1643 Tokens: tk[2:3],
1644 },
1645 },
1646 Tokens: tk[2:3],
1647 },
1648 Tokens: tk[2:4],
1649 },
1650 Tokens: tk[2:4],
1651 },
1652 },
1653 Tokens: tk[1:5],
1654 },
1655 FinallyBlock: &Block{
1656 StatementList: []StatementListItem{
1657 {
1658 Statement: &Statement{
1659 ExpressionStatement: &Expression{
1660 Expressions: []AssignmentExpression{
1661 {
1662 ConditionalExpression: &litB,
1663 Tokens: tk[7:8],
1664 },
1665 },
1666 Tokens: tk[7:8],
1667 },
1668 Tokens: tk[7:9],
1669 },
1670 Tokens: tk[7:9],
1671 },
1672 },
1673 Tokens: tk[6:10],
1674 },
1675 Tokens: tk[:10],
1676 },
1677 Tokens: tk[:10],
1678 },
1679 Tokens: tk[:10],
1680 }
1681 }},
1682 {`try{a;}catch([e]){b;}finally{c;}`, func(t *test, tk Tokens) { // 47
1683 litA := makeConditionLiteral(tk, 2)
1684 litB := makeConditionLiteral(tk, 12)
1685 litC := makeConditionLiteral(tk, 17)
1686 t.Output = StatementListItem{
1687 Statement: &Statement{
1688 TryStatement: &TryStatement{
1689 TryBlock: Block{
1690 StatementList: []StatementListItem{
1691 {
1692 Statement: &Statement{
1693 ExpressionStatement: &Expression{
1694 Expressions: []AssignmentExpression{
1695 {
1696 ConditionalExpression: &litA,
1697 Tokens: tk[2:3],
1698 },
1699 },
1700 Tokens: tk[2:3],
1701 },
1702 Tokens: tk[2:4],
1703 },
1704 Tokens: tk[2:4],
1705 },
1706 },
1707 Tokens: tk[1:5],
1708 },
1709 CatchParameterArrayBindingPattern: &ArrayBindingPattern{
1710 BindingElementList: []BindingElement{
1711 {
1712 SingleNameBinding: &tk[8],
1713 Tokens: tk[8:9],
1714 },
1715 },
1716 Tokens: tk[7:10],
1717 },
1718 CatchBlock: &Block{
1719 StatementList: []StatementListItem{
1720 {
1721 Statement: &Statement{
1722 ExpressionStatement: &Expression{
1723 Expressions: []AssignmentExpression{
1724 {
1725 ConditionalExpression: &litB,
1726 Tokens: tk[12:13],
1727 },
1728 },
1729 Tokens: tk[12:13],
1730 },
1731 Tokens: tk[12:14],
1732 },
1733 Tokens: tk[12:14],
1734 },
1735 },
1736 Tokens: tk[11:15],
1737 },
1738 FinallyBlock: &Block{
1739 StatementList: []StatementListItem{
1740 {
1741 Statement: &Statement{
1742 ExpressionStatement: &Expression{
1743 Expressions: []AssignmentExpression{
1744 {
1745 ConditionalExpression: &litC,
1746 Tokens: tk[17:18],
1747 },
1748 },
1749 Tokens: tk[17:18],
1750 },
1751 Tokens: tk[17:19],
1752 },
1753 Tokens: tk[17:19],
1754 },
1755 },
1756 Tokens: tk[16:20],
1757 },
1758 Tokens: tk[:20],
1759 },
1760 Tokens: tk[:20],
1761 },
1762 Tokens: tk[:20],
1763 }
1764 }},
1765 {`debugger;`, func(t *test, tk Tokens) { // 48
1766 t.Output = StatementListItem{
1767 Statement: &Statement{
1768 Type: StatementDebugger,
1769 Tokens: tk[:2],
1770 },
1771 Tokens: tk[:2],
1772 }
1773 }},
1774 {`label: debugger;`, func(t *test, tk Tokens) { // 49
1775 t.Output = StatementListItem{
1776 Statement: &Statement{
1777 LabelIdentifier: &tk[0],
1778 LabelledItemStatement: &Statement{
1779 Type: StatementDebugger,
1780 Tokens: tk[3:5],
1781 },
1782 Tokens: tk[0:5],
1783 },
1784 Tokens: tk[0:5],
1785 }
1786 }},
1787 {`label: function fn(){}`, func(t *test, tk Tokens) { // 50
1788 t.Output = StatementListItem{
1789 Statement: &Statement{
1790 LabelIdentifier: &tk[0],
1791 LabelledItemFunction: &FunctionDeclaration{
1792 BindingIdentifier: &tk[5],
1793 FormalParameters: FormalParameters{
1794 Tokens: tk[6:8],
1795 },
1796 FunctionBody: Block{
1797 Tokens: tk[8:10],
1798 },
1799 Tokens: tk[3:10],
1800 },
1801 Tokens: tk[:10],
1802 },
1803 Tokens: tk[:10],
1804 }
1805 }},
1806 {`a = b;`, func(t *test, tk Tokens) { // 51
1807 litB := makeConditionLiteral(tk, 4)
1808 t.Output = StatementListItem{
1809 Statement: &Statement{
1810 ExpressionStatement: &Expression{
1811 Expressions: []AssignmentExpression{
1812 {
1813 LeftHandSideExpression: &LeftHandSideExpression{
1814 NewExpression: &NewExpression{
1815 MemberExpression: MemberExpression{
1816 PrimaryExpression: &PrimaryExpression{
1817 IdentifierReference: &tk[0],
1818 Tokens: tk[:1],
1819 },
1820 Tokens: tk[:1],
1821 },
1822 Tokens: tk[:1],
1823 },
1824 Tokens: tk[:1],
1825 },
1826 AssignmentOperator: AssignmentAssign,
1827 AssignmentExpression: &AssignmentExpression{
1828 ConditionalExpression: &litB,
1829 Tokens: tk[4:5],
1830 },
1831 Tokens: tk[:5],
1832 },
1833 },
1834 Tokens: tk[:5],
1835 },
1836 Tokens: tk[:6],
1837 },
1838 Tokens: tk[:6],
1839 }
1840 }},
1841 {`class a{}`, func(t *test, tk Tokens) { // 52
1842 t.Output = StatementListItem{
1843 Declaration: &Declaration{
1844 ClassDeclaration: &ClassDeclaration{
1845 BindingIdentifier: &tk[2],
1846 Tokens: tk[:5],
1847 },
1848 Tokens: tk[:5],
1849 },
1850 Tokens: tk[:5],
1851 }
1852 }},
1853 {`function a(){}`, func(t *test, tk Tokens) { // 53
1854 t.Output = StatementListItem{
1855 Declaration: &Declaration{
1856 FunctionDeclaration: &FunctionDeclaration{
1857 BindingIdentifier: &tk[2],
1858 FormalParameters: FormalParameters{
1859 Tokens: tk[3:5],
1860 },
1861 FunctionBody: Block{
1862 Tokens: tk[5:7],
1863 },
1864 Tokens: tk[:7],
1865 },
1866 Tokens: tk[:7],
1867 },
1868 Tokens: tk[:7],
1869 }
1870 }},
1871 {`let a;`, func(t *test, tk Tokens) { // 54
1872 t.Output = StatementListItem{
1873 Declaration: &Declaration{
1874 LexicalDeclaration: &LexicalDeclaration{
1875 BindingList: []LexicalBinding{
1876 {
1877 BindingIdentifier: &tk[2],
1878 Tokens: tk[2:3],
1879 },
1880 },
1881 Tokens: tk[:4],
1882 },
1883 Tokens: tk[:4],
1884 },
1885 Tokens: tk[:4],
1886 }
1887 }},
1888 {`const a = 1;`, func(t *test, tk Tokens) { // 55
1889 litA := makeConditionLiteral(tk, 6)
1890 t.Output = StatementListItem{
1891 Declaration: &Declaration{
1892 LexicalDeclaration: &LexicalDeclaration{
1893 LetOrConst: Const,
1894 BindingList: []LexicalBinding{
1895 {
1896 BindingIdentifier: &tk[2],
1897 Initializer: &AssignmentExpression{
1898 ConditionalExpression: &litA,
1899 Tokens: tk[6:7],
1900 },
1901 Tokens: tk[2:7],
1902 },
1903 },
1904 Tokens: tk[:8],
1905 },
1906 Tokens: tk[:8],
1907 },
1908 Tokens: tk[:8],
1909 }
1910 }},
1911 {`async function fn(){}`, func(t *test, tk Tokens) { // 56
1912 t.Output = StatementListItem{
1913 Declaration: &Declaration{
1914 FunctionDeclaration: &FunctionDeclaration{
1915 Type: FunctionAsync,
1916 BindingIdentifier: &tk[4],
1917 FormalParameters: FormalParameters{
1918 Tokens: tk[5:7],
1919 },
1920 FunctionBody: Block{
1921 Tokens: tk[7:9],
1922 },
1923 Tokens: tk[:9],
1924 },
1925 Tokens: tk[:9],
1926 },
1927 Tokens: tk[:9],
1928 }
1929 }},
1930 {`async () => {};`, func(t *test, tk Tokens) { // 57
1931 t.Output = StatementListItem{
1932 Statement: &Statement{
1933 ExpressionStatement: &Expression{
1934 Expressions: []AssignmentExpression{
1935 {
1936 ArrowFunction: &ArrowFunction{
1937 Async: true,
1938 FormalParameters: &FormalParameters{
1939 Tokens: tk[2:4],
1940 },
1941 FunctionBody: &Block{
1942 Tokens: tk[7:9],
1943 },
1944 Tokens: tk[:9],
1945 },
1946 Tokens: tk[:9],
1947 },
1948 },
1949 Tokens: tk[:9],
1950 },
1951 Tokens: tk[:10],
1952 },
1953 Tokens: tk[:10],
1954 }
1955 }},
1956 {`for await(a of b) {}`, func(t *test, tk Tokens) { // 58
1957 t.Await = true
1958 litB := makeConditionLiteral(tk, 8)
1959 t.Output = StatementListItem{
1960 Statement: &Statement{
1961 IterationStatementFor: &IterationStatementFor{
1962 Type: ForAwaitOfLeftHandSide,
1963 LeftHandSideExpression: &LeftHandSideExpression{
1964 NewExpression: &NewExpression{
1965 MemberExpression: MemberExpression{
1966 PrimaryExpression: &PrimaryExpression{
1967 IdentifierReference: &tk[4],
1968 Tokens: tk[4:5],
1969 },
1970 Tokens: tk[4:5],
1971 },
1972 Tokens: tk[4:5],
1973 },
1974 Tokens: tk[4:5],
1975 },
1976 Of: &AssignmentExpression{
1977 ConditionalExpression: &litB,
1978 Tokens: tk[8:9],
1979 },
1980 Statement: Statement{
1981 BlockStatement: &Block{
1982 Tokens: tk[11:13],
1983 },
1984 Tokens: tk[11:13],
1985 },
1986 Tokens: tk[:13],
1987 },
1988 Tokens: tk[:13],
1989 },
1990 Tokens: tk[:13],
1991 }
1992 }},
1993 {`for await(var a of b) {}`, func(t *test, tk Tokens) { // 59
1994 t.Await = true
1995 litB := makeConditionLiteral(tk, 10)
1996 t.Output = StatementListItem{
1997 Statement: &Statement{
1998 IterationStatementFor: &IterationStatementFor{
1999 Type: ForAwaitOfVar,
2000 ForBindingIdentifier: &tk[6],
2001 Of: &AssignmentExpression{
2002 ConditionalExpression: &litB,
2003 Tokens: tk[10:11],
2004 },
2005 Statement: Statement{
2006 BlockStatement: &Block{
2007 Tokens: tk[13:15],
2008 },
2009 Tokens: tk[13:15],
2010 },
2011 Tokens: tk[:15],
2012 },
2013 Tokens: tk[:15],
2014 },
2015 Tokens: tk[:15],
2016 }
2017 }},
2018 {`for await(let {a} of b) {}`, func(t *test, tk Tokens) { // 60
2019 t.Await = true
2020 litB := makeConditionLiteral(tk, 12)
2021 t.Output = StatementListItem{
2022 Statement: &Statement{
2023 IterationStatementFor: &IterationStatementFor{
2024 Type: ForAwaitOfLet,
2025 ForBindingPatternObject: &ObjectBindingPattern{
2026 BindingPropertyList: []BindingProperty{
2027 {
2028 PropertyName: PropertyName{
2029 LiteralPropertyName: &tk[7],
2030 Tokens: tk[7:8],
2031 },
2032 BindingElement: BindingElement{
2033 SingleNameBinding: &tk[7],
2034 Tokens: tk[7:8],
2035 },
2036 Tokens: tk[7:8],
2037 },
2038 },
2039 Tokens: tk[6:9],
2040 },
2041 Of: &AssignmentExpression{
2042 ConditionalExpression: &litB,
2043 Tokens: tk[12:13],
2044 },
2045 Statement: Statement{
2046 BlockStatement: &Block{
2047 Tokens: tk[15:17],
2048 },
2049 Tokens: tk[15:17],
2050 },
2051 Tokens: tk[:17],
2052 },
2053 Tokens: tk[:17],
2054 },
2055 Tokens: tk[:17],
2056 }
2057 }},
2058 {`for await(const [a] of b) {}`, func(t *test, tk Tokens) { // 61
2059 t.Await = true
2060 litB := makeConditionLiteral(tk, 12)
2061 t.Output = StatementListItem{
2062 Statement: &Statement{
2063 IterationStatementFor: &IterationStatementFor{
2064 Type: ForAwaitOfConst,
2065 ForBindingPatternArray: &ArrayBindingPattern{
2066 BindingElementList: []BindingElement{
2067 {
2068 SingleNameBinding: &tk[7],
2069 Tokens: tk[7:8],
2070 },
2071 },
2072 Tokens: tk[6:9],
2073 },
2074 Of: &AssignmentExpression{
2075 ConditionalExpression: &litB,
2076 Tokens: tk[12:13],
2077 },
2078 Statement: Statement{
2079 BlockStatement: &Block{
2080 Tokens: tk[15:17],
2081 },
2082 Tokens: tk[15:17],
2083 },
2084 Tokens: tk[:17],
2085 },
2086 Tokens: tk[:17],
2087 },
2088 Tokens: tk[:17],
2089 }
2090 }},
2091 {`try{a;}catch{b;}`, func(t *test, tk Tokens) { // 62
2092 litA := makeConditionLiteral(tk, 2)
2093 litB := makeConditionLiteral(tk, 7)
2094 t.Output = StatementListItem{
2095 Statement: &Statement{
2096 TryStatement: &TryStatement{
2097 TryBlock: Block{
2098 StatementList: []StatementListItem{
2099 {
2100 Statement: &Statement{
2101 ExpressionStatement: &Expression{
2102 Expressions: []AssignmentExpression{
2103 {
2104 ConditionalExpression: &litA,
2105 Tokens: tk[2:3],
2106 },
2107 },
2108 Tokens: tk[2:3],
2109 },
2110 Tokens: tk[2:4],
2111 },
2112 Tokens: tk[2:4],
2113 },
2114 },
2115 Tokens: tk[1:5],
2116 },
2117 CatchBlock: &Block{
2118 StatementList: []StatementListItem{
2119 {
2120 Statement: &Statement{
2121 ExpressionStatement: &Expression{
2122 Expressions: []AssignmentExpression{
2123 {
2124 ConditionalExpression: &litB,
2125 Tokens: tk[7:8],
2126 },
2127 },
2128 Tokens: tk[7:8],
2129 },
2130 Tokens: tk[7:9],
2131 },
2132 Tokens: tk[7:9],
2133 },
2134 },
2135 Tokens: tk[6:10],
2136 },
2137 Tokens: tk[:10],
2138 },
2139 Tokens: tk[:10],
2140 },
2141 Tokens: tk[:10],
2142 }
2143 }},
2144 {`try{a;}catch{b;}finally{c;}`, func(t *test, tk Tokens) { // 63
2145 litA := makeConditionLiteral(tk, 2)
2146 litB := makeConditionLiteral(tk, 7)
2147 litC := makeConditionLiteral(tk, 12)
2148 t.Output = StatementListItem{
2149 Statement: &Statement{
2150 TryStatement: &TryStatement{
2151 TryBlock: Block{
2152 StatementList: []StatementListItem{
2153 {
2154 Statement: &Statement{
2155 ExpressionStatement: &Expression{
2156 Expressions: []AssignmentExpression{
2157 {
2158 ConditionalExpression: &litA,
2159 Tokens: tk[2:3],
2160 },
2161 },
2162 Tokens: tk[2:3],
2163 },
2164 Tokens: tk[2:4],
2165 },
2166 Tokens: tk[2:4],
2167 },
2168 },
2169 Tokens: tk[1:5],
2170 },
2171 CatchBlock: &Block{
2172 StatementList: []StatementListItem{
2173 {
2174 Statement: &Statement{
2175 ExpressionStatement: &Expression{
2176 Expressions: []AssignmentExpression{
2177 {
2178 ConditionalExpression: &litB,
2179 Tokens: tk[7:8],
2180 },
2181 },
2182 Tokens: tk[7:8],
2183 },
2184 Tokens: tk[7:9],
2185 },
2186 Tokens: tk[7:9],
2187 },
2188 },
2189 Tokens: tk[6:10],
2190 },
2191 FinallyBlock: &Block{
2192 StatementList: []StatementListItem{
2193 {
2194 Statement: &Statement{
2195 ExpressionStatement: &Expression{
2196 Expressions: []AssignmentExpression{
2197 {
2198 ConditionalExpression: &litC,
2199 Tokens: tk[12:13],
2200 },
2201 },
2202 Tokens: tk[12:13],
2203 },
2204 Tokens: tk[12:14],
2205 },
2206 Tokens: tk[12:14],
2207 },
2208 },
2209 Tokens: tk[11:15],
2210 },
2211 Tokens: tk[:15],
2212 },
2213 Tokens: tk[:15],
2214 },
2215 Tokens: tk[:15],
2216 }
2217 }},
2218 }, func(t *test) (Type, error) {
2219 var sl StatementListItem
2220 err := sl.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
2221 return sl, err
2222 })
2223 }
2224
2225 func TestBlock(t *testing.T) {
2226 doTests(t, []sourceFn{
2227 {``, func(t *test, tk Tokens) { // 1
2228 t.Err = Error{
2229 Err: ErrMissingOpeningBrace,
2230 Parsing: "Block",
2231 Token: tk[0],
2232 }
2233 }},
2234 {"{\n}", func(t *test, tk Tokens) { // 2
2235 t.Output = Block{
2236 Tokens: tk[:3],
2237 }
2238 }},
2239 {"{\n,\n}", func(t *test, tk Tokens) { // 3
2240 t.Err = Error{
2241 Err: Error{
2242 Err: Error{
2243 Err: Error{
2244 Err: assignmentError(tk[2]),
2245 Parsing: "Expression",
2246 Token: tk[2],
2247 },
2248 Parsing: "Statement",
2249 Token: tk[2],
2250 },
2251 Parsing: "StatementListItem",
2252 Token: tk[2],
2253 },
2254 Parsing: "Block",
2255 Token: tk[2],
2256 }
2257 }},
2258 {"{\na\n}", func(t *test, tk Tokens) { // 4
2259 litA := makeConditionLiteral(tk, 2)
2260 t.Output = Block{
2261 StatementList: []StatementListItem{
2262 {
2263 Statement: &Statement{
2264 ExpressionStatement: &Expression{
2265 Expressions: []AssignmentExpression{
2266 {
2267 ConditionalExpression: &litA,
2268 Tokens: tk[2:3],
2269 },
2270 },
2271 Tokens: tk[2:3],
2272 },
2273 Tokens: tk[2:3],
2274 },
2275 Tokens: tk[2:3],
2276 },
2277 },
2278 Tokens: tk[:5],
2279 }
2280 }},
2281 {"{\na\nfunction}", func(t *test, tk Tokens) { // 5
2282 t.Err = Error{
2283 Err: Error{
2284 Err: Error{
2285 Err: ErrInvalidStatement,
2286 Parsing: "Statement",
2287 Token: tk[4],
2288 },
2289 Parsing: "StatementListItem",
2290 Token: tk[4],
2291 },
2292 Parsing: "Block",
2293 Token: tk[4],
2294 }
2295 }},
2296 {"{\na\nb\n}", func(t *test, tk Tokens) { // 6
2297 litA := makeConditionLiteral(tk, 2)
2298 litB := makeConditionLiteral(tk, 4)
2299 t.Output = Block{
2300 StatementList: []StatementListItem{
2301 {
2302 Statement: &Statement{
2303 ExpressionStatement: &Expression{
2304 Expressions: []AssignmentExpression{
2305 {
2306 ConditionalExpression: &litA,
2307 Tokens: tk[2:3],
2308 },
2309 },
2310 Tokens: tk[2:3],
2311 },
2312 Tokens: tk[2:3],
2313 },
2314 Tokens: tk[2:3],
2315 },
2316 {
2317 Statement: &Statement{
2318 ExpressionStatement: &Expression{
2319 Expressions: []AssignmentExpression{
2320 {
2321 ConditionalExpression: &litB,
2322 Tokens: tk[4:5],
2323 },
2324 },
2325 Tokens: tk[4:5],
2326 },
2327 Tokens: tk[4:5],
2328 },
2329 Tokens: tk[4:5],
2330 },
2331 },
2332 Tokens: tk[:7],
2333 }
2334 }},
2335 }, func(t *test) (Type, error) {
2336 var b Block
2337 err := b.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
2338 return b, err
2339 })
2340 }
2341
2342 func TestStatementListItem(t *testing.T) {
2343 doTests(t, []sourceFn{
2344 {``, func(t *test, tk Tokens) { // 1
2345 t.Err = Error{
2346 Err: Error{
2347 Err: Error{
2348 Err: assignmentError(tk[0]),
2349 Parsing: "Expression",
2350 Token: tk[0],
2351 },
2352 Parsing: "Statement",
2353 Token: tk[0],
2354 },
2355 Parsing: "StatementListItem",
2356 Token: tk[0],
2357 }
2358 }},
2359 {"let", func(t *test, tk Tokens) { // 2
2360 t.Err = Error{
2361 Err: Error{
2362 Err: Error{
2363 Err: Error{
2364 Err: ErrNoIdentifier,
2365 Parsing: "LexicalBinding",
2366 Token: tk[1],
2367 },
2368 Parsing: "LexicalDeclaration",
2369 Token: tk[1],
2370 },
2371 Parsing: "Declaration",
2372 Token: tk[0],
2373 },
2374 Parsing: "StatementListItem",
2375 Token: tk[0],
2376 }
2377 }},
2378 {"const", func(t *test, tk Tokens) { // 3
2379 t.Err = Error{
2380 Err: Error{
2381 Err: Error{
2382 Err: Error{
2383 Err: ErrNoIdentifier,
2384 Parsing: "LexicalBinding",
2385 Token: tk[1],
2386 },
2387 Parsing: "LexicalDeclaration",
2388 Token: tk[1],
2389 },
2390 Parsing: "Declaration",
2391 Token: tk[0],
2392 },
2393 Parsing: "StatementListItem",
2394 Token: tk[0],
2395 }
2396 }},
2397 {"class", func(t *test, tk Tokens) { // 4
2398 t.Err = Error{
2399 Err: Error{
2400 Err: ErrInvalidStatement,
2401 Parsing: "Statement",
2402 Token: tk[0],
2403 },
2404 Parsing: "StatementListItem",
2405 Token: tk[0],
2406 }
2407 }},
2408 {"class\na", func(t *test, tk Tokens) { // 5
2409 t.Err = Error{
2410 Err: Error{
2411 Err: Error{
2412 Err: ErrMissingOpeningBrace,
2413 Parsing: "ClassDeclaration",
2414 Token: tk[3],
2415 },
2416 Parsing: "Declaration",
2417 Token: tk[0],
2418 },
2419 Parsing: "StatementListItem",
2420 Token: tk[0],
2421 }
2422 }},
2423 {"async", func(t *test, tk Tokens) { // 6
2424 t.Err = Error{
2425 Err: Error{
2426 Err: Error{
2427 Err: assignmentCustomError(tk[0], Error{
2428 Err: ErrInvalidFunction,
2429 Parsing: "FunctionDeclaration",
2430 Token: tk[1],
2431 }),
2432 Parsing: "Expression",
2433 Token: tk[0],
2434 },
2435 Parsing: "Statement",
2436 Token: tk[0],
2437 },
2438 Parsing: "StatementListItem",
2439 Token: tk[0],
2440 }
2441 }},
2442 {"async function\na", func(t *test, tk Tokens) { // 7
2443 t.Err = Error{
2444 Err: Error{
2445 Err: Error{
2446 Err: Error{
2447 Err: ErrMissingOpeningParenthesis,
2448 Parsing: "FormalParameters",
2449 Token: tk[5],
2450 },
2451 Parsing: "FunctionDeclaration",
2452 Token: tk[5],
2453 },
2454 Parsing: "Declaration",
2455 Token: tk[0],
2456 },
2457 Parsing: "StatementListItem",
2458 Token: tk[0],
2459 }
2460 }},
2461 {"async function\n*\na", func(t *test, tk Tokens) { // 8
2462 t.Err = Error{
2463 Err: Error{
2464 Err: Error{
2465 Err: Error{
2466 Err: ErrMissingOpeningParenthesis,
2467 Parsing: "FormalParameters",
2468 Token: tk[7],
2469 },
2470 Parsing: "FunctionDeclaration",
2471 Token: tk[7],
2472 },
2473 Parsing: "Declaration",
2474 Token: tk[0],
2475 },
2476 Parsing: "StatementListItem",
2477 Token: tk[0],
2478 }
2479 }},
2480 {"async function\n*", func(t *test, tk Tokens) { // 9
2481 t.Err = Error{
2482 Err: Error{
2483 Err: ErrInvalidStatement,
2484 Parsing: "Statement",
2485 Token: tk[0],
2486 },
2487 Parsing: "StatementListItem",
2488 Token: tk[0],
2489 }
2490 }},
2491 {"async\nfunction\na", func(t *test, tk Tokens) { // 10
2492 t.Err = Error{
2493 Err: Error{
2494 Err: Error{
2495 Err: assignmentCustomError(tk[0], Error{
2496 Err: ErrInvalidFunction,
2497 Parsing: "FunctionDeclaration",
2498 Token: tk[1],
2499 }),
2500 Parsing: "Expression",
2501 Token: tk[0],
2502 },
2503 Parsing: "Statement",
2504 Token: tk[0],
2505 },
2506 Parsing: "StatementListItem",
2507 Token: tk[0],
2508 }
2509 }},
2510 {"function", func(t *test, tk Tokens) { // 11
2511 t.Err = Error{
2512 Err: Error{
2513 Err: ErrInvalidStatement,
2514 Parsing: "Statement",
2515 Token: tk[0],
2516 },
2517 Parsing: "StatementListItem",
2518 Token: tk[0],
2519 }
2520 }},
2521 {"function\n*", func(t *test, tk Tokens) { // 12
2522 t.Err = Error{
2523 Err: Error{
2524 Err: ErrInvalidStatement,
2525 Parsing: "Statement",
2526 Token: tk[0],
2527 },
2528 Parsing: "StatementListItem",
2529 Token: tk[0],
2530 }
2531 }},
2532 {"function\n*\na", func(t *test, tk Tokens) { // 13
2533 t.Err = Error{
2534 Err: Error{
2535 Err: Error{
2536 Err: Error{
2537 Err: ErrMissingOpeningParenthesis,
2538 Parsing: "FormalParameters",
2539 Token: tk[5],
2540 },
2541 Parsing: "FunctionDeclaration",
2542 Token: tk[5],
2543 },
2544 Parsing: "Declaration",
2545 Token: tk[0],
2546 },
2547 Parsing: "StatementListItem",
2548 Token: tk[0],
2549 }
2550 }},
2551 {"function\na", func(t *test, tk Tokens) { // 14
2552 t.Err = Error{
2553 Err: Error{
2554 Err: Error{
2555 Err: Error{
2556 Err: ErrMissingOpeningParenthesis,
2557 Parsing: "FormalParameters",
2558 Token: tk[3],
2559 },
2560 Parsing: "FunctionDeclaration",
2561 Token: tk[3],
2562 },
2563 Parsing: "Declaration",
2564 Token: tk[0],
2565 },
2566 Parsing: "StatementListItem",
2567 Token: tk[0],
2568 }
2569 }},
2570 {"function\na(){}", func(t *test, tk Tokens) { // 15
2571 t.Output = StatementListItem{
2572 Declaration: &Declaration{
2573 FunctionDeclaration: &FunctionDeclaration{
2574 BindingIdentifier: &tk[2],
2575 FormalParameters: FormalParameters{
2576 Tokens: tk[3:5],
2577 },
2578 FunctionBody: Block{
2579 Tokens: tk[5:7],
2580 },
2581 Tokens: tk[:7],
2582 },
2583 Tokens: tk[:7],
2584 },
2585 Tokens: tk[:7],
2586 }
2587 }},
2588 {"a", func(t *test, tk Tokens) { // 16
2589 litA := makeConditionLiteral(tk, 0)
2590 t.Output = StatementListItem{
2591 Statement: &Statement{
2592 ExpressionStatement: &Expression{
2593 Expressions: []AssignmentExpression{
2594 {
2595 ConditionalExpression: &litA,
2596 Tokens: tk[:1],
2597 },
2598 },
2599 Tokens: tk[:1],
2600 },
2601 Tokens: tk[:1],
2602 },
2603 Tokens: tk[:1],
2604 }
2605 }},
2606 }, func(t *test) (Type, error) {
2607 var si StatementListItem
2608 err := si.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
2609 return si, err
2610 })
2611 }
2612
2613 func TestStatement(t *testing.T) {
2614 doTests(t, []sourceFn{
2615 {``, func(t *test, tk Tokens) { // 1
2616 t.Err = Error{
2617 Err: Error{
2618 Err: assignmentError(tk[0]),
2619 Parsing: "Expression",
2620 Token: tk[0],
2621 },
2622 Parsing: "Statement",
2623 Token: tk[0],
2624 }
2625 }},
2626 {"{,}", func(t *test, tk Tokens) { // 2
2627 t.Err = Error{
2628 Err: Error{
2629 Err: Error{
2630 Err: Error{
2631 Err: Error{
2632 Err: assignmentError(tk[1]),
2633 Parsing: "Expression",
2634 Token: tk[1],
2635 },
2636 Parsing: "Statement",
2637 Token: tk[1],
2638 },
2639 Parsing: "StatementListItem",
2640 Token: tk[1],
2641 },
2642 Parsing: "Block",
2643 Token: tk[1],
2644 },
2645 Parsing: "Statement",
2646 Token: tk[0],
2647 }
2648 }},
2649 {"{}", func(t *test, tk Tokens) { // 3
2650 t.Output = Statement{
2651 BlockStatement: &Block{
2652 Tokens: tk[:2],
2653 },
2654 Tokens: tk[:2],
2655 }
2656 }},
2657 {"var", func(t *test, tk Tokens) { // 4
2658 t.Err = Error{
2659 Err: Error{
2660 Err: Error{
2661 Err: ErrNoIdentifier,
2662 Parsing: "LexicalBinding",
2663 Token: tk[1],
2664 },
2665 Parsing: "VariableStatement",
2666 Token: tk[1],
2667 },
2668 Parsing: "Statement",
2669 Token: tk[0],
2670 }
2671 }},
2672 {"var\na", func(t *test, tk Tokens) { // 5
2673 t.Output = Statement{
2674 VariableStatement: &VariableStatement{
2675 VariableDeclarationList: []VariableDeclaration{
2676 {
2677 BindingIdentifier: &tk[2],
2678 Tokens: tk[2:3],
2679 },
2680 },
2681 Tokens: tk[:3],
2682 },
2683 Tokens: tk[:3],
2684 }
2685 }},
2686 {";", func(t *test, tk Tokens) { // 6
2687 t.Output = Statement{
2688 Tokens: tk[:1],
2689 }
2690 }},
2691 {"if", func(t *test, tk Tokens) { // 7
2692 t.Err = Error{
2693 Err: Error{
2694 Err: ErrMissingOpeningParenthesis,
2695 Parsing: "IfStatement",
2696 Token: tk[1],
2697 },
2698 Parsing: "Statement",
2699 Token: tk[0],
2700 }
2701 }},
2702 {"if(a){}", func(t *test, tk Tokens) { // 8
2703 litA := makeConditionLiteral(tk, 2)
2704 t.Output = Statement{
2705 IfStatement: &IfStatement{
2706 Expression: Expression{
2707 Expressions: []AssignmentExpression{
2708 {
2709 ConditionalExpression: &litA,
2710 Tokens: tk[2:3],
2711 },
2712 },
2713 Tokens: tk[2:3],
2714 },
2715 Statement: Statement{
2716 BlockStatement: &Block{
2717 Tokens: tk[4:6],
2718 },
2719 Tokens: tk[4:6],
2720 },
2721 Tokens: tk[:6],
2722 },
2723 Tokens: tk[:6],
2724 }
2725 }},
2726 {"do", func(t *test, tk Tokens) { // 9
2727 t.Err = Error{
2728 Err: Error{
2729 Err: Error{
2730 Err: Error{
2731 Err: assignmentError(tk[1]),
2732 Parsing: "Expression",
2733 Token: tk[1],
2734 },
2735 Parsing: "Statement",
2736 Token: tk[1],
2737 },
2738 Parsing: "IterationStatementDo",
2739 Token: tk[1],
2740 },
2741 Parsing: "Statement",
2742 Token: tk[0],
2743 }
2744 }},
2745 {"do {} while(1)", func(t *test, tk Tokens) { // 10
2746 litA := makeConditionLiteral(tk, 7)
2747 t.Output = Statement{
2748 IterationStatementDo: &IterationStatementDo{
2749 Statement: Statement{
2750 BlockStatement: &Block{
2751 Tokens: tk[2:4],
2752 },
2753 Tokens: tk[2:4],
2754 },
2755 Expression: Expression{
2756 Expressions: []AssignmentExpression{
2757 {
2758 ConditionalExpression: &litA,
2759 Tokens: tk[7:8],
2760 },
2761 },
2762 Tokens: tk[7:8],
2763 },
2764 Tokens: tk[:9],
2765 },
2766 Tokens: tk[:9],
2767 }
2768 }},
2769 {"while", func(t *test, tk Tokens) { // 11
2770 t.Err = Error{
2771 Err: Error{
2772 Err: ErrMissingOpeningParenthesis,
2773 Parsing: "IterationStatementWhile",
2774 Token: tk[1],
2775 },
2776 Parsing: "Statement",
2777 Token: tk[0],
2778 }
2779 }},
2780 {"while (a) {}", func(t *test, tk Tokens) { // 12
2781 litA := makeConditionLiteral(tk, 3)
2782 t.Output = Statement{
2783 IterationStatementWhile: &IterationStatementWhile{
2784 Expression: Expression{
2785 Expressions: []AssignmentExpression{
2786 {
2787 ConditionalExpression: &litA,
2788 Tokens: tk[3:4],
2789 },
2790 },
2791 Tokens: tk[3:4],
2792 },
2793 Statement: Statement{
2794 BlockStatement: &Block{
2795 Tokens: tk[6:8],
2796 },
2797 Tokens: tk[6:8],
2798 },
2799 Tokens: tk[:8],
2800 },
2801 Tokens: tk[:8],
2802 }
2803 }},
2804 {"for", func(t *test, tk Tokens) { // 13
2805 t.Err = Error{
2806 Err: Error{
2807 Err: ErrMissingOpeningParenthesis,
2808 Parsing: "IterationStatementFor",
2809 Token: tk[1],
2810 },
2811 Parsing: "Statement",
2812 Token: tk[0],
2813 }
2814 }},
2815 {"for (;;) {}", func(t *test, tk Tokens) { // 14
2816 t.Output = Statement{
2817 IterationStatementFor: &IterationStatementFor{
2818 Statement: Statement{
2819 BlockStatement: &Block{
2820 Tokens: tk[7:9],
2821 },
2822 Tokens: tk[7:9],
2823 },
2824 Tokens: tk[:9],
2825 },
2826 Tokens: tk[:9],
2827 }
2828 }},
2829 {"switch", func(t *test, tk Tokens) { // 15
2830 t.Err = Error{
2831 Err: Error{
2832 Err: ErrMissingOpeningParenthesis,
2833 Parsing: "SwitchStatement",
2834 Token: tk[1],
2835 },
2836 Parsing: "Statement",
2837 Token: tk[0],
2838 }
2839 }},
2840 {"switch (a) {}", func(t *test, tk Tokens) { // 16
2841 litA := makeConditionLiteral(tk, 3)
2842 t.Output = Statement{
2843 SwitchStatement: &SwitchStatement{
2844 Expression: Expression{
2845 Expressions: []AssignmentExpression{
2846 {
2847 ConditionalExpression: &litA,
2848 Tokens: tk[3:4],
2849 },
2850 },
2851 Tokens: tk[3:4],
2852 },
2853 Tokens: tk[:8],
2854 },
2855 Tokens: tk[:8],
2856 }
2857 }},
2858 {"continue", func(t *test, tk Tokens) { // 17
2859 t.Output = Statement{
2860 Type: StatementContinue,
2861 Tokens: tk[:1],
2862 }
2863 }},
2864 {"continue;", func(t *test, tk Tokens) { // 18
2865 t.Output = Statement{
2866 Type: StatementContinue,
2867 Tokens: tk[:2],
2868 }
2869 }},
2870 {"continue\nswitch", func(t *test, tk Tokens) { // 19
2871 t.Output = Statement{
2872 Type: StatementContinue,
2873 Tokens: tk[:1],
2874 }
2875 }},
2876 {"continue switch", func(t *test, tk Tokens) { // 20
2877 t.Err = Error{
2878 Err: ErrNoIdentifier,
2879 Parsing: "Statement",
2880 Token: tk[2],
2881 }
2882 }},
2883 {"continue a", func(t *test, tk Tokens) { // 21
2884 t.Output = Statement{
2885 Type: StatementContinue,
2886 LabelIdentifier: &tk[2],
2887 Tokens: tk[:3],
2888 }
2889 }},
2890 {"continue a\n", func(t *test, tk Tokens) { // 22
2891 t.Output = Statement{
2892 Type: StatementContinue,
2893 LabelIdentifier: &tk[2],
2894 Tokens: tk[:3],
2895 }
2896 }},
2897 {"continue a;", func(t *test, tk Tokens) { // 23
2898 t.Output = Statement{
2899 Type: StatementContinue,
2900 LabelIdentifier: &tk[2],
2901 Tokens: tk[:4],
2902 }
2903 }},
2904 {"continue a b", func(t *test, tk Tokens) { // 24
2905 t.Err = Error{
2906 Err: ErrMissingSemiColon,
2907 Parsing: "Statement",
2908 Token: tk[3],
2909 }
2910 }},
2911 {"break", func(t *test, tk Tokens) { // 25
2912 t.Output = Statement{
2913 Type: StatementBreak,
2914 Tokens: tk[:1],
2915 }
2916 }},
2917 {"break;", func(t *test, tk Tokens) { // 26
2918 t.Output = Statement{
2919 Type: StatementBreak,
2920 Tokens: tk[:2],
2921 }
2922 }},
2923 {"break\nswitch", func(t *test, tk Tokens) { // 27
2924 t.Output = Statement{
2925 Type: StatementBreak,
2926 Tokens: tk[:1],
2927 }
2928 }},
2929 {"break switch", func(t *test, tk Tokens) { // 28
2930 t.Err = Error{
2931 Err: ErrNoIdentifier,
2932 Parsing: "Statement",
2933 Token: tk[2],
2934 }
2935 }},
2936 {"break a", func(t *test, tk Tokens) { // 29
2937 t.Output = Statement{
2938 Type: StatementBreak,
2939 LabelIdentifier: &tk[2],
2940 Tokens: tk[:3],
2941 }
2942 }},
2943 {"break a\n", func(t *test, tk Tokens) { // 30
2944 t.Output = Statement{
2945 Type: StatementBreak,
2946 LabelIdentifier: &tk[2],
2947 Tokens: tk[:3],
2948 }
2949 }},
2950 {"break a;", func(t *test, tk Tokens) { // 31
2951 t.Output = Statement{
2952 Type: StatementBreak,
2953 LabelIdentifier: &tk[2],
2954 Tokens: tk[:4],
2955 }
2956 }},
2957 {"break a b", func(t *test, tk Tokens) { // 32
2958 t.Err = Error{
2959 Err: ErrMissingSemiColon,
2960 Parsing: "Statement",
2961 Token: tk[3],
2962 }
2963 }},
2964 {"return", func(t *test, tk Tokens) { // 33
2965 t.Err = Error{
2966 Err: ErrInvalidStatement,
2967 Parsing: "Statement",
2968 Token: tk[0],
2969 }
2970 }},
2971 {"return", func(t *test, tk Tokens) { // 34
2972 t.Ret = true
2973 t.Output = Statement{
2974 Type: StatementReturn,
2975 Tokens: tk[:1],
2976 }
2977 }},
2978 {"return;", func(t *test, tk Tokens) { // 35
2979 t.Ret = true
2980 t.Output = Statement{
2981 Type: StatementReturn,
2982 Tokens: tk[:2],
2983 }
2984 }},
2985 {"return\na", func(t *test, tk Tokens) { // 36
2986 t.Ret = true
2987 t.Output = Statement{
2988 Type: StatementReturn,
2989 Tokens: tk[:1],
2990 }
2991 }},
2992 {"return ,", func(t *test, tk Tokens) { // 37
2993 t.Ret = true
2994 t.Err = Error{
2995 Err: Error{
2996 Err: assignmentError(tk[2]),
2997 Parsing: "Expression",
2998 Token: tk[2],
2999 },
3000 Parsing: "Statement",
3001 Token: tk[2],
3002 }
3003 }},
3004 {"return a", func(t *test, tk Tokens) { // 38
3005 t.Ret = true
3006 litA := makeConditionLiteral(tk, 2)
3007 t.Output = Statement{
3008 Type: StatementReturn,
3009 ExpressionStatement: &Expression{
3010 Expressions: []AssignmentExpression{
3011 {
3012 ConditionalExpression: &litA,
3013 Tokens: tk[2:3],
3014 },
3015 },
3016 Tokens: tk[2:3],
3017 },
3018 Tokens: tk[:3],
3019 }
3020 }},
3021 {"return a;", func(t *test, tk Tokens) { // 39
3022 t.Ret = true
3023 litA := makeConditionLiteral(tk, 2)
3024 t.Output = Statement{
3025 Type: StatementReturn,
3026 ExpressionStatement: &Expression{
3027 Expressions: []AssignmentExpression{
3028 {
3029 ConditionalExpression: &litA,
3030 Tokens: tk[2:3],
3031 },
3032 },
3033 Tokens: tk[2:3],
3034 },
3035 Tokens: tk[:4],
3036 }
3037 }},
3038 {"return a b", func(t *test, tk Tokens) { // 40
3039 t.Ret = true
3040 t.Err = Error{
3041 Err: ErrMissingSemiColon,
3042 Parsing: "Statement",
3043 Token: tk[3],
3044 }
3045 }},
3046 {"with", func(t *test, tk Tokens) { // 41
3047 t.Err = Error{
3048 Err: Error{
3049 Err: ErrMissingOpeningParenthesis,
3050 Parsing: "WithStatement",
3051 Token: tk[1],
3052 },
3053 Parsing: "Statement",
3054 Token: tk[0],
3055 }
3056 }},
3057 {"with (a) {}", func(t *test, tk Tokens) { // 42
3058 litA := makeConditionLiteral(tk, 3)
3059 t.Output = Statement{
3060 WithStatement: &WithStatement{
3061 Expression: Expression{
3062 Expressions: []AssignmentExpression{
3063 {
3064 ConditionalExpression: &litA,
3065 Tokens: tk[3:4],
3066 },
3067 },
3068 Tokens: tk[3:4],
3069 },
3070 Statement: Statement{
3071 BlockStatement: &Block{
3072 Tokens: tk[6:8],
3073 },
3074 Tokens: tk[6:8],
3075 },
3076 Tokens: tk[:8],
3077 },
3078 Tokens: tk[:8],
3079 }
3080 }},
3081 {"throw", func(t *test, tk Tokens) { // 43
3082 t.Err = Error{
3083 Err: Error{
3084 Err: assignmentError(tk[1]),
3085 Parsing: "Expression",
3086 Token: tk[1],
3087 },
3088 Parsing: "Statement",
3089 Token: tk[1],
3090 }
3091 }},
3092 {"throw\na", func(t *test, tk Tokens) { // 44
3093 t.Err = Error{
3094 Err: Error{
3095 Err: assignmentError(tk[1]),
3096 Parsing: "Expression",
3097 Token: tk[1],
3098 },
3099 Parsing: "Statement",
3100 Token: tk[1],
3101 }
3102 }},
3103 {"throw a", func(t *test, tk Tokens) { // 45
3104 litA := makeConditionLiteral(tk, 2)
3105 t.Output = Statement{
3106 Type: StatementThrow,
3107 ExpressionStatement: &Expression{
3108 Expressions: []AssignmentExpression{
3109 {
3110 ConditionalExpression: &litA,
3111 Tokens: tk[2:3],
3112 },
3113 },
3114 Tokens: tk[2:3],
3115 },
3116 Tokens: tk[:3],
3117 }
3118 }},
3119 {"throw a;", func(t *test, tk Tokens) { // 46
3120 litA := makeConditionLiteral(tk, 2)
3121 t.Output = Statement{
3122 Type: StatementThrow,
3123 ExpressionStatement: &Expression{
3124 Expressions: []AssignmentExpression{
3125 {
3126 ConditionalExpression: &litA,
3127 Tokens: tk[2:3],
3128 },
3129 },
3130 Tokens: tk[2:3],
3131 },
3132 Tokens: tk[:4],
3133 }
3134 }},
3135 {"throw a b", func(t *test, tk Tokens) { // 47
3136 t.Err = Error{
3137 Err: ErrMissingSemiColon,
3138 Parsing: "Statement",
3139 Token: tk[3],
3140 }
3141 }},
3142 {"try", func(t *test, tk Tokens) { // 48
3143 t.Err = Error{
3144 Err: Error{
3145 Err: Error{
3146 Err: ErrMissingOpeningBrace,
3147 Parsing: "Block",
3148 Token: tk[1],
3149 },
3150 Parsing: "TryStatement",
3151 Token: tk[1],
3152 },
3153 Parsing: "Statement",
3154 Token: tk[0],
3155 }
3156 }},
3157 {"try{}finally{}", func(t *test, tk Tokens) { // 49
3158 t.Output = Statement{
3159 TryStatement: &TryStatement{
3160 TryBlock: Block{
3161 Tokens: tk[1:3],
3162 },
3163 FinallyBlock: &Block{
3164 Tokens: tk[4:6],
3165 },
3166 Tokens: tk[:6],
3167 },
3168 Tokens: tk[:6],
3169 }
3170 }},
3171 {"debugger", func(t *test, tk Tokens) { // 50
3172 t.Output = Statement{
3173 Type: StatementDebugger,
3174 Tokens: tk[:1],
3175 }
3176 }},
3177 {"debugger;", func(t *test, tk Tokens) { // 51
3178 t.Output = Statement{
3179 Type: StatementDebugger,
3180 Tokens: tk[:2],
3181 }
3182 }},
3183 {"debugger a", func(t *test, tk Tokens) { // 52
3184 t.Err = Error{
3185 Err: ErrMissingSemiColon,
3186 Parsing: "Statement",
3187 Token: tk[1],
3188 }
3189 }},
3190 {"debugger\na", func(t *test, tk Tokens) { // 53
3191 t.Output = Statement{
3192 Type: StatementDebugger,
3193 Tokens: tk[:1],
3194 }
3195 }},
3196 {"a\n:\nfunction", func(t *test, tk Tokens) { // 54
3197 t.Err = Error{
3198 Err: Error{
3199 Err: ErrNoIdentifier,
3200 Parsing: "FunctionDeclaration",
3201 Token: tk[5],
3202 },
3203 Parsing: "Statement",
3204 Token: tk[4],
3205 }
3206 }},
3207 {"a\n:\nfunction\nb(){}", func(t *test, tk Tokens) { // 55
3208 t.Output = Statement{
3209 LabelIdentifier: &tk[0],
3210 LabelledItemFunction: &FunctionDeclaration{
3211 BindingIdentifier: &tk[6],
3212 FormalParameters: FormalParameters{
3213 Tokens: tk[7:9],
3214 },
3215 FunctionBody: Block{
3216 Tokens: tk[9:11],
3217 },
3218 Tokens: tk[4:11],
3219 },
3220 Tokens: tk[:11],
3221 }
3222 }},
3223 {"a\n:", func(t *test, tk Tokens) { // 56
3224 t.Err = Error{
3225 Err: Error{
3226 Err: Error{
3227 Err: assignmentError(tk[3]),
3228 Parsing: "Expression",
3229 Token: tk[3],
3230 },
3231 Parsing: "Statement",
3232 Token: tk[3],
3233 },
3234 Parsing: "Statement",
3235 Token: tk[3],
3236 }
3237 }},
3238 {"function", func(t *test, tk Tokens) { // 57
3239 t.Err = Error{
3240 Err: ErrInvalidStatement,
3241 Parsing: "Statement",
3242 Token: tk[0],
3243 }
3244 }},
3245 {"class", func(t *test, tk Tokens) { // 58
3246 t.Err = Error{
3247 Err: ErrInvalidStatement,
3248 Parsing: "Statement",
3249 Token: tk[0],
3250 }
3251 }},
3252 {"async function", func(t *test, tk Tokens) { // 59
3253 t.Err = Error{
3254 Err: ErrInvalidStatement,
3255 Parsing: "Statement",
3256 Token: tk[0],
3257 }
3258 }},
3259 {"a", func(t *test, tk Tokens) { // 60
3260 litA := makeConditionLiteral(tk, 0)
3261 t.Output = Statement{
3262 ExpressionStatement: &Expression{
3263 Expressions: []AssignmentExpression{
3264 {
3265 ConditionalExpression: &litA,
3266 Tokens: tk[:1],
3267 },
3268 },
3269 Tokens: tk[:1],
3270 },
3271 Tokens: tk[:1],
3272 }
3273 }},
3274 {"a;", func(t *test, tk Tokens) { // 61
3275 litA := makeConditionLiteral(tk, 0)
3276 t.Output = Statement{
3277 ExpressionStatement: &Expression{
3278 Expressions: []AssignmentExpression{
3279 {
3280 ConditionalExpression: &litA,
3281 Tokens: tk[:1],
3282 },
3283 },
3284 Tokens: tk[:1],
3285 },
3286 Tokens: tk[:2],
3287 }
3288 }},
3289 {"a b", func(t *test, tk Tokens) { // 62
3290 t.Err = Error{
3291 Err: ErrMissingSemiColon,
3292 Parsing: "Statement",
3293 Token: tk[1],
3294 }
3295 }},
3296 {"a\nb", func(t *test, tk Tokens) { // 63
3297 litA := makeConditionLiteral(tk, 0)
3298 t.Output = Statement{
3299 ExpressionStatement: &Expression{
3300 Expressions: []AssignmentExpression{
3301 {
3302 ConditionalExpression: &litA,
3303 Tokens: tk[:1],
3304 },
3305 },
3306 Tokens: tk[:1],
3307 },
3308 Tokens: tk[:1],
3309 }
3310 }},
3311 }, func(t *test) (Type, error) {
3312 var s Statement
3313 err := s.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
3314 return s, err
3315 })
3316 }
3317
3318 func TestIfStatement(t *testing.T) {
3319 doTests(t, []sourceFn{
3320 {``, func(t *test, tk Tokens) { // 1
3321 t.Err = Error{
3322 Err: ErrInvalidIfStatement,
3323 Parsing: "IfStatement",
3324 Token: tk[0],
3325 }
3326 }},
3327 {`if`, func(t *test, tk Tokens) { // 2
3328 t.Err = Error{
3329 Err: ErrMissingOpeningParenthesis,
3330 Parsing: "IfStatement",
3331 Token: tk[1],
3332 }
3333 }},
3334 {"if\n(\n)", func(t *test, tk Tokens) { // 3
3335 t.Err = Error{
3336 Err: Error{
3337 Err: assignmentError(tk[4]),
3338 Parsing: "Expression",
3339 Token: tk[4],
3340 },
3341 Parsing: "IfStatement",
3342 Token: tk[4],
3343 }
3344 }},
3345 {"if\n(\na\nb\n)", func(t *test, tk Tokens) { // 4
3346 t.Err = Error{
3347 Err: ErrMissingClosingParenthesis,
3348 Parsing: "IfStatement",
3349 Token: tk[6],
3350 }
3351 }},
3352 {"if\n(\na\n)\n", func(t *test, tk Tokens) { // 5
3353 t.Err = Error{
3354 Err: Error{
3355 Err: Error{
3356 Err: assignmentError(tk[8]),
3357 Parsing: "Expression",
3358 Token: tk[8],
3359 },
3360 Parsing: "Statement",
3361 Token: tk[8],
3362 },
3363 Parsing: "IfStatement",
3364 Token: tk[8],
3365 }
3366 }},
3367 {"if\n(\na\n)\nb", func(t *test, tk Tokens) { // 6
3368 litA := makeConditionLiteral(tk, 4)
3369 litB := makeConditionLiteral(tk, 8)
3370 t.Output = IfStatement{
3371 Expression: Expression{
3372 Expressions: []AssignmentExpression{
3373 {
3374 ConditionalExpression: &litA,
3375 Tokens: tk[4:5],
3376 },
3377 },
3378 Tokens: tk[4:5],
3379 },
3380 Statement: Statement{
3381 ExpressionStatement: &Expression{
3382 Expressions: []AssignmentExpression{
3383 {
3384 ConditionalExpression: &litB,
3385 Tokens: tk[8:9],
3386 },
3387 },
3388 Tokens: tk[8:9],
3389 },
3390 Tokens: tk[8:9],
3391 },
3392 Tokens: tk[:9],
3393 }
3394 }},
3395 {"if\n(\na\n)\nb\nelse", func(t *test, tk Tokens) { // 7
3396 t.Err = Error{
3397 Err: Error{
3398 Err: Error{
3399 Err: assignmentError(tk[11]),
3400 Parsing: "Expression",
3401 Token: tk[11],
3402 },
3403 Parsing: "Statement",
3404 Token: tk[11],
3405 },
3406 Parsing: "IfStatement",
3407 Token: tk[11],
3408 }
3409 }},
3410 {"if\n(\na\n)\nb\nelse\nc", func(t *test, tk Tokens) { // 8
3411 litA := makeConditionLiteral(tk, 4)
3412 litB := makeConditionLiteral(tk, 8)
3413 litC := makeConditionLiteral(tk, 12)
3414 t.Output = IfStatement{
3415 Expression: Expression{
3416 Expressions: []AssignmentExpression{
3417 {
3418 ConditionalExpression: &litA,
3419 Tokens: tk[4:5],
3420 },
3421 },
3422 Tokens: tk[4:5],
3423 },
3424 Statement: Statement{
3425 ExpressionStatement: &Expression{
3426 Expressions: []AssignmentExpression{
3427 {
3428 ConditionalExpression: &litB,
3429 Tokens: tk[8:9],
3430 },
3431 },
3432 Tokens: tk[8:9],
3433 },
3434 Tokens: tk[8:9],
3435 },
3436 ElseStatement: &Statement{
3437 ExpressionStatement: &Expression{
3438 Expressions: []AssignmentExpression{
3439 {
3440 ConditionalExpression: &litC,
3441 Tokens: tk[12:13],
3442 },
3443 },
3444 Tokens: tk[12:13],
3445 },
3446 Tokens: tk[12:13],
3447 },
3448 Tokens: tk[:13],
3449 }
3450 }},
3451 {"if (a) b: function c(){}", func(t *test, tk Tokens) { // 9
3452 t.Err = Error{
3453 Err: ErrLabelledFunction,
3454 Parsing: "IfStatement",
3455 Token: tk[6],
3456 }
3457 }},
3458 {"if (a){b}else c: function d(){}", func(t *test, tk Tokens) { // 10
3459 t.Err = Error{
3460 Err: ErrLabelledFunction,
3461 Parsing: "IfStatement",
3462 Token: tk[10],
3463 }
3464 }},
3465 }, func(t *test) (Type, error) {
3466 var is IfStatement
3467 err := is.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
3468 return is, err
3469 })
3470 }
3471
3472 func TestIterationStatementDo(t *testing.T) {
3473 doTests(t, []sourceFn{
3474 {``, func(t *test, tk Tokens) { // 1
3475 t.Err = Error{
3476 Err: ErrInvalidIterationStatementDo,
3477 Parsing: "IterationStatementDo",
3478 Token: tk[0],
3479 }
3480 }},
3481 {`do`, func(t *test, tk Tokens) { // 2
3482 t.Err = Error{
3483 Err: Error{
3484 Err: Error{
3485 Err: assignmentError(tk[1]),
3486 Parsing: "Expression",
3487 Token: tk[1],
3488 },
3489 Parsing: "Statement",
3490 Token: tk[1],
3491 },
3492 Parsing: "IterationStatementDo",
3493 Token: tk[1],
3494 }
3495 }},
3496 {"do\na", func(t *test, tk Tokens) { // 3
3497 t.Err = Error{
3498 Err: ErrInvalidIterationStatementDo,
3499 Parsing: "IterationStatementDo",
3500 Token: tk[3],
3501 }
3502 }},
3503 {"do\na\nwhile", func(t *test, tk Tokens) { // 4
3504 t.Err = Error{
3505 Err: ErrMissingOpeningParenthesis,
3506 Parsing: "IterationStatementDo",
3507 Token: tk[5],
3508 }
3509 }},
3510 {"do\na\nwhile\n(\n)", func(t *test, tk Tokens) { // 5
3511 t.Err = Error{
3512 Err: Error{
3513 Err: assignmentError(tk[8]),
3514 Parsing: "Expression",
3515 Token: tk[8],
3516 },
3517 Parsing: "IterationStatementDo",
3518 Token: tk[8],
3519 }
3520 }},
3521 {"do\na\nwhile\n(\nb\nc\n)", func(t *test, tk Tokens) { // 6
3522 t.Err = Error{
3523 Err: ErrMissingClosingParenthesis,
3524 Parsing: "IterationStatementDo",
3525 Token: tk[10],
3526 }
3527 }},
3528 {"do\na\nwhile\n(\nb\n)", func(t *test, tk Tokens) { // 7
3529 litA := makeConditionLiteral(tk, 2)
3530 litB := makeConditionLiteral(tk, 8)
3531 t.Output = IterationStatementDo{
3532 Statement: Statement{
3533 ExpressionStatement: &Expression{
3534 Expressions: []AssignmentExpression{
3535 {
3536 ConditionalExpression: &litA,
3537 Tokens: tk[2:3],
3538 },
3539 },
3540 Tokens: tk[2:3],
3541 },
3542 Tokens: tk[2:3],
3543 },
3544 Expression: Expression{
3545 Expressions: []AssignmentExpression{
3546 {
3547 ConditionalExpression: &litB,
3548 Tokens: tk[8:9],
3549 },
3550 },
3551 Tokens: tk[8:9],
3552 },
3553 Tokens: tk[:11],
3554 }
3555 }},
3556 {"do\na\nwhile\n(\nb\n)\n;", func(t *test, tk Tokens) { // 8
3557 litA := makeConditionLiteral(tk, 2)
3558 litB := makeConditionLiteral(tk, 8)
3559 t.Output = IterationStatementDo{
3560 Statement: Statement{
3561 ExpressionStatement: &Expression{
3562 Expressions: []AssignmentExpression{
3563 {
3564 ConditionalExpression: &litA,
3565 Tokens: tk[2:3],
3566 },
3567 },
3568 Tokens: tk[2:3],
3569 },
3570 Tokens: tk[2:3],
3571 },
3572 Expression: Expression{
3573 Expressions: []AssignmentExpression{
3574 {
3575 ConditionalExpression: &litB,
3576 Tokens: tk[8:9],
3577 },
3578 },
3579 Tokens: tk[8:9],
3580 },
3581 Tokens: tk[:13],
3582 }
3583 }},
3584 {"do\na\nwhile\n(\nb\n) c", func(t *test, tk Tokens) { // 9
3585 t.Err = Error{
3586 Err: ErrMissingSemiColon,
3587 Parsing: "IterationStatementDo",
3588 Token: tk[11],
3589 }
3590 }},
3591 {"do\na\nwhile\n(\nb\n)\nc", func(t *test, tk Tokens) { // 10
3592 litA := makeConditionLiteral(tk, 2)
3593 litB := makeConditionLiteral(tk, 8)
3594 t.Output = IterationStatementDo{
3595 Statement: Statement{
3596 ExpressionStatement: &Expression{
3597 Expressions: []AssignmentExpression{
3598 {
3599 ConditionalExpression: &litA,
3600 Tokens: tk[2:3],
3601 },
3602 },
3603 Tokens: tk[2:3],
3604 },
3605 Tokens: tk[2:3],
3606 },
3607 Expression: Expression{
3608 Expressions: []AssignmentExpression{
3609 {
3610 ConditionalExpression: &litB,
3611 Tokens: tk[8:9],
3612 },
3613 },
3614 Tokens: tk[8:9],
3615 },
3616 Tokens: tk[:11],
3617 }
3618 }},
3619 {"do\na:function b(){}\nwhile\n(\ntrue\n)", func(t *test, tk Tokens) { // 11
3620 t.Err = Error{
3621 Err: ErrLabelledFunction,
3622 Parsing: "IterationStatementDo",
3623 Token: tk[2],
3624 }
3625 }},
3626 }, func(t *test) (Type, error) {
3627 var is IterationStatementDo
3628 err := is.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
3629 return is, err
3630 })
3631 }
3632
3633 func TestIterationStatementWhile(t *testing.T) {
3634 doTests(t, []sourceFn{
3635 {``, func(t *test, tk Tokens) { // 1
3636 t.Err = Error{
3637 Err: ErrInvalidIterationStatementWhile,
3638 Parsing: "IterationStatementWhile",
3639 Token: tk[0],
3640 }
3641 }},
3642 {`while`, func(t *test, tk Tokens) { // 2
3643 t.Err = Error{
3644 Err: ErrMissingOpeningParenthesis,
3645 Parsing: "IterationStatementWhile",
3646 Token: tk[1],
3647 }
3648 }},
3649 {"while\n(\n)", func(t *test, tk Tokens) { // 3
3650 t.Err = Error{
3651 Err: Error{
3652 Err: assignmentError(tk[4]),
3653 Parsing: "Expression",
3654 Token: tk[4],
3655 },
3656 Parsing: "IterationStatementWhile",
3657 Token: tk[4],
3658 }
3659 }},
3660 {"while\n(\na\nb\n)", func(t *test, tk Tokens) { // 4
3661 t.Err = Error{
3662 Err: ErrMissingClosingParenthesis,
3663 Parsing: "IterationStatementWhile",
3664 Token: tk[6],
3665 }
3666 }},
3667 {"while\n(\na\n)", func(t *test, tk Tokens) { // 5
3668 t.Err = Error{
3669 Err: Error{
3670 Err: Error{
3671 Err: assignmentError(tk[7]),
3672 Parsing: "Expression",
3673 Token: tk[7],
3674 },
3675 Parsing: "Statement",
3676 Token: tk[7],
3677 },
3678 Parsing: "IterationStatementWhile",
3679 Token: tk[7],
3680 }
3681 }},
3682 {"while\n(\na\n)\nb", func(t *test, tk Tokens) { // 6
3683 litA := makeConditionLiteral(tk, 4)
3684 litB := makeConditionLiteral(tk, 8)
3685 t.Output = IterationStatementWhile{
3686 Expression: Expression{
3687 Expressions: []AssignmentExpression{
3688 {
3689 ConditionalExpression: &litA,
3690 Tokens: tk[4:5],
3691 },
3692 },
3693 Tokens: tk[4:5],
3694 },
3695 Statement: Statement{
3696 ExpressionStatement: &Expression{
3697 Expressions: []AssignmentExpression{
3698 {
3699 ConditionalExpression: &litB,
3700 Tokens: tk[8:9],
3701 },
3702 },
3703 Tokens: tk[8:9],
3704 },
3705 Tokens: tk[8:9],
3706 },
3707 Tokens: tk[:9],
3708 }
3709 }},
3710 {"while(yield a){}", func(t *test, tk Tokens) { // 7
3711 t.Yield = true
3712 litA := makeConditionLiteral(tk, 4)
3713 t.Output = IterationStatementWhile{
3714 Expression: Expression{
3715 Expressions: []AssignmentExpression{
3716 {
3717 Yield: true,
3718 AssignmentExpression: &AssignmentExpression{
3719 ConditionalExpression: &litA,
3720 Tokens: tk[4:5],
3721 },
3722 Tokens: tk[2:5],
3723 },
3724 },
3725 Tokens: tk[2:5],
3726 },
3727 Statement: Statement{
3728 BlockStatement: &Block{
3729 Tokens: tk[6:8],
3730 },
3731 Tokens: tk[6:8],
3732 },
3733 Tokens: tk[:8],
3734 }
3735 }},
3736 {"while (true) a:function b(){}", func(t *test, tk Tokens) { // 8
3737 t.Err = Error{
3738 Err: ErrLabelledFunction,
3739 Parsing: "IterationStatementWhile",
3740 Token: tk[6],
3741 }
3742 }},
3743 }, func(t *test) (Type, error) {
3744 var is IterationStatementWhile
3745 err := is.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
3746 return is, err
3747 })
3748 }
3749
3750 func TestIterationStatementFor(t *testing.T) {
3751 doTests(t, []sourceFn{
3752 {``, func(t *test, tk Tokens) { // 1
3753 t.Err = Error{
3754 Err: ErrInvalidIterationStatementFor,
3755 Parsing: "IterationStatementFor",
3756 Token: tk[0],
3757 }
3758 }},
3759 {`for`, func(t *test, tk Tokens) { // 2
3760 t.Err = Error{
3761 Err: ErrMissingOpeningParenthesis,
3762 Parsing: "IterationStatementFor",
3763 Token: tk[1],
3764 }
3765 }},
3766 {"for\nawait", func(t *test, tk Tokens) { // 3
3767 t.Err = Error{
3768 Err: ErrMissingOpeningParenthesis,
3769 Parsing: "IterationStatementFor",
3770 Token: tk[2],
3771 }
3772 }},
3773 {"for\nawait", func(t *test, tk Tokens) { // 4
3774 t.Await = true
3775 t.Err = Error{
3776 Err: ErrMissingOpeningParenthesis,
3777 Parsing: "IterationStatementFor",
3778 Token: tk[3],
3779 }
3780 }},
3781 {"for\n(\n)", func(t *test, tk Tokens) { // 5
3782 t.Err = Error{
3783 Err: Error{
3784 Err: assignmentError(tk[4]),
3785 Parsing: "Expression",
3786 Token: tk[4],
3787 },
3788 Parsing: "IterationStatementFor",
3789 Token: tk[4],
3790 }
3791 }},
3792 {"for\nawait\n(\n)", func(t *test, tk Tokens) { // 6
3793 t.Await = true
3794 t.Err = Error{
3795 Err: Error{
3796 Err: Error{
3797 Err: Error{
3798 Err: Error{
3799 Err: ErrNoIdentifier,
3800 Parsing: "PrimaryExpression",
3801 Token: tk[6],
3802 },
3803 Parsing: "MemberExpression",
3804 Token: tk[6],
3805 },
3806 Parsing: "NewExpression",
3807 Token: tk[6],
3808 },
3809 Parsing: "LeftHandSideExpression",
3810 Token: tk[6],
3811 },
3812 Parsing: "IterationStatementFor",
3813 Token: tk[6],
3814 }
3815 }},
3816 {"for\n(\n;\n)", func(t *test, tk Tokens) { // 7
3817 t.Err = Error{
3818 Err: Error{
3819 Err: assignmentError(tk[6]),
3820 Parsing: "Expression",
3821 Token: tk[6],
3822 },
3823 Parsing: "IterationStatementFor",
3824 Token: tk[6],
3825 }
3826 }},
3827 {"for\nawait\n(\n;\n)", func(t *test, tk Tokens) { // 8
3828 t.Await = true
3829 t.Err = Error{
3830 Err: ErrInvalidForAwaitLoop,
3831 Parsing: "IterationStatementFor",
3832 Token: tk[6],
3833 }
3834 }},
3835 {"for\n(\n;\n;\n)", func(t *test, tk Tokens) { // 9
3836 t.Err = Error{
3837 Err: Error{
3838 Err: Error{
3839 Err: assignmentError(tk[9]),
3840 Parsing: "Expression",
3841 Token: tk[9],
3842 },
3843 Parsing: "Statement",
3844 Token: tk[9],
3845 },
3846 Parsing: "IterationStatementFor",
3847 Token: tk[9],
3848 }
3849 }},
3850 {"for\n(\n;\n;\n)\na", func(t *test, tk Tokens) { // 10
3851 litA := makeConditionLiteral(tk, 10)
3852 t.Output = IterationStatementFor{
3853 Statement: Statement{
3854 ExpressionStatement: &Expression{
3855 Expressions: []AssignmentExpression{
3856 {
3857 ConditionalExpression: &litA,
3858 Tokens: tk[10:11],
3859 },
3860 },
3861 Tokens: tk[10:11],
3862 },
3863 Tokens: tk[10:11],
3864 },
3865 Tokens: tk[:11],
3866 }
3867 }},
3868 {"for\n(\n;\n,\n)", func(t *test, tk Tokens) { // 11
3869 t.Err = Error{
3870 Err: Error{
3871 Err: assignmentError(tk[6]),
3872 Parsing: "Expression",
3873 Token: tk[6],
3874 },
3875 Parsing: "IterationStatementFor",
3876 Token: tk[6],
3877 }
3878 }},
3879 {"for\n(\n;\n;\n,)", func(t *test, tk Tokens) { // 12
3880 t.Err = Error{
3881 Err: Error{
3882 Err: assignmentError(tk[8]),
3883 Parsing: "Expression",
3884 Token: tk[8],
3885 },
3886 Parsing: "IterationStatementFor",
3887 Token: tk[8],
3888 }
3889 }},
3890 {"for\n(\n;\na\n;\n)\nb", func(t *test, tk Tokens) { // 13
3891 litA := makeConditionLiteral(tk, 6)
3892 litB := makeConditionLiteral(tk, 12)
3893 t.Output = IterationStatementFor{
3894 Conditional: &Expression{
3895 Expressions: []AssignmentExpression{
3896 {
3897 ConditionalExpression: &litA,
3898 Tokens: tk[6:7],
3899 },
3900 },
3901 Tokens: tk[6:7],
3902 },
3903 Statement: Statement{
3904 ExpressionStatement: &Expression{
3905 Expressions: []AssignmentExpression{
3906 {
3907 ConditionalExpression: &litB,
3908 Tokens: tk[12:13],
3909 },
3910 },
3911 Tokens: tk[12:13],
3912 },
3913 Tokens: tk[12:13],
3914 },
3915 Tokens: tk[:13],
3916 }
3917 }},
3918 {"for\n(\n;\n;\na\n)\nb", func(t *test, tk Tokens) { // 14
3919 litA := makeConditionLiteral(tk, 8)
3920 litB := makeConditionLiteral(tk, 12)
3921 t.Output = IterationStatementFor{
3922 Afterthought: &Expression{
3923 Expressions: []AssignmentExpression{
3924 {
3925 ConditionalExpression: &litA,
3926 Tokens: tk[8:9],
3927 },
3928 },
3929 Tokens: tk[8:9],
3930 },
3931 Statement: Statement{
3932 ExpressionStatement: &Expression{
3933 Expressions: []AssignmentExpression{
3934 {
3935 ConditionalExpression: &litB,
3936 Tokens: tk[12:13],
3937 },
3938 },
3939 Tokens: tk[12:13],
3940 },
3941 Tokens: tk[12:13],
3942 },
3943 Tokens: tk[:13],
3944 }
3945 }},
3946 {"for\n(\n;\na\n;\nb\n)\nc", func(t *test, tk Tokens) { // 15
3947 litA := makeConditionLiteral(tk, 6)
3948 litB := makeConditionLiteral(tk, 10)
3949 litC := makeConditionLiteral(tk, 14)
3950 t.Output = IterationStatementFor{
3951 Conditional: &Expression{
3952 Expressions: []AssignmentExpression{
3953 {
3954 ConditionalExpression: &litA,
3955 Tokens: tk[6:7],
3956 },
3957 },
3958 Tokens: tk[6:7],
3959 },
3960 Afterthought: &Expression{
3961 Expressions: []AssignmentExpression{
3962 {
3963 ConditionalExpression: &litB,
3964 Tokens: tk[10:11],
3965 },
3966 },
3967 Tokens: tk[10:11],
3968 },
3969 Statement: Statement{
3970 ExpressionStatement: &Expression{
3971 Expressions: []AssignmentExpression{
3972 {
3973 ConditionalExpression: &litC,
3974 Tokens: tk[14:15],
3975 },
3976 },
3977 Tokens: tk[14:15],
3978 },
3979 Tokens: tk[14:15],
3980 },
3981 Tokens: tk[:15],
3982 }
3983 }},
3984 {"for\n(\nvar)", func(t *test, tk Tokens) { // 16
3985 t.Err = Error{
3986 Err: Error{
3987 Err: ErrNoIdentifier,
3988 Parsing: "LexicalBinding",
3989 Token: tk[5],
3990 },
3991 Parsing: "IterationStatementFor",
3992 Token: tk[5],
3993 }
3994 }},
3995 {"for\n(\nvar\na\nb)", func(t *test, tk Tokens) { // 17
3996 t.Err = Error{
3997 Err: ErrMissingSemiColon,
3998 Parsing: "IterationStatementFor",
3999 Token: tk[8],
4000 }
4001 }},
4002 {"for\n(\nvar\na,\nb)", func(t *test, tk Tokens) { // 18
4003 t.Err = Error{
4004 Err: ErrMissingSemiColon,
4005 Parsing: "IterationStatementFor",
4006 Token: tk[10],
4007 }
4008 }},
4009 {"for\n(\nvar\na\n;\n;\n)\n{}", func(t *test, tk Tokens) { // 19
4010 t.Output = IterationStatementFor{
4011 Type: ForNormalVar,
4012 InitVar: []VariableDeclaration{
4013 {
4014 BindingIdentifier: &tk[6],
4015 Tokens: tk[6:7],
4016 },
4017 },
4018 Statement: Statement{
4019 BlockStatement: &Block{
4020 Tokens: tk[14:16],
4021 },
4022 Tokens: tk[14:16],
4023 },
4024 Tokens: tk[:16],
4025 }
4026 }},
4027 {"for\n(\nvar\na\n,\nb\n;\n;\n)\n{}", func(t *test, tk Tokens) { // 20
4028 t.Output = IterationStatementFor{
4029 Type: ForNormalVar,
4030 InitVar: []VariableDeclaration{
4031 {
4032 BindingIdentifier: &tk[6],
4033 Tokens: tk[6:7],
4034 },
4035 {
4036 BindingIdentifier: &tk[10],
4037 Tokens: tk[10:11],
4038 },
4039 },
4040 Statement: Statement{
4041 BlockStatement: &Block{
4042 Tokens: tk[18:20],
4043 },
4044 Tokens: tk[18:20],
4045 },
4046 Tokens: tk[:20],
4047 }
4048 }},
4049 {"for\n(\nvar\na\n;\nb\n;\n)\n{}", func(t *test, tk Tokens) { // 21
4050 litB := makeConditionLiteral(tk, 10)
4051 t.Output = IterationStatementFor{
4052 Type: ForNormalVar,
4053 InitVar: []VariableDeclaration{
4054 {
4055 BindingIdentifier: &tk[6],
4056 Tokens: tk[6:7],
4057 },
4058 },
4059 Conditional: &Expression{
4060 Expressions: []AssignmentExpression{
4061 {
4062 ConditionalExpression: &litB,
4063 Tokens: tk[10:11],
4064 },
4065 },
4066 Tokens: tk[10:11],
4067 },
4068 Statement: Statement{
4069 BlockStatement: &Block{
4070 Tokens: tk[16:18],
4071 },
4072 Tokens: tk[16:18],
4073 },
4074 Tokens: tk[:18],
4075 }
4076 }},
4077 {"for\n(\nvar\na\n;\nb)", func(t *test, tk Tokens) { // 22
4078 t.Err = Error{
4079 Err: ErrMissingSemiColon,
4080 Parsing: "IterationStatementFor",
4081 Token: tk[11],
4082 }
4083 }},
4084 {"for\n(\nvar\na\n,\nb\n;\nc\n;\n)\n{}", func(t *test, tk Tokens) { // 23
4085 litC := makeConditionLiteral(tk, 14)
4086 t.Output = IterationStatementFor{
4087 Type: ForNormalVar,
4088 InitVar: []VariableDeclaration{
4089 {
4090 BindingIdentifier: &tk[6],
4091 Tokens: tk[6:7],
4092 },
4093 {
4094 BindingIdentifier: &tk[10],
4095 Tokens: tk[10:11],
4096 },
4097 },
4098 Conditional: &Expression{
4099 Expressions: []AssignmentExpression{
4100 {
4101 ConditionalExpression: &litC,
4102 Tokens: tk[14:15],
4103 },
4104 },
4105 Tokens: tk[14:15],
4106 },
4107 Statement: Statement{
4108 BlockStatement: &Block{
4109 Tokens: tk[20:22],
4110 },
4111 Tokens: tk[20:22],
4112 },
4113 Tokens: tk[:22],
4114 }
4115 }},
4116 {"for\n(\nvar\na\n;\n;\nb\nc)", func(t *test, tk Tokens) { // 24
4117 t.Err = Error{
4118 Err: ErrMissingClosingParenthesis,
4119 Parsing: "IterationStatementFor",
4120 Token: tk[14],
4121 }
4122 }},
4123 {"for\n(\nvar\na\n;\n;\nb\n)\n{}", func(t *test, tk Tokens) { // 25
4124 litB := makeConditionLiteral(tk, 12)
4125 t.Output = IterationStatementFor{
4126 Type: ForNormalVar,
4127 InitVar: []VariableDeclaration{
4128 {
4129 BindingIdentifier: &tk[6],
4130 Tokens: tk[6:7],
4131 },
4132 },
4133 Afterthought: &Expression{
4134 Expressions: []AssignmentExpression{
4135 {
4136 ConditionalExpression: &litB,
4137 Tokens: tk[12:13],
4138 },
4139 },
4140 Tokens: tk[12:13],
4141 },
4142 Statement: Statement{
4143 BlockStatement: &Block{
4144 Tokens: tk[16:18],
4145 },
4146 Tokens: tk[16:18],
4147 },
4148 Tokens: tk[:18],
4149 }
4150 }},
4151 {"for\n(\nvar\na\n,\nb\n;\n;\nc\n)\n{}", func(t *test, tk Tokens) { // 26
4152 litC := makeConditionLiteral(tk, 16)
4153 t.Output = IterationStatementFor{
4154 Type: ForNormalVar,
4155 InitVar: []VariableDeclaration{
4156 {
4157 BindingIdentifier: &tk[6],
4158 Tokens: tk[6:7],
4159 },
4160 {
4161 BindingIdentifier: &tk[10],
4162 Tokens: tk[10:11],
4163 },
4164 },
4165 Afterthought: &Expression{
4166 Expressions: []AssignmentExpression{
4167 {
4168 ConditionalExpression: &litC,
4169 Tokens: tk[16:17],
4170 },
4171 },
4172 Tokens: tk[16:17],
4173 },
4174 Statement: Statement{
4175 BlockStatement: &Block{
4176 Tokens: tk[20:22],
4177 },
4178 Tokens: tk[20:22],
4179 },
4180 Tokens: tk[:22],
4181 }
4182 }},
4183 {"for\n(\nvar\na\n;\nb\n;\nc\n)\n{}", func(t *test, tk Tokens) { // 27
4184 litB := makeConditionLiteral(tk, 10)
4185 litC := makeConditionLiteral(tk, 14)
4186 t.Output = IterationStatementFor{
4187 Type: ForNormalVar,
4188 InitVar: []VariableDeclaration{
4189 {
4190 BindingIdentifier: &tk[6],
4191 Tokens: tk[6:7],
4192 },
4193 },
4194 Conditional: &Expression{
4195 Expressions: []AssignmentExpression{
4196 {
4197 ConditionalExpression: &litB,
4198 Tokens: tk[10:11],
4199 },
4200 },
4201 Tokens: tk[10:11],
4202 },
4203 Afterthought: &Expression{
4204 Expressions: []AssignmentExpression{
4205 {
4206 ConditionalExpression: &litC,
4207 Tokens: tk[14:15],
4208 },
4209 },
4210 Tokens: tk[14:15],
4211 },
4212 Statement: Statement{
4213 BlockStatement: &Block{
4214 Tokens: tk[18:20],
4215 },
4216 Tokens: tk[18:20],
4217 },
4218 Tokens: tk[:20],
4219 }
4220 }},
4221 {"for\n(\nvar\na\n,\nb\n;\nc\n;\nd\n)\n{}", func(t *test, tk Tokens) { // 28
4222 litC := makeConditionLiteral(tk, 14)
4223 litD := makeConditionLiteral(tk, 18)
4224 t.Output = IterationStatementFor{
4225 Type: ForNormalVar,
4226 InitVar: []VariableDeclaration{
4227 {
4228 BindingIdentifier: &tk[6],
4229 Tokens: tk[6:7],
4230 },
4231 {
4232 BindingIdentifier: &tk[10],
4233 Tokens: tk[10:11],
4234 },
4235 },
4236 Conditional: &Expression{
4237 Expressions: []AssignmentExpression{
4238 {
4239 ConditionalExpression: &litC,
4240 Tokens: tk[14:15],
4241 },
4242 },
4243 Tokens: tk[14:15],
4244 },
4245 Afterthought: &Expression{
4246 Expressions: []AssignmentExpression{
4247 {
4248 ConditionalExpression: &litD,
4249 Tokens: tk[18:19],
4250 },
4251 },
4252 Tokens: tk[18:19],
4253 },
4254 Statement: Statement{
4255 BlockStatement: &Block{
4256 Tokens: tk[22:24],
4257 },
4258 Tokens: tk[22:24],
4259 },
4260 Tokens: tk[:24],
4261 }
4262 }},
4263 {"for\n(\nlet)", func(t *test, tk Tokens) { // 29
4264 t.Err = Error{
4265 Err: Error{
4266 Err: Error{
4267 Err: ErrNoIdentifier,
4268 Parsing: "LexicalBinding",
4269 Token: tk[5],
4270 },
4271 Parsing: "LexicalDeclaration",
4272 Token: tk[5],
4273 },
4274 Parsing: "IterationStatementFor",
4275 Token: tk[4],
4276 }
4277 }},
4278 {"for\n(\nlet\na\nb)", func(t *test, tk Tokens) { // 30
4279 t.Err = Error{
4280 Err: ErrMissingSemiColon,
4281 Parsing: "IterationStatementFor",
4282 Token: tk[8],
4283 }
4284 }},
4285 {"for\n(\nlet\na,\nb)", func(t *test, tk Tokens) { // 31
4286 t.Err = Error{
4287 Err: Error{
4288 Err: ErrInvalidLexicalDeclaration,
4289 Parsing: "LexicalDeclaration",
4290 Token: tk[10],
4291 },
4292 Parsing: "IterationStatementFor",
4293 Token: tk[4],
4294 }
4295 }},
4296 {"for\n(\nlet\na\n;\n;\n)\n{}", func(t *test, tk Tokens) { // 32
4297 t.Output = IterationStatementFor{
4298 Type: ForNormalLexicalDeclaration,
4299 InitLexical: &LexicalDeclaration{
4300 LetOrConst: Let,
4301 BindingList: []LexicalBinding{
4302 {
4303 BindingIdentifier: &tk[6],
4304 Tokens: tk[6:7],
4305 },
4306 },
4307 Tokens: tk[4:9],
4308 },
4309 Statement: Statement{
4310 BlockStatement: &Block{
4311 Tokens: tk[14:16],
4312 },
4313 Tokens: tk[14:16],
4314 },
4315 Tokens: tk[:16],
4316 }
4317 }},
4318 {"for\n(\nlet\na\n,\nb\n;\n;\n)\n{}", func(t *test, tk Tokens) { // 33
4319 t.Output = IterationStatementFor{
4320 Type: ForNormalLexicalDeclaration,
4321 InitLexical: &LexicalDeclaration{
4322 LetOrConst: Let,
4323 BindingList: []LexicalBinding{
4324 {
4325 BindingIdentifier: &tk[6],
4326 Tokens: tk[6:7],
4327 },
4328 {
4329 BindingIdentifier: &tk[10],
4330 Tokens: tk[10:11],
4331 },
4332 },
4333 Tokens: tk[4:13],
4334 },
4335 Statement: Statement{
4336 BlockStatement: &Block{
4337 Tokens: tk[18:20],
4338 },
4339 Tokens: tk[18:20],
4340 },
4341 Tokens: tk[:20],
4342 }
4343 }},
4344 {"for\n(\nlet\na\n;\nb\n;\n)\n{}", func(t *test, tk Tokens) { // 34
4345 litB := makeConditionLiteral(tk, 10)
4346 t.Output = IterationStatementFor{
4347 Type: ForNormalLexicalDeclaration,
4348 InitLexical: &LexicalDeclaration{
4349 LetOrConst: Let,
4350 BindingList: []LexicalBinding{
4351 {
4352 BindingIdentifier: &tk[6],
4353 Tokens: tk[6:7],
4354 },
4355 },
4356 Tokens: tk[4:9],
4357 },
4358 Conditional: &Expression{
4359 Expressions: []AssignmentExpression{
4360 {
4361 ConditionalExpression: &litB,
4362 Tokens: tk[10:11],
4363 },
4364 },
4365 Tokens: tk[10:11],
4366 },
4367 Statement: Statement{
4368 BlockStatement: &Block{
4369 Tokens: tk[16:18],
4370 },
4371 Tokens: tk[16:18],
4372 },
4373 Tokens: tk[:18],
4374 }
4375 }},
4376 {"for\n(\nlet\na\n;\n;\nb\n)\n{}", func(t *test, tk Tokens) { // 35
4377 litB := makeConditionLiteral(tk, 12)
4378 t.Output = IterationStatementFor{
4379 Type: ForNormalLexicalDeclaration,
4380 InitLexical: &LexicalDeclaration{
4381 LetOrConst: Let,
4382 BindingList: []LexicalBinding{
4383 {
4384 BindingIdentifier: &tk[6],
4385 Tokens: tk[6:7],
4386 },
4387 },
4388 Tokens: tk[4:9],
4389 },
4390 Afterthought: &Expression{
4391 Expressions: []AssignmentExpression{
4392 {
4393 ConditionalExpression: &litB,
4394 Tokens: tk[12:13],
4395 },
4396 },
4397 Tokens: tk[12:13],
4398 },
4399 Statement: Statement{
4400 BlockStatement: &Block{
4401 Tokens: tk[16:18],
4402 },
4403 Tokens: tk[16:18],
4404 },
4405 Tokens: tk[:18],
4406 }
4407 }},
4408 {"for\n(\nlet\na\n;\nb\n;\nc\n)\n{}", func(t *test, tk Tokens) { // 36
4409 litB := makeConditionLiteral(tk, 10)
4410 litC := makeConditionLiteral(tk, 14)
4411 t.Output = IterationStatementFor{
4412 Type: ForNormalLexicalDeclaration,
4413 InitLexical: &LexicalDeclaration{
4414 LetOrConst: Let,
4415 BindingList: []LexicalBinding{
4416 {
4417 BindingIdentifier: &tk[6],
4418 Tokens: tk[6:7],
4419 },
4420 },
4421 Tokens: tk[4:9],
4422 },
4423 Conditional: &Expression{
4424 Expressions: []AssignmentExpression{
4425 {
4426 ConditionalExpression: &litB,
4427 Tokens: tk[10:11],
4428 },
4429 },
4430 Tokens: tk[10:11],
4431 },
4432 Afterthought: &Expression{
4433 Expressions: []AssignmentExpression{
4434 {
4435 ConditionalExpression: &litC,
4436 Tokens: tk[14:15],
4437 },
4438 },
4439 Tokens: tk[14:15],
4440 },
4441 Statement: Statement{
4442 BlockStatement: &Block{
4443 Tokens: tk[18:20],
4444 },
4445 Tokens: tk[18:20],
4446 },
4447 Tokens: tk[:20],
4448 }
4449 }},
4450 {"for\n(\nconst)", func(t *test, tk Tokens) { // 37
4451 t.Err = Error{
4452 Err: Error{
4453 Err: Error{
4454 Err: ErrNoIdentifier,
4455 Parsing: "LexicalBinding",
4456 Token: tk[5],
4457 },
4458 Parsing: "LexicalDeclaration",
4459 Token: tk[5],
4460 },
4461 Parsing: "IterationStatementFor",
4462 Token: tk[4],
4463 }
4464 }},
4465 {"for\n(\nconst\na\nb)", func(t *test, tk Tokens) { // 38
4466 t.Err = Error{
4467 Err: ErrMissingSemiColon,
4468 Parsing: "IterationStatementFor",
4469 Token: tk[8],
4470 }
4471 }},
4472 {"for\n(\nconst\na,\nb)", func(t *test, tk Tokens) { // 39
4473 t.Err = Error{
4474 Err: Error{
4475 Err: ErrInvalidLexicalDeclaration,
4476 Parsing: "LexicalDeclaration",
4477 Token: tk[10],
4478 },
4479 Parsing: "IterationStatementFor",
4480 Token: tk[4],
4481 }
4482 }},
4483 {"for\n(\nconst\na\n;\n;\n)\n{}", func(t *test, tk Tokens) { // 40
4484 t.Output = IterationStatementFor{
4485 Type: ForNormalLexicalDeclaration,
4486 InitLexical: &LexicalDeclaration{
4487 LetOrConst: Const,
4488 BindingList: []LexicalBinding{
4489 {
4490 BindingIdentifier: &tk[6],
4491 Tokens: tk[6:7],
4492 },
4493 },
4494 Tokens: tk[4:9],
4495 },
4496 Statement: Statement{
4497 BlockStatement: &Block{
4498 Tokens: tk[14:16],
4499 },
4500 Tokens: tk[14:16],
4501 },
4502 Tokens: tk[:16],
4503 }
4504 }},
4505 {"for\n(\nconst\na\n,\nb\n;\n;\n)\n{}", func(t *test, tk Tokens) { // 41
4506 t.Output = IterationStatementFor{
4507 Type: ForNormalLexicalDeclaration,
4508 InitLexical: &LexicalDeclaration{
4509 LetOrConst: Const,
4510 BindingList: []LexicalBinding{
4511 {
4512 BindingIdentifier: &tk[6],
4513 Tokens: tk[6:7],
4514 },
4515 {
4516 BindingIdentifier: &tk[10],
4517 Tokens: tk[10:11],
4518 },
4519 },
4520 Tokens: tk[4:13],
4521 },
4522 Statement: Statement{
4523 BlockStatement: &Block{
4524 Tokens: tk[18:20],
4525 },
4526 Tokens: tk[18:20],
4527 },
4528 Tokens: tk[:20],
4529 }
4530 }},
4531 {"for\n(\nconst\na\n;\nb\n;\n)\n{}", func(t *test, tk Tokens) { // 42
4532 litB := makeConditionLiteral(tk, 10)
4533 t.Output = IterationStatementFor{
4534 Type: ForNormalLexicalDeclaration,
4535 InitLexical: &LexicalDeclaration{
4536 LetOrConst: Const,
4537 BindingList: []LexicalBinding{
4538 {
4539 BindingIdentifier: &tk[6],
4540 Tokens: tk[6:7],
4541 },
4542 },
4543 Tokens: tk[4:9],
4544 },
4545 Conditional: &Expression{
4546 Expressions: []AssignmentExpression{
4547 {
4548 ConditionalExpression: &litB,
4549 Tokens: tk[10:11],
4550 },
4551 },
4552 Tokens: tk[10:11],
4553 },
4554 Statement: Statement{
4555 BlockStatement: &Block{
4556 Tokens: tk[16:18],
4557 },
4558 Tokens: tk[16:18],
4559 },
4560 Tokens: tk[:18],
4561 }
4562 }},
4563 {"for\n(\nconst\na\n;\n;\nb\n)\n{}", func(t *test, tk Tokens) { // 43
4564 litB := makeConditionLiteral(tk, 12)
4565 t.Output = IterationStatementFor{
4566 Type: ForNormalLexicalDeclaration,
4567 InitLexical: &LexicalDeclaration{
4568 LetOrConst: Const,
4569 BindingList: []LexicalBinding{
4570 {
4571 BindingIdentifier: &tk[6],
4572 Tokens: tk[6:7],
4573 },
4574 },
4575 Tokens: tk[4:9],
4576 },
4577 Afterthought: &Expression{
4578 Expressions: []AssignmentExpression{
4579 {
4580 ConditionalExpression: &litB,
4581 Tokens: tk[12:13],
4582 },
4583 },
4584 Tokens: tk[12:13],
4585 },
4586 Statement: Statement{
4587 BlockStatement: &Block{
4588 Tokens: tk[16:18],
4589 },
4590 Tokens: tk[16:18],
4591 },
4592 Tokens: tk[:18],
4593 }
4594 }},
4595 {"for\n(\nconst\na\n;\nb\n;\nc\n)\n{}", func(t *test, tk Tokens) { // 44
4596 litB := makeConditionLiteral(tk, 10)
4597 litC := makeConditionLiteral(tk, 14)
4598 t.Output = IterationStatementFor{
4599 Type: ForNormalLexicalDeclaration,
4600 InitLexical: &LexicalDeclaration{
4601 LetOrConst: Const,
4602 BindingList: []LexicalBinding{
4603 {
4604 BindingIdentifier: &tk[6],
4605 Tokens: tk[6:7],
4606 },
4607 },
4608 Tokens: tk[4:9],
4609 },
4610 Conditional: &Expression{
4611 Expressions: []AssignmentExpression{
4612 {
4613 ConditionalExpression: &litB,
4614 Tokens: tk[10:11],
4615 },
4616 },
4617 Tokens: tk[10:11],
4618 },
4619 Afterthought: &Expression{
4620 Expressions: []AssignmentExpression{
4621 {
4622 ConditionalExpression: &litC,
4623 Tokens: tk[14:15],
4624 },
4625 },
4626 Tokens: tk[14:15],
4627 },
4628 Statement: Statement{
4629 BlockStatement: &Block{
4630 Tokens: tk[18:20],
4631 },
4632 Tokens: tk[18:20],
4633 },
4634 Tokens: tk[:20],
4635 }
4636 }},
4637 {"for\n(\nvar\n{}\n=\na\n;\n;\n)\n;", func(t *test, tk Tokens) { // 45
4638 litA := makeConditionLiteral(tk, 11)
4639 t.Output = IterationStatementFor{
4640 Type: ForNormalVar,
4641 InitVar: []VariableDeclaration{
4642 {
4643 ObjectBindingPattern: &ObjectBindingPattern{
4644 Tokens: tk[6:8],
4645 },
4646 Initializer: &AssignmentExpression{
4647 ConditionalExpression: &litA,
4648 Tokens: tk[11:12],
4649 },
4650 Tokens: tk[6:12],
4651 },
4652 },
4653 Statement: Statement{
4654 Tokens: tk[19:20],
4655 },
4656 Tokens: tk[:20],
4657 }
4658 }},
4659 {"for\n(\nvar\n[]\n=\na\n;\n;\n)\n;", func(t *test, tk Tokens) { // 46
4660 litA := makeConditionLiteral(tk, 11)
4661 t.Output = IterationStatementFor{
4662 Type: ForNormalVar,
4663 InitVar: []VariableDeclaration{
4664 {
4665 ArrayBindingPattern: &ArrayBindingPattern{
4666 Tokens: tk[6:8],
4667 },
4668 Initializer: &AssignmentExpression{
4669 ConditionalExpression: &litA,
4670 Tokens: tk[11:12],
4671 },
4672 Tokens: tk[6:12],
4673 },
4674 },
4675 Statement: Statement{
4676 Tokens: tk[19:20],
4677 },
4678 Tokens: tk[:20],
4679 }
4680 }},
4681 {"for\n(\nlet\n{}\n=\na\n;\n;\n)\n;", func(t *test, tk Tokens) { // 47
4682 litA := makeConditionLiteral(tk, 11)
4683 t.Output = IterationStatementFor{
4684 Type: ForNormalLexicalDeclaration,
4685 InitLexical: &LexicalDeclaration{
4686 LetOrConst: Let,
4687 BindingList: []LexicalBinding{
4688 {
4689 ObjectBindingPattern: &ObjectBindingPattern{
4690 Tokens: tk[6:8],
4691 },
4692 Initializer: &AssignmentExpression{
4693 ConditionalExpression: &litA,
4694 Tokens: tk[11:12],
4695 },
4696 Tokens: tk[6:12],
4697 },
4698 },
4699 Tokens: tk[4:14],
4700 },
4701 Statement: Statement{
4702 Tokens: tk[19:20],
4703 },
4704 Tokens: tk[:20],
4705 }
4706 }},
4707 {"for\n(\nlet\n[]\n=\na\n;\n;\n)\n;", func(t *test, tk Tokens) { // 48
4708 litA := makeConditionLiteral(tk, 11)
4709 t.Output = IterationStatementFor{
4710 Type: ForNormalLexicalDeclaration,
4711 InitLexical: &LexicalDeclaration{
4712 LetOrConst: Let,
4713 BindingList: []LexicalBinding{
4714 {
4715 ArrayBindingPattern: &ArrayBindingPattern{
4716 Tokens: tk[6:8],
4717 },
4718 Initializer: &AssignmentExpression{
4719 ConditionalExpression: &litA,
4720 Tokens: tk[11:12],
4721 },
4722 Tokens: tk[6:12],
4723 },
4724 },
4725 Tokens: tk[4:14],
4726 },
4727 Statement: Statement{
4728 Tokens: tk[19:20],
4729 },
4730 Tokens: tk[:20],
4731 }
4732 }},
4733 {"for\n(\nconst\n{}\n=\na\n;\n;\n)\n;", func(t *test, tk Tokens) { // 49
4734 litA := makeConditionLiteral(tk, 11)
4735 t.Output = IterationStatementFor{
4736 Type: ForNormalLexicalDeclaration,
4737 InitLexical: &LexicalDeclaration{
4738 LetOrConst: Const,
4739 BindingList: []LexicalBinding{
4740 {
4741 ObjectBindingPattern: &ObjectBindingPattern{
4742 Tokens: tk[6:8],
4743 },
4744 Initializer: &AssignmentExpression{
4745 ConditionalExpression: &litA,
4746 Tokens: tk[11:12],
4747 },
4748 Tokens: tk[6:12],
4749 },
4750 },
4751 Tokens: tk[4:14],
4752 },
4753 Statement: Statement{
4754 Tokens: tk[19:20],
4755 },
4756 Tokens: tk[:20],
4757 }
4758 }},
4759 {"for\n(\nconst\n[]\n=\na\n;\n;\n)\n;", func(t *test, tk Tokens) { // 50
4760 litA := makeConditionLiteral(tk, 11)
4761 t.Output = IterationStatementFor{
4762 Type: ForNormalLexicalDeclaration,
4763 InitLexical: &LexicalDeclaration{
4764 LetOrConst: Const,
4765 BindingList: []LexicalBinding{
4766 {
4767 ArrayBindingPattern: &ArrayBindingPattern{
4768 Tokens: tk[6:8],
4769 },
4770 Initializer: &AssignmentExpression{
4771 ConditionalExpression: &litA,
4772 Tokens: tk[11:12],
4773 },
4774 Tokens: tk[6:12],
4775 },
4776 },
4777 Tokens: tk[4:14],
4778 },
4779 Statement: Statement{
4780 Tokens: tk[19:20],
4781 },
4782 Tokens: tk[:20],
4783 }
4784 }},
4785 {"for\n(\nvar\n{,}\nin)", func(t *test, tk Tokens) { // 51
4786 t.Err = Error{
4787 Err: Error{
4788 Err: Error{
4789 Err: Error{
4790 Err: ErrInvalidPropertyName,
4791 Parsing: "PropertyName",
4792 Token: tk[7],
4793 },
4794 Parsing: "BindingProperty",
4795 Token: tk[7],
4796 },
4797 Parsing: "ObjectBindingPattern",
4798 Token: tk[7],
4799 },
4800 Parsing: "IterationStatementFor",
4801 Token: tk[6],
4802 }
4803 }},
4804 {"for\n(\nvar\n[+]\nin)", func(t *test, tk Tokens) { // 52
4805 t.Err = Error{
4806 Err: Error{
4807 Err: Error{
4808 Err: ErrNoIdentifier,
4809 Parsing: "BindingElement",
4810 Token: tk[7],
4811 },
4812 Parsing: "ArrayBindingPattern",
4813 Token: tk[7],
4814 },
4815 Parsing: "IterationStatementFor",
4816 Token: tk[6],
4817 }
4818 }},
4819 {"for\n(\nvar\n,\nin)", func(t *test, tk Tokens) { // 53
4820 t.Err = Error{
4821 Err: ErrNoIdentifier,
4822 Parsing: "IterationStatementFor",
4823 Token: tk[6],
4824 }
4825 }},
4826 {"for\n(\nlet\n{,}\nin)", func(t *test, tk Tokens) { // 54
4827 t.Err = Error{
4828 Err: Error{
4829 Err: Error{
4830 Err: Error{
4831 Err: ErrInvalidPropertyName,
4832 Parsing: "PropertyName",
4833 Token: tk[7],
4834 },
4835 Parsing: "BindingProperty",
4836 Token: tk[7],
4837 },
4838 Parsing: "ObjectBindingPattern",
4839 Token: tk[7],
4840 },
4841 Parsing: "IterationStatementFor",
4842 Token: tk[6],
4843 }
4844 }},
4845 {"for\n(\nlet\n[+]\nin)", func(t *test, tk Tokens) { // 55
4846 t.Err = Error{
4847 Err: Error{
4848 Err: Error{
4849 Err: ErrNoIdentifier,
4850 Parsing: "BindingElement",
4851 Token: tk[7],
4852 },
4853 Parsing: "ArrayBindingPattern",
4854 Token: tk[7],
4855 },
4856 Parsing: "IterationStatementFor",
4857 Token: tk[6],
4858 }
4859 }},
4860 {"for\n(\nlet\n,\nin)", func(t *test, tk Tokens) { // 56
4861 t.Err = Error{
4862 Err: ErrNoIdentifier,
4863 Parsing: "IterationStatementFor",
4864 Token: tk[6],
4865 }
4866 }},
4867 {"for\n(\nconst\n{,}\nin)", func(t *test, tk Tokens) { // 57
4868 t.Err = Error{
4869 Err: Error{
4870 Err: Error{
4871 Err: Error{
4872 Err: ErrInvalidPropertyName,
4873 Parsing: "PropertyName",
4874 Token: tk[7],
4875 },
4876 Parsing: "BindingProperty",
4877 Token: tk[7],
4878 },
4879 Parsing: "ObjectBindingPattern",
4880 Token: tk[7],
4881 },
4882 Parsing: "IterationStatementFor",
4883 Token: tk[6],
4884 }
4885 }},
4886 {"for\n(\nconst\n[+]\nin)", func(t *test, tk Tokens) { // 58
4887 t.Err = Error{
4888 Err: Error{
4889 Err: Error{
4890 Err: ErrNoIdentifier,
4891 Parsing: "BindingElement",
4892 Token: tk[7],
4893 },
4894 Parsing: "ArrayBindingPattern",
4895 Token: tk[7],
4896 },
4897 Parsing: "IterationStatementFor",
4898 Token: tk[6],
4899 }
4900 }},
4901 {"for\n(\nconst\n,\nin)", func(t *test, tk Tokens) { // 59
4902 t.Err = Error{
4903 Err: ErrNoIdentifier,
4904 Parsing: "IterationStatementFor",
4905 Token: tk[6],
4906 }
4907 }},
4908 {"for\n(\nvar\n{}\nin\n)", func(t *test, tk Tokens) { // 60
4909 t.Err = Error{
4910 Err: Error{
4911 Err: assignmentError(tk[11]),
4912 Parsing: "Expression",
4913 Token: tk[11],
4914 },
4915 Parsing: "IterationStatementFor",
4916 Token: tk[11],
4917 }
4918 }},
4919 {"for\n(\nlet\n{}\nin\n)", func(t *test, tk Tokens) { // 61
4920 t.Err = Error{
4921 Err: Error{
4922 Err: assignmentError(tk[11]),
4923 Parsing: "Expression",
4924 Token: tk[11],
4925 },
4926 Parsing: "IterationStatementFor",
4927 Token: tk[11],
4928 }
4929 }},
4930 {"for\n(\nconst\n{}\nin\n)", func(t *test, tk Tokens) { // 62
4931 t.Err = Error{
4932 Err: Error{
4933 Err: assignmentError(tk[11]),
4934 Parsing: "Expression",
4935 Token: tk[11],
4936 },
4937 Parsing: "IterationStatementFor",
4938 Token: tk[11],
4939 }
4940 }},
4941 {"for\n(\nvar\na\nin\nb\n)\n;", func(t *test, tk Tokens) { // 63
4942 litB := makeConditionLiteral(tk, 10)
4943 t.Output = IterationStatementFor{
4944 Type: ForInVar,
4945 ForBindingIdentifier: &tk[6],
4946 In: &Expression{
4947 Expressions: []AssignmentExpression{
4948 {
4949 ConditionalExpression: &litB,
4950 Tokens: tk[10:11],
4951 },
4952 },
4953 Tokens: tk[10:11],
4954 },
4955 Statement: Statement{
4956 Tokens: tk[14:15],
4957 },
4958 Tokens: tk[:15],
4959 }
4960 }},
4961 {"for\n(\nlet\na\nin\nb\n)\n;", func(t *test, tk Tokens) { // 64
4962 litB := makeConditionLiteral(tk, 10)
4963 t.Output = IterationStatementFor{
4964 Type: ForInLet,
4965 ForBindingIdentifier: &tk[6],
4966 In: &Expression{
4967 Expressions: []AssignmentExpression{
4968 {
4969 ConditionalExpression: &litB,
4970 Tokens: tk[10:11],
4971 },
4972 },
4973 Tokens: tk[10:11],
4974 },
4975 Statement: Statement{
4976 Tokens: tk[14:15],
4977 },
4978 Tokens: tk[:15],
4979 }
4980 }},
4981 {"for\n(\nconst\na\nin\nb\n)\n;", func(t *test, tk Tokens) { // 65
4982 litB := makeConditionLiteral(tk, 10)
4983 t.Output = IterationStatementFor{
4984 Type: ForInConst,
4985 ForBindingIdentifier: &tk[6],
4986 In: &Expression{
4987 Expressions: []AssignmentExpression{
4988 {
4989 ConditionalExpression: &litB,
4990 Tokens: tk[10:11],
4991 },
4992 },
4993 Tokens: tk[10:11],
4994 },
4995 Statement: Statement{
4996 Tokens: tk[14:15],
4997 },
4998 Tokens: tk[:15],
4999 }
5000 }},
5001 {"for\n(\nvar\n{}\nin\nb\n)\n;", func(t *test, tk Tokens) { // 66
5002 litB := makeConditionLiteral(tk, 11)
5003 t.Output = IterationStatementFor{
5004 Type: ForInVar,
5005 ForBindingPatternObject: &ObjectBindingPattern{
5006 Tokens: tk[6:8],
5007 },
5008 In: &Expression{
5009 Expressions: []AssignmentExpression{
5010 {
5011 ConditionalExpression: &litB,
5012 Tokens: tk[11:12],
5013 },
5014 },
5015 Tokens: tk[11:12],
5016 },
5017 Statement: Statement{
5018 Tokens: tk[15:16],
5019 },
5020 Tokens: tk[:16],
5021 }
5022 }},
5023 {"for\n(\nlet\n{}\nin\nb\n)\n;", func(t *test, tk Tokens) { // 67
5024 litB := makeConditionLiteral(tk, 11)
5025 t.Output = IterationStatementFor{
5026 Type: ForInLet,
5027 ForBindingPatternObject: &ObjectBindingPattern{
5028 Tokens: tk[6:8],
5029 },
5030 In: &Expression{
5031 Expressions: []AssignmentExpression{
5032 {
5033 ConditionalExpression: &litB,
5034 Tokens: tk[11:12],
5035 },
5036 },
5037 Tokens: tk[11:12],
5038 },
5039 Statement: Statement{
5040 Tokens: tk[15:16],
5041 },
5042 Tokens: tk[:16],
5043 }
5044 }},
5045 {"for\n(\nconst\n{}\nin\nb\n)\n;", func(t *test, tk Tokens) { // 68
5046 litB := makeConditionLiteral(tk, 11)
5047 t.Output = IterationStatementFor{
5048 Type: ForInConst,
5049 ForBindingPatternObject: &ObjectBindingPattern{
5050 Tokens: tk[6:8],
5051 },
5052 In: &Expression{
5053 Expressions: []AssignmentExpression{
5054 {
5055 ConditionalExpression: &litB,
5056 Tokens: tk[11:12],
5057 },
5058 },
5059 Tokens: tk[11:12],
5060 },
5061 Statement: Statement{
5062 Tokens: tk[15:16],
5063 },
5064 Tokens: tk[:16],
5065 }
5066 }},
5067 {"for\n(\nvar\n[]\nin\nb\n)\n;", func(t *test, tk Tokens) { // 69
5068 litB := makeConditionLiteral(tk, 11)
5069 t.Output = IterationStatementFor{
5070 Type: ForInVar,
5071 ForBindingPatternArray: &ArrayBindingPattern{
5072 Tokens: tk[6:8],
5073 },
5074 In: &Expression{
5075 Expressions: []AssignmentExpression{
5076 {
5077 ConditionalExpression: &litB,
5078 Tokens: tk[11:12],
5079 },
5080 },
5081 Tokens: tk[11:12],
5082 },
5083 Statement: Statement{
5084 Tokens: tk[15:16],
5085 },
5086 Tokens: tk[:16],
5087 }
5088 }},
5089 {"for\n(\nlet\n[]\nin\nb\n)\n;", func(t *test, tk Tokens) { // 70
5090 litB := makeConditionLiteral(tk, 11)
5091 t.Output = IterationStatementFor{
5092 Type: ForInLet,
5093 ForBindingPatternArray: &ArrayBindingPattern{
5094 Tokens: tk[6:8],
5095 },
5096 In: &Expression{
5097 Expressions: []AssignmentExpression{
5098 {
5099 ConditionalExpression: &litB,
5100 Tokens: tk[11:12],
5101 },
5102 },
5103 Tokens: tk[11:12],
5104 },
5105 Statement: Statement{
5106 Tokens: tk[15:16],
5107 },
5108 Tokens: tk[:16],
5109 }
5110 }},
5111 {"for\n(\nconst\n[]\nin\nb\n)\n;", func(t *test, tk Tokens) { // 71
5112 litB := makeConditionLiteral(tk, 11)
5113 t.Output = IterationStatementFor{
5114 Type: ForInConst,
5115 ForBindingPatternArray: &ArrayBindingPattern{
5116 Tokens: tk[6:8],
5117 },
5118 In: &Expression{
5119 Expressions: []AssignmentExpression{
5120 {
5121 ConditionalExpression: &litB,
5122 Tokens: tk[11:12],
5123 },
5124 },
5125 Tokens: tk[11:12],
5126 },
5127 Statement: Statement{
5128 Tokens: tk[15:16],
5129 },
5130 Tokens: tk[:16],
5131 }
5132 }},
5133 {"for\nawait\n(\nvar\na\nin\nb\n)\n;", func(t *test, tk Tokens) { // 72
5134 t.Await = true
5135 t.Err = Error{
5136 Err: ErrInvalidForAwaitLoop,
5137 Parsing: "IterationStatementFor",
5138 Token: tk[6],
5139 }
5140 }},
5141 {"for\n(\nvar\n{,}\nof)", func(t *test, tk Tokens) { // 73
5142 t.Err = Error{
5143 Err: Error{
5144 Err: Error{
5145 Err: Error{
5146 Err: ErrInvalidPropertyName,
5147 Parsing: "PropertyName",
5148 Token: tk[7],
5149 },
5150 Parsing: "BindingProperty",
5151 Token: tk[7],
5152 },
5153 Parsing: "ObjectBindingPattern",
5154 Token: tk[7],
5155 },
5156 Parsing: "IterationStatementFor",
5157 Token: tk[6],
5158 }
5159 }},
5160 {"for\n(\nvar\n[+]\nof)", func(t *test, tk Tokens) { // 74
5161 t.Err = Error{
5162 Err: Error{
5163 Err: Error{
5164 Err: ErrNoIdentifier,
5165 Parsing: "BindingElement",
5166 Token: tk[7],
5167 },
5168 Parsing: "ArrayBindingPattern",
5169 Token: tk[7],
5170 },
5171 Parsing: "IterationStatementFor",
5172 Token: tk[6],
5173 }
5174 }},
5175 {"for\n(\nvar\n,\nof)", func(t *test, tk Tokens) { // 75
5176 t.Err = Error{
5177 Err: ErrNoIdentifier,
5178 Parsing: "IterationStatementFor",
5179 Token: tk[6],
5180 }
5181 }},
5182 {"for\n(\nlet\n{,}\nof)", func(t *test, tk Tokens) { // 76
5183 t.Err = Error{
5184 Err: Error{
5185 Err: Error{
5186 Err: Error{
5187 Err: ErrInvalidPropertyName,
5188 Parsing: "PropertyName",
5189 Token: tk[7],
5190 },
5191 Parsing: "BindingProperty",
5192 Token: tk[7],
5193 },
5194 Parsing: "ObjectBindingPattern",
5195 Token: tk[7],
5196 },
5197 Parsing: "IterationStatementFor",
5198 Token: tk[6],
5199 }
5200 }},
5201 {"for\n(\nlet\n[+]\nof)", func(t *test, tk Tokens) { // 77
5202 t.Err = Error{
5203 Err: Error{
5204 Err: Error{
5205 Err: ErrNoIdentifier,
5206 Parsing: "BindingElement",
5207 Token: tk[7],
5208 },
5209 Parsing: "ArrayBindingPattern",
5210 Token: tk[7],
5211 },
5212 Parsing: "IterationStatementFor",
5213 Token: tk[6],
5214 }
5215 }},
5216 {"for\n(\nlet\n,\nof)", func(t *test, tk Tokens) { // 78
5217 t.Err = Error{
5218 Err: ErrNoIdentifier,
5219 Parsing: "IterationStatementFor",
5220 Token: tk[6],
5221 }
5222 }},
5223 {"for\n(\nconst\n{,}\nof)", func(t *test, tk Tokens) { // 79
5224 t.Err = Error{
5225 Err: Error{
5226 Err: Error{
5227 Err: Error{
5228 Err: ErrInvalidPropertyName,
5229 Parsing: "PropertyName",
5230 Token: tk[7],
5231 },
5232 Parsing: "BindingProperty",
5233 Token: tk[7],
5234 },
5235 Parsing: "ObjectBindingPattern",
5236 Token: tk[7],
5237 },
5238 Parsing: "IterationStatementFor",
5239 Token: tk[6],
5240 }
5241 }},
5242 {"for\n(\nconst\n[+]\nof)", func(t *test, tk Tokens) { // 80
5243 t.Err = Error{
5244 Err: Error{
5245 Err: Error{
5246 Err: ErrNoIdentifier,
5247 Parsing: "BindingElement",
5248 Token: tk[7],
5249 },
5250 Parsing: "ArrayBindingPattern",
5251 Token: tk[7],
5252 },
5253 Parsing: "IterationStatementFor",
5254 Token: tk[6],
5255 }
5256 }},
5257 {"for\n(\nconst\n,\nof)", func(t *test, tk Tokens) { // 81
5258 t.Err = Error{
5259 Err: ErrNoIdentifier,
5260 Parsing: "IterationStatementFor",
5261 Token: tk[6],
5262 }
5263 }},
5264 {"for\n(\nvar\n{}\nof\n)", func(t *test, tk Tokens) { // 82
5265 t.Err = Error{
5266 Err: assignmentError(tk[11]),
5267 Parsing: "IterationStatementFor",
5268 Token: tk[11],
5269 }
5270 }},
5271 {"for\n(\nlet\n{}\nof\n)", func(t *test, tk Tokens) { // 83
5272 t.Err = Error{
5273 Err: assignmentError(tk[11]),
5274 Parsing: "IterationStatementFor",
5275 Token: tk[11],
5276 }
5277 }},
5278 {"for\n(\nconst\n{}\nof\n)", func(t *test, tk Tokens) { // 84
5279 t.Err = Error{
5280 Err: assignmentError(tk[11]),
5281 Parsing: "IterationStatementFor",
5282 Token: tk[11],
5283 }
5284 }},
5285 {"for\n(\nvar\na\nof\nb\n)\n;", func(t *test, tk Tokens) { // 85
5286 litB := makeConditionLiteral(tk, 10)
5287 t.Output = IterationStatementFor{
5288 Type: ForOfVar,
5289 ForBindingIdentifier: &tk[6],
5290 Of: &AssignmentExpression{
5291 ConditionalExpression: &litB,
5292 Tokens: tk[10:11],
5293 },
5294 Statement: Statement{
5295 Tokens: tk[14:15],
5296 },
5297 Tokens: tk[:15],
5298 }
5299 }},
5300 {"for\n(\nlet\na\nof\nb\n)\n;", func(t *test, tk Tokens) { // 86
5301 litB := makeConditionLiteral(tk, 10)
5302 t.Output = IterationStatementFor{
5303 Type: ForOfLet,
5304 ForBindingIdentifier: &tk[6],
5305 Of: &AssignmentExpression{
5306 ConditionalExpression: &litB,
5307 Tokens: tk[10:11],
5308 },
5309 Statement: Statement{
5310 Tokens: tk[14:15],
5311 },
5312 Tokens: tk[:15],
5313 }
5314 }},
5315 {"for\n(\nconst\na\nof\nb\n)\n;", func(t *test, tk Tokens) { // 87
5316 litB := makeConditionLiteral(tk, 10)
5317 t.Output = IterationStatementFor{
5318 Type: ForOfConst,
5319 ForBindingIdentifier: &tk[6],
5320 Of: &AssignmentExpression{
5321 ConditionalExpression: &litB,
5322 Tokens: tk[10:11],
5323 },
5324 Statement: Statement{
5325 Tokens: tk[14:15],
5326 },
5327 Tokens: tk[:15],
5328 }
5329 }},
5330 {"for\n(\nvar\n{}\nof\nb\n)\n;", func(t *test, tk Tokens) { // 88
5331 litB := makeConditionLiteral(tk, 11)
5332 t.Output = IterationStatementFor{
5333 Type: ForOfVar,
5334 ForBindingPatternObject: &ObjectBindingPattern{
5335 Tokens: tk[6:8],
5336 },
5337 Of: &AssignmentExpression{
5338 ConditionalExpression: &litB,
5339 Tokens: tk[11:12],
5340 },
5341 Statement: Statement{
5342 Tokens: tk[15:16],
5343 },
5344 Tokens: tk[:16],
5345 }
5346 }},
5347 {"for\n(\nlet\n{}\nof\nb\n)\n;", func(t *test, tk Tokens) { // 89
5348 litB := makeConditionLiteral(tk, 11)
5349 t.Output = IterationStatementFor{
5350 Type: ForOfLet,
5351 ForBindingPatternObject: &ObjectBindingPattern{
5352 Tokens: tk[6:8],
5353 },
5354 Of: &AssignmentExpression{
5355 ConditionalExpression: &litB,
5356 Tokens: tk[11:12],
5357 },
5358 Statement: Statement{
5359 Tokens: tk[15:16],
5360 },
5361 Tokens: tk[:16],
5362 }
5363 }},
5364 {"for\n(\nconst\n{}\nof\nb\n)\n;", func(t *test, tk Tokens) { // 90
5365 litB := makeConditionLiteral(tk, 11)
5366 t.Output = IterationStatementFor{
5367 Type: ForOfConst,
5368 ForBindingPatternObject: &ObjectBindingPattern{
5369 Tokens: tk[6:8],
5370 },
5371 Of: &AssignmentExpression{
5372 ConditionalExpression: &litB,
5373 Tokens: tk[11:12],
5374 },
5375 Statement: Statement{
5376 Tokens: tk[15:16],
5377 },
5378 Tokens: tk[:16],
5379 }
5380 }},
5381 {"for\n(\nvar\n[]\nof\nb\n)\n;", func(t *test, tk Tokens) { // 91
5382 litB := makeConditionLiteral(tk, 11)
5383 t.Output = IterationStatementFor{
5384 Type: ForOfVar,
5385 ForBindingPatternArray: &ArrayBindingPattern{
5386 Tokens: tk[6:8],
5387 },
5388 Of: &AssignmentExpression{
5389 ConditionalExpression: &litB,
5390 Tokens: tk[11:12],
5391 },
5392 Statement: Statement{
5393 Tokens: tk[15:16],
5394 },
5395 Tokens: tk[:16],
5396 }
5397 }},
5398 {"for\n(\nlet\n[]\nof\nb\n)\n;", func(t *test, tk Tokens) { // 92
5399 litB := makeConditionLiteral(tk, 11)
5400 t.Output = IterationStatementFor{
5401 Type: ForOfLet,
5402 ForBindingPatternArray: &ArrayBindingPattern{
5403 Tokens: tk[6:8],
5404 },
5405 Of: &AssignmentExpression{
5406 ConditionalExpression: &litB,
5407 Tokens: tk[11:12],
5408 },
5409 Statement: Statement{
5410 Tokens: tk[15:16],
5411 },
5412 Tokens: tk[:16],
5413 }
5414 }},
5415 {"for\n(\nconst\n[]\nof\nb\n)\n;", func(t *test, tk Tokens) { // 93
5416 litB := makeConditionLiteral(tk, 11)
5417 t.Output = IterationStatementFor{
5418 Type: ForOfConst,
5419 ForBindingPatternArray: &ArrayBindingPattern{
5420 Tokens: tk[6:8],
5421 },
5422 Of: &AssignmentExpression{
5423 ConditionalExpression: &litB,
5424 Tokens: tk[11:12],
5425 },
5426 Statement: Statement{
5427 Tokens: tk[15:16],
5428 },
5429 Tokens: tk[:16],
5430 }
5431 }},
5432 {"for\nawait\n(\nvar\na\nof\nb\n)\n;", func(t *test, tk Tokens) { // 94
5433 t.Await = true
5434 litB := makeConditionLiteral(tk, 12)
5435 t.Output = IterationStatementFor{
5436 Type: ForAwaitOfVar,
5437 ForBindingIdentifier: &tk[8],
5438 Of: &AssignmentExpression{
5439 ConditionalExpression: &litB,
5440 Tokens: tk[12:13],
5441 },
5442 Statement: Statement{
5443 Tokens: tk[16:17],
5444 },
5445 Tokens: tk[:17],
5446 }
5447 }},
5448 {"for\nawait\n(\nlet\na\nof\nb\n)\n;", func(t *test, tk Tokens) { // 95
5449 t.Await = true
5450 litB := makeConditionLiteral(tk, 12)
5451 t.Output = IterationStatementFor{
5452 Type: ForAwaitOfLet,
5453 ForBindingIdentifier: &tk[8],
5454 Of: &AssignmentExpression{
5455 ConditionalExpression: &litB,
5456 Tokens: tk[12:13],
5457 },
5458 Statement: Statement{
5459 Tokens: tk[16:17],
5460 },
5461 Tokens: tk[:17],
5462 }
5463 }},
5464 {"for\nawait\n(\nconst\na\nof\nb\n)\n;", func(t *test, tk Tokens) { // 96
5465 t.Await = true
5466 litB := makeConditionLiteral(tk, 12)
5467 t.Output = IterationStatementFor{
5468 Type: ForAwaitOfConst,
5469 ForBindingIdentifier: &tk[8],
5470 Of: &AssignmentExpression{
5471 ConditionalExpression: &litB,
5472 Tokens: tk[12:13],
5473 },
5474 Statement: Statement{
5475 Tokens: tk[16:17],
5476 },
5477 Tokens: tk[:17],
5478 }
5479 }},
5480 {"for\nawait\n(\n)", func(t *test, tk Tokens) { // 97
5481 t.Await = true
5482 t.Err = Error{
5483 Err: Error{
5484 Err: Error{
5485 Err: Error{
5486 Err: Error{
5487 Err: ErrNoIdentifier,
5488 Parsing: "PrimaryExpression",
5489 Token: tk[6],
5490 },
5491 Parsing: "MemberExpression",
5492 Token: tk[6],
5493 },
5494 Parsing: "NewExpression",
5495 Token: tk[6],
5496 },
5497 Parsing: "LeftHandSideExpression",
5498 Token: tk[6],
5499 },
5500 Parsing: "IterationStatementFor",
5501 Token: tk[6],
5502 }
5503 }},
5504 {"for\nawait\n(\na\n)", func(t *test, tk Tokens) { // 98
5505 t.Await = true
5506 t.Err = Error{
5507 Err: ErrInvalidForAwaitLoop,
5508 Parsing: "IterationStatementFor",
5509 Token: tk[8],
5510 }
5511 }},
5512 {"for\nawait\n(\na\nof\n)", func(t *test, tk Tokens) { // 99
5513 t.Await = true
5514 t.Err = Error{
5515 Err: assignmentError(tk[10]),
5516 Parsing: "IterationStatementFor",
5517 Token: tk[10],
5518 }
5519 }},
5520 {"for\nawait\n(\na\nof\nb\n)\n;", func(t *test, tk Tokens) { // 100
5521 t.Await = true
5522 litB := makeConditionLiteral(tk, 10)
5523 t.Output = IterationStatementFor{
5524 Type: ForAwaitOfLeftHandSide,
5525 LeftHandSideExpression: &LeftHandSideExpression{
5526 NewExpression: &NewExpression{
5527 MemberExpression: MemberExpression{
5528 PrimaryExpression: &PrimaryExpression{
5529 IdentifierReference: &tk[6],
5530 Tokens: tk[6:7],
5531 },
5532 Tokens: tk[6:7],
5533 },
5534 Tokens: tk[6:7],
5535 },
5536 Tokens: tk[6:7],
5537 },
5538 Of: &AssignmentExpression{
5539 ConditionalExpression: &litB,
5540 Tokens: tk[10:11],
5541 },
5542 Statement: Statement{
5543 Tokens: tk[14:15],
5544 },
5545 Tokens: tk[:15],
5546 }
5547 }},
5548 {"for\n(\n)\n;", func(t *test, tk Tokens) { // 101
5549 t.Err = Error{
5550 Err: Error{
5551 Err: assignmentError(tk[4]),
5552 Parsing: "Expression",
5553 Token: tk[4],
5554 },
5555 Parsing: "IterationStatementFor",
5556 Token: tk[4],
5557 }
5558 }},
5559 {"for\n(\na\n)", func(t *test, tk Tokens) { // 102
5560 t.Err = Error{
5561 Err: ErrMissingSemiColon,
5562 Parsing: "IterationStatementFor",
5563 Token: tk[6],
5564 }
5565 }},
5566 {"for\n(\na\n;\n;\n)\n;", func(t *test, tk Tokens) { // 103
5567 litA := makeConditionLiteral(tk, 4)
5568 t.Output = IterationStatementFor{
5569 Type: ForNormalExpression,
5570 InitExpression: &Expression{
5571 Expressions: []AssignmentExpression{
5572 {
5573 ConditionalExpression: &litA,
5574 Tokens: tk[4:5],
5575 },
5576 },
5577 Tokens: tk[4:5],
5578 },
5579 Statement: Statement{
5580 Tokens: tk[12:13],
5581 },
5582 Tokens: tk[:13],
5583 }
5584 }},
5585 {"for\n(\na\nin\nb\n)\n;", func(t *test, tk Tokens) { // 104
5586 litB := makeConditionLiteral(tk, 8)
5587 t.Output = IterationStatementFor{
5588 Type: ForInLeftHandSide,
5589 LeftHandSideExpression: &LeftHandSideExpression{
5590 NewExpression: &NewExpression{
5591 MemberExpression: MemberExpression{
5592 PrimaryExpression: &PrimaryExpression{
5593 IdentifierReference: &tk[4],
5594 Tokens: tk[4:5],
5595 },
5596 Tokens: tk[4:5],
5597 },
5598 Tokens: tk[4:5],
5599 },
5600 Tokens: tk[4:5],
5601 },
5602 In: &Expression{
5603 Expressions: []AssignmentExpression{
5604 {
5605 ConditionalExpression: &litB,
5606 Tokens: tk[8:9],
5607 },
5608 },
5609 Tokens: tk[8:9],
5610 },
5611 Statement: Statement{
5612 Tokens: tk[12:13],
5613 },
5614 Tokens: tk[:13],
5615 }
5616 }},
5617 {"for\n(\na\nof\nb\n)\n;", func(t *test, tk Tokens) { // 105
5618 litB := makeConditionLiteral(tk, 8)
5619 t.Output = IterationStatementFor{
5620 Type: ForOfLeftHandSide,
5621 LeftHandSideExpression: &LeftHandSideExpression{
5622 NewExpression: &NewExpression{
5623 MemberExpression: MemberExpression{
5624 PrimaryExpression: &PrimaryExpression{
5625 IdentifierReference: &tk[4],
5626 Tokens: tk[4:5],
5627 },
5628 Tokens: tk[4:5],
5629 },
5630 Tokens: tk[4:5],
5631 },
5632 Tokens: tk[4:5],
5633 },
5634 Of: &AssignmentExpression{
5635 ConditionalExpression: &litB,
5636 Tokens: tk[8:9],
5637 },
5638 Statement: Statement{
5639 Tokens: tk[12:13],
5640 },
5641 Tokens: tk[:13],
5642 }
5643 }},
5644 {"for\n(\na\n,\nb\nin)", func(t *test, tk Tokens) { // 106
5645 t.Err = Error{
5646 Err: ErrMissingSemiColon,
5647 Parsing: "IterationStatementFor",
5648 Token: tk[10],
5649 }
5650 }},
5651 {"for\n(\na\n,\nb\nof)", func(t *test, tk Tokens) { // 107
5652 t.Err = Error{
5653 Err: ErrMissingSemiColon,
5654 Parsing: "IterationStatementFor",
5655 Token: tk[10],
5656 }
5657 }},
5658 {"for\n(\na\n=\n1\nin)", func(t *test, tk Tokens) { // 108
5659 t.Err = Error{
5660 Err: ErrMissingSemiColon,
5661 Parsing: "IterationStatementFor",
5662 Token: tk[10],
5663 }
5664 }},
5665 {"for\n(\na\n=\n1\nof)", func(t *test, tk Tokens) { // 109
5666 t.Err = Error{
5667 Err: ErrMissingSemiColon,
5668 Parsing: "IterationStatementFor",
5669 Token: tk[10],
5670 }
5671 }},
5672 {"for\n(\n!a\nin)", func(t *test, tk Tokens) { // 110
5673 t.Err = Error{
5674 Err: ErrMissingSemiColon,
5675 Parsing: "IterationStatementFor",
5676 Token: tk[7],
5677 }
5678 }},
5679 {"for\n(\n!a\nof)", func(t *test, tk Tokens) { // 111
5680 t.Err = Error{
5681 Err: ErrMissingSemiColon,
5682 Parsing: "IterationStatementFor",
5683 Token: tk[7],
5684 }
5685 }},
5686 {"for (c in d) a: function b(){}", func(t *test, tk Tokens) { // 112
5687 t.Err = Error{
5688 Err: ErrLabelledFunction,
5689 Parsing: "IterationStatementFor",
5690 Token: tk[10],
5691 }
5692 }},
5693 }, func(t *test) (Type, error) {
5694 var is IterationStatementFor
5695 err := is.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
5696 return is, err
5697 })
5698 }
5699
5700 func TestSwitchStatement(t *testing.T) {
5701 doTests(t, []sourceFn{
5702 {``, func(t *test, tk Tokens) { // 1
5703 t.Err = Error{
5704 Err: ErrInvalidSwitchStatement,
5705 Parsing: "SwitchStatement",
5706 Token: tk[0],
5707 }
5708 }},
5709 {`switch`, func(t *test, tk Tokens) { // 2
5710 t.Err = Error{
5711 Err: ErrMissingOpeningParenthesis,
5712 Parsing: "SwitchStatement",
5713 Token: tk[1],
5714 }
5715 }},
5716 {"switch\n(\n)", func(t *test, tk Tokens) { // 3
5717 t.Err = Error{
5718 Err: Error{
5719 Err: assignmentError(tk[4]),
5720 Parsing: "Expression",
5721 Token: tk[4],
5722 },
5723 Parsing: "SwitchStatement",
5724 Token: tk[4],
5725 }
5726 }},
5727 {"switch\n(\na\nb\n)", func(t *test, tk Tokens) { // 4
5728 t.Err = Error{
5729 Err: ErrMissingClosingParenthesis,
5730 Parsing: "SwitchStatement",
5731 Token: tk[6],
5732 }
5733 }},
5734 {"switch\n(\na\n)", func(t *test, tk Tokens) { // 5
5735 t.Err = Error{
5736 Err: ErrMissingOpeningBrace,
5737 Parsing: "SwitchStatement",
5738 Token: tk[7],
5739 }
5740 }},
5741 {"switch\n(\na\n)\n{\n}", func(t *test, tk Tokens) { // 6
5742 litA := makeConditionLiteral(tk, 4)
5743 t.Output = SwitchStatement{
5744 Expression: Expression{
5745 Expressions: []AssignmentExpression{
5746 {
5747 ConditionalExpression: &litA,
5748 Tokens: tk[4:5],
5749 },
5750 },
5751 Tokens: tk[4:5],
5752 },
5753 Tokens: tk[:11],
5754 }
5755 }},
5756 {"switch\n(\na\n)\n{\ndefault\n}", func(t *test, tk Tokens) { // 7
5757 t.Err = Error{
5758 Err: ErrMissingColon,
5759 Parsing: "SwitchStatement",
5760 Token: tk[12],
5761 }
5762 }},
5763 {"switch\n(\na\n)\n{\ndefault\n:\n}", func(t *test, tk Tokens) { // 8
5764 litA := makeConditionLiteral(tk, 4)
5765 t.Output = SwitchStatement{
5766 Expression: Expression{
5767 Expressions: []AssignmentExpression{
5768 {
5769 ConditionalExpression: &litA,
5770 Tokens: tk[4:5],
5771 },
5772 },
5773 Tokens: tk[4:5],
5774 },
5775 DefaultClause: []StatementListItem{},
5776 Tokens: tk[:15],
5777 }
5778 }},
5779 {"switch\n(\na\n)\n{\ndefault\n:\nlet\n}", func(t *test, tk Tokens) { // 9
5780 t.Err = Error{
5781 Err: Error{
5782 Err: Error{
5783 Err: Error{
5784 Err: Error{
5785 Err: ErrNoIdentifier,
5786 Parsing: "LexicalBinding",
5787 Token: tk[16],
5788 },
5789 Parsing: "LexicalDeclaration",
5790 Token: tk[16],
5791 },
5792 Parsing: "Declaration",
5793 Token: tk[14],
5794 },
5795 Parsing: "StatementListItem",
5796 Token: tk[14],
5797 },
5798 Parsing: "SwitchStatement",
5799 Token: tk[14],
5800 }
5801 }},
5802 {"switch\n(\na\n)\n{\ndefault\n:\nb\n}", func(t *test, tk Tokens) { // 10
5803 litA := makeConditionLiteral(tk, 4)
5804 litB := makeConditionLiteral(tk, 14)
5805 t.Output = SwitchStatement{
5806 Expression: Expression{
5807 Expressions: []AssignmentExpression{
5808 {
5809 ConditionalExpression: &litA,
5810 Tokens: tk[4:5],
5811 },
5812 },
5813 Tokens: tk[4:5],
5814 },
5815 DefaultClause: []StatementListItem{
5816 {
5817 Statement: &Statement{
5818 ExpressionStatement: &Expression{
5819 Expressions: []AssignmentExpression{
5820 {
5821 ConditionalExpression: &litB,
5822 Tokens: tk[14:15],
5823 },
5824 },
5825 Tokens: tk[14:15],
5826 },
5827 Tokens: tk[14:15],
5828 },
5829 Tokens: tk[14:15],
5830 },
5831 },
5832 Tokens: tk[:17],
5833 }
5834 }},
5835 {"switch\n(\na\n)\n{\ndefault\n:\nb;\nc\n}", func(t *test, tk Tokens) { // 11
5836 litA := makeConditionLiteral(tk, 4)
5837 litB := makeConditionLiteral(tk, 14)
5838 litC := makeConditionLiteral(tk, 17)
5839 t.Output = SwitchStatement{
5840 Expression: Expression{
5841 Expressions: []AssignmentExpression{
5842 {
5843 ConditionalExpression: &litA,
5844 Tokens: tk[4:5],
5845 },
5846 },
5847 Tokens: tk[4:5],
5848 },
5849 DefaultClause: []StatementListItem{
5850 {
5851 Statement: &Statement{
5852 ExpressionStatement: &Expression{
5853 Expressions: []AssignmentExpression{
5854 {
5855 ConditionalExpression: &litB,
5856 Tokens: tk[14:15],
5857 },
5858 },
5859 Tokens: tk[14:15],
5860 },
5861 Tokens: tk[14:16],
5862 },
5863 Tokens: tk[14:16],
5864 },
5865 {
5866 Statement: &Statement{
5867 ExpressionStatement: &Expression{
5868 Expressions: []AssignmentExpression{
5869 {
5870 ConditionalExpression: &litC,
5871 Tokens: tk[17:18],
5872 },
5873 },
5874 Tokens: tk[17:18],
5875 },
5876 Tokens: tk[17:18],
5877 },
5878 Tokens: tk[17:18],
5879 },
5880 },
5881 Tokens: tk[:20],
5882 }
5883 }},
5884 {"switch\n(\na\n)\n{\ndefault\n:\ncase}", func(t *test, tk Tokens) { // 12
5885 t.Err = Error{
5886 Err: Error{
5887 Err: Error{
5888 Err: assignmentError(tk[15]),
5889 Parsing: "Expression",
5890 Token: tk[15],
5891 },
5892 Parsing: "CaseClause",
5893 Token: tk[15],
5894 },
5895 Parsing: "SwitchStatement",
5896 Token: tk[14],
5897 }
5898 }},
5899 {"switch\n(\na\n)\n{\ndefault\n:\ncase b:\n}", func(t *test, tk Tokens) { // 13
5900 litA := makeConditionLiteral(tk, 4)
5901 litB := makeConditionLiteral(tk, 16)
5902 t.Output = SwitchStatement{
5903 Expression: Expression{
5904 Expressions: []AssignmentExpression{
5905 {
5906 ConditionalExpression: &litA,
5907 Tokens: tk[4:5],
5908 },
5909 },
5910 Tokens: tk[4:5],
5911 },
5912 DefaultClause: []StatementListItem{},
5913 PostDefaultCaseClauses: []CaseClause{
5914 {
5915 Expression: Expression{
5916 Expressions: []AssignmentExpression{
5917 {
5918 ConditionalExpression: &litB,
5919 Tokens: tk[16:17],
5920 },
5921 },
5922 Tokens: tk[16:17],
5923 },
5924 Tokens: tk[14:18],
5925 },
5926 },
5927 Tokens: tk[:20],
5928 }
5929 }},
5930 {"switch\n(\na\n)\n{\ndefault\n:\ncase b:\ncase c:}", func(t *test, tk Tokens) { // 14
5931 litA := makeConditionLiteral(tk, 4)
5932 litB := makeConditionLiteral(tk, 16)
5933 litC := makeConditionLiteral(tk, 21)
5934 t.Output = SwitchStatement{
5935 Expression: Expression{
5936 Expressions: []AssignmentExpression{
5937 {
5938 ConditionalExpression: &litA,
5939 Tokens: tk[4:5],
5940 },
5941 },
5942 Tokens: tk[4:5],
5943 },
5944 DefaultClause: []StatementListItem{},
5945 PostDefaultCaseClauses: []CaseClause{
5946 {
5947 Expression: Expression{
5948 Expressions: []AssignmentExpression{
5949 {
5950 ConditionalExpression: &litB,
5951 Tokens: tk[16:17],
5952 },
5953 },
5954 Tokens: tk[16:17],
5955 },
5956 Tokens: tk[14:18],
5957 },
5958 {
5959 Expression: Expression{
5960 Expressions: []AssignmentExpression{
5961 {
5962 ConditionalExpression: &litC,
5963 Tokens: tk[21:22],
5964 },
5965 },
5966 Tokens: tk[21:22],
5967 },
5968 Tokens: tk[19:23],
5969 },
5970 },
5971 Tokens: tk[:24],
5972 }
5973 }},
5974 {"switch\n(\na\n)\n{\ncase b:\n}", func(t *test, tk Tokens) { // 15
5975 litA := makeConditionLiteral(tk, 4)
5976 litB := makeConditionLiteral(tk, 12)
5977 t.Output = SwitchStatement{
5978 Expression: Expression{
5979 Expressions: []AssignmentExpression{
5980 {
5981 ConditionalExpression: &litA,
5982 Tokens: tk[4:5],
5983 },
5984 },
5985 Tokens: tk[4:5],
5986 },
5987 CaseClauses: []CaseClause{
5988 {
5989 Expression: Expression{
5990 Expressions: []AssignmentExpression{
5991 {
5992 ConditionalExpression: &litB,
5993 Tokens: tk[12:13],
5994 },
5995 },
5996 Tokens: tk[12:13],
5997 },
5998 Tokens: tk[10:14],
5999 },
6000 },
6001 Tokens: tk[:16],
6002 }
6003 }},
6004 {"switch\n(\na\n)\n{\ncase b:\ncase c:}", func(t *test, tk Tokens) { // 15
6005 litA := makeConditionLiteral(tk, 4)
6006 litB := makeConditionLiteral(tk, 12)
6007 litC := makeConditionLiteral(tk, 17)
6008 t.Output = SwitchStatement{
6009 Expression: Expression{
6010 Expressions: []AssignmentExpression{
6011 {
6012 ConditionalExpression: &litA,
6013 Tokens: tk[4:5],
6014 },
6015 },
6016 Tokens: tk[4:5],
6017 },
6018 CaseClauses: []CaseClause{
6019 {
6020 Expression: Expression{
6021 Expressions: []AssignmentExpression{
6022 {
6023 ConditionalExpression: &litB,
6024 Tokens: tk[12:13],
6025 },
6026 },
6027 Tokens: tk[12:13],
6028 },
6029 Tokens: tk[10:14],
6030 },
6031 {
6032 Expression: Expression{
6033 Expressions: []AssignmentExpression{
6034 {
6035 ConditionalExpression: &litC,
6036 Tokens: tk[17:18],
6037 },
6038 },
6039 Tokens: tk[17:18],
6040 },
6041 Tokens: tk[15:19],
6042 },
6043 },
6044 Tokens: tk[:20],
6045 }
6046 }},
6047 {"switch\n(\na\n)\n{\ncase b:\ncase c:\ndefault\n:\nd\ne\ncase f:\ncase g:}", func(t *test, tk Tokens) { // 16
6048 litA := makeConditionLiteral(tk, 4)
6049 litB := makeConditionLiteral(tk, 12)
6050 litC := makeConditionLiteral(tk, 17)
6051 litD := makeConditionLiteral(tk, 24)
6052 litE := makeConditionLiteral(tk, 26)
6053 litF := makeConditionLiteral(tk, 30)
6054 litG := makeConditionLiteral(tk, 35)
6055 t.Output = SwitchStatement{
6056 Expression: Expression{
6057 Expressions: []AssignmentExpression{
6058 {
6059 ConditionalExpression: &litA,
6060 Tokens: tk[4:5],
6061 },
6062 },
6063 Tokens: tk[4:5],
6064 },
6065 CaseClauses: []CaseClause{
6066 {
6067 Expression: Expression{
6068 Expressions: []AssignmentExpression{
6069 {
6070 ConditionalExpression: &litB,
6071 Tokens: tk[12:13],
6072 },
6073 },
6074 Tokens: tk[12:13],
6075 },
6076 Tokens: tk[10:14],
6077 },
6078 {
6079 Expression: Expression{
6080 Expressions: []AssignmentExpression{
6081 {
6082 ConditionalExpression: &litC,
6083 Tokens: tk[17:18],
6084 },
6085 },
6086 Tokens: tk[17:18],
6087 },
6088 Tokens: tk[15:19],
6089 },
6090 },
6091 DefaultClause: []StatementListItem{
6092 {
6093 Statement: &Statement{
6094 ExpressionStatement: &Expression{
6095 Expressions: []AssignmentExpression{
6096 {
6097 ConditionalExpression: &litD,
6098 Tokens: tk[24:25],
6099 },
6100 },
6101 Tokens: tk[24:25],
6102 },
6103 Tokens: tk[24:25],
6104 },
6105 Tokens: tk[24:25],
6106 },
6107 {
6108 Statement: &Statement{
6109 ExpressionStatement: &Expression{
6110 Expressions: []AssignmentExpression{
6111 {
6112 ConditionalExpression: &litE,
6113 Tokens: tk[26:27],
6114 },
6115 },
6116 Tokens: tk[26:27],
6117 },
6118 Tokens: tk[26:27],
6119 },
6120 Tokens: tk[26:27],
6121 },
6122 },
6123 PostDefaultCaseClauses: []CaseClause{
6124 {
6125 Expression: Expression{
6126 Expressions: []AssignmentExpression{
6127 {
6128 ConditionalExpression: &litF,
6129 Tokens: tk[30:31],
6130 },
6131 },
6132 Tokens: tk[30:31],
6133 },
6134 Tokens: tk[28:32],
6135 },
6136 {
6137 Expression: Expression{
6138 Expressions: []AssignmentExpression{
6139 {
6140 ConditionalExpression: &litG,
6141 Tokens: tk[35:36],
6142 },
6143 },
6144 Tokens: tk[35:36],
6145 },
6146 Tokens: tk[33:37],
6147 },
6148 },
6149 Tokens: tk[:38],
6150 }
6151 }},
6152 {"switch\n(\na\n)\n{\ncase b:\ncase c:\ndefault\n:\nd;\ne;\ncase f:\ncase g:default:}", func(t *test, tk Tokens) { // 17
6153 t.Err = Error{
6154 Err: ErrDuplicateDefaultClause,
6155 Parsing: "SwitchStatement",
6156 Token: tk[39],
6157 }
6158 }},
6159 }, func(t *test) (Type, error) {
6160 var ss SwitchStatement
6161 err := ss.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
6162 return ss, err
6163 })
6164 }
6165
6166 func TestCaseClause(t *testing.T) {
6167 doTests(t, []sourceFn{
6168 {``, func(t *test, tk Tokens) { // 1
6169 t.Err = Error{
6170 Err: ErrMissingCaseClause,
6171 Parsing: "CaseClause",
6172 Token: tk[0],
6173 }
6174 }},
6175 {`case`, func(t *test, tk Tokens) { // 2
6176 t.Err = Error{
6177 Err: Error{
6178 Err: assignmentError(tk[1]),
6179 Parsing: "Expression",
6180 Token: tk[1],
6181 },
6182 Parsing: "CaseClause",
6183 Token: tk[1],
6184 }
6185 }},
6186 {"case\na", func(t *test, tk Tokens) { // 3
6187 t.Err = Error{
6188 Err: ErrMissingColon,
6189 Parsing: "CaseClause",
6190 Token: tk[3],
6191 }
6192 }},
6193 {"case\na\n:", func(t *test, tk Tokens) { // 4
6194 litA := makeConditionLiteral(tk, 2)
6195 t.Output = CaseClause{
6196 Expression: Expression{
6197 Expressions: []AssignmentExpression{
6198 {
6199 ConditionalExpression: &litA,
6200 Tokens: tk[2:3],
6201 },
6202 },
6203 Tokens: tk[2:3],
6204 },
6205 Tokens: tk[:5],
6206 }
6207 }},
6208 {"case\na\n:case", func(t *test, tk Tokens) { // 5
6209 litA := makeConditionLiteral(tk, 2)
6210 t.Output = CaseClause{
6211 Expression: Expression{
6212 Expressions: []AssignmentExpression{
6213 {
6214 ConditionalExpression: &litA,
6215 Tokens: tk[2:3],
6216 },
6217 },
6218 Tokens: tk[2:3],
6219 },
6220 Tokens: tk[:5],
6221 }
6222 }},
6223 {"case\na\n:default", func(t *test, tk Tokens) { // 6
6224 litA := makeConditionLiteral(tk, 2)
6225 t.Output = CaseClause{
6226 Expression: Expression{
6227 Expressions: []AssignmentExpression{
6228 {
6229 ConditionalExpression: &litA,
6230 Tokens: tk[2:3],
6231 },
6232 },
6233 Tokens: tk[2:3],
6234 },
6235 Tokens: tk[:5],
6236 }
6237 }},
6238 {"case\na\n:\nlet", func(t *test, tk Tokens) { // 7
6239 t.Err = Error{
6240 Err: Error{
6241 Err: Error{
6242 Err: Error{
6243 Err: Error{
6244 Err: ErrNoIdentifier,
6245 Parsing: "LexicalBinding",
6246 Token: tk[7],
6247 },
6248 Parsing: "LexicalDeclaration",
6249 Token: tk[7],
6250 },
6251 Parsing: "Declaration",
6252 Token: tk[6],
6253 },
6254 Parsing: "StatementListItem",
6255 Token: tk[6],
6256 },
6257 Parsing: "CaseClause",
6258 Token: tk[6],
6259 }
6260 }},
6261 {"case\na\n:\nb\nc", func(t *test, tk Tokens) { // 8
6262 litA := makeConditionLiteral(tk, 2)
6263 litB := makeConditionLiteral(tk, 6)
6264 litC := makeConditionLiteral(tk, 8)
6265 t.Output = CaseClause{
6266 Expression: Expression{
6267 Expressions: []AssignmentExpression{
6268 {
6269 ConditionalExpression: &litA,
6270 Tokens: tk[2:3],
6271 },
6272 },
6273 Tokens: tk[2:3],
6274 },
6275 StatementList: []StatementListItem{
6276 {
6277 Statement: &Statement{
6278 ExpressionStatement: &Expression{
6279 Expressions: []AssignmentExpression{
6280 {
6281 ConditionalExpression: &litB,
6282 Tokens: tk[6:7],
6283 },
6284 },
6285 Tokens: tk[6:7],
6286 },
6287 Tokens: tk[6:7],
6288 },
6289 Tokens: tk[6:7],
6290 },
6291 {
6292 Statement: &Statement{
6293 ExpressionStatement: &Expression{
6294 Expressions: []AssignmentExpression{
6295 {
6296 ConditionalExpression: &litC,
6297 Tokens: tk[8:9],
6298 },
6299 },
6300 Tokens: tk[8:9],
6301 },
6302 Tokens: tk[8:9],
6303 },
6304 Tokens: tk[8:9],
6305 },
6306 },
6307 Tokens: tk[:9],
6308 }
6309 }},
6310 }, func(t *test) (Type, error) {
6311 var cc CaseClause
6312 err := cc.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
6313 return cc, err
6314 })
6315 }
6316
6317 func TestWithStatement(t *testing.T) {
6318 doTests(t, []sourceFn{
6319 {``, func(t *test, tk Tokens) { // 1
6320 t.Err = Error{
6321 Err: ErrInvalidWithStatement,
6322 Parsing: "WithStatement",
6323 Token: tk[0],
6324 }
6325 }},
6326 {`with`, func(t *test, tk Tokens) { // 2
6327 t.Err = Error{
6328 Err: ErrMissingOpeningParenthesis,
6329 Parsing: "WithStatement",
6330 Token: tk[1],
6331 }
6332 }},
6333 {"with\n(\n)", func(t *test, tk Tokens) { // 3
6334 t.Err = Error{
6335 Err: Error{
6336 Err: assignmentError(tk[4]),
6337 Parsing: "Expression",
6338 Token: tk[4],
6339 },
6340 Parsing: "WithStatement",
6341 Token: tk[4],
6342 }
6343 }},
6344 {"with\n(\na\nb\n)", func(t *test, tk Tokens) { // 4
6345 t.Err = Error{
6346 Err: ErrMissingClosingParenthesis,
6347 Parsing: "WithStatement",
6348 Token: tk[6],
6349 }
6350 }},
6351 {"with\n(\na\n)", func(t *test, tk Tokens) { // 5
6352 t.Err = Error{
6353 Err: Error{
6354 Err: Error{
6355 Err: assignmentError(tk[7]),
6356 Parsing: "Expression",
6357 Token: tk[7],
6358 },
6359 Parsing: "Statement",
6360 Token: tk[7],
6361 },
6362 Parsing: "WithStatement",
6363 Token: tk[7],
6364 }
6365 }},
6366 {"with\n(\na\n)\n;", func(t *test, tk Tokens) { // 6
6367 litA := makeConditionLiteral(tk, 4)
6368 t.Output = WithStatement{
6369 Expression: Expression{
6370 Expressions: []AssignmentExpression{
6371 {
6372 ConditionalExpression: &litA,
6373 Tokens: tk[4:5],
6374 },
6375 },
6376 Tokens: tk[4:5],
6377 },
6378 Statement: Statement{
6379 Tokens: tk[8:9],
6380 },
6381 Tokens: tk[:9],
6382 }
6383 }},
6384 {"with (b) a: function b(){}", func(t *test, tk Tokens) { // 7
6385 t.Err = Error{
6386 Err: ErrLabelledFunction,
6387 Parsing: "WithStatement",
6388 Token: tk[6],
6389 }
6390 }},
6391 }, func(t *test) (Type, error) {
6392 var ws WithStatement
6393 err := ws.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
6394 return ws, err
6395 })
6396 }
6397
6398 func TestTryStatement(t *testing.T) {
6399 doTests(t, []sourceFn{
6400 {``, func(t *test, tk Tokens) { // 1
6401 t.Err = Error{
6402 Err: ErrInvalidTryStatement,
6403 Parsing: "TryStatement",
6404 Token: tk[0],
6405 }
6406 }},
6407 {`try`, func(t *test, tk Tokens) { // 2
6408 t.Err = Error{
6409 Err: Error{
6410 Err: ErrMissingOpeningBrace,
6411 Parsing: "Block",
6412 Token: tk[1],
6413 },
6414 Parsing: "TryStatement",
6415 Token: tk[1],
6416 }
6417 }},
6418 {"try\n{\n}", func(t *test, tk Tokens) { // 3
6419 t.Err = Error{
6420 Err: ErrMissingCatchFinally,
6421 Parsing: "TryStatement",
6422 Token: tk[5],
6423 }
6424 }},
6425 {"try\n{\n}\ncatch", func(t *test, tk Tokens) { // 4
6426 t.Err = Error{
6427 Err: Error{
6428 Err: ErrMissingOpeningBrace,
6429 Parsing: "Block",
6430 Token: tk[7],
6431 },
6432 Parsing: "TryStatement",
6433 Token: tk[7],
6434 }
6435 }},
6436 {"try\n{\n}\ncatch\n{,}", func(t *test, tk Tokens) { // 5
6437 t.Err = Error{
6438 Err: Error{
6439 Err: Error{
6440 Err: Error{
6441 Err: Error{
6442 Err: assignmentError(tk[9]),
6443 Parsing: "Expression",
6444 Token: tk[9],
6445 },
6446 Parsing: "Statement",
6447 Token: tk[9],
6448 },
6449 Parsing: "StatementListItem",
6450 Token: tk[9],
6451 },
6452 Parsing: "Block",
6453 Token: tk[9],
6454 },
6455 Parsing: "TryStatement",
6456 Token: tk[8],
6457 }
6458 }},
6459 {"try\n{\n}\ncatch\n{\n}", func(t *test, tk Tokens) { // 6
6460 t.Output = TryStatement{
6461 TryBlock: Block{
6462 Tokens: tk[2:5],
6463 },
6464 CatchBlock: &Block{
6465 Tokens: tk[8:11],
6466 },
6467 Tokens: tk[:11],
6468 }
6469 }},
6470 {"try\n{\n}\ncatch\n(\n)", func(t *test, tk Tokens) { // 7
6471 t.Err = Error{
6472 Err: ErrNoIdentifier,
6473 Parsing: "TryStatement",
6474 Token: tk[10],
6475 }
6476 }},
6477 {"try\n{\n}\ncatch\n(\na\n)\n{\n}", func(t *test, tk Tokens) { // 8
6478 t.Output = TryStatement{
6479 TryBlock: Block{
6480 Tokens: tk[2:5],
6481 },
6482 CatchParameterBindingIdentifier: &tk[10],
6483 CatchBlock: &Block{
6484 Tokens: tk[14:17],
6485 },
6486 Tokens: tk[:17],
6487 }
6488 }},
6489 {"try\n{\n}\ncatch\n(\n{,}\n)", func(t *test, tk Tokens) { // 9
6490 t.Err = Error{
6491 Err: Error{
6492 Err: Error{
6493 Err: Error{
6494 Err: ErrInvalidPropertyName,
6495 Parsing: "PropertyName",
6496 Token: tk[11],
6497 },
6498 Parsing: "BindingProperty",
6499 Token: tk[11],
6500 },
6501 Parsing: "ObjectBindingPattern",
6502 Token: tk[11],
6503 },
6504 Parsing: "TryStatement",
6505 Token: tk[10],
6506 }
6507 }},
6508 {"try\n{\n}\ncatch\n(\n{}\n)\n{\n}", func(t *test, tk Tokens) { // 10
6509 t.Output = TryStatement{
6510 TryBlock: Block{
6511 Tokens: tk[2:5],
6512 },
6513 CatchParameterObjectBindingPattern: &ObjectBindingPattern{
6514 Tokens: tk[10:12],
6515 },
6516 CatchBlock: &Block{
6517 Tokens: tk[15:18],
6518 },
6519 Tokens: tk[:18],
6520 }
6521 }},
6522 {"try\n{\n}\ncatch\n(\n[!]\n)", func(t *test, tk Tokens) { // 11
6523 t.Err = Error{
6524 Err: Error{
6525 Err: Error{
6526 Err: ErrNoIdentifier,
6527 Parsing: "BindingElement",
6528 Token: tk[11],
6529 },
6530 Parsing: "ArrayBindingPattern",
6531 Token: tk[11],
6532 },
6533 Parsing: "TryStatement",
6534 Token: tk[10],
6535 }
6536 }},
6537 {"try\n{\n}\ncatch\n(\n[]\n)\n{\n}", func(t *test, tk Tokens) { // 12
6538 t.Output = TryStatement{
6539 TryBlock: Block{
6540 Tokens: tk[2:5],
6541 },
6542 CatchParameterArrayBindingPattern: &ArrayBindingPattern{
6543 Tokens: tk[10:12],
6544 },
6545 CatchBlock: &Block{
6546 Tokens: tk[15:18],
6547 },
6548 Tokens: tk[:18],
6549 }
6550 }},
6551 {"try\n{\n}\nfinally", func(t *test, tk Tokens) { // 13
6552 t.Err = Error{
6553 Err: Error{
6554 Err: ErrMissingOpeningBrace,
6555 Parsing: "Block",
6556 Token: tk[7],
6557 },
6558 Parsing: "TryStatement",
6559 Token: tk[7],
6560 }
6561 }},
6562 {"try\n{\n}\nfinally\n{\n}", func(t *test, tk Tokens) { // 14
6563 t.Output = TryStatement{
6564 TryBlock: Block{
6565 Tokens: tk[2:5],
6566 },
6567 FinallyBlock: &Block{
6568 Tokens: tk[8:11],
6569 },
6570 Tokens: tk[:11],
6571 }
6572 }},
6573 {"try\n{\n}\nfinally\n{\n}\ncatch\n{\n}", func(t *test, tk Tokens) { // 15
6574 t.Output = TryStatement{
6575 TryBlock: Block{
6576 Tokens: tk[2:5],
6577 },
6578 FinallyBlock: &Block{
6579 Tokens: tk[8:11],
6580 },
6581 Tokens: tk[:11],
6582 }
6583 }},
6584 {"try\n{\n}\ncatch\n{\n}\nfinally\n{\n}", func(t *test, tk Tokens) { // 16
6585 t.Output = TryStatement{
6586 TryBlock: Block{
6587 Tokens: tk[2:5],
6588 },
6589 CatchBlock: &Block{
6590 Tokens: tk[8:11],
6591 },
6592 FinallyBlock: &Block{
6593 Tokens: tk[14:17],
6594 },
6595 Tokens: tk[:17],
6596 }
6597 }},
6598 {"try\n{\n}\ncatch\n(\na\nb\n)", func(t *test, tk Tokens) { // 17
6599 t.Err = Error{
6600 Err: ErrMissingClosingParenthesis,
6601 Parsing: "TryStatement",
6602 Token: tk[12],
6603 }
6604 }},
6605 }, func(t *test) (Type, error) {
6606 var ts TryStatement
6607 err := ts.parse(&t.Tokens, t.Yield, t.Await, t.Ret)
6608 return ts, err
6609 })
6610 }
6611
6612 func TestVariableStatement(t *testing.T) {
6613 doTests(t, []sourceFn{
6614 {``, func(t *test, tk Tokens) { // 1
6615 t.Err = Error{
6616 Err: ErrInvalidVariableStatement,
6617 Parsing: "VariableStatement",
6618 Token: tk[0],
6619 }
6620 }},
6621 {`var`, func(t *test, tk Tokens) { // 2
6622 t.Err = Error{
6623 Err: Error{
6624 Err: ErrNoIdentifier,
6625 Parsing: "LexicalBinding",
6626 Token: tk[1],
6627 },
6628 Parsing: "VariableStatement",
6629 Token: tk[1],
6630 }
6631 }},
6632 {"var\na", func(t *test, tk Tokens) { // 3
6633 t.Output = VariableStatement{
6634 VariableDeclarationList: []VariableDeclaration{
6635 {
6636 BindingIdentifier: &tk[2],
6637 Tokens: tk[2:3],
6638 },
6639 },
6640 Tokens: tk[:3],
6641 }
6642 }},
6643 {"var\na\n,", func(t *test, tk Tokens) { // 4
6644 t.Err = Error{
6645 Err: Error{
6646 Err: ErrNoIdentifier,
6647 Parsing: "LexicalBinding",
6648 Token: tk[5],
6649 },
6650 Parsing: "VariableStatement",
6651 Token: tk[5],
6652 }
6653 }},
6654 {"var\na\n", func(t *test, tk Tokens) { // 5
6655 t.Output = VariableStatement{
6656 VariableDeclarationList: []VariableDeclaration{
6657 {
6658 BindingIdentifier: &tk[2],
6659 Tokens: tk[2:3],
6660 },
6661 },
6662 Tokens: tk[:3],
6663 }
6664 }},
6665 {"var\na\n;", func(t *test, tk Tokens) { // 6
6666 t.Output = VariableStatement{
6667 VariableDeclarationList: []VariableDeclaration{
6668 {
6669 BindingIdentifier: &tk[2],
6670 Tokens: tk[2:3],
6671 },
6672 },
6673 Tokens: tk[:5],
6674 }
6675 }},
6676 {"var\na\nb", func(t *test, tk Tokens) { // 7
6677 t.Output = VariableStatement{
6678 VariableDeclarationList: []VariableDeclaration{
6679 {
6680 BindingIdentifier: &tk[2],
6681 Tokens: tk[2:3],
6682 },
6683 },
6684 Tokens: tk[:3],
6685 }
6686 }},
6687 {"var\na\n,\nb", func(t *test, tk Tokens) { // 8
6688 t.Output = VariableStatement{
6689 VariableDeclarationList: []VariableDeclaration{
6690 {
6691 BindingIdentifier: &tk[2],
6692 Tokens: tk[2:3],
6693 },
6694 {
6695 BindingIdentifier: &tk[6],
6696 Tokens: tk[6:7],
6697 },
6698 },
6699 Tokens: tk[:7],
6700 }
6701 }},
6702 {"var\na\n,\nb\n", func(t *test, tk Tokens) { // 9
6703 t.Output = VariableStatement{
6704 VariableDeclarationList: []VariableDeclaration{
6705 {
6706 BindingIdentifier: &tk[2],
6707 Tokens: tk[2:3],
6708 },
6709 {
6710 BindingIdentifier: &tk[6],
6711 Tokens: tk[6:7],
6712 },
6713 },
6714 Tokens: tk[:7],
6715 }
6716 }},
6717 {"var\na\n,\nb\n;", func(t *test, tk Tokens) { // 10
6718 t.Output = VariableStatement{
6719 VariableDeclarationList: []VariableDeclaration{
6720 {
6721 BindingIdentifier: &tk[2],
6722 Tokens: tk[2:3],
6723 },
6724 {
6725 BindingIdentifier: &tk[6],
6726 Tokens: tk[6:7],
6727 },
6728 },
6729 Tokens: tk[:9],
6730 }
6731 }},
6732 {"var\na b\n;", func(t *test, tk Tokens) { // 11
6733 t.Err = Error{
6734 Err: ErrMissingComma,
6735 Parsing: "VariableStatement",
6736 Token: tk[3],
6737 }
6738 }},
6739 }, func(t *test) (Type, error) {
6740 var vs VariableStatement
6741 err := vs.parse(&t.Tokens, t.Yield, t.Await)
6742 return vs, err
6743 })
6744 }
6745