javascript - ast_module_test.go
1 package javascript
2
3 import "testing"
4
5 func TestModuleOld(t *testing.T) {
6 doTests(t, []sourceFn{
7 {`import 'a';`, func(t *test, tk Tokens) { // 1
8 t.Output = Module{
9 ModuleListItems: []ModuleItem{
10 {
11 ImportDeclaration: &ImportDeclaration{
12 FromClause: FromClause{
13 ModuleSpecifier: &tk[2],
14 Tokens: tk[2:3],
15 },
16 Tokens: tk[:4],
17 },
18 Tokens: tk[:4],
19 },
20 },
21 Tokens: tk[:4],
22 }
23 }},
24 {`import a from 'b';`, func(t *test, tk Tokens) { // 2
25 t.Output = Module{
26 ModuleListItems: []ModuleItem{
27 {
28 ImportDeclaration: &ImportDeclaration{
29 ImportClause: &ImportClause{
30 ImportedDefaultBinding: &tk[2],
31 Tokens: tk[2:3],
32 },
33 FromClause: FromClause{
34 ModuleSpecifier: &tk[6],
35 Tokens: tk[4:7],
36 },
37 Tokens: tk[:8],
38 },
39 Tokens: tk[:8],
40 },
41 },
42 Tokens: tk[:8],
43 }
44 }},
45 {`import * as a from 'b';`, func(t *test, tk Tokens) { // 3
46 t.Output = Module{
47 ModuleListItems: []ModuleItem{
48 {
49 ImportDeclaration: &ImportDeclaration{
50 ImportClause: &ImportClause{
51 NameSpaceImport: &tk[6],
52 Tokens: tk[2:7],
53 },
54 FromClause: FromClause{
55 ModuleSpecifier: &tk[10],
56 Tokens: tk[8:11],
57 },
58 Tokens: tk[:12],
59 },
60 Tokens: tk[:12],
61 },
62 },
63 Tokens: tk[:12],
64 }
65 }},
66 {`import {a} from 'b';`, func(t *test, tk Tokens) { // 4
67 t.Output = Module{
68 ModuleListItems: []ModuleItem{
69 {
70 ImportDeclaration: &ImportDeclaration{
71 ImportClause: &ImportClause{
72 NamedImports: &NamedImports{
73 ImportList: []ImportSpecifier{
74 {
75 IdentifierName: &tk[3],
76 ImportedBinding: &tk[3],
77 Tokens: tk[3:4],
78 },
79 },
80 Tokens: tk[2:5],
81 },
82 Tokens: tk[2:5],
83 },
84 FromClause: FromClause{
85 ModuleSpecifier: &tk[8],
86 Tokens: tk[6:9],
87 },
88 Tokens: tk[:10],
89 },
90 Tokens: tk[:10],
91 },
92 },
93 Tokens: tk[:10],
94 }
95 }},
96 {`import {a as b} from 'c';`, func(t *test, tk Tokens) { // 5
97 t.Output = Module{
98 ModuleListItems: []ModuleItem{
99 {
100 ImportDeclaration: &ImportDeclaration{
101 ImportClause: &ImportClause{
102 NamedImports: &NamedImports{
103 ImportList: []ImportSpecifier{
104 {
105 IdentifierName: &tk[3],
106 ImportedBinding: &tk[7],
107 Tokens: tk[3:8],
108 },
109 },
110 Tokens: tk[2:9],
111 },
112 Tokens: tk[2:9],
113 },
114 FromClause: FromClause{
115 ModuleSpecifier: &tk[12],
116 Tokens: tk[10:13],
117 },
118 Tokens: tk[:14],
119 },
120 Tokens: tk[:14],
121 },
122 },
123 Tokens: tk[:14],
124 }
125 }},
126 {`import {a as b, c} from 'd';`, func(t *test, tk Tokens) { // 6
127 t.Output = Module{
128 ModuleListItems: []ModuleItem{
129 {
130 ImportDeclaration: &ImportDeclaration{
131 ImportClause: &ImportClause{
132 NamedImports: &NamedImports{
133 ImportList: []ImportSpecifier{
134 {
135 IdentifierName: &tk[3],
136 ImportedBinding: &tk[7],
137 Tokens: tk[3:8],
138 },
139 {
140 IdentifierName: &tk[10],
141 ImportedBinding: &tk[10],
142 Tokens: tk[10:11],
143 },
144 },
145 Tokens: tk[2:12],
146 },
147 Tokens: tk[2:12],
148 },
149 FromClause: FromClause{
150 ModuleSpecifier: &tk[15],
151 Tokens: tk[13:16],
152 },
153 Tokens: tk[:17],
154 },
155 Tokens: tk[:17],
156 },
157 },
158 Tokens: tk[:17],
159 }
160 }},
161 {`import a, * as b from 'c';`, func(t *test, tk Tokens) { // 7
162 t.Output = Module{
163 ModuleListItems: []ModuleItem{
164 {
165 ImportDeclaration: &ImportDeclaration{
166 ImportClause: &ImportClause{
167 ImportedDefaultBinding: &tk[2],
168 NameSpaceImport: &tk[9],
169 Tokens: tk[2:10],
170 },
171 FromClause: FromClause{
172 ModuleSpecifier: &tk[13],
173 Tokens: tk[11:14],
174 },
175 Tokens: tk[:15],
176 },
177 Tokens: tk[:15],
178 },
179 },
180 Tokens: tk[:15],
181 }
182 }},
183 {`import a, {b} from 'c';`, func(t *test, tk Tokens) { // 8
184 t.Output = Module{
185 ModuleListItems: []ModuleItem{
186 {
187 ImportDeclaration: &ImportDeclaration{
188 ImportClause: &ImportClause{
189 ImportedDefaultBinding: &tk[2],
190 NamedImports: &NamedImports{
191 ImportList: []ImportSpecifier{
192 {
193 IdentifierName: &tk[6],
194 ImportedBinding: &tk[6],
195 Tokens: tk[6:7],
196 },
197 },
198 Tokens: tk[5:8],
199 },
200 Tokens: tk[2:8],
201 },
202 FromClause: FromClause{
203 ModuleSpecifier: &tk[11],
204 Tokens: tk[9:12],
205 },
206 Tokens: tk[:13],
207 },
208 Tokens: tk[:13],
209 },
210 },
211 Tokens: tk[:13],
212 }
213 }},
214 {`export {};`, func(t *test, tk Tokens) { // 9
215 t.Output = Module{
216 ModuleListItems: []ModuleItem{
217 {
218 ExportDeclaration: &ExportDeclaration{
219 ExportClause: &ExportClause{
220 Tokens: tk[2:4],
221 },
222 Tokens: tk[:5],
223 },
224 Tokens: tk[:5],
225 },
226 },
227 Tokens: tk[:5],
228 }
229 }},
230 {`export {a};`, func(t *test, tk Tokens) { // 10
231 t.Output = Module{
232 ModuleListItems: []ModuleItem{
233 {
234 ExportDeclaration: &ExportDeclaration{
235 ExportClause: &ExportClause{
236 ExportList: []ExportSpecifier{
237 {
238 IdentifierName: &tk[3],
239 EIdentifierName: &tk[3],
240 Tokens: tk[3:4],
241 },
242 },
243 Tokens: tk[2:5],
244 },
245 Tokens: tk[:6],
246 },
247 Tokens: tk[:6],
248 },
249 },
250 Tokens: tk[:6],
251 }
252 }},
253 {`export {a as b};`, func(t *test, tk Tokens) { // 11
254 t.Output = Module{
255 ModuleListItems: []ModuleItem{
256 {
257 ExportDeclaration: &ExportDeclaration{
258 ExportClause: &ExportClause{
259 ExportList: []ExportSpecifier{
260 {
261 IdentifierName: &tk[3],
262 EIdentifierName: &tk[7],
263 Tokens: tk[3:8],
264 },
265 },
266 Tokens: tk[2:9],
267 },
268 Tokens: tk[:10],
269 },
270 Tokens: tk[:10],
271 },
272 },
273 Tokens: tk[:10],
274 }
275 }},
276 {`export {a as b, c as d, e, f};`, func(t *test, tk Tokens) { // 12
277 t.Output = Module{
278 ModuleListItems: []ModuleItem{
279 {
280 ExportDeclaration: &ExportDeclaration{
281 ExportClause: &ExportClause{
282 ExportList: []ExportSpecifier{
283 {
284 IdentifierName: &tk[3],
285 EIdentifierName: &tk[7],
286 Tokens: tk[3:8],
287 },
288 {
289 IdentifierName: &tk[10],
290 EIdentifierName: &tk[14],
291 Tokens: tk[10:15],
292 },
293 {
294 IdentifierName: &tk[17],
295 EIdentifierName: &tk[17],
296 Tokens: tk[17:18],
297 },
298 {
299 IdentifierName: &tk[20],
300 EIdentifierName: &tk[20],
301 Tokens: tk[20:21],
302 },
303 },
304 Tokens: tk[2:22],
305 },
306 Tokens: tk[:23],
307 },
308 Tokens: tk[:23],
309 },
310 },
311 Tokens: tk[:23],
312 }
313 }},
314 {`export * from 'a';`, func(t *test, tk Tokens) { // 13
315 t.Output = Module{
316 ModuleListItems: []ModuleItem{
317 {
318 ExportDeclaration: &ExportDeclaration{
319 FromClause: &FromClause{
320 ModuleSpecifier: &tk[6],
321 Tokens: tk[4:7],
322 },
323 Tokens: tk[:8],
324 },
325 Tokens: tk[:8],
326 },
327 },
328 Tokens: tk[:8],
329 }
330 }},
331 {`export {} from 'a';`, func(t *test, tk Tokens) { // 14
332 t.Output = Module{
333 ModuleListItems: []ModuleItem{
334 {
335 ExportDeclaration: &ExportDeclaration{
336 ExportClause: &ExportClause{
337 Tokens: tk[2:4],
338 },
339 FromClause: &FromClause{
340 ModuleSpecifier: &tk[7],
341 Tokens: tk[5:8],
342 },
343 Tokens: tk[:9],
344 },
345 Tokens: tk[:9],
346 },
347 },
348 Tokens: tk[:9],
349 }
350 }},
351 {`export {a} from 'b';`, func(t *test, tk Tokens) { // 15
352 t.Output = Module{
353 ModuleListItems: []ModuleItem{
354 {
355 ExportDeclaration: &ExportDeclaration{
356 ExportClause: &ExportClause{
357 ExportList: []ExportSpecifier{
358 {
359 IdentifierName: &tk[3],
360 EIdentifierName: &tk[3],
361 Tokens: tk[3:4],
362 },
363 },
364 Tokens: tk[2:5],
365 },
366 FromClause: &FromClause{
367 ModuleSpecifier: &tk[8],
368 Tokens: tk[6:9],
369 },
370 Tokens: tk[:10],
371 },
372 Tokens: tk[:10],
373 },
374 },
375 Tokens: tk[:10],
376 }
377 }},
378 {`export {a as b} from 'c';`, func(t *test, tk Tokens) { // 16
379 t.Output = Module{
380 ModuleListItems: []ModuleItem{
381 {
382 ExportDeclaration: &ExportDeclaration{
383 ExportClause: &ExportClause{
384 ExportList: []ExportSpecifier{
385 {
386 IdentifierName: &tk[3],
387 EIdentifierName: &tk[7],
388 Tokens: tk[3:8],
389 },
390 },
391 Tokens: tk[2:9],
392 },
393 FromClause: &FromClause{
394 ModuleSpecifier: &tk[12],
395 Tokens: tk[10:13],
396 },
397 Tokens: tk[:14],
398 },
399 Tokens: tk[:14],
400 },
401 },
402 Tokens: tk[:14],
403 }
404 }},
405 {`export {a as b, c as d, e, f} from 'g';`, func(t *test, tk Tokens) { // 17
406 t.Output = Module{
407 ModuleListItems: []ModuleItem{
408 {
409 ExportDeclaration: &ExportDeclaration{
410 ExportClause: &ExportClause{
411 ExportList: []ExportSpecifier{
412 {
413 IdentifierName: &tk[3],
414 EIdentifierName: &tk[7],
415 Tokens: tk[3:8],
416 },
417 {
418 IdentifierName: &tk[10],
419 EIdentifierName: &tk[14],
420 Tokens: tk[10:15],
421 },
422 {
423 IdentifierName: &tk[17],
424 EIdentifierName: &tk[17],
425 Tokens: tk[17:18],
426 },
427 {
428 IdentifierName: &tk[20],
429 EIdentifierName: &tk[20],
430 Tokens: tk[20:21],
431 },
432 },
433 Tokens: tk[2:22],
434 },
435 FromClause: &FromClause{
436 ModuleSpecifier: &tk[25],
437 Tokens: tk[23:26],
438 },
439 Tokens: tk[:27],
440 },
441 Tokens: tk[:27],
442 },
443 },
444 Tokens: tk[:27],
445 }
446 }},
447 {`export var a = 1;`, func(t *test, tk Tokens) { // 18
448 litA := makeConditionLiteral(tk, 8)
449 t.Output = Module{
450 ModuleListItems: []ModuleItem{
451 {
452 ExportDeclaration: &ExportDeclaration{
453 VariableStatement: &VariableStatement{
454 VariableDeclarationList: []VariableDeclaration{
455 {
456 BindingIdentifier: &tk[4],
457 Initializer: &AssignmentExpression{
458 ConditionalExpression: &litA,
459 Tokens: tk[8:9],
460 },
461 Tokens: tk[4:9],
462 },
463 },
464 Tokens: tk[2:10],
465 },
466 Tokens: tk[:10],
467 },
468 Tokens: tk[:10],
469 },
470 },
471 Tokens: tk[:10],
472 }
473 }},
474 {`export function a(){}`, func(t *test, tk Tokens) { // 19
475 t.Output = Module{
476 ModuleListItems: []ModuleItem{
477 {
478 ExportDeclaration: &ExportDeclaration{
479 Declaration: &Declaration{
480 FunctionDeclaration: &FunctionDeclaration{
481 BindingIdentifier: &tk[4],
482 FormalParameters: FormalParameters{
483 Tokens: tk[5:7],
484 },
485 FunctionBody: Block{
486 Tokens: tk[7:9],
487 },
488 Tokens: tk[2:9],
489 },
490 Tokens: tk[2:9],
491 },
492 Tokens: tk[:9],
493 },
494 Tokens: tk[:9],
495 },
496 },
497 Tokens: tk[:9],
498 }
499 }},
500 {`export default function(){}`, func(t *test, tk Tokens) { // 20
501 t.Output = Module{
502 ModuleListItems: []ModuleItem{
503 {
504 ExportDeclaration: &ExportDeclaration{
505 DefaultFunction: &FunctionDeclaration{
506 FormalParameters: FormalParameters{
507 Tokens: tk[5:7],
508 },
509 FunctionBody: Block{
510 Tokens: tk[7:9],
511 },
512 Tokens: tk[4:9],
513 },
514 Tokens: tk[:9],
515 },
516 Tokens: tk[:9],
517 },
518 },
519 Tokens: tk[:9],
520 }
521 }},
522 {`export default class{}`, func(t *test, tk Tokens) { // 21
523 t.Output = Module{
524 ModuleListItems: []ModuleItem{
525 {
526 ExportDeclaration: &ExportDeclaration{
527 DefaultClass: &ClassDeclaration{
528 Tokens: tk[4:7],
529 },
530 Tokens: tk[:7],
531 },
532 Tokens: tk[:7],
533 },
534 },
535 Tokens: tk[:7],
536 }
537 }},
538 {`export default 1;`, func(t *test, tk Tokens) { // 22
539 litA := makeConditionLiteral(tk, 4)
540 t.Output = Module{
541 ModuleListItems: []ModuleItem{
542 {
543 ExportDeclaration: &ExportDeclaration{
544 DefaultAssignmentExpression: &AssignmentExpression{
545 ConditionalExpression: &litA,
546 Tokens: tk[4:5],
547 },
548 Tokens: tk[:6],
549 },
550 Tokens: tk[:6],
551 },
552 },
553 Tokens: tk[:6],
554 }
555 }},
556 {`1;`, func(t *test, tk Tokens) { // 23
557 litA := makeConditionLiteral(tk, 0)
558 t.Output = Module{
559 ModuleListItems: []ModuleItem{
560 {
561 StatementListItem: &StatementListItem{
562 Statement: &Statement{
563 ExpressionStatement: &Expression{
564 Expressions: []AssignmentExpression{
565 {
566 ConditionalExpression: &litA,
567 Tokens: tk[:1],
568 },
569 },
570 Tokens: tk[:1],
571 },
572 Tokens: tk[:2],
573 },
574 Tokens: tk[:2],
575 },
576 Tokens: tk[:2],
577 },
578 },
579 Tokens: tk[:2],
580 }
581 }},
582 }, func(t *test) (Type, error) {
583 var m Module
584 err := m.parse(&t.Tokens)
585 return m, err
586 })
587 }
588
589 func TestModule(t *testing.T) {
590 doTests(t, []sourceFn{
591 {``, func(t *test, tk Tokens) { // 1
592 t.Output = Module{
593 Tokens: tk[:0],
594 }
595 }},
596 {`import`, func(t *test, tk Tokens) { // 2
597 t.Err = Error{
598 Err: Error{
599 Err: Error{
600 Err: ErrInvalidImport,
601 Parsing: "ImportClause",
602 Token: tk[1],
603 },
604 Parsing: "ImportDeclaration",
605 Token: tk[1],
606 },
607 Parsing: "ModuleItem",
608 Token: tk[0],
609 }
610 }},
611 {`;;`, func(t *test, tk Tokens) { // 3
612 t.Output = Module{
613 ModuleListItems: []ModuleItem{
614 {
615 StatementListItem: &StatementListItem{
616 Statement: &Statement{
617 Tokens: tk[:1],
618 },
619 Tokens: tk[:1],
620 },
621 Tokens: tk[:1],
622 },
623 {
624 StatementListItem: &StatementListItem{
625 Statement: &Statement{
626 Tokens: tk[1:2],
627 },
628 Tokens: tk[1:2],
629 },
630 Tokens: tk[1:2],
631 },
632 },
633 Tokens: tk[:2],
634 }
635 }},
636 {`await a`, func(t *test, tk Tokens) { // 4
637 t.Output = Module{
638 ModuleListItems: []ModuleItem{
639 {
640 StatementListItem: &StatementListItem{
641 Statement: &Statement{
642 ExpressionStatement: &Expression{
643 Expressions: []AssignmentExpression{
644 {
645 ConditionalExpression: WrapConditional(UnaryExpression{
646 UnaryOperators: []UnaryOperator{
647 UnaryAwait,
648 },
649 UpdateExpression: UpdateExpression{
650 LeftHandSideExpression: &LeftHandSideExpression{
651 NewExpression: &NewExpression{
652 MemberExpression: MemberExpression{
653 PrimaryExpression: &PrimaryExpression{
654 IdentifierReference: &tk[2],
655 Tokens: tk[2:3],
656 },
657 Tokens: tk[2:3],
658 },
659 Tokens: tk[2:3],
660 },
661 Tokens: tk[2:3],
662 },
663 Tokens: tk[2:3],
664 },
665 Tokens: tk[:3],
666 }),
667 Tokens: tk[:3],
668 },
669 },
670 Tokens: tk[:3],
671 },
672 Tokens: tk[:3],
673 },
674 Tokens: tk[:3],
675 },
676 Tokens: tk[:3],
677 },
678 },
679 Tokens: tk[:3],
680 }
681 }},
682 }, func(t *test) (Type, error) {
683 var m Module
684 err := m.parse(&t.Tokens)
685 return m, err
686 })
687 }
688
689 func TestModuleItem(t *testing.T) {
690 doTests(t, []sourceFn{ // 1
691 {``, func(t *test, tk Tokens) { // 1
692 t.Err = Error{
693 Err: Error{
694 Err: Error{
695 Err: Error{
696 Err: assignmentError(tk[0]),
697 Parsing: "Expression",
698 Token: tk[0],
699 },
700 Parsing: "Statement",
701 Token: tk[0],
702 },
703 Parsing: "StatementListItem",
704 Token: tk[0],
705 },
706 Parsing: "ModuleItem",
707 Token: tk[0],
708 }
709 }},
710 {"import", func(t *test, tk Tokens) { // 2
711 t.Err = Error{
712 Err: Error{
713 Err: Error{
714 Err: ErrInvalidImport,
715 Parsing: "ImportClause",
716 Token: tk[1],
717 },
718 Parsing: "ImportDeclaration",
719 Token: tk[1],
720 },
721 Parsing: "ModuleItem",
722 Token: tk[0],
723 }
724 }},
725 {"import\n'a';", func(t *test, tk Tokens) { // 3
726 t.Output = ModuleItem{
727 ImportDeclaration: &ImportDeclaration{
728 FromClause: FromClause{
729 ModuleSpecifier: &tk[2],
730 Tokens: tk[2:3],
731 },
732 Tokens: tk[:4],
733 },
734 Tokens: tk[:4],
735 }
736 }},
737 {"export", func(t *test, tk Tokens) { // 4
738 t.Err = Error{
739 Err: Error{
740 Err: Error{
741 Err: ErrInvalidDeclaration,
742 Parsing: "Declaration",
743 Token: tk[1],
744 },
745 Parsing: "ExportDeclaration",
746 Token: tk[1],
747 },
748 Parsing: "ModuleItem",
749 Token: tk[0],
750 }
751 }},
752 {"export\n*\nfrom\n'a';", func(t *test, tk Tokens) { // 5
753 t.Output = ModuleItem{
754 ExportDeclaration: &ExportDeclaration{
755 FromClause: &FromClause{
756 ModuleSpecifier: &tk[6],
757 Tokens: tk[4:7],
758 },
759 Tokens: tk[:8],
760 },
761 Tokens: tk[:8],
762 }
763 }},
764 {"var", func(t *test, tk Tokens) { // 6
765 t.Err = Error{
766 Err: Error{
767 Err: Error{
768 Err: Error{
769 Err: Error{
770 Err: ErrNoIdentifier,
771 Parsing: "LexicalBinding",
772 Token: tk[1],
773 },
774 Parsing: "VariableStatement",
775 Token: tk[1],
776 },
777 Parsing: "Statement",
778 Token: tk[0],
779 },
780 Parsing: "StatementListItem",
781 Token: tk[0],
782 },
783 Parsing: "ModuleItem",
784 Token: tk[0],
785 }
786 }},
787 {"var\na;", func(t *test, tk Tokens) { // 7
788 t.Output = ModuleItem{
789 StatementListItem: &StatementListItem{
790 Statement: &Statement{
791 VariableStatement: &VariableStatement{
792 VariableDeclarationList: []VariableDeclaration{
793 {
794 BindingIdentifier: &tk[2],
795 Tokens: tk[2:3],
796 },
797 },
798 Tokens: tk[:4],
799 },
800 Tokens: tk[:4],
801 },
802 Tokens: tk[:4],
803 },
804 Tokens: tk[:4],
805 }
806 }},
807 {"import.meta", func(t *test, tk Tokens) { // 8
808 t.Output = ModuleItem{
809 StatementListItem: &StatementListItem{
810 Statement: &Statement{
811 ExpressionStatement: &Expression{
812 Expressions: []AssignmentExpression{
813 {
814 ConditionalExpression: WrapConditional(MemberExpression{
815 ImportMeta: true,
816 Tokens: tk[:3],
817 }),
818 Tokens: tk[:3],
819 },
820 },
821 Tokens: tk[:3],
822 },
823 Tokens: tk[:3],
824 },
825 Tokens: tk[:3],
826 },
827 Tokens: tk[:3],
828 }
829 }},
830 {"import(a)", func(t *test, tk Tokens) { // 9
831 t.Output = ModuleItem{
832 StatementListItem: &StatementListItem{
833 Statement: &Statement{
834 ExpressionStatement: &Expression{
835 Expressions: []AssignmentExpression{
836 {
837 ConditionalExpression: WrapConditional(&CallExpression{
838 ImportCall: &AssignmentExpression{
839 ConditionalExpression: WrapConditional(&PrimaryExpression{
840 IdentifierReference: &tk[2],
841 Tokens: tk[2:3],
842 }),
843 Tokens: tk[2:3],
844 },
845 Tokens: tk[:4],
846 }),
847 Tokens: tk[:4],
848 },
849 },
850 Tokens: tk[:4],
851 },
852 Tokens: tk[:4],
853 },
854 Tokens: tk[:4],
855 },
856 Tokens: tk[:4],
857 }
858 }},
859 }, func(t *test) (Type, error) {
860 var mi ModuleItem
861 err := mi.parse(&t.Tokens)
862 return mi, err
863 })
864 }
865
866 func TestImportDeclaration(t *testing.T) {
867 doTests(t, []sourceFn{ // 1
868 {``, func(t *test, tk Tokens) {
869 t.Err = Error{
870 Err: ErrInvalidImport,
871 Parsing: "ImportDeclaration",
872 Token: tk[0],
873 }
874 }},
875 {"import", func(t *test, tk Tokens) { // 2
876 t.Err = Error{
877 Err: Error{
878 Err: ErrInvalidImport,
879 Parsing: "ImportClause",
880 Token: tk[1],
881 },
882 Parsing: "ImportDeclaration",
883 Token: tk[1],
884 }
885 }},
886 {"import\n\"\";", func(t *test, tk Tokens) { // 3
887 t.Output = ImportDeclaration{
888 FromClause: FromClause{
889 ModuleSpecifier: &tk[2],
890 Tokens: tk[2:3],
891 },
892 Tokens: tk[:4],
893 }
894 }},
895 {"import\n*\n", func(t *test, tk Tokens) { // 4
896 t.Err = Error{
897 Err: Error{
898 Err: ErrInvalidNameSpaceImport,
899 Parsing: "ImportClause",
900 Token: tk[4],
901 },
902 Parsing: "ImportDeclaration",
903 Token: tk[2],
904 }
905 }},
906 {"import\n*\nas\na\n", func(t *test, tk Tokens) { // 5
907 t.Err = Error{
908 Err: Error{
909 Err: ErrMissingFrom,
910 Parsing: "FromClause",
911 Token: tk[8],
912 },
913 Parsing: "ImportDeclaration",
914 Token: tk[8],
915 }
916 }},
917 {"import\n*\nas\na\nfrom\n\"\";", func(t *test, tk Tokens) { // 6
918 t.Output = ImportDeclaration{
919 ImportClause: &ImportClause{
920 NameSpaceImport: &tk[6],
921 Tokens: tk[2:7],
922 },
923 FromClause: FromClause{
924 ModuleSpecifier: &tk[10],
925 Tokens: tk[8:11],
926 },
927 Tokens: tk[:12],
928 }
929 }},
930 {"import\n\"\"", func(t *test, tk Tokens) { // 7
931 t.Output = ImportDeclaration{
932 FromClause: FromClause{
933 ModuleSpecifier: &tk[2],
934 Tokens: tk[2:3],
935 },
936 Tokens: tk[:3],
937 }
938 }},
939 {"import\n\"\"\na", func(t *test, tk Tokens) { // 8
940 t.Output = ImportDeclaration{
941 FromClause: FromClause{
942 ModuleSpecifier: &tk[2],
943 Tokens: tk[2:3],
944 },
945 Tokens: tk[:3],
946 }
947 }},
948 {"import\n\"\" a", func(t *test, tk Tokens) { // 9
949 t.Err = Error{
950 Err: ErrMissingSemiColon,
951 Parsing: "ImportDeclaration",
952 Token: tk[3],
953 }
954 }},
955 }, func(t *test) (Type, error) {
956 var id ImportDeclaration
957 err := id.parse(&t.Tokens)
958 return id, err
959 })
960 }
961
962 func TestImportClause(t *testing.T) {
963 doTests(t, []sourceFn{
964 {``, func(t *test, tk Tokens) { // 1
965 t.Err = Error{
966 Err: ErrInvalidImport,
967 Parsing: "ImportClause",
968 Token: tk[0],
969 }
970 }},
971 {`for`, func(t *test, tk Tokens) { // 2
972 t.Err = Error{
973 Err: ErrNoIdentifier,
974 Parsing: "ImportClause",
975 Token: tk[0],
976 }
977 }},
978 {"a\n", func(t *test, tk Tokens) { // 3
979 t.Output = ImportClause{
980 ImportedDefaultBinding: &tk[0],
981 Tokens: tk[:1],
982 }
983 }},
984 {"a\n,", func(t *test, tk Tokens) { // 4
985 t.Err = Error{
986 Err: ErrInvalidImport,
987 Parsing: "ImportClause",
988 Token: tk[3],
989 }
990 }},
991 {"a\n,\n*", func(t *test, tk Tokens) { // 5
992 t.Err = Error{
993 Err: ErrInvalidNameSpaceImport,
994 Parsing: "ImportClause",
995 Token: tk[5],
996 }
997 }},
998 {"a\n,\n*\nas", func(t *test, tk Tokens) { // 6
999 t.Err = Error{
1000 Err: ErrNoIdentifier,
1001 Parsing: "ImportClause",
1002 Token: tk[7],
1003 }
1004 }},
1005 {"a\n,\n*\nas\nb", func(t *test, tk Tokens) { // 7
1006 t.Output = ImportClause{
1007 ImportedDefaultBinding: &tk[0],
1008 NameSpaceImport: &tk[8],
1009 Tokens: tk[:9],
1010 }
1011 }},
1012 {",", func(t *test, tk Tokens) { // 8
1013 t.Err = Error{
1014 Err: ErrInvalidImport,
1015 Parsing: "ImportClause",
1016 Token: tk[0],
1017 }
1018 }},
1019 {"*", func(t *test, tk Tokens) { // 9
1020 t.Err = Error{
1021 Err: ErrInvalidNameSpaceImport,
1022 Parsing: "ImportClause",
1023 Token: tk[1],
1024 }
1025 }},
1026 {"*\nas", func(t *test, tk Tokens) { // 10
1027 t.Err = Error{
1028 Err: ErrNoIdentifier,
1029 Parsing: "ImportClause",
1030 Token: tk[3],
1031 }
1032 }},
1033 {"*\nas\nb", func(t *test, tk Tokens) { // 11
1034 t.Output = ImportClause{
1035 NameSpaceImport: &tk[4],
1036 Tokens: tk[:5],
1037 }
1038 }},
1039 {"a\n,\n{+}", func(t *test, tk Tokens) { // 12
1040 t.Err = Error{
1041 Err: Error{
1042 Err: Error{
1043 Err: ErrInvalidImportSpecifier,
1044 Parsing: "ImportSpecifier",
1045 Token: tk[5],
1046 },
1047 Parsing: "NamedImports",
1048 Token: tk[5],
1049 },
1050 Parsing: "ImportClause",
1051 Token: tk[4],
1052 }
1053 }},
1054 {"a\n,\n{}", func(t *test, tk Tokens) { // 13
1055 t.Output = ImportClause{
1056 ImportedDefaultBinding: &tk[0],
1057 NamedImports: &NamedImports{
1058 Tokens: tk[4:6],
1059 },
1060 Tokens: tk[:6],
1061 }
1062 }},
1063 {"{+}", func(t *test, tk Tokens) { // 14
1064 t.Err = Error{
1065 Err: Error{
1066 Err: Error{
1067 Err: ErrInvalidImportSpecifier,
1068 Parsing: "ImportSpecifier",
1069 Token: tk[1],
1070 },
1071 Parsing: "NamedImports",
1072 Token: tk[1],
1073 },
1074 Parsing: "ImportClause",
1075 Token: tk[0],
1076 }
1077 }},
1078 {"{}", func(t *test, tk Tokens) { // 15
1079 t.Output = ImportClause{
1080 NamedImports: &NamedImports{
1081 Tokens: tk[:2],
1082 },
1083 Tokens: tk[:2],
1084 }
1085 }},
1086 }, func(t *test) (Type, error) {
1087 var ic ImportClause
1088 err := ic.parse(&t.Tokens)
1089 return ic, err
1090 })
1091 }
1092
1093 func TestFromClause(t *testing.T) {
1094 doTests(t, []sourceFn{
1095 {``, func(t *test, tk Tokens) { // 1
1096 t.Err = Error{
1097 Err: ErrMissingFrom,
1098 Parsing: "FromClause",
1099 Token: tk[0],
1100 }
1101 }},
1102 {"from\n", func(t *test, tk Tokens) { // 2
1103 t.Err = Error{
1104 Err: ErrMissingModuleSpecifier,
1105 Parsing: "FromClause",
1106 Token: tk[2],
1107 }
1108 }},
1109 {"from\n\"\"", func(t *test, tk Tokens) { // 3
1110 t.Output = FromClause{
1111 ModuleSpecifier: &tk[2],
1112 Tokens: tk[:3],
1113 }
1114 }},
1115 }, func(t *test) (Type, error) {
1116 var fc FromClause
1117 err := fc.parse(&t.Tokens)
1118 return fc, err
1119 })
1120 }
1121
1122 func TestNamedImports(t *testing.T) {
1123 doTests(t, []sourceFn{
1124 {``, func(t *test, tk Tokens) { // 1
1125 t.Err = Error{
1126 Err: ErrInvalidNamedImport,
1127 Parsing: "NamedImports",
1128 Token: tk[0],
1129 }
1130 }},
1131 {"{\n}", func(t *test, tk Tokens) { // 2
1132 t.Output = NamedImports{
1133 Tokens: tk[:3],
1134 }
1135 }},
1136 {"{\n,}", func(t *test, tk Tokens) { // 3
1137 t.Err = Error{
1138 Err: Error{
1139 Err: ErrInvalidImportSpecifier,
1140 Parsing: "ImportSpecifier",
1141 Token: tk[2],
1142 },
1143 Parsing: "NamedImports",
1144 Token: tk[2],
1145 }
1146 }},
1147 {"{\na\n}", func(t *test, tk Tokens) { // 4
1148 t.Output = NamedImports{
1149 ImportList: []ImportSpecifier{
1150 {
1151 IdentifierName: &tk[2],
1152 ImportedBinding: &tk[2],
1153 Tokens: tk[2:3],
1154 },
1155 },
1156 Tokens: tk[:5],
1157 }
1158 }},
1159 {"{\na\n,\n}", func(t *test, tk Tokens) { // 5
1160 t.Output = NamedImports{
1161 ImportList: []ImportSpecifier{
1162 {
1163 IdentifierName: &tk[2],
1164 ImportedBinding: &tk[2],
1165 Tokens: tk[2:3],
1166 },
1167 },
1168 Tokens: tk[:7],
1169 }
1170 }},
1171 {"{\na\nb}", func(t *test, tk Tokens) { // 6
1172 t.Err = Error{
1173 Err: ErrInvalidNamedImport,
1174 Parsing: "NamedImports",
1175 Token: tk[4],
1176 }
1177 }},
1178 {"{\na\n,\nb\n}", func(t *test, tk Tokens) { // 7
1179 t.Output = NamedImports{
1180 ImportList: []ImportSpecifier{
1181 {
1182 IdentifierName: &tk[2],
1183 ImportedBinding: &tk[2],
1184 Tokens: tk[2:3],
1185 },
1186 {
1187 IdentifierName: &tk[6],
1188 ImportedBinding: &tk[6],
1189 Tokens: tk[6:7],
1190 },
1191 },
1192 Tokens: tk[:9],
1193 }
1194 }},
1195 {"{\na\n,\na\n}", func(t *test, tk Tokens) { // 8
1196 t.Err = Error{
1197 Err: ErrInvalidNamedImport,
1198 Parsing: "NamedImports",
1199 Token: tk[6],
1200 }
1201 }},
1202 {"{\na\n,\nb as a\n}", func(t *test, tk Tokens) { // 9
1203 t.Err = Error{
1204 Err: ErrInvalidNamedImport,
1205 Parsing: "NamedImports",
1206 Token: tk[6],
1207 }
1208 }},
1209 {"{\na as b\n,\nb\n}", func(t *test, tk Tokens) { // 9
1210 t.Err = Error{
1211 Err: ErrInvalidNamedImport,
1212 Parsing: "NamedImports",
1213 Token: tk[10],
1214 }
1215 }},
1216 {"{\na as c\n,\nb as c\n}", func(t *test, tk Tokens) { // 9
1217 t.Err = Error{
1218 Err: ErrInvalidNamedImport,
1219 Parsing: "NamedImports",
1220 Token: tk[10],
1221 }
1222 }},
1223 }, func(t *test) (Type, error) {
1224 var ni NamedImports
1225 err := ni.parse(&t.Tokens)
1226 return ni, err
1227 })
1228 }
1229
1230 func TestImportSpecifier(t *testing.T) {
1231 doTests(t, []sourceFn{
1232 {``, func(t *test, tk Tokens) { // 1
1233 t.Err = Error{
1234 Err: ErrInvalidImportSpecifier,
1235 Parsing: "ImportSpecifier",
1236 Token: tk[0],
1237 }
1238 }},
1239 {`,`, func(t *test, tk Tokens) { // 2
1240 t.Err = Error{
1241 Err: ErrInvalidImportSpecifier,
1242 Parsing: "ImportSpecifier",
1243 Token: tk[0],
1244 }
1245 }},
1246 {"a", func(t *test, tk Tokens) { // 3
1247 t.Output = ImportSpecifier{
1248 IdentifierName: &tk[0],
1249 ImportedBinding: &tk[0],
1250 Tokens: tk[:1],
1251 }
1252 }},
1253 {"for", func(t *test, tk Tokens) { // 4
1254 t.Output = ImportSpecifier{
1255 IdentifierName: &tk[0],
1256 ImportedBinding: &tk[0],
1257 Tokens: tk[:1],
1258 }
1259 }},
1260 {"for\nas", func(t *test, tk Tokens) { // 5
1261 t.Output = ImportSpecifier{
1262 IdentifierName: &tk[0],
1263 ImportedBinding: &tk[0],
1264 Tokens: tk[:1],
1265 }
1266 }},
1267 {"a\nas", func(t *test, tk Tokens) { // 6
1268 t.Err = Error{
1269 Err: ErrNoIdentifier,
1270 Parsing: "ImportSpecifier",
1271 Token: tk[3],
1272 }
1273 }},
1274 {"a\nas\nb", func(t *test, tk Tokens) { // 7
1275 t.Output = ImportSpecifier{
1276 IdentifierName: &tk[0],
1277 ImportedBinding: &tk[4],
1278 Tokens: tk[:5],
1279 }
1280 }},
1281 }, func(t *test) (Type, error) {
1282 var is ImportSpecifier
1283 err := is.parse(&t.Tokens)
1284 return is, err
1285 })
1286 }
1287
1288 func TestExportDeclaration(t *testing.T) {
1289 doTests(t, []sourceFn{
1290 {``, func(t *test, tk Tokens) { // 1
1291 t.Err = Error{
1292 Err: ErrInvalidExportDeclaration,
1293 Parsing: "ExportDeclaration",
1294 Token: tk[0],
1295 }
1296 }},
1297 {"export\ndefault\nfunction", func(t *test, tk Tokens) { // 2
1298 t.Err = Error{
1299 Err: Error{
1300 Err: Error{
1301 Err: ErrMissingOpeningParenthesis,
1302 Parsing: "FormalParameters",
1303 Token: tk[5],
1304 },
1305 Parsing: "FunctionDeclaration",
1306 Token: tk[5],
1307 },
1308 Parsing: "ExportDeclaration",
1309 Token: tk[4],
1310 }
1311 }},
1312 {"export\ndefault\nfunction(){}", func(t *test, tk Tokens) { // 3
1313 t.Output = ExportDeclaration{
1314 DefaultFunction: &FunctionDeclaration{
1315 FormalParameters: FormalParameters{
1316 Tokens: tk[5:7],
1317 },
1318 FunctionBody: Block{
1319 Tokens: tk[7:9],
1320 },
1321 Tokens: tk[4:9],
1322 },
1323 Tokens: tk[:9],
1324 }
1325 }},
1326 {"export\ndefault\nclass", func(t *test, tk Tokens) { // 4
1327 t.Err = Error{
1328 Err: Error{
1329 Err: ErrMissingOpeningBrace,
1330 Parsing: "ClassDeclaration",
1331 Token: tk[5],
1332 },
1333 Parsing: "ExportDeclaration",
1334 Token: tk[4],
1335 }
1336 }},
1337 {"export\ndefault\nclass{}", func(t *test, tk Tokens) { // 5
1338 t.Output = ExportDeclaration{
1339 DefaultClass: &ClassDeclaration{
1340 Tokens: tk[4:7],
1341 },
1342 Tokens: tk[:7],
1343 }
1344 }},
1345 {"export\ndefault\n,", func(t *test, tk Tokens) { // 6
1346 t.Err = Error{
1347 Err: assignmentError(tk[4]),
1348 Parsing: "ExportDeclaration",
1349 Token: tk[4],
1350 }
1351 }},
1352 {"export\ndefault\n1", func(t *test, tk Tokens) { // 7
1353 lit1 := makeConditionLiteral(tk, 4)
1354 t.Output = ExportDeclaration{
1355 DefaultAssignmentExpression: &AssignmentExpression{
1356 ConditionalExpression: &lit1,
1357 Tokens: tk[4:5],
1358 },
1359 Tokens: tk[:5],
1360 }
1361 }},
1362 {"export\ndefault\n1 2", func(t *test, tk Tokens) { // 8
1363 t.Err = Error{
1364 Err: ErrMissingSemiColon,
1365 Parsing: "ExportDeclaration",
1366 Token: tk[5],
1367 }
1368 }},
1369 {"export\ndefault\n1; 2", func(t *test, tk Tokens) { // 9
1370 lit1 := makeConditionLiteral(tk, 4)
1371 t.Output = ExportDeclaration{
1372 DefaultAssignmentExpression: &AssignmentExpression{
1373 ConditionalExpression: &lit1,
1374 Tokens: tk[4:5],
1375 },
1376 Tokens: tk[:6],
1377 }
1378 }},
1379 {"export\n*", func(t *test, tk Tokens) { // 10
1380 t.Err = Error{
1381 Err: Error{
1382 Err: ErrMissingFrom,
1383 Parsing: "FromClause",
1384 Token: tk[3],
1385 },
1386 Parsing: "ExportDeclaration",
1387 Token: tk[3],
1388 }
1389 }},
1390 {"export\n*\nfrom\n''", func(t *test, tk Tokens) { // 11
1391 t.Output = ExportDeclaration{
1392 FromClause: &FromClause{
1393 ModuleSpecifier: &tk[6],
1394 Tokens: tk[4:7],
1395 },
1396 Tokens: tk[:7],
1397 }
1398 }},
1399 {"export\n*\nfrom\n'' b", func(t *test, tk Tokens) { // 12
1400 t.Err = Error{
1401 Err: ErrMissingSemiColon,
1402 Parsing: "ExportDeclaration",
1403 Token: tk[7],
1404 }
1405 }},
1406 {"export\n*\nfrom\n'';b", func(t *test, tk Tokens) { // 13
1407 t.Output = ExportDeclaration{
1408 FromClause: &FromClause{
1409 ModuleSpecifier: &tk[6],
1410 Tokens: tk[4:7],
1411 },
1412 Tokens: tk[:8],
1413 }
1414 }},
1415 {"export\nvar", func(t *test, tk Tokens) { // 14
1416 t.Err = Error{
1417 Err: Error{
1418 Err: Error{
1419 Err: ErrNoIdentifier,
1420 Parsing: "LexicalBinding",
1421 Token: tk[3],
1422 },
1423 Parsing: "VariableStatement",
1424 Token: tk[3],
1425 },
1426 Parsing: "ExportDeclaration",
1427 Token: tk[2],
1428 }
1429 }},
1430 {"export\nvar\na", func(t *test, tk Tokens) { // 15
1431 t.Output = ExportDeclaration{
1432 VariableStatement: &VariableStatement{
1433 VariableDeclarationList: []VariableDeclaration{
1434 {
1435 BindingIdentifier: &tk[4],
1436 Tokens: tk[4:5],
1437 },
1438 },
1439 Tokens: tk[2:5],
1440 },
1441 Tokens: tk[:5],
1442 }
1443 }},
1444 {"export\n{,}", func(t *test, tk Tokens) { // 16
1445 t.Err = Error{
1446 Err: Error{
1447 Err: Error{
1448 Err: ErrNoIdentifier,
1449 Parsing: "ExportSpecifier",
1450 Token: tk[3],
1451 },
1452 Parsing: "ExportClause",
1453 Token: tk[3],
1454 },
1455 Parsing: "ExportDeclaration",
1456 Token: tk[2],
1457 }
1458 }},
1459 {"export\n{}", func(t *test, tk Tokens) { // 17
1460 t.Output = ExportDeclaration{
1461 ExportClause: &ExportClause{
1462 Tokens: tk[2:4],
1463 },
1464 Tokens: tk[:4],
1465 }
1466 }},
1467 {"export\n{};", func(t *test, tk Tokens) { // 18
1468 t.Output = ExportDeclaration{
1469 ExportClause: &ExportClause{
1470 Tokens: tk[2:4],
1471 },
1472 Tokens: tk[:5],
1473 }
1474 }},
1475 {"export\n{} b", func(t *test, tk Tokens) { // 19
1476 t.Err = Error{
1477 Err: ErrMissingSemiColon,
1478 Parsing: "ExportDeclaration",
1479 Token: tk[4],
1480 }
1481 }},
1482 {"export\n{}\nfrom\n''", func(t *test, tk Tokens) { // 20
1483 t.Output = ExportDeclaration{
1484 ExportClause: &ExportClause{
1485 Tokens: tk[2:4],
1486 },
1487 FromClause: &FromClause{
1488 ModuleSpecifier: &tk[7],
1489 Tokens: tk[5:8],
1490 },
1491 Tokens: tk[:8],
1492 }
1493 }},
1494 {"export\n{}\nfrom\n'' a", func(t *test, tk Tokens) { // 21
1495 t.Err = Error{
1496 Err: ErrMissingSemiColon,
1497 Parsing: "ExportDeclaration",
1498 Token: tk[8],
1499 }
1500 }},
1501 {"export\n{}\nfrom\n'';a", func(t *test, tk Tokens) { // 22
1502 t.Output = ExportDeclaration{
1503 ExportClause: &ExportClause{
1504 Tokens: tk[2:4],
1505 },
1506 FromClause: &FromClause{
1507 ModuleSpecifier: &tk[7],
1508 Tokens: tk[5:8],
1509 },
1510 Tokens: tk[:9],
1511 }
1512 }},
1513 {"export\n*\nas\na\nfrom\n'';", func(t *test, tk Tokens) { // 23
1514 t.Output = ExportDeclaration{
1515 ExportFromClause: &tk[6],
1516 FromClause: &FromClause{
1517 ModuleSpecifier: &tk[10],
1518 Tokens: tk[8:11],
1519 },
1520 Tokens: tk[:12],
1521 }
1522 }},
1523 {"export * as ;", func(t *test, tk Tokens) { // 24
1524 t.Err = Error{
1525 Err: ErrNoIdentifier,
1526 Parsing: "ExportDeclaration",
1527 Token: tk[6],
1528 }
1529 }},
1530 }, func(t *test) (Type, error) {
1531 var ed ExportDeclaration
1532 err := ed.parse(&t.Tokens)
1533 return ed, err
1534 })
1535 }
1536
1537 func TestExportClause(t *testing.T) {
1538 doTests(t, []sourceFn{
1539 {``, func(t *test, tk Tokens) { // 1
1540 t.Err = Error{
1541 Err: ErrInvalidExportClause,
1542 Parsing: "ExportClause",
1543 Token: tk[0],
1544 }
1545 }},
1546 {"{\n}", func(t *test, tk Tokens) { // 2
1547 t.Output = ExportClause{
1548 Tokens: tk[:3],
1549 }
1550 }},
1551 {"{\n,}", func(t *test, tk Tokens) { // 3
1552 t.Err = Error{
1553 Err: Error{
1554 Err: ErrNoIdentifier,
1555 Parsing: "ExportSpecifier",
1556 Token: tk[2],
1557 },
1558 Parsing: "ExportClause",
1559 Token: tk[2],
1560 }
1561 }},
1562 {"{\na\n}", func(t *test, tk Tokens) { // 4
1563 t.Output = ExportClause{
1564 ExportList: []ExportSpecifier{
1565 {
1566 IdentifierName: &tk[2],
1567 EIdentifierName: &tk[2],
1568 Tokens: tk[2:3],
1569 },
1570 },
1571 Tokens: tk[:5],
1572 }
1573 }},
1574 {"{\na\nb}", func(t *test, tk Tokens) { // 5
1575 t.Err = Error{
1576 Err: ErrInvalidExportClause,
1577 Parsing: "ExportClause",
1578 Token: tk[4],
1579 }
1580 }},
1581 {"{\na\n,\n}", func(t *test, tk Tokens) { // 6
1582 t.Output = ExportClause{
1583 ExportList: []ExportSpecifier{
1584 {
1585 IdentifierName: &tk[2],
1586 EIdentifierName: &tk[2],
1587 Tokens: tk[2:3],
1588 },
1589 },
1590 Tokens: tk[:7],
1591 }
1592 }},
1593 {"{\na\n,\nb\n}", func(t *test, tk Tokens) { // 7
1594 t.Output = ExportClause{
1595 ExportList: []ExportSpecifier{
1596 {
1597 IdentifierName: &tk[2],
1598 EIdentifierName: &tk[2],
1599 Tokens: tk[2:3],
1600 },
1601 {
1602 IdentifierName: &tk[6],
1603 EIdentifierName: &tk[6],
1604 Tokens: tk[6:7],
1605 },
1606 },
1607 Tokens: tk[:9],
1608 }
1609 }},
1610 }, func(t *test) (Type, error) {
1611 var ec ExportClause
1612 err := ec.parse(&t.Tokens)
1613 return ec, err
1614 })
1615 }
1616
1617 func TestExportSpecifier(t *testing.T) {
1618 doTests(t, []sourceFn{
1619 {``, func(t *test, tk Tokens) { // 1
1620 t.Err = Error{
1621 Err: ErrNoIdentifier,
1622 Parsing: "ExportSpecifier",
1623 Token: tk[0],
1624 }
1625 }},
1626 {`+`, func(t *test, tk Tokens) { // 2
1627 t.Err = Error{
1628 Err: ErrNoIdentifier,
1629 Parsing: "ExportSpecifier",
1630 Token: tk[0],
1631 }
1632 }},
1633 {"a", func(t *test, tk Tokens) { // 3
1634 t.Output = ExportSpecifier{
1635 IdentifierName: &tk[0],
1636 EIdentifierName: &tk[0],
1637 Tokens: tk[:1],
1638 }
1639 }},
1640 {"for", func(t *test, tk Tokens) { // 4
1641 t.Output = ExportSpecifier{
1642 IdentifierName: &tk[0],
1643 EIdentifierName: &tk[0],
1644 Tokens: tk[:1],
1645 }
1646 }},
1647 {"a\nas", func(t *test, tk Tokens) { // 5
1648 t.Err = Error{
1649 Err: ErrNoIdentifier,
1650 Parsing: "ExportSpecifier",
1651 Token: tk[3],
1652 }
1653 }},
1654 {"a\nas\n,", func(t *test, tk Tokens) { // 6
1655 t.Err = Error{
1656 Err: ErrNoIdentifier,
1657 Parsing: "ExportSpecifier",
1658 Token: tk[4],
1659 }
1660 }},
1661 {"a\nas\nb", func(t *test, tk Tokens) { // 7
1662 t.Output = ExportSpecifier{
1663 IdentifierName: &tk[0],
1664 EIdentifierName: &tk[4],
1665 Tokens: tk[:5],
1666 }
1667 }},
1668 }, func(t *test) (Type, error) {
1669 var es ExportSpecifier
1670 err := es.parse(&t.Tokens)
1671 return es, err
1672 })
1673 }
1674