javascript - ast_expression_test.go
1 package javascript
2
3 import "testing"
4
5 func TestLeftHandSideExpressionOld(t *testing.T) {
6 doTests(t, []sourceFn{
7 {`this`, func(t *test, tk Tokens) { // 1
8 t.Output = LeftHandSideExpression{
9 NewExpression: &NewExpression{
10 MemberExpression: MemberExpression{
11 PrimaryExpression: &PrimaryExpression{
12 This: &tk[0],
13 Tokens: tk[:1],
14 },
15 Tokens: tk[:1],
16 },
17 Tokens: tk[:1],
18 },
19 Tokens: tk[:1],
20 }
21 }},
22 {`someIdentifier`, func(t *test, tk Tokens) { // 2
23 t.Output = LeftHandSideExpression{
24 NewExpression: &NewExpression{
25 MemberExpression: MemberExpression{
26 PrimaryExpression: &PrimaryExpression{
27 IdentifierReference: &tk[0],
28 Tokens: tk[:1],
29 },
30 Tokens: tk[:1],
31 },
32 Tokens: tk[:1],
33 },
34 Tokens: tk[:1],
35 }
36 }},
37 {`new someIdentifier`, func(t *test, tk Tokens) { // 3
38 t.Output = LeftHandSideExpression{
39 NewExpression: &NewExpression{
40 News: 1,
41 MemberExpression: MemberExpression{
42 PrimaryExpression: &PrimaryExpression{
43 IdentifierReference: &tk[2],
44 Tokens: tk[2:3],
45 },
46 Tokens: tk[2:3],
47 },
48 Tokens: tk[:3],
49 },
50 Tokens: tk[:3],
51 }
52 }},
53 {`new new someIdentifier`, func(t *test, tk Tokens) { // 4
54 t.Output = LeftHandSideExpression{
55 NewExpression: &NewExpression{
56 News: 2,
57 MemberExpression: MemberExpression{
58 PrimaryExpression: &PrimaryExpression{
59 IdentifierReference: &tk[4],
60 Tokens: tk[4:5],
61 },
62 Tokens: tk[4:5],
63 },
64 Tokens: tk[:5],
65 },
66 Tokens: tk[:5],
67 }
68 }},
69 {`null`, func(t *test, tk Tokens) { // 5
70 t.Output = LeftHandSideExpression{
71 NewExpression: &NewExpression{
72 MemberExpression: MemberExpression{
73 PrimaryExpression: &PrimaryExpression{
74 Literal: &tk[0],
75 Tokens: tk[:1],
76 },
77 Tokens: tk[:1],
78 },
79 Tokens: tk[:1],
80 },
81 Tokens: tk[:1],
82 }
83 }},
84 {`true`, func(t *test, tk Tokens) { // 6
85 t.Output = LeftHandSideExpression{
86 NewExpression: &NewExpression{
87 MemberExpression: MemberExpression{
88 PrimaryExpression: &PrimaryExpression{
89 Literal: &tk[0],
90 Tokens: tk[:1],
91 },
92 Tokens: tk[:1],
93 },
94 Tokens: tk[:1],
95 },
96 Tokens: tk[:1],
97 }
98 }},
99 {`false`, func(t *test, tk Tokens) { // 7
100 t.Output = LeftHandSideExpression{
101 NewExpression: &NewExpression{
102 MemberExpression: MemberExpression{
103 PrimaryExpression: &PrimaryExpression{
104 Literal: &tk[0],
105 Tokens: tk[:1],
106 },
107 Tokens: tk[:1],
108 },
109 Tokens: tk[:1],
110 },
111 Tokens: tk[:1],
112 }
113 }},
114 {`0`, func(t *test, tk Tokens) { // 8
115 t.Output = LeftHandSideExpression{
116 NewExpression: &NewExpression{
117 MemberExpression: MemberExpression{
118 PrimaryExpression: &PrimaryExpression{
119 Literal: &tk[0],
120 Tokens: tk[:1],
121 },
122 Tokens: tk[:1],
123 },
124 Tokens: tk[:1],
125 },
126 Tokens: tk[:1],
127 }
128 }},
129 {`"Hello"`, func(t *test, tk Tokens) { // 9
130 t.Output = LeftHandSideExpression{
131 NewExpression: &NewExpression{
132 MemberExpression: MemberExpression{
133 PrimaryExpression: &PrimaryExpression{
134 Literal: &tk[0],
135 Tokens: tk[:1],
136 },
137 Tokens: tk[:1],
138 },
139 Tokens: tk[:1],
140 },
141 Tokens: tk[:1],
142 }
143 }},
144 {`[]`, func(t *test, tk Tokens) { // 10
145 t.Output = LeftHandSideExpression{
146 NewExpression: &NewExpression{
147 MemberExpression: MemberExpression{
148 PrimaryExpression: &PrimaryExpression{
149 ArrayLiteral: &ArrayLiteral{
150 Tokens: tk[:2],
151 },
152 Tokens: tk[:2],
153 },
154 Tokens: tk[:2],
155 },
156 Tokens: tk[:2],
157 },
158 Tokens: tk[:2],
159 }
160 }},
161 {`{}`, func(t *test, tk Tokens) { // 11
162 t.Output = LeftHandSideExpression{
163 NewExpression: &NewExpression{
164 MemberExpression: MemberExpression{
165 PrimaryExpression: &PrimaryExpression{
166 ObjectLiteral: &ObjectLiteral{
167 Tokens: tk[:2],
168 },
169 Tokens: tk[:2],
170 },
171 Tokens: tk[:2],
172 },
173 Tokens: tk[:2],
174 },
175 Tokens: tk[:2],
176 }
177 }},
178 {`super.runMe`, func(t *test, tk Tokens) { // 12
179 t.Output = LeftHandSideExpression{
180 NewExpression: &NewExpression{
181 MemberExpression: MemberExpression{
182 SuperProperty: true,
183 IdentifierName: &tk[2],
184 Tokens: tk[:3],
185 },
186 Tokens: tk[:3],
187 },
188 Tokens: tk[:3],
189 }
190 }},
191 {`super[runMe]`, func(t *test, tk Tokens) { // 13
192 litA := makeConditionLiteral(tk, 2)
193 t.Output = LeftHandSideExpression{
194 NewExpression: &NewExpression{
195 MemberExpression: MemberExpression{
196 SuperProperty: true,
197 Expression: &Expression{
198 Expressions: []AssignmentExpression{
199 {
200 ConditionalExpression: &litA,
201 Tokens: tk[2:3],
202 },
203 },
204 Tokens: tk[2:3],
205 },
206 Tokens: tk[:4],
207 },
208 Tokens: tk[:4],
209 },
210 Tokens: tk[:4],
211 }
212 }},
213 {`this.key.field.next`, func(t *test, tk Tokens) { // 14
214 t.Output = LeftHandSideExpression{
215 NewExpression: &NewExpression{
216 MemberExpression: MemberExpression{
217 MemberExpression: &MemberExpression{
218 MemberExpression: &MemberExpression{
219 MemberExpression: &MemberExpression{
220 PrimaryExpression: &PrimaryExpression{
221 This: &tk[0],
222 Tokens: tk[:1],
223 },
224 Tokens: tk[:1],
225 },
226 IdentifierName: &tk[2],
227 Tokens: tk[:3],
228 },
229 IdentifierName: &tk[4],
230 Tokens: tk[:5],
231 },
232 IdentifierName: &tk[6],
233 Tokens: tk[:7],
234 },
235 Tokens: tk[:7],
236 },
237 Tokens: tk[:7],
238 }
239 }},
240 {`new.target`, func(t *test, tk Tokens) { // 15
241 t.Output = LeftHandSideExpression{
242 NewExpression: &NewExpression{
243 MemberExpression: MemberExpression{
244 NewTarget: true,
245 Tokens: tk[:3],
246 },
247 Tokens: tk[:3],
248 },
249 Tokens: tk[:3],
250 }
251 }},
252 {`new className()`, func(t *test, tk Tokens) { // 16
253 t.Output = LeftHandSideExpression{
254 NewExpression: &NewExpression{
255 MemberExpression: MemberExpression{
256 MemberExpression: &MemberExpression{
257 PrimaryExpression: &PrimaryExpression{
258 IdentifierReference: &tk[2],
259 Tokens: tk[2:3],
260 },
261 Tokens: tk[2:3],
262 },
263 Arguments: &Arguments{
264 Tokens: tk[3:5],
265 },
266 Tokens: tk[:5],
267 },
268 Tokens: tk[:5],
269 },
270 Tokens: tk[:5],
271 }
272 }},
273 {`new new className()`, func(t *test, tk Tokens) { // 17
274 t.Output = LeftHandSideExpression{
275 NewExpression: &NewExpression{
276 News: 1,
277 MemberExpression: MemberExpression{
278 MemberExpression: &MemberExpression{
279 PrimaryExpression: &PrimaryExpression{
280 IdentifierReference: &tk[4],
281 Tokens: tk[4:5],
282 },
283 Tokens: tk[4:5],
284 },
285 Arguments: &Arguments{
286 Tokens: tk[5:7],
287 },
288 Tokens: tk[2:7],
289 },
290 Tokens: tk[:7],
291 },
292 Tokens: tk[:7],
293 }
294 }},
295 {`new new className()()`, func(t *test, tk Tokens) { // 18
296 t.Output = LeftHandSideExpression{
297 NewExpression: &NewExpression{
298 MemberExpression: MemberExpression{
299 MemberExpression: &MemberExpression{
300 MemberExpression: &MemberExpression{
301 PrimaryExpression: &PrimaryExpression{
302 IdentifierReference: &tk[4],
303 Tokens: tk[4:5],
304 },
305 Tokens: tk[4:5],
306 },
307 Arguments: &Arguments{
308 Tokens: tk[5:7],
309 },
310 Tokens: tk[2:7],
311 },
312 Arguments: &Arguments{
313 Tokens: tk[7:9],
314 },
315 Tokens: tk[:9],
316 },
317 Tokens: tk[:9],
318 },
319 Tokens: tk[:9],
320 }
321 }},
322 {`call()`, func(t *test, tk Tokens) { // 19
323 t.Output = LeftHandSideExpression{
324 CallExpression: &CallExpression{
325 MemberExpression: &MemberExpression{
326 PrimaryExpression: &PrimaryExpression{
327 IdentifierReference: &tk[0],
328 Tokens: tk[:1],
329 },
330 Tokens: tk[:1],
331 },
332 Arguments: &Arguments{
333 Tokens: tk[1:3],
334 },
335 Tokens: tk[:3],
336 },
337 Tokens: tk[:3],
338 }
339 }},
340 {"a\n?.\nb\n.\nc\n?.\nd", func(t *test, tk Tokens) { // 20
341 t.Output = LeftHandSideExpression{
342 OptionalExpression: &OptionalExpression{
343 OptionalExpression: &OptionalExpression{
344 MemberExpression: &MemberExpression{
345 PrimaryExpression: &PrimaryExpression{
346 IdentifierReference: &tk[0],
347 Tokens: tk[:1],
348 },
349 Tokens: tk[:1],
350 },
351 OptionalChain: OptionalChain{
352 OptionalChain: &OptionalChain{
353 IdentifierName: &tk[4],
354 Tokens: tk[2:5],
355 },
356 IdentifierName: &tk[8],
357 Tokens: tk[2:9],
358 },
359 Tokens: tk[:9],
360 },
361 OptionalChain: OptionalChain{
362 IdentifierName: &tk[12],
363 Tokens: tk[10:13],
364 },
365 Tokens: tk[:13],
366 },
367 Tokens: tk[:13],
368 }
369 }},
370 {"a\n()\n?.\nb\n.\nc\n?.\nd", func(t *test, tk Tokens) { // 21
371 t.Output = LeftHandSideExpression{
372 OptionalExpression: &OptionalExpression{
373 OptionalExpression: &OptionalExpression{
374 CallExpression: &CallExpression{
375 MemberExpression: &MemberExpression{
376 PrimaryExpression: &PrimaryExpression{
377 IdentifierReference: &tk[0],
378 Tokens: tk[:1],
379 },
380 Tokens: tk[:1],
381 },
382 Arguments: &Arguments{
383 Tokens: tk[2:4],
384 },
385 Tokens: tk[:4],
386 },
387 OptionalChain: OptionalChain{
388 OptionalChain: &OptionalChain{
389 IdentifierName: &tk[7],
390 Tokens: tk[5:8],
391 },
392 IdentifierName: &tk[11],
393 Tokens: tk[5:12],
394 },
395 Tokens: tk[:12],
396 },
397 OptionalChain: OptionalChain{
398 IdentifierName: &tk[15],
399 Tokens: tk[13:16],
400 },
401 Tokens: tk[:16],
402 },
403 Tokens: tk[:16],
404 }
405 }},
406 {"a()?.", func(t *test, tk Tokens) { // 22
407 t.Err = Error{
408 Err: Error{
409 Err: Error{
410 Err: ErrInvalidOptionalChain,
411 Parsing: "OptionalChain",
412 Token: tk[4],
413 },
414 Parsing: "OptionalExpression",
415 Token: tk[3],
416 },
417 Parsing: "LeftHandSideExpression",
418 Token: tk[3],
419 }
420 }},
421 {"a?.", func(t *test, tk Tokens) { // 22
422 t.Err = Error{
423 Err: Error{
424 Err: Error{
425 Err: ErrInvalidOptionalChain,
426 Parsing: "OptionalChain",
427 Token: tk[2],
428 },
429 Parsing: "OptionalExpression",
430 Token: tk[1],
431 },
432 Parsing: "LeftHandSideExpression",
433 Token: tk[1],
434 }
435 }},
436 }, func(t *test) (Type, error) {
437 var lhs LeftHandSideExpression
438 err := lhs.parse(&t.Tokens, t.Yield, t.Await)
439 return lhs, err
440 })
441 }
442
443 func TestAssignmentExpressionOld(t *testing.T) {
444 doTests(t, []sourceFn{
445 {`yield 1`, func(t *test, tk Tokens) {}}, // 1
446 {`yield 1`, func(t *test, tk Tokens) { // 2
447 t.Yield = true
448 litA := makeConditionLiteral(tk, 2)
449 t.Output = AssignmentExpression{
450 Yield: true,
451 AssignmentExpression: &AssignmentExpression{
452 ConditionalExpression: &litA,
453 Tokens: tk[2:3],
454 },
455 Tokens: tk[:3],
456 }
457 }},
458 {`yield *1`, func(t *test, tk Tokens) { // 3
459 t.Yield = true
460 litA := makeConditionLiteral(tk, 3)
461 t.Output = AssignmentExpression{
462 Yield: true,
463 Delegate: true,
464 AssignmentExpression: &AssignmentExpression{
465 ConditionalExpression: &litA,
466 Tokens: tk[3:4],
467 },
468 Tokens: tk[:4],
469 }
470 }},
471 {`a => {}`, func(t *test, tk Tokens) { // 4
472 t.Output = AssignmentExpression{
473 ArrowFunction: &ArrowFunction{
474 BindingIdentifier: &tk[0],
475 FunctionBody: &Block{
476 Tokens: tk[4:6],
477 },
478 Tokens: tk[:6],
479 },
480 Tokens: tk[:6],
481 }
482 }},
483 {`a => 1`, func(t *test, tk Tokens) { // 5
484 litA := makeConditionLiteral(tk, 4)
485 t.Output = AssignmentExpression{
486 ArrowFunction: &ArrowFunction{
487 BindingIdentifier: &tk[0],
488 AssignmentExpression: &AssignmentExpression{
489 ConditionalExpression: &litA,
490 Tokens: tk[4:5],
491 },
492 Tokens: tk[:5],
493 },
494 Tokens: tk[:5],
495 }
496 }},
497 {`async a => 1`, func(t *test, tk Tokens) { // 6
498 litA := makeConditionLiteral(tk, 6)
499 t.Output = AssignmentExpression{
500 ArrowFunction: &ArrowFunction{
501 Async: true,
502 BindingIdentifier: &tk[2],
503 AssignmentExpression: &AssignmentExpression{
504 ConditionalExpression: &litA,
505 Tokens: tk[6:7],
506 },
507 Tokens: tk[:7],
508 },
509 Tokens: tk[:7],
510 }
511 }},
512 {`() => {}`, func(t *test, tk Tokens) { // 7
513 t.Output = AssignmentExpression{
514 ArrowFunction: &ArrowFunction{
515 FormalParameters: &FormalParameters{
516 Tokens: tk[:2],
517 },
518 FunctionBody: &Block{
519 Tokens: tk[5:7],
520 },
521 Tokens: tk[:7],
522 },
523 Tokens: tk[:7],
524 }
525 }},
526 {`(a) => b`, func(t *test, tk Tokens) { // 8
527 litB := makeConditionLiteral(tk, 6)
528 t.Output = AssignmentExpression{
529 ArrowFunction: &ArrowFunction{
530 FormalParameters: &FormalParameters{
531 FormalParameterList: []BindingElement{
532 {
533 SingleNameBinding: &tk[1],
534 Tokens: tk[1:2],
535 },
536 },
537 Tokens: tk[:3],
538 },
539 AssignmentExpression: &AssignmentExpression{
540 ConditionalExpression: &litB,
541 Tokens: tk[6:7],
542 },
543 Tokens: tk[:7],
544 },
545 Tokens: tk[:7],
546 }
547 }},
548 {`(a, b) => c`, func(t *test, tk Tokens) { // 9
549 litC := makeConditionLiteral(tk, 9)
550 t.Output = AssignmentExpression{
551 ArrowFunction: &ArrowFunction{
552 FormalParameters: &FormalParameters{
553 FormalParameterList: []BindingElement{
554 {
555 SingleNameBinding: &tk[1],
556 Tokens: tk[1:2],
557 },
558 {
559 SingleNameBinding: &tk[4],
560 Tokens: tk[4:5],
561 },
562 },
563 Tokens: tk[:6],
564 },
565 AssignmentExpression: &AssignmentExpression{
566 ConditionalExpression: &litC,
567 Tokens: tk[9:10],
568 },
569 Tokens: tk[:10],
570 },
571 Tokens: tk[:10],
572 }
573 }},
574 {`(a, b, c) => d`, func(t *test, tk Tokens) { // 10
575 litD := makeConditionLiteral(tk, 12)
576 t.Output = AssignmentExpression{
577 ArrowFunction: &ArrowFunction{
578 FormalParameters: &FormalParameters{
579 FormalParameterList: []BindingElement{
580 {
581 SingleNameBinding: &tk[1],
582 Tokens: tk[1:2],
583 },
584 {
585 SingleNameBinding: &tk[4],
586 Tokens: tk[4:5],
587 },
588 {
589 SingleNameBinding: &tk[7],
590 Tokens: tk[7:8],
591 },
592 },
593 Tokens: tk[:9],
594 },
595 AssignmentExpression: &AssignmentExpression{
596 ConditionalExpression: &litD,
597 Tokens: tk[12:13],
598 },
599 Tokens: tk[:13],
600 },
601 Tokens: tk[:13],
602 }
603 }},
604 {`(a, ...b) => c`, func(t *test, tk Tokens) { // 11
605 litC := makeConditionLiteral(tk, 10)
606 t.Output = AssignmentExpression{
607 ArrowFunction: &ArrowFunction{
608 FormalParameters: &FormalParameters{
609 FormalParameterList: []BindingElement{
610 {
611 SingleNameBinding: &tk[1],
612 Tokens: tk[1:2],
613 },
614 },
615 BindingIdentifier: &tk[5],
616 Tokens: tk[:7],
617 },
618 AssignmentExpression: &AssignmentExpression{
619 ConditionalExpression: &litC,
620 Tokens: tk[10:11],
621 },
622 Tokens: tk[:11],
623 },
624 Tokens: tk[:11],
625 }
626 }},
627 {`(a, ...[b]) => c`, func(t *test, tk Tokens) { // 12
628 litC := makeConditionLiteral(tk, 12)
629 t.Output = AssignmentExpression{
630 ArrowFunction: &ArrowFunction{
631 FormalParameters: &FormalParameters{
632 FormalParameterList: []BindingElement{
633 {
634 SingleNameBinding: &tk[1],
635 Tokens: tk[1:2],
636 },
637 },
638 ArrayBindingPattern: &ArrayBindingPattern{
639 BindingElementList: []BindingElement{
640 {
641 SingleNameBinding: &tk[6],
642 Tokens: tk[6:7],
643 },
644 },
645 Tokens: tk[5:8],
646 },
647 Tokens: tk[:9],
648 },
649 AssignmentExpression: &AssignmentExpression{
650 ConditionalExpression: &litC,
651 Tokens: tk[12:13],
652 },
653 Tokens: tk[:13],
654 },
655 Tokens: tk[:13],
656 }
657 }},
658 {`(a, ...{b}) => c`, func(t *test, tk Tokens) { // 13
659 litC := makeConditionLiteral(tk, 12)
660 t.Output = AssignmentExpression{
661 ArrowFunction: &ArrowFunction{
662 FormalParameters: &FormalParameters{
663 FormalParameterList: []BindingElement{
664 {
665 SingleNameBinding: &tk[1],
666 Tokens: tk[1:2],
667 },
668 },
669 ObjectBindingPattern: &ObjectBindingPattern{
670 BindingPropertyList: []BindingProperty{
671 {
672 PropertyName: PropertyName{
673 LiteralPropertyName: &tk[6],
674 Tokens: tk[6:7],
675 },
676 BindingElement: BindingElement{
677 SingleNameBinding: &tk[6],
678 Tokens: tk[6:7],
679 },
680 Tokens: tk[6:7],
681 },
682 },
683 Tokens: tk[5:8],
684 },
685 Tokens: tk[:9],
686 },
687 AssignmentExpression: &AssignmentExpression{
688 ConditionalExpression: &litC,
689 Tokens: tk[12:13],
690 },
691 Tokens: tk[:13],
692 },
693 Tokens: tk[:13],
694 }
695 }},
696 {`a = 1`, func(t *test, tk Tokens) { // 14
697 litA := makeConditionLiteral(tk, 4)
698 t.Output = AssignmentExpression{
699 LeftHandSideExpression: &LeftHandSideExpression{
700 NewExpression: &NewExpression{
701 MemberExpression: MemberExpression{
702 PrimaryExpression: &PrimaryExpression{
703 IdentifierReference: &tk[0],
704 Tokens: tk[:1],
705 },
706 Tokens: tk[:1],
707 },
708 Tokens: tk[:1],
709 },
710 Tokens: tk[:1],
711 },
712 AssignmentOperator: AssignmentAssign,
713 AssignmentExpression: &AssignmentExpression{
714 ConditionalExpression: &litA,
715 Tokens: tk[4:5],
716 },
717 Tokens: tk[:5],
718 }
719 }},
720 {`a *= 1`, func(t *test, tk Tokens) { // 15
721 litA := makeConditionLiteral(tk, 4)
722 t.Output = AssignmentExpression{
723 LeftHandSideExpression: &LeftHandSideExpression{
724 NewExpression: &NewExpression{
725 MemberExpression: MemberExpression{
726 PrimaryExpression: &PrimaryExpression{
727 IdentifierReference: &tk[0],
728 Tokens: tk[:1],
729 },
730 Tokens: tk[:1],
731 },
732 Tokens: tk[:1],
733 },
734 Tokens: tk[:1],
735 },
736 AssignmentOperator: AssignmentMultiply,
737 AssignmentExpression: &AssignmentExpression{
738 ConditionalExpression: &litA,
739 Tokens: tk[4:5],
740 },
741 Tokens: tk[:5],
742 }
743 }},
744 {`a /= 1`, func(t *test, tk Tokens) { // 16
745 litA := makeConditionLiteral(tk, 4)
746 t.Output = AssignmentExpression{
747 LeftHandSideExpression: &LeftHandSideExpression{
748 NewExpression: &NewExpression{
749 MemberExpression: MemberExpression{
750 PrimaryExpression: &PrimaryExpression{
751 IdentifierReference: &tk[0],
752 Tokens: tk[:1],
753 },
754 Tokens: tk[:1],
755 },
756 Tokens: tk[:1],
757 },
758 Tokens: tk[:1],
759 },
760 AssignmentOperator: AssignmentDivide,
761 AssignmentExpression: &AssignmentExpression{
762 ConditionalExpression: &litA,
763 Tokens: tk[4:5],
764 },
765 Tokens: tk[:5],
766 }
767 }},
768 {`a %= 1`, func(t *test, tk Tokens) { // 17
769 litA := makeConditionLiteral(tk, 4)
770 t.Output = AssignmentExpression{
771 LeftHandSideExpression: &LeftHandSideExpression{
772 NewExpression: &NewExpression{
773 MemberExpression: MemberExpression{
774 PrimaryExpression: &PrimaryExpression{
775 IdentifierReference: &tk[0],
776 Tokens: tk[:1],
777 },
778 Tokens: tk[:1],
779 },
780 Tokens: tk[:1],
781 },
782 Tokens: tk[:1],
783 },
784 AssignmentOperator: AssignmentRemainder,
785 AssignmentExpression: &AssignmentExpression{
786 ConditionalExpression: &litA,
787 Tokens: tk[4:5],
788 },
789 Tokens: tk[:5],
790 }
791 }},
792 {`a += 1`, func(t *test, tk Tokens) { // 18
793 litA := makeConditionLiteral(tk, 4)
794 t.Output = AssignmentExpression{
795 LeftHandSideExpression: &LeftHandSideExpression{
796 NewExpression: &NewExpression{
797 MemberExpression: MemberExpression{
798 PrimaryExpression: &PrimaryExpression{
799 IdentifierReference: &tk[0],
800 Tokens: tk[:1],
801 },
802 Tokens: tk[:1],
803 },
804 Tokens: tk[:1],
805 },
806 Tokens: tk[:1],
807 },
808 AssignmentOperator: AssignmentAdd,
809 AssignmentExpression: &AssignmentExpression{
810 ConditionalExpression: &litA,
811 Tokens: tk[4:5],
812 },
813 Tokens: tk[:5],
814 }
815 }},
816 {`a -= 1`, func(t *test, tk Tokens) { // 19
817 litA := makeConditionLiteral(tk, 4)
818 t.Output = AssignmentExpression{
819 LeftHandSideExpression: &LeftHandSideExpression{
820 NewExpression: &NewExpression{
821 MemberExpression: MemberExpression{
822 PrimaryExpression: &PrimaryExpression{
823 IdentifierReference: &tk[0],
824 Tokens: tk[:1],
825 },
826 Tokens: tk[:1],
827 },
828 Tokens: tk[:1],
829 },
830 Tokens: tk[:1],
831 },
832 AssignmentOperator: AssignmentSubtract,
833 AssignmentExpression: &AssignmentExpression{
834 ConditionalExpression: &litA,
835 Tokens: tk[4:5],
836 },
837 Tokens: tk[:5],
838 }
839 }},
840 {`a <<= 1`, func(t *test, tk Tokens) { // 20
841 litA := makeConditionLiteral(tk, 4)
842 t.Output = AssignmentExpression{
843 LeftHandSideExpression: &LeftHandSideExpression{
844 NewExpression: &NewExpression{
845 MemberExpression: MemberExpression{
846 PrimaryExpression: &PrimaryExpression{
847 IdentifierReference: &tk[0],
848 Tokens: tk[:1],
849 },
850 Tokens: tk[:1],
851 },
852 Tokens: tk[:1],
853 },
854 Tokens: tk[:1],
855 },
856 AssignmentOperator: AssignmentLeftShift,
857 AssignmentExpression: &AssignmentExpression{
858 ConditionalExpression: &litA,
859 Tokens: tk[4:5],
860 },
861 Tokens: tk[:5],
862 }
863 }},
864 {`a >>= 1`, func(t *test, tk Tokens) { // 21
865 litA := makeConditionLiteral(tk, 6)
866 t.Output = AssignmentExpression{
867 LeftHandSideExpression: &LeftHandSideExpression{
868 NewExpression: &NewExpression{
869 MemberExpression: MemberExpression{
870 PrimaryExpression: &PrimaryExpression{
871 IdentifierReference: &tk[0],
872 Tokens: tk[:1],
873 },
874 Tokens: tk[:1],
875 },
876 Tokens: tk[:1],
877 },
878 Tokens: tk[:1],
879 },
880 AssignmentOperator: AssignmentSignPropagatingRightShift,
881 AssignmentExpression: &AssignmentExpression{
882 ConditionalExpression: &litA,
883 Tokens: tk[6:7],
884 },
885 Tokens: tk[:7],
886 }
887 }},
888 {`a >>>= 1`, func(t *test, tk Tokens) { // 22
889 litA := makeConditionLiteral(tk, 7)
890 t.Output = AssignmentExpression{
891 LeftHandSideExpression: &LeftHandSideExpression{
892 NewExpression: &NewExpression{
893 MemberExpression: MemberExpression{
894 PrimaryExpression: &PrimaryExpression{
895 IdentifierReference: &tk[0],
896 Tokens: tk[:1],
897 },
898 Tokens: tk[:1],
899 },
900 Tokens: tk[:1],
901 },
902 Tokens: tk[:1],
903 },
904 AssignmentOperator: AssignmentZeroFillRightShift,
905 AssignmentExpression: &AssignmentExpression{
906 ConditionalExpression: &litA,
907 Tokens: tk[7:8],
908 },
909 Tokens: tk[:8],
910 }
911 }},
912 {`a &= 1`, func(t *test, tk Tokens) { // 23
913 litA := makeConditionLiteral(tk, 4)
914 t.Output = AssignmentExpression{
915 LeftHandSideExpression: &LeftHandSideExpression{
916 NewExpression: &NewExpression{
917 MemberExpression: MemberExpression{
918 PrimaryExpression: &PrimaryExpression{
919 IdentifierReference: &tk[0],
920 Tokens: tk[:1],
921 },
922 Tokens: tk[:1],
923 },
924 Tokens: tk[:1],
925 },
926 Tokens: tk[:1],
927 },
928 AssignmentOperator: AssignmentBitwiseAND,
929 AssignmentExpression: &AssignmentExpression{
930 ConditionalExpression: &litA,
931 Tokens: tk[4:5],
932 },
933 Tokens: tk[:5],
934 }
935 }},
936 {`a ^= 1`, func(t *test, tk Tokens) { // 24
937 litA := makeConditionLiteral(tk, 4)
938 t.Output = AssignmentExpression{
939 LeftHandSideExpression: &LeftHandSideExpression{
940 NewExpression: &NewExpression{
941 MemberExpression: MemberExpression{
942 PrimaryExpression: &PrimaryExpression{
943 IdentifierReference: &tk[0],
944 Tokens: tk[:1],
945 },
946 Tokens: tk[:1],
947 },
948 Tokens: tk[:1],
949 },
950 Tokens: tk[:1],
951 },
952 AssignmentOperator: AssignmentBitwiseXOR,
953 AssignmentExpression: &AssignmentExpression{
954 ConditionalExpression: &litA,
955 Tokens: tk[4:5],
956 },
957 Tokens: tk[:5],
958 }
959 }},
960 {`a |= 1`, func(t *test, tk Tokens) { // 25
961 litA := makeConditionLiteral(tk, 4)
962 t.Output = AssignmentExpression{
963 LeftHandSideExpression: &LeftHandSideExpression{
964 NewExpression: &NewExpression{
965 MemberExpression: MemberExpression{
966 PrimaryExpression: &PrimaryExpression{
967 IdentifierReference: &tk[0],
968 Tokens: tk[:1],
969 },
970 Tokens: tk[:1],
971 },
972 Tokens: tk[:1],
973 },
974 Tokens: tk[:1],
975 },
976 AssignmentOperator: AssignmentBitwiseOR,
977 AssignmentExpression: &AssignmentExpression{
978 ConditionalExpression: &litA,
979 Tokens: tk[4:5],
980 },
981 Tokens: tk[:5],
982 }
983 }},
984 {`a **= 1`, func(t *test, tk Tokens) { // 26
985 litA := makeConditionLiteral(tk, 4)
986 t.Output = AssignmentExpression{
987 LeftHandSideExpression: &LeftHandSideExpression{
988 NewExpression: &NewExpression{
989 MemberExpression: MemberExpression{
990 PrimaryExpression: &PrimaryExpression{
991 IdentifierReference: &tk[0],
992 Tokens: tk[:1],
993 },
994 Tokens: tk[:1],
995 },
996 Tokens: tk[:1],
997 },
998 Tokens: tk[:1],
999 },
1000 AssignmentOperator: AssignmentExponentiation,
1001 AssignmentExpression: &AssignmentExpression{
1002 ConditionalExpression: &litA,
1003 Tokens: tk[4:5],
1004 },
1005 Tokens: tk[:5],
1006 }
1007 }},
1008 {`import(a)`, func(t *test, tk Tokens) { // 27
1009 litA := makeConditionLiteral(tk, 2)
1010 call := wrapConditional(UpdateExpression{
1011 LeftHandSideExpression: &LeftHandSideExpression{
1012 CallExpression: &CallExpression{
1013 ImportCall: &AssignmentExpression{
1014 ConditionalExpression: &litA,
1015 Tokens: tk[2:3],
1016 },
1017 Tokens: tk[0:4],
1018 },
1019 Tokens: tk[0:4],
1020 },
1021 Tokens: tk[0:4],
1022 })
1023 t.Output = AssignmentExpression{
1024 ConditionalExpression: &call,
1025 Tokens: tk[0:4],
1026 }
1027 }},
1028 }, func(t *test) (Type, error) {
1029 var ae AssignmentExpression
1030 err := ae.parse(&t.Tokens, t.In, t.Yield, t.Await)
1031 return ae, err
1032 })
1033 }
1034
1035 func TestAssignmentExpression(t *testing.T) {
1036 doTests(t, []sourceFn{
1037 {``, func(t *test, tk Tokens) { // 1
1038 t.Err = assignmentError(tk[0])
1039 }},
1040 {"yield", func(t *test, tk Tokens) { // 2
1041 litYield := makeConditionLiteral(tk, 0)
1042 t.Output = AssignmentExpression{
1043 ConditionalExpression: &litYield,
1044 Tokens: tk[:1],
1045 }
1046 }},
1047 {"yield", func(t *test, tk Tokens) { // 3
1048 t.Yield = true
1049 t.Err = Error{
1050 Err: assignmentError(tk[1]),
1051 Parsing: "AssignmentExpression",
1052 Token: tk[1],
1053 }
1054 }},
1055 {"yield ,", func(t *test, tk Tokens) { // 4
1056 t.Yield = true
1057 t.Err = Error{
1058 Err: assignmentError(tk[2]),
1059 Parsing: "AssignmentExpression",
1060 Token: tk[2],
1061 }
1062 }},
1063 {"yield 1", func(t *test, tk Tokens) { // 5
1064 lit1 := makeConditionLiteral(tk, 2)
1065 t.Yield = true
1066 t.Output = AssignmentExpression{
1067 Yield: true,
1068 AssignmentExpression: &AssignmentExpression{
1069 ConditionalExpression: &lit1,
1070 Tokens: tk[2:3],
1071 },
1072 Tokens: tk[:3],
1073 }
1074 }},
1075 {"yield *\n", func(t *test, tk Tokens) { // 6
1076 t.Yield = true
1077 t.Err = Error{
1078 Err: assignmentError(tk[4]),
1079 Parsing: "AssignmentExpression",
1080 Token: tk[4],
1081 }
1082 }},
1083 {"yield *\n*", func(t *test, tk Tokens) { // 7
1084 t.Yield = true
1085 t.Err = Error{
1086 Err: assignmentError(tk[4]),
1087 Parsing: "AssignmentExpression",
1088 Token: tk[4],
1089 }
1090 }},
1091 {"yield *\n1", func(t *test, tk Tokens) { // 8
1092 lit1 := makeConditionLiteral(tk, 4)
1093 t.Yield = true
1094 t.Output = AssignmentExpression{
1095 Yield: true,
1096 Delegate: true,
1097 AssignmentExpression: &AssignmentExpression{
1098 ConditionalExpression: &lit1,
1099 Tokens: tk[4:5],
1100 },
1101 Tokens: tk[:5],
1102 }
1103 }},
1104 {"async", func(t *test, tk Tokens) { // 9
1105 t.Err = assignmentCustomError(tk[0], Error{
1106 Err: ErrInvalidFunction,
1107 Parsing: "FunctionDeclaration",
1108 Token: tk[1],
1109 })
1110 }},
1111 {"async a => {}", func(t *test, tk Tokens) { // 10
1112 t.Output = AssignmentExpression{
1113 ArrowFunction: &ArrowFunction{
1114 Async: true,
1115 BindingIdentifier: &tk[2],
1116 FunctionBody: &Block{
1117 Tokens: tk[6:8],
1118 },
1119 Tokens: tk[:8],
1120 },
1121 Tokens: tk[:8],
1122 }
1123 }},
1124 {"() => {}", func(t *test, tk Tokens) { // 11
1125 t.Output = AssignmentExpression{
1126 ArrowFunction: &ArrowFunction{
1127 FormalParameters: &FormalParameters{
1128 Tokens: tk[:2],
1129 },
1130 FunctionBody: &Block{
1131 Tokens: tk[5:7],
1132 },
1133 Tokens: tk[:7],
1134 },
1135 Tokens: tk[:7],
1136 }
1137 }},
1138 {"a => {}", func(t *test, tk Tokens) { // 12
1139 t.Output = AssignmentExpression{
1140 ArrowFunction: &ArrowFunction{
1141 BindingIdentifier: &tk[0],
1142 FunctionBody: &Block{
1143 Tokens: tk[4:6],
1144 },
1145 Tokens: tk[:6],
1146 },
1147 Tokens: tk[:6],
1148 }
1149 }},
1150 {"() => a", func(t *test, tk Tokens) { // 13
1151 litA := makeConditionLiteral(tk, 5)
1152 t.Output = AssignmentExpression{
1153 ArrowFunction: &ArrowFunction{
1154 FormalParameters: &FormalParameters{
1155 Tokens: tk[:2],
1156 },
1157 AssignmentExpression: &AssignmentExpression{
1158 ConditionalExpression: &litA,
1159 Tokens: tk[5:6],
1160 },
1161 Tokens: tk[:6],
1162 },
1163 Tokens: tk[:6],
1164 }
1165 }},
1166 {"a => b", func(t *test, tk Tokens) { // 14
1167 litB := makeConditionLiteral(tk, 4)
1168 t.Output = AssignmentExpression{
1169 ArrowFunction: &ArrowFunction{
1170 BindingIdentifier: &tk[0],
1171 AssignmentExpression: &AssignmentExpression{
1172 ConditionalExpression: &litB,
1173 Tokens: tk[4:5],
1174 },
1175 Tokens: tk[:5],
1176 },
1177 Tokens: tk[:5],
1178 }
1179 }},
1180 {"a =>", func(t *test, tk Tokens) { // 15
1181 t.Err = Error{
1182 Err: Error{
1183 Err: assignmentError(tk[3]),
1184 Parsing: "ArrowFunction",
1185 Token: tk[3],
1186 },
1187 Parsing: "AssignmentExpression",
1188 Token: tk[0],
1189 }
1190 }},
1191 {"1", func(t *test, tk Tokens) { // 16
1192 lit1 := makeConditionLiteral(tk, 0)
1193 t.Output = AssignmentExpression{
1194 ConditionalExpression: &lit1,
1195 Tokens: tk[:1],
1196 }
1197 }},
1198 {",", func(t *test, tk Tokens) { // 17
1199 t.Err = assignmentError(tk[0])
1200 }},
1201 {"a\n=", func(t *test, tk Tokens) { // 18
1202 t.Err = Error{
1203 Err: assignmentError(tk[3]),
1204 Parsing: "AssignmentExpression",
1205 Token: tk[3],
1206 }
1207 }},
1208 {"a\n=\n1", func(t *test, tk Tokens) { // 19
1209 lit1 := makeConditionLiteral(tk, 4)
1210 t.Output = AssignmentExpression{
1211 LeftHandSideExpression: &LeftHandSideExpression{
1212 NewExpression: &NewExpression{
1213 MemberExpression: MemberExpression{
1214 PrimaryExpression: &PrimaryExpression{
1215 IdentifierReference: &tk[0],
1216 Tokens: tk[:1],
1217 },
1218 Tokens: tk[:1],
1219 },
1220 Tokens: tk[:1],
1221 },
1222 Tokens: tk[:1],
1223 },
1224 AssignmentOperator: AssignmentAssign,
1225 AssignmentExpression: &AssignmentExpression{
1226 ConditionalExpression: &lit1,
1227 Tokens: tk[4:5],
1228 },
1229 Tokens: tk[:5],
1230 }
1231 }},
1232 {"[a] = 1", func(t *test, tk Tokens) { // 20
1233 lit1 := makeConditionLiteral(tk, 6)
1234 t.Output = AssignmentExpression{
1235 AssignmentPattern: &AssignmentPattern{
1236 ArrayAssignmentPattern: &ArrayAssignmentPattern{
1237 AssignmentElements: []AssignmentElement{
1238 {
1239 DestructuringAssignmentTarget: DestructuringAssignmentTarget{
1240 LeftHandSideExpression: &LeftHandSideExpression{
1241 NewExpression: &NewExpression{
1242 MemberExpression: MemberExpression{
1243 PrimaryExpression: &PrimaryExpression{
1244 IdentifierReference: &tk[1],
1245 Tokens: tk[1:2],
1246 },
1247 Tokens: tk[1:2],
1248 },
1249 Tokens: tk[1:2],
1250 },
1251 Tokens: tk[1:2],
1252 },
1253 Tokens: tk[1:2],
1254 },
1255 Tokens: tk[1:2],
1256 },
1257 },
1258 Tokens: tk[:3],
1259 },
1260 Tokens: tk[:3],
1261 },
1262 AssignmentOperator: AssignmentAssign,
1263 AssignmentExpression: &AssignmentExpression{
1264 ConditionalExpression: &lit1,
1265 Tokens: tk[6:7],
1266 },
1267 Tokens: tk[:7],
1268 }
1269 }},
1270 {"{a} = 1", func(t *test, tk Tokens) { // 21
1271 lit1 := makeConditionLiteral(tk, 6)
1272 t.Output = AssignmentExpression{
1273 AssignmentPattern: &AssignmentPattern{
1274 ObjectAssignmentPattern: &ObjectAssignmentPattern{
1275 AssignmentPropertyList: []AssignmentProperty{
1276 {
1277 PropertyName: PropertyName{
1278 LiteralPropertyName: &tk[1],
1279 Tokens: tk[1:2],
1280 },
1281 DestructuringAssignmentTarget: &DestructuringAssignmentTarget{
1282 LeftHandSideExpression: &LeftHandSideExpression{
1283 NewExpression: &NewExpression{
1284 MemberExpression: MemberExpression{
1285 PrimaryExpression: &PrimaryExpression{
1286 IdentifierReference: &tk[1],
1287 Tokens: tk[1:2],
1288 },
1289 Tokens: tk[1:2],
1290 },
1291 Tokens: tk[1:2],
1292 },
1293 Tokens: tk[1:2],
1294 },
1295 Tokens: tk[1:2],
1296 },
1297 Tokens: tk[1:2],
1298 },
1299 },
1300 Tokens: tk[:3],
1301 },
1302 Tokens: tk[:3],
1303 },
1304 AssignmentOperator: AssignmentAssign,
1305 AssignmentExpression: &AssignmentExpression{
1306 ConditionalExpression: &lit1,
1307 Tokens: tk[6:7],
1308 },
1309 Tokens: tk[:7],
1310 }
1311 }},
1312 {"a *= 1", func(t *test, tk Tokens) { // 22
1313 lit1 := makeConditionLiteral(tk, 4)
1314 t.Output = AssignmentExpression{
1315 LeftHandSideExpression: &LeftHandSideExpression{
1316 NewExpression: &NewExpression{
1317 MemberExpression: MemberExpression{
1318 PrimaryExpression: &PrimaryExpression{
1319 IdentifierReference: &tk[0],
1320 Tokens: tk[:1],
1321 },
1322 Tokens: tk[:1],
1323 },
1324 Tokens: tk[:1],
1325 },
1326 Tokens: tk[:1],
1327 },
1328 AssignmentOperator: AssignmentMultiply,
1329 AssignmentExpression: &AssignmentExpression{
1330 ConditionalExpression: &lit1,
1331 Tokens: tk[4:5],
1332 },
1333 Tokens: tk[:5],
1334 }
1335 }},
1336 {"a /= 1", func(t *test, tk Tokens) { // 23
1337 lit1 := makeConditionLiteral(tk, 4)
1338 t.Output = AssignmentExpression{
1339 LeftHandSideExpression: &LeftHandSideExpression{
1340 NewExpression: &NewExpression{
1341 MemberExpression: MemberExpression{
1342 PrimaryExpression: &PrimaryExpression{
1343 IdentifierReference: &tk[0],
1344 Tokens: tk[:1],
1345 },
1346 Tokens: tk[:1],
1347 },
1348 Tokens: tk[:1],
1349 },
1350 Tokens: tk[:1],
1351 },
1352 AssignmentOperator: AssignmentDivide,
1353 AssignmentExpression: &AssignmentExpression{
1354 ConditionalExpression: &lit1,
1355 Tokens: tk[4:5],
1356 },
1357 Tokens: tk[:5],
1358 }
1359 }},
1360 {"a %= 1", func(t *test, tk Tokens) { // 24
1361 lit1 := makeConditionLiteral(tk, 4)
1362 t.Output = AssignmentExpression{
1363 LeftHandSideExpression: &LeftHandSideExpression{
1364 NewExpression: &NewExpression{
1365 MemberExpression: MemberExpression{
1366 PrimaryExpression: &PrimaryExpression{
1367 IdentifierReference: &tk[0],
1368 Tokens: tk[:1],
1369 },
1370 Tokens: tk[:1],
1371 },
1372 Tokens: tk[:1],
1373 },
1374 Tokens: tk[:1],
1375 },
1376 AssignmentOperator: AssignmentRemainder,
1377 AssignmentExpression: &AssignmentExpression{
1378 ConditionalExpression: &lit1,
1379 Tokens: tk[4:5],
1380 },
1381 Tokens: tk[:5],
1382 }
1383 }},
1384 {"a += 1", func(t *test, tk Tokens) { // 25
1385 lit1 := makeConditionLiteral(tk, 4)
1386 t.Output = AssignmentExpression{
1387 LeftHandSideExpression: &LeftHandSideExpression{
1388 NewExpression: &NewExpression{
1389 MemberExpression: MemberExpression{
1390 PrimaryExpression: &PrimaryExpression{
1391 IdentifierReference: &tk[0],
1392 Tokens: tk[:1],
1393 },
1394 Tokens: tk[:1],
1395 },
1396 Tokens: tk[:1],
1397 },
1398 Tokens: tk[:1],
1399 },
1400 AssignmentOperator: AssignmentAdd,
1401 AssignmentExpression: &AssignmentExpression{
1402 ConditionalExpression: &lit1,
1403 Tokens: tk[4:5],
1404 },
1405 Tokens: tk[:5],
1406 }
1407 }},
1408 {"a -= 1", func(t *test, tk Tokens) { // 26
1409 lit1 := makeConditionLiteral(tk, 4)
1410 t.Output = AssignmentExpression{
1411 LeftHandSideExpression: &LeftHandSideExpression{
1412 NewExpression: &NewExpression{
1413 MemberExpression: MemberExpression{
1414 PrimaryExpression: &PrimaryExpression{
1415 IdentifierReference: &tk[0],
1416 Tokens: tk[:1],
1417 },
1418 Tokens: tk[:1],
1419 },
1420 Tokens: tk[:1],
1421 },
1422 Tokens: tk[:1],
1423 },
1424 AssignmentOperator: AssignmentSubtract,
1425 AssignmentExpression: &AssignmentExpression{
1426 ConditionalExpression: &lit1,
1427 Tokens: tk[4:5],
1428 },
1429 Tokens: tk[:5],
1430 }
1431 }},
1432 {"a <<= 1", func(t *test, tk Tokens) { // 27
1433 lit1 := makeConditionLiteral(tk, 4)
1434 t.Output = AssignmentExpression{
1435 LeftHandSideExpression: &LeftHandSideExpression{
1436 NewExpression: &NewExpression{
1437 MemberExpression: MemberExpression{
1438 PrimaryExpression: &PrimaryExpression{
1439 IdentifierReference: &tk[0],
1440 Tokens: tk[:1],
1441 },
1442 Tokens: tk[:1],
1443 },
1444 Tokens: tk[:1],
1445 },
1446 Tokens: tk[:1],
1447 },
1448 AssignmentOperator: AssignmentLeftShift,
1449 AssignmentExpression: &AssignmentExpression{
1450 ConditionalExpression: &lit1,
1451 Tokens: tk[4:5],
1452 },
1453 Tokens: tk[:5],
1454 }
1455 }},
1456 {"a >>= 1", func(t *test, tk Tokens) { // 28
1457 lit1 := makeConditionLiteral(tk, 6)
1458 t.Output = AssignmentExpression{
1459 LeftHandSideExpression: &LeftHandSideExpression{
1460 NewExpression: &NewExpression{
1461 MemberExpression: MemberExpression{
1462 PrimaryExpression: &PrimaryExpression{
1463 IdentifierReference: &tk[0],
1464 Tokens: tk[:1],
1465 },
1466 Tokens: tk[:1],
1467 },
1468 Tokens: tk[:1],
1469 },
1470 Tokens: tk[:1],
1471 },
1472 AssignmentOperator: AssignmentSignPropagatingRightShift,
1473 AssignmentExpression: &AssignmentExpression{
1474 ConditionalExpression: &lit1,
1475 Tokens: tk[6:7],
1476 },
1477 Tokens: tk[:7],
1478 }
1479 }},
1480 {"a >>>= 1", func(t *test, tk Tokens) { // 29
1481 lit1 := makeConditionLiteral(tk, 7)
1482 t.Output = AssignmentExpression{
1483 LeftHandSideExpression: &LeftHandSideExpression{
1484 NewExpression: &NewExpression{
1485 MemberExpression: MemberExpression{
1486 PrimaryExpression: &PrimaryExpression{
1487 IdentifierReference: &tk[0],
1488 Tokens: tk[:1],
1489 },
1490 Tokens: tk[:1],
1491 },
1492 Tokens: tk[:1],
1493 },
1494 Tokens: tk[:1],
1495 },
1496 AssignmentOperator: AssignmentZeroFillRightShift,
1497 AssignmentExpression: &AssignmentExpression{
1498 ConditionalExpression: &lit1,
1499 Tokens: tk[7:8],
1500 },
1501 Tokens: tk[:8],
1502 }
1503 }},
1504 {"a &= 1", func(t *test, tk Tokens) { // 30
1505 lit1 := makeConditionLiteral(tk, 4)
1506 t.Output = AssignmentExpression{
1507 LeftHandSideExpression: &LeftHandSideExpression{
1508 NewExpression: &NewExpression{
1509 MemberExpression: MemberExpression{
1510 PrimaryExpression: &PrimaryExpression{
1511 IdentifierReference: &tk[0],
1512 Tokens: tk[:1],
1513 },
1514 Tokens: tk[:1],
1515 },
1516 Tokens: tk[:1],
1517 },
1518 Tokens: tk[:1],
1519 },
1520 AssignmentOperator: AssignmentBitwiseAND,
1521 AssignmentExpression: &AssignmentExpression{
1522 ConditionalExpression: &lit1,
1523 Tokens: tk[4:5],
1524 },
1525 Tokens: tk[:5],
1526 }
1527 }},
1528 {"a ^= 1", func(t *test, tk Tokens) { // 31
1529 lit1 := makeConditionLiteral(tk, 4)
1530 t.Output = AssignmentExpression{
1531 LeftHandSideExpression: &LeftHandSideExpression{
1532 NewExpression: &NewExpression{
1533 MemberExpression: MemberExpression{
1534 PrimaryExpression: &PrimaryExpression{
1535 IdentifierReference: &tk[0],
1536 Tokens: tk[:1],
1537 },
1538 Tokens: tk[:1],
1539 },
1540 Tokens: tk[:1],
1541 },
1542 Tokens: tk[:1],
1543 },
1544 AssignmentOperator: AssignmentBitwiseXOR,
1545 AssignmentExpression: &AssignmentExpression{
1546 ConditionalExpression: &lit1,
1547 Tokens: tk[4:5],
1548 },
1549 Tokens: tk[:5],
1550 }
1551 }},
1552 {"a |= 1", func(t *test, tk Tokens) { // 32
1553 lit1 := makeConditionLiteral(tk, 4)
1554 t.Output = AssignmentExpression{
1555 LeftHandSideExpression: &LeftHandSideExpression{
1556 NewExpression: &NewExpression{
1557 MemberExpression: MemberExpression{
1558 PrimaryExpression: &PrimaryExpression{
1559 IdentifierReference: &tk[0],
1560 Tokens: tk[:1],
1561 },
1562 Tokens: tk[:1],
1563 },
1564 Tokens: tk[:1],
1565 },
1566 Tokens: tk[:1],
1567 },
1568 AssignmentOperator: AssignmentBitwiseOR,
1569 AssignmentExpression: &AssignmentExpression{
1570 ConditionalExpression: &lit1,
1571 Tokens: tk[4:5],
1572 },
1573 Tokens: tk[:5],
1574 }
1575 }},
1576 {"a **= 1", func(t *test, tk Tokens) { // 33
1577 lit1 := makeConditionLiteral(tk, 4)
1578 t.Output = AssignmentExpression{
1579 LeftHandSideExpression: &LeftHandSideExpression{
1580 NewExpression: &NewExpression{
1581 MemberExpression: MemberExpression{
1582 PrimaryExpression: &PrimaryExpression{
1583 IdentifierReference: &tk[0],
1584 Tokens: tk[:1],
1585 },
1586 Tokens: tk[:1],
1587 },
1588 Tokens: tk[:1],
1589 },
1590 Tokens: tk[:1],
1591 },
1592 AssignmentOperator: AssignmentExponentiation,
1593 AssignmentExpression: &AssignmentExpression{
1594 ConditionalExpression: &lit1,
1595 Tokens: tk[4:5],
1596 },
1597 Tokens: tk[:5],
1598 }
1599 }},
1600 {"a &&= 1", func(t *test, tk Tokens) { // 34
1601 lit1 := makeConditionLiteral(tk, 4)
1602 t.Output = AssignmentExpression{
1603 LeftHandSideExpression: &LeftHandSideExpression{
1604 NewExpression: &NewExpression{
1605 MemberExpression: MemberExpression{
1606 PrimaryExpression: &PrimaryExpression{
1607 IdentifierReference: &tk[0],
1608 Tokens: tk[:1],
1609 },
1610 Tokens: tk[:1],
1611 },
1612 Tokens: tk[:1],
1613 },
1614 Tokens: tk[:1],
1615 },
1616 AssignmentOperator: AssignmentLogicalAnd,
1617 AssignmentExpression: &AssignmentExpression{
1618 ConditionalExpression: &lit1,
1619 Tokens: tk[4:5],
1620 },
1621 Tokens: tk[:5],
1622 }
1623 }},
1624 {"a ||= 1", func(t *test, tk Tokens) { // 35
1625 lit1 := makeConditionLiteral(tk, 4)
1626 t.Output = AssignmentExpression{
1627 LeftHandSideExpression: &LeftHandSideExpression{
1628 NewExpression: &NewExpression{
1629 MemberExpression: MemberExpression{
1630 PrimaryExpression: &PrimaryExpression{
1631 IdentifierReference: &tk[0],
1632 Tokens: tk[:1],
1633 },
1634 Tokens: tk[:1],
1635 },
1636 Tokens: tk[:1],
1637 },
1638 Tokens: tk[:1],
1639 },
1640 AssignmentOperator: AssignmentLogicalOr,
1641 AssignmentExpression: &AssignmentExpression{
1642 ConditionalExpression: &lit1,
1643 Tokens: tk[4:5],
1644 },
1645 Tokens: tk[:5],
1646 }
1647 }},
1648 {"a ??= 1", func(t *test, tk Tokens) { // 36
1649 lit1 := makeConditionLiteral(tk, 4)
1650 t.Output = AssignmentExpression{
1651 LeftHandSideExpression: &LeftHandSideExpression{
1652 NewExpression: &NewExpression{
1653 MemberExpression: MemberExpression{
1654 PrimaryExpression: &PrimaryExpression{
1655 IdentifierReference: &tk[0],
1656 Tokens: tk[:1],
1657 },
1658 Tokens: tk[:1],
1659 },
1660 Tokens: tk[:1],
1661 },
1662 Tokens: tk[:1],
1663 },
1664 AssignmentOperator: AssignmentNullish,
1665 AssignmentExpression: &AssignmentExpression{
1666 ConditionalExpression: &lit1,
1667 Tokens: tk[4:5],
1668 },
1669 Tokens: tk[:5],
1670 }
1671 }},
1672 {"[a, b] = [b, a]", func(t *test, tk Tokens) { // 37
1673 t.Output = AssignmentExpression{
1674 AssignmentPattern: &AssignmentPattern{
1675 ArrayAssignmentPattern: &ArrayAssignmentPattern{
1676 AssignmentElements: []AssignmentElement{
1677 {
1678 DestructuringAssignmentTarget: DestructuringAssignmentTarget{
1679 LeftHandSideExpression: &LeftHandSideExpression{
1680 NewExpression: &NewExpression{
1681 MemberExpression: MemberExpression{
1682 PrimaryExpression: &PrimaryExpression{
1683 IdentifierReference: &tk[1],
1684 Tokens: tk[1:2],
1685 },
1686 Tokens: tk[1:2],
1687 },
1688 Tokens: tk[1:2],
1689 },
1690 Tokens: tk[1:2],
1691 },
1692 Tokens: tk[1:2],
1693 },
1694 Tokens: tk[1:2],
1695 },
1696 {
1697 DestructuringAssignmentTarget: DestructuringAssignmentTarget{
1698 LeftHandSideExpression: &LeftHandSideExpression{
1699 NewExpression: &NewExpression{
1700 MemberExpression: MemberExpression{
1701 PrimaryExpression: &PrimaryExpression{
1702 IdentifierReference: &tk[4],
1703 Tokens: tk[4:5],
1704 },
1705 Tokens: tk[4:5],
1706 },
1707 Tokens: tk[4:5],
1708 },
1709 Tokens: tk[4:5],
1710 },
1711 Tokens: tk[4:5],
1712 },
1713 Tokens: tk[4:5],
1714 },
1715 },
1716 Tokens: tk[:6],
1717 },
1718 Tokens: tk[:6],
1719 },
1720 AssignmentOperator: AssignmentAssign,
1721 AssignmentExpression: &AssignmentExpression{
1722 ConditionalExpression: WrapConditional(&ArrayLiteral{
1723 ElementList: []ArrayElement{
1724 {
1725 AssignmentExpression: AssignmentExpression{
1726 ConditionalExpression: WrapConditional(&PrimaryExpression{
1727 IdentifierReference: &tk[10],
1728 Tokens: tk[10:11],
1729 }),
1730 Tokens: tk[10:11],
1731 },
1732 Tokens: tk[10:11],
1733 },
1734 {
1735 AssignmentExpression: AssignmentExpression{
1736 ConditionalExpression: WrapConditional(&PrimaryExpression{
1737 IdentifierReference: &tk[13],
1738 Tokens: tk[13:14],
1739 }),
1740 Tokens: tk[13:14],
1741 },
1742 Tokens: tk[13:14],
1743 },
1744 },
1745 Tokens: tk[9:15],
1746 }),
1747 Tokens: tk[9:15],
1748 },
1749 Tokens: tk[:15],
1750 }
1751 }},
1752 {"[a.b, a.c] = [a.c, a.b]", func(t *test, tk Tokens) { // 38
1753 t.Output = AssignmentExpression{
1754 AssignmentPattern: &AssignmentPattern{
1755 ArrayAssignmentPattern: &ArrayAssignmentPattern{
1756 AssignmentElements: []AssignmentElement{
1757 {
1758 DestructuringAssignmentTarget: DestructuringAssignmentTarget{
1759 LeftHandSideExpression: &LeftHandSideExpression{
1760 NewExpression: &NewExpression{
1761 MemberExpression: MemberExpression{
1762 MemberExpression: &MemberExpression{
1763 PrimaryExpression: &PrimaryExpression{
1764 IdentifierReference: &tk[1],
1765 Tokens: tk[1:2],
1766 },
1767 Tokens: tk[1:2],
1768 },
1769 IdentifierName: &tk[3],
1770 Tokens: tk[1:4],
1771 },
1772 Tokens: tk[1:4],
1773 },
1774 Tokens: tk[1:4],
1775 },
1776 Tokens: tk[1:4],
1777 },
1778 Tokens: tk[1:4],
1779 },
1780 {
1781 DestructuringAssignmentTarget: DestructuringAssignmentTarget{
1782 LeftHandSideExpression: &LeftHandSideExpression{
1783 NewExpression: &NewExpression{
1784 MemberExpression: MemberExpression{
1785 MemberExpression: &MemberExpression{
1786 PrimaryExpression: &PrimaryExpression{
1787 IdentifierReference: &tk[6],
1788 Tokens: tk[6:7],
1789 },
1790 Tokens: tk[6:7],
1791 },
1792 IdentifierName: &tk[8],
1793 Tokens: tk[6:9],
1794 },
1795 Tokens: tk[6:9],
1796 },
1797 Tokens: tk[6:9],
1798 },
1799 Tokens: tk[6:9],
1800 },
1801 Tokens: tk[6:9],
1802 },
1803 },
1804 Tokens: tk[:10],
1805 },
1806 Tokens: tk[:10],
1807 },
1808 AssignmentOperator: AssignmentAssign,
1809 AssignmentExpression: &AssignmentExpression{
1810 ConditionalExpression: WrapConditional(&ArrayLiteral{
1811 ElementList: []ArrayElement{
1812 {
1813 AssignmentExpression: AssignmentExpression{
1814 ConditionalExpression: WrapConditional(&MemberExpression{
1815 MemberExpression: &MemberExpression{
1816 PrimaryExpression: &PrimaryExpression{
1817 IdentifierReference: &tk[14],
1818 Tokens: tk[14:15],
1819 },
1820 Tokens: tk[14:15],
1821 },
1822 IdentifierName: &tk[16],
1823 Tokens: tk[14:17],
1824 }),
1825 Tokens: tk[14:17],
1826 },
1827 Tokens: tk[14:17],
1828 },
1829 {
1830 AssignmentExpression: AssignmentExpression{
1831 ConditionalExpression: WrapConditional(&MemberExpression{
1832 MemberExpression: &MemberExpression{
1833 PrimaryExpression: &PrimaryExpression{
1834 IdentifierReference: &tk[19],
1835 Tokens: tk[19:20],
1836 },
1837 Tokens: tk[19:20],
1838 },
1839 IdentifierName: &tk[21],
1840 Tokens: tk[19:22],
1841 }),
1842 Tokens: tk[19:22],
1843 },
1844 Tokens: tk[19:22],
1845 },
1846 },
1847 Tokens: tk[13:23],
1848 }),
1849 Tokens: tk[13:23],
1850 },
1851 Tokens: tk[:23],
1852 }
1853 }},
1854 {"async (1) => 1", func(t *test, tk Tokens) { // 39
1855 t.Err = Error{
1856 Err: Error{
1857 Err: Error{
1858 Err: Error{
1859 Err: ErrNoIdentifier,
1860 Parsing: "BindingElement",
1861 Token: tk[3],
1862 },
1863 Parsing: "FormalParameters",
1864 Token: tk[3],
1865 },
1866 Parsing: "ArrowFunction",
1867 Token: tk[2],
1868 },
1869 Parsing: "AssignmentExpression",
1870 Token: tk[0],
1871 }
1872 }},
1873 {"(...a)", func(t *test, tk Tokens) { // 40
1874 t.Err = Error{
1875 Err: ErrMissingArrow,
1876 Parsing: "AssignmentExpression",
1877 Token: tk[4],
1878 }
1879 }},
1880 {"[1] =", func(t *test, tk Tokens) { // 41
1881 t.Err = Error{
1882 Err: Error{
1883 Err: Error{
1884 Err: Error{
1885 Err: Error{
1886 Err: ErrInvalidDestructuringAssignmentTarget,
1887 Parsing: "DestructuringAssignmentTarget",
1888 Token: tk[1],
1889 },
1890 Parsing: "AssignmentElement",
1891 Token: tk[1],
1892 },
1893 Parsing: "ArrayAssignmentPattern",
1894 Token: tk[0],
1895 },
1896 Parsing: "AssignmentPattern",
1897 Token: tk[0],
1898 },
1899 Parsing: "AssignmentExpression",
1900 Token: tk[0],
1901 }
1902 }},
1903 {"{[\"a\"]: b} = c", func(t *test, tk Tokens) { // 42
1904 t.Err = Error{
1905 Err: Error{
1906 Err: Error{
1907 Err: Error{
1908 Err: Error{
1909 Err: ErrNotSimple,
1910 Parsing: "PropertyName",
1911 Token: tk[1],
1912 },
1913 Parsing: "AssignmentProperty",
1914 Token: tk[1],
1915 },
1916 Parsing: "ObjectAssignmentPattern",
1917 Token: tk[1],
1918 },
1919 Parsing: "AssignmentPattern",
1920 Token: tk[0],
1921 },
1922 Parsing: "AssignmentExpression",
1923 Token: tk[0],
1924 }
1925 }},
1926 {"{...a} = b", func(t *test, tk Tokens) { // 43
1927 t.Output = AssignmentExpression{
1928 AssignmentPattern: &AssignmentPattern{
1929 ObjectAssignmentPattern: &ObjectAssignmentPattern{
1930 AssignmentPropertyList: []AssignmentProperty{},
1931 AssignmentRestElement: &LeftHandSideExpression{
1932 NewExpression: &NewExpression{
1933 MemberExpression: MemberExpression{
1934 PrimaryExpression: &PrimaryExpression{
1935 IdentifierReference: &tk[2],
1936 Tokens: tk[2:3],
1937 },
1938 Tokens: tk[2:3],
1939 },
1940 Tokens: tk[2:3],
1941 },
1942 Tokens: tk[2:3],
1943 },
1944 Tokens: tk[:4],
1945 },
1946 Tokens: tk[:4],
1947 },
1948 AssignmentOperator: AssignmentAssign,
1949 AssignmentExpression: &AssignmentExpression{
1950 ConditionalExpression: WrapConditional(&PrimaryExpression{
1951 IdentifierReference: &tk[7],
1952 Tokens: tk[7:8],
1953 }),
1954 Tokens: tk[7:8],
1955 },
1956 Tokens: tk[:8],
1957 }
1958 }},
1959 {"{...{a}} = b", func(t *test, tk Tokens) { // 44
1960 t.Err = Error{
1961 Err: Error{
1962 Err: Error{
1963 Err: ErrBadRestElement,
1964 Parsing: "ObjectAssignmentPattern",
1965 Token: tk[2],
1966 },
1967 Parsing: "AssignmentPattern",
1968 Token: tk[0],
1969 },
1970 Parsing: "AssignmentExpression",
1971 Token: tk[0],
1972 }
1973 }},
1974 {"{...a=b} = c", func(t *test, tk Tokens) { // 45
1975 t.Err = Error{
1976 Err: Error{
1977 Err: Error{
1978 Err: ErrInvalidAssignment,
1979 Parsing: "ObjectAssignmentPattern",
1980 Token: tk[2],
1981 },
1982 Parsing: "AssignmentPattern",
1983 Token: tk[0],
1984 },
1985 Parsing: "AssignmentExpression",
1986 Token: tk[0],
1987 }
1988 }},
1989 {"{a=b} = c", func(t *test, tk Tokens) { // 46
1990 t.Output = AssignmentExpression{
1991 AssignmentPattern: &AssignmentPattern{
1992 ObjectAssignmentPattern: &ObjectAssignmentPattern{
1993 AssignmentPropertyList: []AssignmentProperty{
1994 {
1995 PropertyName: PropertyName{
1996 LiteralPropertyName: &tk[1],
1997 Tokens: tk[1:2],
1998 },
1999 Initializer: &AssignmentExpression{
2000 ConditionalExpression: WrapConditional(&PrimaryExpression{
2001 IdentifierReference: &tk[3],
2002 Tokens: tk[3:4],
2003 }),
2004 Tokens: tk[3:4],
2005 },
2006 Tokens: tk[1:4],
2007 },
2008 },
2009 Tokens: tk[:5],
2010 },
2011 Tokens: tk[:5],
2012 },
2013 AssignmentOperator: AssignmentAssign,
2014 AssignmentExpression: &AssignmentExpression{
2015 ConditionalExpression: WrapConditional(&PrimaryExpression{
2016 IdentifierReference: &tk[8],
2017 Tokens: tk[8:9],
2018 }),
2019 Tokens: tk[8:9],
2020 },
2021 Tokens: tk[:9],
2022 }
2023 }},
2024 {"{a: b = c} = d", func(t *test, tk Tokens) { // 47
2025 t.Output = AssignmentExpression{
2026 AssignmentPattern: &AssignmentPattern{
2027 ObjectAssignmentPattern: &ObjectAssignmentPattern{
2028 AssignmentPropertyList: []AssignmentProperty{
2029 {
2030 PropertyName: PropertyName{
2031 LiteralPropertyName: &tk[1],
2032 Tokens: tk[1:2],
2033 },
2034 DestructuringAssignmentTarget: &DestructuringAssignmentTarget{
2035 LeftHandSideExpression: &LeftHandSideExpression{
2036 NewExpression: &NewExpression{
2037 MemberExpression: MemberExpression{
2038 PrimaryExpression: &PrimaryExpression{
2039 IdentifierReference: &tk[4],
2040 Tokens: tk[4:5],
2041 },
2042 Tokens: tk[4:5],
2043 },
2044 Tokens: tk[4:5],
2045 },
2046 Tokens: tk[4:5],
2047 },
2048 Tokens: tk[4:5],
2049 },
2050 Initializer: &AssignmentExpression{
2051 ConditionalExpression: WrapConditional(&PrimaryExpression{
2052 IdentifierReference: &tk[8],
2053 Tokens: tk[8:9],
2054 }),
2055 Tokens: tk[8:9],
2056 },
2057 Tokens: tk[1:9],
2058 },
2059 },
2060 Tokens: tk[0:10],
2061 },
2062 Tokens: tk[0:10],
2063 },
2064 AssignmentOperator: AssignmentAssign,
2065 AssignmentExpression: &AssignmentExpression{
2066 ConditionalExpression: WrapConditional(&PrimaryExpression{
2067 IdentifierReference: &tk[13],
2068 Tokens: tk[13:14],
2069 }),
2070 Tokens: tk[13:14],
2071 },
2072 Tokens: tk[:14],
2073 }
2074 }},
2075 {"{a: {b}} = c", func(t *test, tk Tokens) { // 48
2076 t.Output = AssignmentExpression{
2077 AssignmentPattern: &AssignmentPattern{
2078 ObjectAssignmentPattern: &ObjectAssignmentPattern{
2079 AssignmentPropertyList: []AssignmentProperty{
2080 {
2081 PropertyName: PropertyName{
2082 LiteralPropertyName: &tk[1],
2083 Tokens: tk[1:2],
2084 },
2085 DestructuringAssignmentTarget: &DestructuringAssignmentTarget{
2086 AssignmentPattern: &AssignmentPattern{
2087 ObjectAssignmentPattern: &ObjectAssignmentPattern{
2088 AssignmentPropertyList: []AssignmentProperty{
2089 {
2090 PropertyName: PropertyName{
2091 LiteralPropertyName: &tk[5],
2092 Tokens: tk[5:6],
2093 },
2094 DestructuringAssignmentTarget: &DestructuringAssignmentTarget{
2095 LeftHandSideExpression: &LeftHandSideExpression{
2096 NewExpression: &NewExpression{
2097 MemberExpression: MemberExpression{
2098 PrimaryExpression: &PrimaryExpression{
2099 IdentifierReference: &tk[5],
2100 Tokens: tk[5:6],
2101 },
2102 Tokens: tk[5:6],
2103 },
2104 Tokens: tk[5:6],
2105 },
2106 Tokens: tk[5:6],
2107 },
2108 Tokens: tk[5:6],
2109 },
2110 Tokens: tk[5:6],
2111 },
2112 },
2113 Tokens: tk[4:7],
2114 },
2115 Tokens: tk[4:7],
2116 },
2117 Tokens: tk[4:7],
2118 },
2119 Tokens: tk[1:7],
2120 },
2121 },
2122 Tokens: tk[0:8],
2123 },
2124 Tokens: tk[0:8],
2125 },
2126 AssignmentOperator: AssignmentAssign,
2127 AssignmentExpression: &AssignmentExpression{
2128 ConditionalExpression: WrapConditional(&PrimaryExpression{
2129 IdentifierReference: &tk[11],
2130 Tokens: tk[11:12],
2131 }),
2132 Tokens: tk[11:12],
2133 },
2134 Tokens: tk[:12],
2135 }
2136 }},
2137 {"{a: 1} = c", func(t *test, tk Tokens) { // 49
2138 t.Err = Error{
2139 Err: Error{
2140 Err: Error{
2141 Err: Error{
2142 Err: Error{
2143 Err: ErrInvalidDestructuringAssignmentTarget,
2144 Parsing: "DestructuringAssignmentTarget",
2145 Token: tk[4],
2146 },
2147 Parsing: "AssignmentProperty",
2148 Token: tk[1],
2149 },
2150 Parsing: "ObjectAssignmentPattern",
2151 Token: tk[1],
2152 },
2153 Parsing: "AssignmentPattern",
2154 Token: tk[0],
2155 },
2156 Parsing: "AssignmentExpression",
2157 Token: tk[0],
2158 }
2159 }},
2160 {"{a: !b} = c", func(t *test, tk Tokens) { // 50
2161 t.Err = Error{
2162 Err: Error{
2163 Err: Error{
2164 Err: Error{
2165 Err: Error{
2166 Err: ErrInvalidDestructuringAssignmentTarget,
2167 Parsing: "DestructuringAssignmentTarget",
2168 Token: tk[4],
2169 },
2170 Parsing: "AssignmentProperty",
2171 Token: tk[1],
2172 },
2173 Parsing: "ObjectAssignmentPattern",
2174 Token: tk[1],
2175 },
2176 Parsing: "AssignmentPattern",
2177 Token: tk[0],
2178 },
2179 Parsing: "AssignmentExpression",
2180 Token: tk[0],
2181 }
2182 }},
2183 {"{a: ()=>b} = c", func(t *test, tk Tokens) { // 51
2184 t.Err = Error{
2185 Err: Error{
2186 Err: Error{
2187 Err: Error{
2188 Err: Error{
2189 Err: ErrInvalidDestructuringAssignmentTarget,
2190 Parsing: "DestructuringAssignmentTarget",
2191 Token: tk[4],
2192 },
2193 Parsing: "AssignmentProperty",
2194 Token: tk[1],
2195 },
2196 Parsing: "ObjectAssignmentPattern",
2197 Token: tk[1],
2198 },
2199 Parsing: "AssignmentPattern",
2200 Token: tk[0],
2201 },
2202 Parsing: "AssignmentExpression",
2203 Token: tk[0],
2204 }
2205 }},
2206 {"{a: {b} = c} = d", func(t *test, tk Tokens) { // 52
2207 t.Output = AssignmentExpression{
2208 AssignmentPattern: &AssignmentPattern{
2209 ObjectAssignmentPattern: &ObjectAssignmentPattern{
2210 AssignmentPropertyList: []AssignmentProperty{
2211 {
2212 PropertyName: PropertyName{
2213 LiteralPropertyName: &tk[1],
2214 Tokens: tk[1:2],
2215 },
2216 DestructuringAssignmentTarget: &DestructuringAssignmentTarget{
2217 AssignmentPattern: &AssignmentPattern{
2218 ObjectAssignmentPattern: &ObjectAssignmentPattern{
2219 AssignmentPropertyList: []AssignmentProperty{
2220 {
2221 PropertyName: PropertyName{
2222 LiteralPropertyName: &tk[5],
2223 Tokens: tk[5:6],
2224 },
2225 DestructuringAssignmentTarget: &DestructuringAssignmentTarget{
2226 LeftHandSideExpression: &LeftHandSideExpression{
2227 NewExpression: &NewExpression{
2228 MemberExpression: MemberExpression{
2229 PrimaryExpression: &PrimaryExpression{
2230 IdentifierReference: &tk[5],
2231 Tokens: tk[5:6],
2232 },
2233 Tokens: tk[5:6],
2234 },
2235 Tokens: tk[5:6],
2236 },
2237 Tokens: tk[5:6],
2238 },
2239 Tokens: tk[5:6],
2240 },
2241 Tokens: tk[5:6],
2242 },
2243 },
2244 Tokens: tk[4:7],
2245 },
2246 Tokens: tk[4:7],
2247 },
2248 Tokens: tk[4:7],
2249 },
2250 Initializer: &AssignmentExpression{
2251 ConditionalExpression: WrapConditional(&PrimaryExpression{
2252 IdentifierReference: &tk[10],
2253 Tokens: tk[10:11],
2254 }),
2255 Tokens: tk[10:11],
2256 },
2257 Tokens: tk[1:11],
2258 },
2259 },
2260 Tokens: tk[:12],
2261 },
2262 Tokens: tk[:12],
2263 },
2264 AssignmentOperator: AssignmentAssign,
2265 AssignmentExpression: &AssignmentExpression{
2266 ConditionalExpression: WrapConditional(&PrimaryExpression{
2267 IdentifierReference: &tk[15],
2268 Tokens: tk[15:16],
2269 }),
2270 Tokens: tk[15:16],
2271 },
2272 Tokens: tk[:16],
2273 }
2274 }},
2275 {"{a: {b: !c}} = d", func(t *test, tk Tokens) { // 53
2276 t.Err = Error{
2277 Err: Error{
2278 Err: Error{
2279 Err: Error{
2280 Err: Error{
2281 Err: Error{
2282 Err: Error{
2283 Err: Error{
2284 Err: Error{
2285 Err: ErrInvalidDestructuringAssignmentTarget,
2286 Parsing: "DestructuringAssignmentTarget",
2287 Token: tk[8],
2288 },
2289 Parsing: "AssignmentProperty",
2290 Token: tk[5],
2291 },
2292 Parsing: "ObjectAssignmentPattern",
2293 Token: tk[5],
2294 },
2295 Parsing: "AssignmentPattern",
2296 Token: tk[4],
2297 },
2298 Parsing: "DestructuringAssignmentTarget",
2299 Token: tk[4],
2300 },
2301 Parsing: "AssignmentProperty",
2302 Token: tk[1],
2303 },
2304 Parsing: "ObjectAssignmentPattern",
2305 Token: tk[1],
2306 },
2307 Parsing: "AssignmentPattern",
2308 Token: tk[0],
2309 },
2310 Parsing: "AssignmentExpression",
2311 Token: tk[0],
2312 }
2313 }},
2314 {"{...()=>a} = d", func(t *test, tk Tokens) { // 54
2315 t.Err = Error{
2316 Err: Error{
2317 Err: Error{
2318 Err: Error{
2319 Err: ErrInvalidDestructuringAssignmentTarget,
2320 Parsing: "DestructuringAssignmentTarget",
2321 Token: tk[2],
2322 },
2323 Parsing: "ObjectAssignmentPattern",
2324 Token: tk[2],
2325 },
2326 Parsing: "AssignmentPattern",
2327 Token: tk[0],
2328 },
2329 Parsing: "AssignmentExpression",
2330 Token: tk[0],
2331 }
2332 }},
2333 {"{a(){}} = b", func(t *test, tk Tokens) { // 55
2334 t.Err = Error{
2335 Err: Error{
2336 Err: Error{
2337 Err: Error{
2338 Err: ErrInvalidAssignmentProperty,
2339 Parsing: "AssignmentProperty",
2340 Token: tk[1],
2341 },
2342 Parsing: "ObjectAssignmentPattern",
2343 Token: tk[1],
2344 },
2345 Parsing: "AssignmentPattern",
2346 Token: tk[0],
2347 },
2348 Parsing: "AssignmentExpression",
2349 Token: tk[0],
2350 }
2351 }},
2352 {"[...a] = b", func(t *test, tk Tokens) { // 56
2353 t.Output = AssignmentExpression{
2354 AssignmentPattern: &AssignmentPattern{
2355 ArrayAssignmentPattern: &ArrayAssignmentPattern{
2356 AssignmentElements: []AssignmentElement{},
2357 AssignmentRestElement: &LeftHandSideExpression{
2358 NewExpression: &NewExpression{
2359 MemberExpression: MemberExpression{
2360 PrimaryExpression: &PrimaryExpression{
2361 IdentifierReference: &tk[2],
2362 Tokens: tk[2:3],
2363 },
2364 Tokens: tk[2:3],
2365 },
2366 Tokens: tk[2:3],
2367 },
2368 Tokens: tk[2:3],
2369 },
2370 Tokens: tk[:4],
2371 },
2372 Tokens: tk[:4],
2373 },
2374 AssignmentOperator: AssignmentAssign,
2375 AssignmentExpression: &AssignmentExpression{
2376 ConditionalExpression: WrapConditional(&PrimaryExpression{
2377 IdentifierReference: &tk[7],
2378 Tokens: tk[7:8],
2379 }),
2380 Tokens: tk[7:8],
2381 },
2382 Tokens: tk[:8],
2383 }
2384 }},
2385 {"[a().b] = c", func(t *test, tk Tokens) { // 57
2386 t.Output = AssignmentExpression{
2387 AssignmentPattern: &AssignmentPattern{
2388 ArrayAssignmentPattern: &ArrayAssignmentPattern{
2389 AssignmentElements: []AssignmentElement{
2390 {
2391 DestructuringAssignmentTarget: DestructuringAssignmentTarget{
2392 LeftHandSideExpression: &LeftHandSideExpression{
2393 CallExpression: &CallExpression{
2394 CallExpression: &CallExpression{
2395 MemberExpression: &MemberExpression{
2396 PrimaryExpression: &PrimaryExpression{
2397 IdentifierReference: &tk[1],
2398 Tokens: tk[1:2],
2399 },
2400 Tokens: tk[1:2],
2401 },
2402 Arguments: &Arguments{
2403 Tokens: tk[2:4],
2404 },
2405 Tokens: tk[1:4],
2406 },
2407 IdentifierName: &tk[5],
2408 Tokens: tk[1:6],
2409 },
2410 Tokens: tk[1:6],
2411 },
2412 Tokens: tk[1:6],
2413 },
2414 Tokens: tk[1:6],
2415 },
2416 },
2417 Tokens: tk[:7],
2418 },
2419 Tokens: tk[:7],
2420 },
2421 AssignmentOperator: AssignmentAssign,
2422 AssignmentExpression: &AssignmentExpression{
2423 ConditionalExpression: WrapConditional(&PrimaryExpression{
2424 IdentifierReference: &tk[10],
2425 Tokens: tk[10:11],
2426 }),
2427 Tokens: tk[10:11],
2428 },
2429 Tokens: tk[:11],
2430 }
2431 }},
2432 {"[...a=1] = c", func(t *test, tk Tokens) { // 58
2433 t.Err = Error{
2434 Err: Error{
2435 Err: Error{
2436 Err: ErrInvalidAssignment,
2437 Parsing: "ArrayAssignmentPattern",
2438 Token: tk[0],
2439 },
2440 Parsing: "AssignmentPattern",
2441 Token: tk[0],
2442 },
2443 Parsing: "AssignmentExpression",
2444 Token: tk[0],
2445 }
2446 }},
2447 {"[...()=>a] = b", func(t *test, tk Tokens) { // 59
2448 t.Err = Error{
2449 Err: Error{
2450 Err: Error{
2451 Err: Error{
2452 Err: ErrInvalidDestructuringAssignmentTarget,
2453 Parsing: "DestructuringAssignmentTarget",
2454 Token: tk[2],
2455 },
2456 Parsing: "ArrayAssignmentPattern",
2457 Token: tk[0],
2458 },
2459 Parsing: "AssignmentPattern",
2460 Token: tk[0],
2461 },
2462 Parsing: "AssignmentExpression",
2463 Token: tk[0],
2464 }
2465 }},
2466 {"[...[a]] = b", func(t *test, tk Tokens) { // 60
2467 t.Err = Error{
2468 Err: Error{
2469 Err: Error{
2470 Err: ErrBadRestElement,
2471 Parsing: "ArrayAssignmentPattern",
2472 Token: tk[0],
2473 },
2474 Parsing: "AssignmentPattern",
2475 Token: tk[0],
2476 },
2477 Parsing: "AssignmentExpression",
2478 Token: tk[0],
2479 }
2480 }},
2481 {"[a /= b] = c", func(t *test, tk Tokens) { // 61
2482 t.Err = Error{
2483 Err: Error{
2484 Err: Error{
2485 Err: Error{
2486 Err: ErrInvalidAssignment,
2487 Parsing: "AssignmentElement",
2488 Token: tk[1],
2489 },
2490 Parsing: "ArrayAssignmentPattern",
2491 Token: tk[0],
2492 },
2493 Parsing: "AssignmentPattern",
2494 Token: tk[0],
2495 },
2496 Parsing: "AssignmentExpression",
2497 Token: tk[0],
2498 }
2499 }},
2500 {"[...a, ...b] = c", func(t *test, tk Tokens) { // 62
2501 t.Err = Error{
2502 Err: Error{
2503 Err: Error{
2504 Err: ErrBadRestElement,
2505 Parsing: "ArrayAssignmentPattern",
2506 Token: tk[0],
2507 },
2508 Parsing: "AssignmentPattern",
2509 Token: tk[0],
2510 },
2511 Parsing: "AssignmentExpression",
2512 Token: tk[0],
2513 }
2514 }},
2515 {`(a = 1) => true`, func(t *test, tk Tokens) { // 63
2516 t.Output = AssignmentExpression{
2517 ArrowFunction: &ArrowFunction{
2518 FormalParameters: &FormalParameters{
2519 FormalParameterList: []BindingElement{
2520 {
2521 SingleNameBinding: &tk[1],
2522 Initializer: &AssignmentExpression{
2523 ConditionalExpression: WrapConditional(&PrimaryExpression{
2524 Literal: &tk[5],
2525 Tokens: tk[5:6],
2526 }),
2527 Tokens: tk[5:6],
2528 },
2529 Tokens: tk[1:6],
2530 },
2531 },
2532 Tokens: tk[0:7],
2533 },
2534 AssignmentExpression: &AssignmentExpression{
2535 ConditionalExpression: WrapConditional(&PrimaryExpression{
2536 Literal: &tk[10],
2537 Tokens: tk[10:11],
2538 }),
2539 Tokens: tk[10:11],
2540 },
2541 Tokens: tk[0:11],
2542 },
2543 Tokens: tk[0:11],
2544 }
2545 }},
2546 }, func(t *test) (Type, error) {
2547 var ae AssignmentExpression
2548 err := ae.parse(&t.Tokens, t.In, t.Yield, t.Await)
2549 return ae, err
2550 })
2551 }
2552
2553 func TestLeftHandSideExpression(t *testing.T) {
2554 doTests(t, []sourceFn{
2555 {``, func(t *test, tk Tokens) { // 1
2556 t.Err = Error{
2557 Err: Error{
2558 Err: Error{
2559 Err: Error{
2560 Err: ErrNoIdentifier,
2561 Parsing: "PrimaryExpression",
2562 Token: tk[0],
2563 },
2564 Parsing: "MemberExpression",
2565 Token: tk[0],
2566 },
2567 Parsing: "NewExpression",
2568 Token: tk[0],
2569 },
2570 Parsing: "LeftHandSideExpression",
2571 Token: tk[0],
2572 }
2573 }},
2574 {"super\n(,)", func(t *test, tk Tokens) { // 2
2575 t.Err = Error{
2576 Err: Error{
2577 Err: Error{
2578 Err: Error{
2579 Err: assignmentError(tk[3]),
2580 Parsing: "Argument",
2581 Token: tk[3],
2582 },
2583 Parsing: "Arguments",
2584 Token: tk[3],
2585 },
2586 Parsing: "CallExpression",
2587 Token: tk[2],
2588 },
2589 Parsing: "LeftHandSideExpression",
2590 Token: tk[0],
2591 }
2592 }},
2593 {"super\n()", func(t *test, tk Tokens) { // 3
2594 t.Output = LeftHandSideExpression{
2595 CallExpression: &CallExpression{
2596 SuperCall: true,
2597 Arguments: &Arguments{
2598 Tokens: tk[2:4],
2599 },
2600 Tokens: tk[:4],
2601 },
2602 Tokens: tk[:4],
2603 }
2604 }},
2605 {"import\n(,)", func(t *test, tk Tokens) { // 4
2606 t.Err = Error{
2607 Err: Error{
2608 Err: assignmentError(tk[3]),
2609 Parsing: "CallExpression",
2610 Token: tk[3],
2611 },
2612 Parsing: "LeftHandSideExpression",
2613 Token: tk[0],
2614 }
2615 }},
2616 {"import\n(a)", func(t *test, tk Tokens) { // 5
2617 litA := makeConditionLiteral(tk, 3)
2618 t.Output = LeftHandSideExpression{
2619 CallExpression: &CallExpression{
2620 ImportCall: &AssignmentExpression{
2621 ConditionalExpression: &litA,
2622 Tokens: tk[3:4],
2623 },
2624 Tokens: tk[:5],
2625 },
2626 Tokens: tk[:5],
2627 }
2628 }},
2629 {`import(a).then(b)`, func(t *test, tk Tokens) { // 6
2630 litA := makeConditionLiteral(tk, 2)
2631 litB := makeConditionLiteral(tk, 7)
2632 t.Output = LeftHandSideExpression{
2633 CallExpression: &CallExpression{
2634 CallExpression: &CallExpression{
2635 CallExpression: &CallExpression{
2636 ImportCall: &AssignmentExpression{
2637 ConditionalExpression: &litA,
2638 Tokens: tk[2:3],
2639 },
2640 Tokens: tk[0:4],
2641 },
2642 IdentifierName: &tk[5],
2643 Tokens: tk[0:6],
2644 },
2645 Arguments: &Arguments{
2646 ArgumentList: []Argument{
2647 {
2648 AssignmentExpression: AssignmentExpression{
2649 ConditionalExpression: &litB,
2650 Tokens: tk[7:8],
2651 },
2652 Tokens: tk[7:8],
2653 },
2654 },
2655 Tokens: tk[6:9],
2656 },
2657 Tokens: tk[0:9],
2658 },
2659 Tokens: tk[0:9],
2660 }
2661 }},
2662 {`super`, func(t *test, tk Tokens) { // 7
2663 t.Err = Error{
2664 Err: Error{
2665 Err: Error{
2666 Err: ErrInvalidSuperProperty,
2667 Parsing: "MemberExpression",
2668 Token: tk[1],
2669 },
2670 Parsing: "NewExpression",
2671 Token: tk[0],
2672 },
2673 Parsing: "LeftHandSideExpression",
2674 Token: tk[0],
2675 }
2676 }},
2677 {`import`, func(t *test, tk Tokens) { // 8
2678 t.Err = Error{
2679 Err: Error{
2680 Err: Error{
2681 Err: Error{
2682 Err: ErrNoIdentifier,
2683 Parsing: "PrimaryExpression",
2684 Token: tk[0],
2685 },
2686 Parsing: "MemberExpression",
2687 Token: tk[0],
2688 },
2689 Parsing: "NewExpression",
2690 Token: tk[0],
2691 },
2692 Parsing: "LeftHandSideExpression",
2693 Token: tk[0],
2694 }
2695 }},
2696 {",", func(t *test, tk Tokens) { // 9
2697 t.Err = Error{
2698 Err: Error{
2699 Err: Error{
2700 Err: Error{
2701 Err: ErrNoIdentifier,
2702 Parsing: "PrimaryExpression",
2703 Token: tk[0],
2704 },
2705 Parsing: "MemberExpression",
2706 Token: tk[0],
2707 },
2708 Parsing: "NewExpression",
2709 Token: tk[0],
2710 },
2711 Parsing: "LeftHandSideExpression",
2712 Token: tk[0],
2713 }
2714 }},
2715 {"a", func(t *test, tk Tokens) { // 10
2716 t.Output = LeftHandSideExpression{
2717 NewExpression: &NewExpression{
2718 MemberExpression: MemberExpression{
2719 PrimaryExpression: &PrimaryExpression{
2720 IdentifierReference: &tk[0],
2721 Tokens: tk[:1],
2722 },
2723 Tokens: tk[:1],
2724 },
2725 Tokens: tk[:1],
2726 },
2727 Tokens: tk[:1],
2728 }
2729 }},
2730 {"a\n()", func(t *test, tk Tokens) { // 11
2731 t.Output = LeftHandSideExpression{
2732 CallExpression: &CallExpression{
2733 MemberExpression: &MemberExpression{
2734 PrimaryExpression: &PrimaryExpression{
2735 IdentifierReference: &tk[0],
2736 Tokens: tk[:1],
2737 },
2738 Tokens: tk[:1],
2739 },
2740 Arguments: &Arguments{
2741 Tokens: tk[2:4],
2742 },
2743 Tokens: tk[:4],
2744 },
2745 Tokens: tk[:4],
2746 }
2747 }},
2748 {"a\n(,)", func(t *test, tk Tokens) { // 12
2749 t.Err = Error{
2750 Err: Error{
2751 Err: Error{
2752 Err: Error{
2753 Err: assignmentError(tk[3]),
2754 Parsing: "Argument",
2755 Token: tk[3],
2756 },
2757 Parsing: "Arguments",
2758 Token: tk[3],
2759 },
2760 Parsing: "CallExpression",
2761 Token: tk[2],
2762 },
2763 Parsing: "LeftHandSideExpression",
2764 Token: tk[0],
2765 }
2766 }},
2767 {"a().#b", func(t *test, tk Tokens) { // 13
2768 t.Output = LeftHandSideExpression{
2769 CallExpression: &CallExpression{
2770 CallExpression: &CallExpression{
2771 MemberExpression: &MemberExpression{
2772 PrimaryExpression: &PrimaryExpression{
2773 IdentifierReference: &tk[0],
2774 Tokens: tk[:1],
2775 },
2776 Tokens: tk[:1],
2777 },
2778 Arguments: &Arguments{
2779 Tokens: tk[1:3],
2780 },
2781 Tokens: tk[:3],
2782 },
2783 PrivateIdentifier: &tk[4],
2784 Tokens: tk[:5],
2785 },
2786 Tokens: tk[:5],
2787 }
2788 }},
2789 {"a?.#b", func(t *test, tk Tokens) { // 14
2790 t.Output = LeftHandSideExpression{
2791 OptionalExpression: &OptionalExpression{
2792 MemberExpression: &MemberExpression{
2793 PrimaryExpression: &PrimaryExpression{
2794 IdentifierReference: &tk[0],
2795 Tokens: tk[:1],
2796 },
2797 Tokens: tk[:1],
2798 },
2799 OptionalChain: OptionalChain{
2800 PrivateIdentifier: &tk[2],
2801 Tokens: tk[1:3],
2802 },
2803 Tokens: tk[:3],
2804 },
2805 Tokens: tk[:3],
2806 }
2807 }},
2808 }, func(t *test) (Type, error) {
2809 var lhs LeftHandSideExpression
2810 err := lhs.parse(&t.Tokens, t.Yield, t.Await)
2811 return lhs, err
2812 })
2813 }
2814
2815 func TestExpression(t *testing.T) {
2816 doTests(t, []sourceFn{
2817 {``, func(t *test, tk Tokens) { // 1
2818 t.Err = Error{
2819 Err: assignmentError(tk[0]),
2820 Parsing: "Expression",
2821 Token: tk[0],
2822 }
2823 }},
2824 {`a`, func(t *test, tk Tokens) { // 2
2825 litA := makeConditionLiteral(tk, 0)
2826 t.Output = Expression{
2827 Expressions: []AssignmentExpression{
2828 {
2829 ConditionalExpression: &litA,
2830 Tokens: tk[:1],
2831 },
2832 },
2833 Tokens: tk[:1],
2834 }
2835 }},
2836 {"a\n,\n", func(t *test, tk Tokens) { // 3
2837 t.Err = Error{
2838 Err: assignmentError(tk[4]),
2839 Parsing: "Expression",
2840 Token: tk[4],
2841 }
2842 }},
2843 {"a\n,\nb", func(t *test, tk Tokens) { // 4
2844 litA := makeConditionLiteral(tk, 0)
2845 litB := makeConditionLiteral(tk, 4)
2846 t.Output = Expression{
2847 Expressions: []AssignmentExpression{
2848 {
2849 ConditionalExpression: &litA,
2850 Tokens: tk[:1],
2851 },
2852 {
2853 ConditionalExpression: &litB,
2854 Tokens: tk[4:5],
2855 },
2856 },
2857 Tokens: tk[:5],
2858 }
2859 }},
2860 }, func(t *test) (Type, error) {
2861 var e Expression
2862 err := e.parse(&t.Tokens, t.In, t.Yield, t.Await)
2863 return e, err
2864 })
2865 }
2866
2867 func TestNewExpression(t *testing.T) {
2868 doTests(t, []sourceFn{
2869 {``, func(t *test, tk Tokens) { // 1
2870 t.Err = Error{
2871 Err: Error{
2872 Err: Error{
2873 Err: ErrNoIdentifier,
2874 Parsing: "PrimaryExpression",
2875 Token: tk[0],
2876 },
2877 Parsing: "MemberExpression",
2878 Token: tk[0],
2879 },
2880 Parsing: "NewExpression",
2881 Token: tk[0],
2882 }
2883 }},
2884 {",", func(t *test, tk Tokens) { // 2
2885 t.Err = Error{
2886 Err: Error{
2887 Err: Error{
2888 Err: ErrNoIdentifier,
2889 Parsing: "PrimaryExpression",
2890 Token: tk[0],
2891 },
2892 Parsing: "MemberExpression",
2893 Token: tk[0],
2894 },
2895 Parsing: "NewExpression",
2896 Token: tk[0],
2897 }
2898 }},
2899 {"new\n,", func(t *test, tk Tokens) { // 3
2900 t.Err = Error{
2901 Err: Error{
2902 Err: Error{
2903 Err: Error{
2904 Err: ErrNoIdentifier,
2905 Parsing: "PrimaryExpression",
2906 Token: tk[2],
2907 },
2908 Parsing: "MemberExpression",
2909 Token: tk[2],
2910 },
2911 Parsing: "MemberExpression",
2912 Token: tk[0],
2913 },
2914 Parsing: "NewExpression",
2915 Token: tk[0],
2916 }
2917 }},
2918 {"1", func(t *test, tk Tokens) { // 4
2919 t.Output = NewExpression{
2920 MemberExpression: MemberExpression{
2921 PrimaryExpression: &PrimaryExpression{
2922 Literal: &tk[0],
2923 Tokens: tk[:1],
2924 },
2925 Tokens: tk[:1],
2926 },
2927 Tokens: tk[:1],
2928 }
2929 }},
2930 {"new\na", func(t *test, tk Tokens) { // 5
2931 t.Output = NewExpression{
2932 News: 1,
2933 MemberExpression: MemberExpression{
2934 PrimaryExpression: &PrimaryExpression{
2935 IdentifierReference: &tk[2],
2936 Tokens: tk[2:3],
2937 },
2938 Tokens: tk[2:3],
2939 },
2940 Tokens: tk[:3],
2941 }
2942 }},
2943 {"new\na\n()", func(t *test, tk Tokens) { // 6
2944 t.Output = NewExpression{
2945 MemberExpression: MemberExpression{
2946 MemberExpression: &MemberExpression{
2947 PrimaryExpression: &PrimaryExpression{
2948 IdentifierReference: &tk[2],
2949 Tokens: tk[2:3],
2950 },
2951 Tokens: tk[2:3],
2952 },
2953 Arguments: &Arguments{
2954 Tokens: tk[4:6],
2955 },
2956 Tokens: tk[:6],
2957 },
2958 Tokens: tk[:6],
2959 }
2960 }},
2961 {"new\nnew\na\n()", func(t *test, tk Tokens) { // 7
2962 t.Output = NewExpression{
2963 News: 1,
2964 MemberExpression: MemberExpression{
2965 MemberExpression: &MemberExpression{
2966 PrimaryExpression: &PrimaryExpression{
2967 IdentifierReference: &tk[4],
2968 Tokens: tk[4:5],
2969 },
2970 Tokens: tk[4:5],
2971 },
2972 Arguments: &Arguments{
2973 Tokens: tk[6:8],
2974 },
2975 Tokens: tk[2:8],
2976 },
2977 Tokens: tk[:8],
2978 }
2979 }},
2980 {"new new\nnew\na\n()", func(t *test, tk Tokens) { // 8
2981 t.Output = NewExpression{
2982 News: 2,
2983 MemberExpression: MemberExpression{
2984 MemberExpression: &MemberExpression{
2985 PrimaryExpression: &PrimaryExpression{
2986 IdentifierReference: &tk[6],
2987 Tokens: tk[6:7],
2988 },
2989 Tokens: tk[6:7],
2990 },
2991 Arguments: &Arguments{
2992 Tokens: tk[8:10],
2993 },
2994 Tokens: tk[4:10],
2995 },
2996 Tokens: tk[:10],
2997 }
2998 }},
2999 }, func(t *test) (Type, error) {
3000 var ne NewExpression
3001 err := ne.parse(&t.Tokens, t.Yield, t.Await)
3002 return ne, err
3003 })
3004 }
3005
3006 func TestMemberExpression(t *testing.T) {
3007 doTests(t, []sourceFn{
3008 {``, func(t *test, tk Tokens) { // 1
3009 t.Err = Error{
3010 Err: Error{
3011 Err: ErrNoIdentifier,
3012 Parsing: "PrimaryExpression",
3013 Token: tk[0],
3014 },
3015 Parsing: "MemberExpression",
3016 Token: tk[0],
3017 }
3018 }},
3019 {"super\n[\n,\n]", func(t *test, tk Tokens) { // 2
3020 t.Err = Error{
3021 Err: Error{
3022 Err: assignmentError(tk[4]),
3023 Parsing: "Expression",
3024 Token: tk[4],
3025 },
3026 Parsing: "MemberExpression",
3027 Token: tk[4],
3028 }
3029 }},
3030 {"super\n[\n1\n]", func(t *test, tk Tokens) { // 3
3031 lit1 := makeConditionLiteral(tk, 4)
3032 t.Output = MemberExpression{
3033 SuperProperty: true,
3034 Expression: &Expression{
3035 Expressions: []AssignmentExpression{
3036 {
3037 ConditionalExpression: &lit1,
3038 Tokens: tk[4:5],
3039 },
3040 },
3041 Tokens: tk[4:5],
3042 },
3043 Tokens: tk[:7],
3044 }
3045 }},
3046 {"super\n[\n1\n2\n]", func(t *test, tk Tokens) { // 4
3047 t.Err = Error{
3048 Err: ErrInvalidSuperProperty,
3049 Parsing: "MemberExpression",
3050 Token: tk[6],
3051 }
3052 }},
3053 {"super\n.\n", func(t *test, tk Tokens) { // 5
3054 t.Err = Error{
3055 Err: ErrNoIdentifier,
3056 Parsing: "MemberExpression",
3057 Token: tk[4],
3058 }
3059 }},
3060 {"super\n.\n1", func(t *test, tk Tokens) { // 6
3061 t.Err = Error{
3062 Err: ErrNoIdentifier,
3063 Parsing: "MemberExpression",
3064 Token: tk[4],
3065 }
3066 }},
3067 {"super\n.\na", func(t *test, tk Tokens) { // 7
3068 t.Output = MemberExpression{
3069 SuperProperty: true,
3070 IdentifierName: &tk[4],
3071 Tokens: tk[:5],
3072 }
3073 }},
3074 {"super\n", func(t *test, tk Tokens) { // 8
3075 t.Err = Error{
3076 Err: ErrInvalidSuperProperty,
3077 Parsing: "MemberExpression",
3078 Token: tk[2],
3079 }
3080 }},
3081 {"new", func(t *test, tk Tokens) { // 9
3082 t.Err = Error{
3083 Err: Error{
3084 Err: Error{
3085 Err: ErrNoIdentifier,
3086 Parsing: "PrimaryExpression",
3087 Token: tk[1],
3088 },
3089 Parsing: "MemberExpression",
3090 Token: tk[1],
3091 },
3092 Parsing: "MemberExpression",
3093 Token: tk[0],
3094 }
3095 }},
3096 {"new\n.\n", func(t *test, tk Tokens) { // 10
3097 t.Err = Error{
3098 Err: ErrInvalidMetaProperty,
3099 Parsing: "MemberExpression",
3100 Token: tk[0],
3101 }
3102 }},
3103 {"new\n.\ntarget", func(t *test, tk Tokens) { // 11
3104 t.Output = MemberExpression{
3105 NewTarget: true,
3106 Tokens: tk[:5],
3107 }
3108 }},
3109 {"new\n,", func(t *test, tk Tokens) { // 12
3110 t.Err = Error{
3111 Err: Error{
3112 Err: Error{
3113 Err: ErrNoIdentifier,
3114 Parsing: "PrimaryExpression",
3115 Token: tk[2],
3116 },
3117 Parsing: "MemberExpression",
3118 Token: tk[2],
3119 },
3120 Parsing: "MemberExpression",
3121 Token: tk[0],
3122 }
3123 }},
3124 {"new\n1\n", func(t *test, tk Tokens) { // 13
3125 t.Err = Error{
3126 Err: Error{
3127 Err: ErrMissingOpeningParenthesis,
3128 Parsing: "Arguments",
3129 Token: tk[4],
3130 },
3131 Parsing: "MemberExpression",
3132 Token: tk[3],
3133 }
3134 }},
3135 {"new\n1\n()", func(t *test, tk Tokens) { // 14
3136 t.Output = MemberExpression{
3137 MemberExpression: &MemberExpression{
3138 PrimaryExpression: &PrimaryExpression{
3139 Literal: &tk[2],
3140 Tokens: tk[2:3],
3141 },
3142 Tokens: tk[2:3],
3143 },
3144 Arguments: &Arguments{
3145 Tokens: tk[4:6],
3146 },
3147 Tokens: tk[:6],
3148 }
3149 }},
3150 {"new\nnew\n1\n()", func(t *test, tk Tokens) { // 15
3151 t.Err = Error{
3152 Err: Error{
3153 Err: ErrMissingOpeningParenthesis,
3154 Parsing: "Arguments",
3155 Token: tk[8],
3156 },
3157 Parsing: "MemberExpression",
3158 Token: tk[8],
3159 }
3160 }},
3161 {"new\nnew\n1\n()\n()", func(t *test, tk Tokens) { // 16
3162 t.Output = MemberExpression{
3163 MemberExpression: &MemberExpression{
3164 MemberExpression: &MemberExpression{
3165 PrimaryExpression: &PrimaryExpression{
3166 Literal: &tk[4],
3167 Tokens: tk[4:5],
3168 },
3169 Tokens: tk[4:5],
3170 },
3171 Arguments: &Arguments{
3172 Tokens: tk[6:8],
3173 },
3174 Tokens: tk[2:8],
3175 },
3176 Arguments: &Arguments{
3177 Tokens: tk[9:11],
3178 },
3179 Tokens: tk[:11],
3180 }
3181 }},
3182 {",", func(t *test, tk Tokens) { // 17
3183 t.Err = Error{
3184 Err: Error{
3185 Err: ErrNoIdentifier,
3186 Parsing: "PrimaryExpression",
3187 Token: tk[0],
3188 },
3189 Parsing: "MemberExpression",
3190 Token: tk[0],
3191 }
3192 }},
3193 {"1", func(t *test, tk Tokens) { // 18
3194 t.Output = MemberExpression{
3195 PrimaryExpression: &PrimaryExpression{
3196 Literal: &tk[0],
3197 Tokens: tk[:1],
3198 },
3199 Tokens: tk[:1],
3200 }
3201 }},
3202 {"a", func(t *test, tk Tokens) { // 18
3203 t.Output = MemberExpression{
3204 PrimaryExpression: &PrimaryExpression{
3205 IdentifierReference: &tk[0],
3206 Tokens: tk[:1],
3207 },
3208 Tokens: tk[:1],
3209 }
3210 }},
3211 {"a\n`${\n1\n1\n}`", func(t *test, tk Tokens) { // 19
3212 t.Err = Error{
3213 Err: Error{
3214 Err: ErrInvalidTemplate,
3215 Parsing: "TemplateLiteral",
3216 Token: tk[6],
3217 },
3218 Parsing: "MemberExpression",
3219 Token: tk[2],
3220 }
3221 }},
3222 {"a\n``", func(t *test, tk Tokens) { // 20
3223 t.Output = MemberExpression{
3224 MemberExpression: &MemberExpression{
3225 PrimaryExpression: &PrimaryExpression{
3226 IdentifierReference: &tk[0],
3227 Tokens: tk[:1],
3228 },
3229 Tokens: tk[:1],
3230 },
3231 TemplateLiteral: &TemplateLiteral{
3232 NoSubstitutionTemplate: &tk[2],
3233 Tokens: tk[2:3],
3234 },
3235 Tokens: tk[:3],
3236 }
3237 }},
3238 {"a\n.\n", func(t *test, tk Tokens) { // 21
3239 t.Err = Error{
3240 Err: ErrNoIdentifier,
3241 Parsing: "MemberExpression",
3242 Token: tk[2],
3243 }
3244 }},
3245 {"a\n.\nb", func(t *test, tk Tokens) { // 22
3246 t.Output = MemberExpression{
3247 MemberExpression: &MemberExpression{
3248 PrimaryExpression: &PrimaryExpression{
3249 IdentifierReference: &tk[0],
3250 Tokens: tk[:1],
3251 },
3252 Tokens: tk[:1],
3253 },
3254 IdentifierName: &tk[4],
3255 Tokens: tk[:5],
3256 }
3257 }},
3258 {"a\n[\n]", func(t *test, tk Tokens) { // 23
3259 t.Err = Error{
3260 Err: Error{
3261 Err: assignmentError(tk[4]),
3262 Parsing: "Expression",
3263 Token: tk[4],
3264 },
3265 Parsing: "MemberExpression",
3266 Token: tk[2],
3267 }
3268 }},
3269 {"a\n[\n1\n2\n]", func(t *test, tk Tokens) { // 24
3270 t.Err = Error{
3271 Err: ErrMissingClosingBracket,
3272 Parsing: "MemberExpression",
3273 Token: tk[2],
3274 }
3275 }},
3276 {"a\n[\n1\n]", func(t *test, tk Tokens) { // 25
3277 lit1 := makeConditionLiteral(tk, 4)
3278 t.Output = MemberExpression{
3279 MemberExpression: &MemberExpression{
3280 PrimaryExpression: &PrimaryExpression{
3281 IdentifierReference: &tk[0],
3282 Tokens: tk[:1],
3283 },
3284 Tokens: tk[:1],
3285 },
3286 Expression: &Expression{
3287 Expressions: []AssignmentExpression{
3288 {
3289 ConditionalExpression: &lit1,
3290 Tokens: tk[4:5],
3291 },
3292 },
3293 Tokens: tk[4:5],
3294 },
3295 Tokens: tk[:7],
3296 }
3297 }},
3298 {"a\n.\nb\n[\nc\n]\n``", func(t *test, tk Tokens) { // 26
3299 litC := makeConditionLiteral(tk, 8)
3300 t.Output = MemberExpression{
3301 MemberExpression: &MemberExpression{
3302 MemberExpression: &MemberExpression{
3303 MemberExpression: &MemberExpression{
3304 PrimaryExpression: &PrimaryExpression{
3305 IdentifierReference: &tk[0],
3306 Tokens: tk[:1],
3307 },
3308 Tokens: tk[:1],
3309 },
3310 IdentifierName: &tk[4],
3311 Tokens: tk[:5],
3312 },
3313 Expression: &Expression{
3314 Expressions: []AssignmentExpression{
3315 {
3316 ConditionalExpression: &litC,
3317 Tokens: tk[8:9],
3318 },
3319 },
3320 Tokens: tk[8:9],
3321 },
3322 Tokens: tk[:11],
3323 },
3324 TemplateLiteral: &TemplateLiteral{
3325 NoSubstitutionTemplate: &tk[12],
3326 Tokens: tk[12:13],
3327 },
3328 Tokens: tk[:13],
3329 }
3330 }},
3331 {"import . meta", func(t *test, tk Tokens) { // 27
3332 t.Output = MemberExpression{
3333 ImportMeta: true,
3334 Tokens: tk[:5],
3335 }
3336 }},
3337 {"a.#b", func(t *test, tk Tokens) { // 28
3338 t.Output = MemberExpression{
3339 MemberExpression: &MemberExpression{
3340 PrimaryExpression: &PrimaryExpression{
3341 IdentifierReference: &tk[0],
3342 Tokens: tk[:1],
3343 },
3344 Tokens: tk[:1],
3345 },
3346 PrivateIdentifier: &tk[2],
3347 Tokens: tk[:3],
3348 }
3349 }},
3350 {"a.#b.c", func(t *test, tk Tokens) { // 29
3351 t.Output = MemberExpression{
3352 MemberExpression: &MemberExpression{
3353 MemberExpression: &MemberExpression{
3354 PrimaryExpression: &PrimaryExpression{
3355 IdentifierReference: &tk[0],
3356 Tokens: tk[:1],
3357 },
3358 Tokens: tk[:1],
3359 },
3360 PrivateIdentifier: &tk[2],
3361 Tokens: tk[:3],
3362 },
3363 IdentifierName: &tk[4],
3364 Tokens: tk[:5],
3365 }
3366 }},
3367 {"a.#b[\"c\"]", func(t *test, tk Tokens) { // 30
3368 t.Output = MemberExpression{
3369 MemberExpression: &MemberExpression{
3370 MemberExpression: &MemberExpression{
3371 PrimaryExpression: &PrimaryExpression{
3372 IdentifierReference: &tk[0],
3373 Tokens: tk[:1],
3374 },
3375 Tokens: tk[:1],
3376 },
3377 PrivateIdentifier: &tk[2],
3378 Tokens: tk[:3],
3379 },
3380 Expression: &Expression{
3381 Expressions: []AssignmentExpression{
3382 {
3383 ConditionalExpression: WrapConditional(&PrimaryExpression{
3384 Literal: &tk[4],
3385 Tokens: tk[4:5],
3386 }),
3387 Tokens: tk[4:5],
3388 },
3389 },
3390 Tokens: tk[4:5],
3391 },
3392 Tokens: tk[:6],
3393 }
3394 }},
3395 }, func(t *test) (Type, error) {
3396 var me MemberExpression
3397 err := me.parse(&t.Tokens, t.Yield, t.Await)
3398 return me, err
3399 })
3400 }
3401
3402 func TestPrimaryExpression(t *testing.T) {
3403 doTests(t, []sourceFn{
3404 {``, func(t *test, tk Tokens) { // 1
3405 t.Err = Error{
3406 Err: ErrNoIdentifier,
3407 Parsing: "PrimaryExpression",
3408 Token: tk[0],
3409 }
3410 }},
3411 {`this`, func(t *test, tk Tokens) { // 2
3412 t.Output = PrimaryExpression{
3413 This: &tk[0],
3414 Tokens: tk[:1],
3415 }
3416 }},
3417 {`null`, func(t *test, tk Tokens) { // 3
3418 t.Output = PrimaryExpression{
3419 Literal: &tk[0],
3420 Tokens: tk[:1],
3421 }
3422 }},
3423 {`true`, func(t *test, tk Tokens) { // 4
3424 t.Output = PrimaryExpression{
3425 Literal: &tk[0],
3426 Tokens: tk[:1],
3427 }
3428 }},
3429 {`1.234`, func(t *test, tk Tokens) { // 5
3430 t.Output = PrimaryExpression{
3431 Literal: &tk[0],
3432 Tokens: tk[:1],
3433 }
3434 }},
3435 {`"string"`, func(t *test, tk Tokens) { // 6
3436 t.Output = PrimaryExpression{
3437 Literal: &tk[0],
3438 Tokens: tk[:1],
3439 }
3440 }},
3441 {`/a/`, func(t *test, tk Tokens) { // 7
3442 t.Output = PrimaryExpression{
3443 Literal: &tk[0],
3444 Tokens: tk[:1],
3445 }
3446 }},
3447 {`[yield]`, func(t *test, tk Tokens) { // 8
3448 t.Yield = true
3449 t.Err = Error{
3450 Err: Error{
3451 Err: Error{
3452 Err: Error{
3453 Err: assignmentError(tk[2]),
3454 Parsing: "AssignmentExpression",
3455 Token: tk[2],
3456 },
3457 Parsing: "ArrayElement",
3458 Token: tk[1],
3459 },
3460 Parsing: "ArrayLiteral",
3461 Token: tk[1],
3462 },
3463 Parsing: "PrimaryExpression",
3464 Token: tk[0],
3465 }
3466 }},
3467 {`[]`, func(t *test, tk Tokens) { // 9
3468 t.Output = PrimaryExpression{
3469 ArrayLiteral: &ArrayLiteral{
3470 Tokens: tk[:2],
3471 },
3472 Tokens: tk[:2],
3473 }
3474 }},
3475 {`{,}`, func(t *test, tk Tokens) { // 10
3476 t.Err = Error{
3477 Err: Error{
3478 Err: Error{
3479 Err: Error{
3480 Err: ErrInvalidPropertyName,
3481 Parsing: "PropertyName",
3482 Token: tk[1],
3483 },
3484 Parsing: "PropertyDefinition",
3485 Token: tk[1],
3486 },
3487 Parsing: "ObjectLiteral",
3488 Token: tk[1],
3489 },
3490 Parsing: "PrimaryExpression",
3491 Token: tk[0],
3492 }
3493 }},
3494 {`{}`, func(t *test, tk Tokens) { // 11
3495 t.Output = PrimaryExpression{
3496 ObjectLiteral: &ObjectLiteral{
3497 Tokens: tk[:2],
3498 },
3499 Tokens: tk[:2],
3500 }
3501 }},
3502 {"async", func(t *test, tk Tokens) { // 12
3503 t.Err = Error{
3504 Err: Error{
3505 Err: ErrInvalidFunction,
3506 Parsing: "FunctionDeclaration",
3507 Token: tk[1],
3508 },
3509 Parsing: "PrimaryExpression",
3510 Token: tk[0],
3511 }
3512 }},
3513 {"async function(){}", func(t *test, tk Tokens) { // 13
3514 t.Output = PrimaryExpression{
3515 FunctionExpression: &FunctionDeclaration{
3516 Type: FunctionAsync,
3517 FormalParameters: FormalParameters{
3518 Tokens: tk[3:5],
3519 },
3520 FunctionBody: Block{
3521 Tokens: tk[5:7],
3522 },
3523 Tokens: tk[:7],
3524 },
3525 Tokens: tk[:7],
3526 }
3527 }},
3528 {"function", func(t *test, tk Tokens) { // 14
3529 t.Err = Error{
3530 Err: Error{
3531 Err: Error{
3532 Err: ErrMissingOpeningParenthesis,
3533 Parsing: "FormalParameters",
3534 Token: tk[1],
3535 },
3536 Parsing: "FunctionDeclaration",
3537 Token: tk[1],
3538 },
3539 Parsing: "PrimaryExpression",
3540 Token: tk[0],
3541 }
3542 }},
3543 {"function(){}", func(t *test, tk Tokens) { // 15
3544 t.Output = PrimaryExpression{
3545 FunctionExpression: &FunctionDeclaration{
3546 FormalParameters: FormalParameters{
3547 Tokens: tk[1:3],
3548 },
3549 FunctionBody: Block{
3550 Tokens: tk[3:5],
3551 },
3552 Tokens: tk[:5],
3553 },
3554 Tokens: tk[:5],
3555 }
3556 }},
3557 {"class", func(t *test, tk Tokens) { // 16
3558 t.Err = Error{
3559 Err: Error{
3560 Err: ErrMissingOpeningBrace,
3561 Parsing: "ClassDeclaration",
3562 Token: tk[1],
3563 },
3564 Parsing: "PrimaryExpression",
3565 Token: tk[0],
3566 }
3567 }},
3568 {"class{}", func(t *test, tk Tokens) { // 17
3569 t.Output = PrimaryExpression{
3570 ClassExpression: &ClassDeclaration{
3571 Tokens: tk[:3],
3572 },
3573 Tokens: tk[:3],
3574 }
3575 }},
3576 {"``", func(t *test, tk Tokens) { // 18
3577 t.Output = PrimaryExpression{
3578 TemplateLiteral: &TemplateLiteral{
3579 NoSubstitutionTemplate: &tk[0],
3580 Tokens: tk[:1],
3581 },
3582 Tokens: tk[:1],
3583 }
3584 }},
3585 {"`${1 1}`", func(t *test, tk Tokens) { // 19
3586 t.Err = Error{
3587 Err: Error{
3588 Err: ErrInvalidTemplate,
3589 Parsing: "TemplateLiteral",
3590 Token: tk[3],
3591 },
3592 Parsing: "PrimaryExpression",
3593 Token: tk[0],
3594 }
3595 }},
3596 {"(,)", func(t *test, tk Tokens) { // 20
3597 t.Err = Error{
3598 Err: Error{
3599 Err: assignmentError(tk[1]),
3600 Parsing: "ParenthesizedExpression",
3601 Token: tk[1],
3602 },
3603 Parsing: "PrimaryExpression",
3604 Token: tk[0],
3605 }
3606 }},
3607 {"()", func(t *test, tk Tokens) { // 21
3608 t.Output = PrimaryExpression{
3609 ParenthesizedExpression: &ParenthesizedExpression{
3610 Tokens: tk[:2],
3611 },
3612 Tokens: tk[:2],
3613 }
3614 }},
3615 {".", func(t *test, tk Tokens) { // 22
3616 t.Err = Error{
3617 Err: ErrNoIdentifier,
3618 Parsing: "PrimaryExpression",
3619 Token: tk[0],
3620 }
3621 }},
3622 {"a", func(t *test, tk Tokens) { // 23
3623 t.Output = PrimaryExpression{
3624 IdentifierReference: &tk[0],
3625 Tokens: tk[:1],
3626 }
3627 }},
3628 }, func(t *test) (Type, error) {
3629 var pe PrimaryExpression
3630 err := pe.parse(&t.Tokens, t.Yield, t.Await)
3631 return pe, err
3632 })
3633 }
3634
3635 func TestParenthesizedExpression(t *testing.T) {
3636 doTests(t, []sourceFn{
3637 {``, func(t *test, tk Tokens) { // 1
3638 t.Err = Error{
3639 Err: ErrMissingOpeningParenthesis,
3640 Parsing: "ParenthesizedExpression",
3641 Token: tk[0],
3642 }
3643 }},
3644 {"(\n)", func(t *test, tk Tokens) { // 2
3645 t.Output = ParenthesizedExpression{
3646 Tokens: tk[:3],
3647 }
3648 }},
3649 {"(\n...\n[{,}])", func(t *test, tk Tokens) { // 3
3650 t.Err = Error{
3651 Err: Error{
3652 Err: Error{
3653 Err: Error{
3654 Err: Error{
3655 Err: Error{
3656 Err: ErrInvalidPropertyName,
3657 Parsing: "PropertyName",
3658 Token: tk[6],
3659 },
3660 Parsing: "BindingProperty",
3661 Token: tk[6],
3662 },
3663 Parsing: "ObjectBindingPattern",
3664 Token: tk[6],
3665 },
3666 Parsing: "BindingElement",
3667 Token: tk[5],
3668 },
3669 Parsing: "ArrayBindingPattern",
3670 Token: tk[5],
3671 },
3672 Parsing: "ParenthesizedExpression",
3673 Token: tk[4],
3674 }
3675 }},
3676 {"(\n...\n[a]\n)", func(t *test, tk Tokens) { // 4
3677 t.Output = ParenthesizedExpression{
3678 arrayBindingPattern: &ArrayBindingPattern{
3679 BindingElementList: []BindingElement{
3680 {
3681 SingleNameBinding: &tk[5],
3682 Tokens: tk[5:6],
3683 },
3684 },
3685 Tokens: tk[4:7],
3686 },
3687 Tokens: tk[:9],
3688 }
3689 }},
3690 {"(\n...\n{,})", func(t *test, tk Tokens) { // 5
3691 t.Err = Error{
3692 Err: Error{
3693 Err: Error{
3694 Err: Error{
3695 Err: ErrInvalidPropertyName,
3696 Parsing: "PropertyName",
3697 Token: tk[5],
3698 },
3699 Parsing: "BindingProperty",
3700 Token: tk[5],
3701 },
3702 Parsing: "ObjectBindingPattern",
3703 Token: tk[5],
3704 },
3705 Parsing: "ParenthesizedExpression",
3706 Token: tk[4],
3707 }
3708 }},
3709 {"(\n...\n{}\n)", func(t *test, tk Tokens) { // 6
3710 t.Output = ParenthesizedExpression{
3711 objectBindingPattern: &ObjectBindingPattern{
3712 Tokens: tk[4:6],
3713 },
3714 Tokens: tk[:8],
3715 }
3716 }},
3717 {"(\n...\n1\n)", func(t *test, tk Tokens) { // 7
3718 t.Err = Error{
3719 Err: ErrNoIdentifier,
3720 Parsing: "ParenthesizedExpression",
3721 Token: tk[4],
3722 }
3723 }},
3724 {"(\n...\na\n)", func(t *test, tk Tokens) { // 8
3725 t.Output = ParenthesizedExpression{
3726 bindingIdentifier: &tk[4],
3727 Tokens: tk[:7],
3728 }
3729 }},
3730 {"(\n...\na\n,)", func(t *test, tk Tokens) { // 9
3731 t.Err = Error{
3732 Err: ErrMissingClosingParenthesis,
3733 Parsing: "ParenthesizedExpression",
3734 Token: tk[6],
3735 }
3736 }},
3737 {"(\n,)", func(t *test, tk Tokens) { // 10
3738 t.Err = Error{
3739 Err: assignmentError(tk[2]),
3740 Parsing: "ParenthesizedExpression",
3741 Token: tk[2],
3742 }
3743 }},
3744 {"(\n1\n)", func(t *test, tk Tokens) { // 11
3745 lit1 := makeConditionLiteral(tk, 2)
3746 t.Output = ParenthesizedExpression{
3747 Expressions: []AssignmentExpression{
3748 {
3749 ConditionalExpression: &lit1,
3750 Tokens: tk[2:3],
3751 },
3752 },
3753 Tokens: tk[:5],
3754 }
3755 }},
3756 {"(\n1\n2)", func(t *test, tk Tokens) { // 12
3757 t.Err = Error{
3758 Err: ErrMissingComma,
3759 Parsing: "ParenthesizedExpression",
3760 Token: tk[4],
3761 }
3762 }},
3763 {"(\n1\n,\n2\n)", func(t *test, tk Tokens) { // 13
3764 lit1 := makeConditionLiteral(tk, 2)
3765 lit2 := makeConditionLiteral(tk, 6)
3766 t.Output = ParenthesizedExpression{
3767 Expressions: []AssignmentExpression{
3768 {
3769 ConditionalExpression: &lit1,
3770 Tokens: tk[2:3],
3771 },
3772 {
3773 ConditionalExpression: &lit2,
3774 Tokens: tk[6:7],
3775 },
3776 },
3777 Tokens: tk[:9],
3778 }
3779 }},
3780 {"(\n1\n,\n...\na\n)", func(t *test, tk Tokens) { // 14
3781 lit1 := makeConditionLiteral(tk, 2)
3782 t.Output = ParenthesizedExpression{
3783 Expressions: []AssignmentExpression{
3784 {
3785 ConditionalExpression: &lit1,
3786 Tokens: tk[2:3],
3787 },
3788 },
3789 bindingIdentifier: &tk[8],
3790 Tokens: tk[:11],
3791 }
3792 }},
3793 }, func(t *test) (Type, error) {
3794 var c ParenthesizedExpression
3795 err := c.parse(&t.Tokens, t.Yield, t.Await)
3796 return c, err
3797 })
3798 }
3799
3800 func TestArguments(t *testing.T) {
3801 doTests(t, []sourceFn{
3802 {``, func(t *test, tk Tokens) { // 1
3803 t.Err = Error{
3804 Err: ErrMissingOpeningParenthesis,
3805 Parsing: "Arguments",
3806 Token: tk[0],
3807 }
3808 }},
3809 {"(\n)", func(t *test, tk Tokens) { // 2
3810 t.Output = Arguments{
3811 Tokens: tk[:3],
3812 }
3813 }},
3814 {"(\n...\n)", func(t *test, tk Tokens) { // 3
3815 t.Err = Error{
3816 Err: Error{
3817 Err: assignmentError(tk[4]),
3818 Parsing: "Argument",
3819 Token: tk[4],
3820 },
3821 Parsing: "Arguments",
3822 Token: tk[2],
3823 }
3824 }},
3825 {"(\n...\na\n)", func(t *test, tk Tokens) { // 4
3826 litA := makeConditionLiteral(tk, 4)
3827 t.Output = Arguments{
3828 ArgumentList: []Argument{
3829 {
3830 Spread: true,
3831 AssignmentExpression: AssignmentExpression{
3832 ConditionalExpression: &litA,
3833 Tokens: tk[4:5],
3834 },
3835 Tokens: tk[2:5],
3836 },
3837 },
3838 Tokens: tk[:7],
3839 }
3840 }},
3841 {"(\n...\na\nb)", func(t *test, tk Tokens) { // 5
3842 t.Err = Error{
3843 Err: ErrMissingComma,
3844 Parsing: "Arguments",
3845 Token: tk[6],
3846 }
3847 }},
3848 {"(\n,)", func(t *test, tk Tokens) { // 6
3849 t.Err = Error{
3850 Err: Error{
3851 Err: assignmentError(tk[2]),
3852 Parsing: "Argument",
3853 Token: tk[2],
3854 },
3855 Parsing: "Arguments",
3856 Token: tk[2],
3857 }
3858 }},
3859 {"(\na\n)", func(t *test, tk Tokens) { // 7
3860 litA := makeConditionLiteral(tk, 2)
3861 t.Output = Arguments{
3862 ArgumentList: []Argument{
3863 {
3864 AssignmentExpression: AssignmentExpression{
3865 ConditionalExpression: &litA,
3866 Tokens: tk[2:3],
3867 },
3868 Tokens: tk[2:3],
3869 },
3870 },
3871 Tokens: tk[:5],
3872 }
3873 }},
3874 {"(\na\nb)", func(t *test, tk Tokens) { // 8
3875 t.Err = Error{
3876 Err: ErrMissingComma,
3877 Parsing: "Arguments",
3878 Token: tk[4],
3879 }
3880 }},
3881 {"(\na\n,\nb\n)", func(t *test, tk Tokens) { // 9
3882 litA := makeConditionLiteral(tk, 2)
3883 litB := makeConditionLiteral(tk, 6)
3884 t.Output = Arguments{
3885 ArgumentList: []Argument{
3886 {
3887 AssignmentExpression: AssignmentExpression{
3888 ConditionalExpression: &litA,
3889 Tokens: tk[2:3],
3890 },
3891 Tokens: tk[2:3],
3892 },
3893 {
3894 AssignmentExpression: AssignmentExpression{
3895 ConditionalExpression: &litB,
3896 Tokens: tk[6:7],
3897 },
3898 Tokens: tk[6:7],
3899 },
3900 },
3901 Tokens: tk[:9],
3902 }
3903 }},
3904 {"(\na\n,\n...\nb\n)", func(t *test, tk Tokens) { // 10
3905 litA := makeConditionLiteral(tk, 2)
3906 litB := makeConditionLiteral(tk, 8)
3907 t.Output = Arguments{
3908 ArgumentList: []Argument{
3909 {
3910 AssignmentExpression: AssignmentExpression{
3911 ConditionalExpression: &litA,
3912 Tokens: tk[2:3],
3913 },
3914 Tokens: tk[2:3],
3915 },
3916 {
3917 Spread: true,
3918 AssignmentExpression: AssignmentExpression{
3919 ConditionalExpression: &litB,
3920 Tokens: tk[8:9],
3921 },
3922 Tokens: tk[6:9],
3923 },
3924 },
3925 Tokens: tk[:11],
3926 }
3927 }},
3928 {"(async function(){})", func(t *test, tk Tokens) { // 11
3929 t.Output = Arguments{
3930 ArgumentList: []Argument{
3931 {
3932 AssignmentExpression: AssignmentExpression{
3933 ConditionalExpression: WrapConditional(PrimaryExpression{
3934 FunctionExpression: &FunctionDeclaration{
3935 Type: FunctionAsync,
3936 FormalParameters: FormalParameters{
3937 Tokens: tk[4:6],
3938 },
3939 FunctionBody: Block{
3940 Tokens: tk[6:8],
3941 },
3942 Tokens: tk[1:8],
3943 },
3944 Tokens: tk[1:8],
3945 }),
3946 Tokens: tk[1:8],
3947 },
3948 Tokens: tk[1:8],
3949 },
3950 },
3951 Tokens: tk[:9],
3952 }
3953 }},
3954 }, func(t *test) (Type, error) {
3955 var a Arguments
3956 err := a.parse(&t.Tokens, t.Yield, t.Await)
3957 return a, err
3958 })
3959 }
3960
3961 func TestCallExpression(t *testing.T) {
3962 doTests(t, []sourceFn{
3963 {``, func(t *test, tk Tokens) { // 1
3964 t.Err = Error{
3965 Err: ErrInvalidCallExpression,
3966 Parsing: "CallExpression",
3967 Token: tk[0],
3968 }
3969 }},
3970 {"super", func(t *test, tk Tokens) { // 2
3971 t.Err = Error{
3972 Err: Error{
3973 Err: ErrMissingOpeningParenthesis,
3974 Parsing: "Arguments",
3975 Token: tk[1],
3976 },
3977 Parsing: "CallExpression",
3978 Token: tk[1],
3979 }
3980 }},
3981 {"super\n()", func(t *test, tk Tokens) { // 3
3982 t.Output = CallExpression{
3983 SuperCall: true,
3984 Arguments: &Arguments{
3985 Tokens: tk[2:4],
3986 },
3987 Tokens: tk[:4],
3988 }
3989 }},
3990 {"import", func(t *test, tk Tokens) { // 4
3991 t.Err = Error{
3992 Err: ErrMissingOpeningParenthesis,
3993 Parsing: "CallExpression",
3994 Token: tk[1],
3995 }
3996 }},
3997 {"import\n(\n)", func(t *test, tk Tokens) { // 5
3998 t.Err = Error{
3999 Err: assignmentError(tk[4]),
4000 Parsing: "CallExpression",
4001 Token: tk[4],
4002 }
4003 }},
4004 {"import\n(\na\n)", func(t *test, tk Tokens) { // 6
4005 litA := makeConditionLiteral(tk, 4)
4006 t.Output = CallExpression{
4007 ImportCall: &AssignmentExpression{
4008 ConditionalExpression: &litA,
4009 Tokens: tk[4:5],
4010 },
4011 Tokens: tk[:7],
4012 }
4013 }},
4014 {"import\n(\na\n,\nb\n)", func(t *test, tk Tokens) { // 7
4015 t.Err = Error{
4016 Err: ErrMissingClosingParenthesis,
4017 Parsing: "CallExpression",
4018 Token: tk[6],
4019 }
4020 }},
4021 {"super\n()\n`${1 1}`", func(t *test, tk Tokens) { // 8
4022 t.Err = Error{
4023 Err: Error{
4024 Err: ErrInvalidTemplate,
4025 Parsing: "TemplateLiteral",
4026 Token: tk[8],
4027 },
4028 Parsing: "CallExpression",
4029 Token: tk[5],
4030 }
4031 }},
4032 {"super\n()\n``", func(t *test, tk Tokens) { // 9
4033 t.Output = CallExpression{
4034 CallExpression: &CallExpression{
4035 SuperCall: true,
4036 Arguments: &Arguments{
4037 Tokens: tk[2:4],
4038 },
4039 Tokens: tk[:4],
4040 },
4041 TemplateLiteral: &TemplateLiteral{
4042 NoSubstitutionTemplate: &tk[5],
4043 Tokens: tk[5:6],
4044 },
4045 Tokens: tk[:6],
4046 }
4047 }},
4048 {"super\n()\n(,)", func(t *test, tk Tokens) { // 10
4049 t.Err = Error{
4050 Err: Error{
4051 Err: Error{
4052 Err: assignmentError(tk[6]),
4053 Parsing: "Argument",
4054 Token: tk[6],
4055 },
4056 Parsing: "Arguments",
4057 Token: tk[6],
4058 },
4059 Parsing: "CallExpression",
4060 Token: tk[5],
4061 }
4062 }},
4063 {"super\n()\n()", func(t *test, tk Tokens) { // 11
4064 t.Output = CallExpression{
4065 CallExpression: &CallExpression{
4066 SuperCall: true,
4067 Arguments: &Arguments{
4068 Tokens: tk[2:4],
4069 },
4070 Tokens: tk[:4],
4071 },
4072 Arguments: &Arguments{
4073 Tokens: tk[5:7],
4074 },
4075 Tokens: tk[:7],
4076 }
4077 }},
4078 {"super\n()\n.\n", func(t *test, tk Tokens) { // 12
4079 t.Err = Error{
4080 Err: ErrNoIdentifier,
4081 Parsing: "CallExpression",
4082 Token: tk[7],
4083 }
4084 }},
4085 {"super\n()\n.\na", func(t *test, tk Tokens) { // 13
4086 t.Output = CallExpression{
4087 CallExpression: &CallExpression{
4088 SuperCall: true,
4089 Arguments: &Arguments{
4090 Tokens: tk[2:4],
4091 },
4092 Tokens: tk[:4],
4093 },
4094 IdentifierName: &tk[7],
4095 Tokens: tk[:8],
4096 }
4097 }},
4098 {"super\n()\n[\n]", func(t *test, tk Tokens) { // 14
4099 t.Err = Error{
4100 Err: Error{
4101 Err: assignmentError(tk[7]),
4102 Parsing: "Expression",
4103 Token: tk[7],
4104 },
4105 Parsing: "CallExpression",
4106 Token: tk[5],
4107 }
4108 }},
4109 {"super\n()\n[\na\n]", func(t *test, tk Tokens) { // 15
4110 litA := makeConditionLiteral(tk, 7)
4111 t.Output = CallExpression{
4112 CallExpression: &CallExpression{
4113 SuperCall: true,
4114 Arguments: &Arguments{
4115 Tokens: tk[2:4],
4116 },
4117 Tokens: tk[:4],
4118 },
4119 Expression: &Expression{
4120 Expressions: []AssignmentExpression{
4121 {
4122 ConditionalExpression: &litA,
4123 Tokens: tk[7:8],
4124 },
4125 },
4126 Tokens: tk[7:8],
4127 },
4128 Tokens: tk[:10],
4129 }
4130 }},
4131 {"super\n()\n[\na\nb]", func(t *test, tk Tokens) { // 16
4132 t.Err = Error{
4133 Err: ErrMissingClosingBracket,
4134 Parsing: "CallExpression",
4135 Token: tk[9],
4136 }
4137 }},
4138 {"super\n()\n``\n()\n.\na\n[\nb\n]", func(t *test, tk Tokens) { // 17
4139 litB := makeConditionLiteral(tk, 16)
4140 t.Output = CallExpression{
4141 CallExpression: &CallExpression{
4142 CallExpression: &CallExpression{
4143 CallExpression: &CallExpression{
4144 CallExpression: &CallExpression{
4145 SuperCall: true,
4146 Arguments: &Arguments{
4147 Tokens: tk[2:4],
4148 },
4149 Tokens: tk[:4],
4150 },
4151 TemplateLiteral: &TemplateLiteral{
4152 NoSubstitutionTemplate: &tk[5],
4153 Tokens: tk[5:6],
4154 },
4155 Tokens: tk[:6],
4156 },
4157 Arguments: &Arguments{
4158 Tokens: tk[7:9],
4159 },
4160 Tokens: tk[:9],
4161 },
4162 IdentifierName: &tk[12],
4163 Tokens: tk[:13],
4164 },
4165 Expression: &Expression{
4166 Expressions: []AssignmentExpression{
4167 {
4168 ConditionalExpression: &litB,
4169 Tokens: tk[16:17],
4170 },
4171 },
4172 Tokens: tk[16:17],
4173 },
4174 Tokens: tk[:19],
4175 }
4176 }},
4177 }, func(t *test) (Type, error) {
4178 var ce CallExpression
4179 err := ce.parse(&t.Tokens, nil, t.Yield, t.Await)
4180 return ce, err
4181 })
4182 }
4183
4184 func TestOptionalChain(t *testing.T) {
4185 doTests(t, []sourceFn{
4186 {``, func(t *test, tk Tokens) { // 1
4187 t.Err = Error{
4188 Err: ErrMissingOptional,
4189 Parsing: "OptionalChain",
4190 Token: tk[0],
4191 }
4192 }},
4193 {"?.", func(t *test, tk Tokens) { // 2
4194 t.Err = Error{
4195 Err: ErrInvalidOptionalChain,
4196 Parsing: "OptionalChain",
4197 Token: tk[1],
4198 }
4199 }},
4200 {"?.\n", func(t *test, tk Tokens) { // 3
4201 t.Err = Error{
4202 Err: ErrInvalidOptionalChain,
4203 Parsing: "OptionalChain",
4204 Token: tk[2],
4205 }
4206 }},
4207 {"?.\n()", func(t *test, tk Tokens) { // 4
4208 t.Output = OptionalChain{
4209 Arguments: &Arguments{
4210 Tokens: tk[2:4],
4211 },
4212 Tokens: tk[:4],
4213 }
4214 }},
4215 {"?.\n[\na\n]", func(t *test, tk Tokens) { // 5
4216 litA := makeConditionLiteral(tk, 4)
4217 t.Output = OptionalChain{
4218 Expression: &Expression{
4219 Expressions: []AssignmentExpression{
4220 {
4221 ConditionalExpression: &litA,
4222 Tokens: tk[4:5],
4223 },
4224 },
4225 Tokens: tk[4:5],
4226 },
4227 Tokens: tk[:7],
4228 }
4229 }},
4230 {"?.\na", func(t *test, tk Tokens) { // 6
4231 t.Output = OptionalChain{
4232 IdentifierName: &tk[2],
4233 Tokens: tk[:3],
4234 }
4235 }},
4236 {"?.\n``", func(t *test, tk Tokens) { // 7
4237 t.Output = OptionalChain{
4238 TemplateLiteral: &TemplateLiteral{
4239 NoSubstitutionTemplate: &tk[2],
4240 Tokens: tk[2:3],
4241 },
4242 Tokens: tk[:3],
4243 }
4244 }},
4245 {"?.\n()\n``", func(t *test, tk Tokens) { // 8
4246 t.Output = OptionalChain{
4247 OptionalChain: &OptionalChain{
4248 Arguments: &Arguments{
4249 Tokens: tk[2:4],
4250 },
4251 Tokens: tk[:4],
4252 },
4253 TemplateLiteral: &TemplateLiteral{
4254 NoSubstitutionTemplate: &tk[5],
4255 Tokens: tk[5:6],
4256 },
4257 Tokens: tk[:6],
4258 }
4259 }},
4260 {"?.\n``\n[\na\n]", func(t *test, tk Tokens) { // 9
4261 litA := makeConditionLiteral(tk, 6)
4262 t.Output = OptionalChain{
4263 OptionalChain: &OptionalChain{
4264 TemplateLiteral: &TemplateLiteral{
4265 NoSubstitutionTemplate: &tk[2],
4266 Tokens: tk[2:3],
4267 },
4268 Tokens: tk[:3],
4269 },
4270 Expression: &Expression{
4271 Expressions: []AssignmentExpression{
4272 {
4273 ConditionalExpression: &litA,
4274 Tokens: tk[6:7],
4275 },
4276 },
4277 Tokens: tk[6:7],
4278 },
4279 Tokens: tk[:9],
4280 }
4281 }},
4282 {"?.\n[\na\n]\n.\nb", func(t *test, tk Tokens) { // 10
4283 litA := makeConditionLiteral(tk, 4)
4284 t.Output = OptionalChain{
4285 OptionalChain: &OptionalChain{
4286 Expression: &Expression{
4287 Expressions: []AssignmentExpression{
4288 {
4289 ConditionalExpression: &litA,
4290 Tokens: tk[4:5],
4291 },
4292 },
4293 Tokens: tk[4:5],
4294 },
4295 Tokens: tk[:7],
4296 },
4297 IdentifierName: &tk[10],
4298 Tokens: tk[:11],
4299 }
4300 }},
4301 {"?.\na\n()", func(t *test, tk Tokens) { // 11
4302 t.Output = OptionalChain{
4303 OptionalChain: &OptionalChain{
4304 IdentifierName: &tk[2],
4305 Tokens: tk[:3],
4306 },
4307 Arguments: &Arguments{
4308 Tokens: tk[4:6],
4309 },
4310 Tokens: tk[:6],
4311 }
4312 }},
4313 {"?.(.)", func(t *test, tk Tokens) { // 12
4314 t.Err = Error{
4315 Err: Error{
4316 Err: Error{
4317 Err: assignmentError(tk[2]),
4318 Parsing: "Argument",
4319 Token: tk[2],
4320 },
4321 Parsing: "Arguments",
4322 Token: tk[2],
4323 },
4324 Parsing: "OptionalChain",
4325 Token: tk[1],
4326 }
4327 }},
4328 {"?.[]", func(t *test, tk Tokens) { // 13
4329 t.Err = Error{
4330 Err: Error{
4331 Err: assignmentError(tk[2]),
4332 Parsing: "Expression",
4333 Token: tk[2],
4334 },
4335 Parsing: "OptionalChain",
4336 Token: tk[2],
4337 }
4338 }},
4339 {"?.[1 1]", func(t *test, tk Tokens) { // 14
4340 t.Err = Error{
4341 Err: ErrMissingClosingBracket,
4342 Parsing: "OptionalChain",
4343 Token: tk[4],
4344 }
4345 }},
4346 {"?.`${}`", func(t *test, tk Tokens) { // 15
4347 t.Err = Error{
4348 Err: Error{
4349 Err: Error{
4350 Err: assignmentError(tk[2]),
4351 Parsing: "Expression",
4352 Token: tk[2],
4353 },
4354 Parsing: "TemplateLiteral",
4355 Token: tk[2],
4356 },
4357 Parsing: "OptionalChain",
4358 Token: tk[1],
4359 }
4360 }},
4361 {"?.a(.)", func(t *test, tk Tokens) { // 16
4362 t.Err = Error{
4363 Err: Error{
4364 Err: Error{
4365 Err: assignmentError(tk[3]),
4366 Parsing: "Argument",
4367 Token: tk[3],
4368 },
4369 Parsing: "Arguments",
4370 Token: tk[3],
4371 },
4372 Parsing: "OptionalChain",
4373 Token: tk[2],
4374 }
4375 }},
4376 {"?.a[]", func(t *test, tk Tokens) { // 17
4377 t.Err = Error{
4378 Err: Error{
4379 Err: assignmentError(tk[3]),
4380 Parsing: "Expression",
4381 Token: tk[3],
4382 },
4383 Parsing: "OptionalChain",
4384 Token: tk[3],
4385 }
4386 }},
4387 {"?.a[1 1]", func(t *test, tk Tokens) { // 18
4388 t.Err = Error{
4389 Err: ErrMissingClosingBracket,
4390 Parsing: "OptionalChain",
4391 Token: tk[5],
4392 }
4393 }},
4394 {"?.a.", func(t *test, tk Tokens) { // 19
4395 t.Err = Error{
4396 Err: ErrNoIdentifier,
4397 Parsing: "OptionalChain",
4398 Token: tk[3],
4399 }
4400 }},
4401 {"?.a`${}`", func(t *test, tk Tokens) { // 20
4402 t.Err = Error{
4403 Err: Error{
4404 Err: Error{
4405 Err: assignmentError(tk[3]),
4406 Parsing: "Expression",
4407 Token: tk[3],
4408 },
4409 Parsing: "TemplateLiteral",
4410 Token: tk[3],
4411 },
4412 Parsing: "OptionalChain",
4413 Token: tk[2],
4414 }
4415 }},
4416 }, func(t *test) (Type, error) {
4417 var oc OptionalChain
4418 err := oc.parse(&t.Tokens, t.Yield, t.Await)
4419 return oc, err
4420 })
4421 }
4422
4423 func TestOptionalExpression(t *testing.T) {
4424 doTests(t, []sourceFn{
4425 {``, func(t *test, tk Tokens) { // 1
4426 t.Err = Error{
4427 Err: Error{
4428 Err: ErrMissingOptional,
4429 Parsing: "OptionalChain",
4430 Token: tk[0],
4431 },
4432 Parsing: "OptionalExpression",
4433 Token: tk[0],
4434 }
4435 }},
4436 {"?.", func(t *test, tk Tokens) { // 2
4437 t.Err = Error{
4438 Err: Error{
4439 Err: ErrInvalidOptionalChain,
4440 Parsing: "OptionalChain",
4441 Token: tk[1],
4442 },
4443 Parsing: "OptionalExpression",
4444 Token: tk[0],
4445 }
4446 }},
4447 {"?.\na", func(t *test, tk Tokens) { // 3
4448 t.Output = OptionalExpression{
4449 OptionalChain: OptionalChain{
4450 IdentifierName: &tk[2],
4451 Tokens: tk[:3],
4452 },
4453 Tokens: tk[:3],
4454 }
4455 }},
4456 {"?.\na\n?.", func(t *test, tk Tokens) { // 4
4457 t.Err = Error{
4458 Err: Error{
4459 Err: ErrInvalidOptionalChain,
4460 Parsing: "OptionalChain",
4461 Token: tk[5],
4462 },
4463 Parsing: "OptionalExpression",
4464 Token: tk[4],
4465 }
4466 }},
4467 {"?.\na\n?.\nb", func(t *test, tk Tokens) { // 5
4468 t.Output = OptionalExpression{
4469 OptionalExpression: &OptionalExpression{
4470 OptionalChain: OptionalChain{
4471 IdentifierName: &tk[2],
4472 Tokens: tk[:3],
4473 },
4474 Tokens: tk[:3],
4475 },
4476 OptionalChain: OptionalChain{
4477 IdentifierName: &tk[6],
4478 Tokens: tk[4:7],
4479 },
4480 Tokens: tk[:7],
4481 }
4482 }},
4483 }, func(t *test) (Type, error) {
4484 var oe OptionalExpression
4485 err := oe.parse(&t.Tokens, t.Yield, t.Await, nil, nil)
4486 return oe, err
4487 })
4488 }
4489