javascript - ast_function_test.go
1 package javascript
2
3 import (
4 "testing"
5 )
6
7 func TestParseFunction(t *testing.T) {
8 doTests(t, []sourceFn{
9 {`function nameHere(){}`, func(ft *test, t Tokens) { // 1
10 ft.Output = FunctionDeclaration{
11 BindingIdentifier: &t[2],
12 FormalParameters: FormalParameters{
13 Tokens: t[3:5],
14 },
15 FunctionBody: Block{
16 Tokens: t[5:7],
17 },
18 Tokens: t[:7],
19 }
20 }},
21 {`async function nameHere(){}`, func(ft *test, t Tokens) { // 2
22 ft.Output = FunctionDeclaration{
23 Type: FunctionAsync,
24 BindingIdentifier: &t[4],
25 FormalParameters: FormalParameters{
26 Tokens: t[5:7],
27 },
28 FunctionBody: Block{
29 Tokens: t[7:9],
30 },
31 Tokens: t[:9],
32 }
33 }},
34 {`function *nameHere(){}`, func(ft *test, t Tokens) { // 3
35 ft.Output = FunctionDeclaration{
36 Type: FunctionGenerator,
37 BindingIdentifier: &t[3],
38 FormalParameters: FormalParameters{
39 Tokens: t[4:6],
40 },
41 FunctionBody: Block{
42 Tokens: t[6:8],
43 },
44 Tokens: t[:8],
45 }
46 }},
47 {`function (){}`, func(ft *test, t Tokens) { // 4
48 ft.Err = Error{
49 Err: ErrNoIdentifier,
50 Parsing: "FunctionDeclaration",
51 Token: t[2],
52 }
53 }},
54 {`async function (){}`, func(ft *test, t Tokens) { // 5
55 ft.Err = Error{
56 Err: ErrNoIdentifier,
57 Parsing: "FunctionDeclaration",
58 Token: t[4],
59 }
60 }},
61 {`function *(){}`, func(ft *test, t Tokens) { // 6
62 ft.Err = Error{
63 Err: ErrNoIdentifier,
64 Parsing: "FunctionDeclaration",
65 Token: t[3],
66 }
67 }},
68 {`function (){}`, func(ft *test, t Tokens) { // 7
69 ft.Def = true
70 ft.Output = FunctionDeclaration{
71 FormalParameters: FormalParameters{
72 Tokens: t[2:4],
73 },
74 FunctionBody: Block{
75 Tokens: t[4:6],
76 },
77 Tokens: t[:6],
78 }
79 }},
80 {`async function (){}`, func(ft *test, t Tokens) { // 8
81 ft.Def = true
82 ft.Output = FunctionDeclaration{
83 Type: FunctionAsync,
84 FormalParameters: FormalParameters{
85 Tokens: t[4:6],
86 },
87 FunctionBody: Block{
88 Tokens: t[6:8],
89 },
90 Tokens: t[:8],
91 }
92 }},
93 {`function *(){}`, func(ft *test, t Tokens) { // 9
94 ft.Def = true
95 ft.Output = FunctionDeclaration{
96 Type: FunctionGenerator,
97 FormalParameters: FormalParameters{
98 Tokens: t[3:5],
99 },
100 FunctionBody: Block{
101 Tokens: t[5:7],
102 },
103 Tokens: t[:7],
104 }
105 }},
106 {`function myFunc(a){}`, func(ft *test, t Tokens) { // 10
107 ft.Output = FunctionDeclaration{
108 BindingIdentifier: &t[2],
109 FormalParameters: FormalParameters{
110 FormalParameterList: []BindingElement{
111 {
112 SingleNameBinding: &t[4],
113 Tokens: t[4:5],
114 },
115 },
116 Tokens: t[3:6],
117 },
118 FunctionBody: Block{
119 Tokens: t[6:8],
120 },
121 Tokens: t[:8],
122 }
123 }},
124 {`function myFunc(aye, bee){}`, func(ft *test, t Tokens) { // 11
125 ft.Output = FunctionDeclaration{
126 BindingIdentifier: &t[2],
127 FormalParameters: FormalParameters{
128 FormalParameterList: []BindingElement{
129 {
130 SingleNameBinding: &t[4],
131 Tokens: t[4:5],
132 },
133 {
134 SingleNameBinding: &t[7],
135 Tokens: t[7:8],
136 },
137 },
138 Tokens: t[3:9],
139 },
140 FunctionBody: Block{
141 Tokens: t[9:11],
142 },
143 Tokens: t[:11],
144 }
145 }},
146 {`function myFunc(aye, be, sea, ...dee){}`, func(ft *test, t Tokens) { // 12
147 ft.Output = FunctionDeclaration{
148 BindingIdentifier: &t[2],
149 FormalParameters: FormalParameters{
150 FormalParameterList: []BindingElement{
151 {
152 SingleNameBinding: &t[4],
153 Tokens: t[4:5],
154 },
155 {
156 SingleNameBinding: &t[7],
157 Tokens: t[7:8],
158 },
159 {
160 SingleNameBinding: &t[10],
161 Tokens: t[10:11],
162 },
163 },
164 BindingIdentifier: &t[14],
165 Tokens: t[3:16],
166 },
167 FunctionBody: Block{
168 Tokens: t[16:18],
169 },
170 Tokens: t[:18],
171 }
172 }},
173 {`function myFunc(...aye){}`, func(ft *test, t Tokens) { // 13
174 ft.Output = FunctionDeclaration{
175 BindingIdentifier: &t[2],
176 FormalParameters: FormalParameters{
177 BindingIdentifier: &t[5],
178 Tokens: t[3:7],
179 },
180 FunctionBody: Block{
181 Tokens: t[7:9],
182 },
183 Tokens: t[:9],
184 }
185 }},
186 }, func(t *test) (Type, error) {
187 var fd FunctionDeclaration
188 err := fd.parse(&t.Tokens, t.Yield, t.Await, t.Def)
189 return fd, err
190 })
191 }
192
193 func TestFunctionDeclaration(t *testing.T) {
194 doTests(t, []sourceFn{
195 {``, func(t *test, tk Tokens) { // 1
196 t.Err = Error{
197 Err: ErrInvalidFunction,
198 Parsing: "FunctionDeclaration",
199 Token: tk[0],
200 }
201 }},
202 {"function", func(t *test, tk Tokens) { // 2
203 t.Err = Error{
204 Err: ErrNoIdentifier,
205 Parsing: "FunctionDeclaration",
206 Token: tk[1],
207 }
208 }},
209 {"async function", func(t *test, tk Tokens) { // 3
210 t.Err = Error{
211 Err: ErrNoIdentifier,
212 Parsing: "FunctionDeclaration",
213 Token: tk[3],
214 }
215 }},
216 {"async\nfunction", func(t *test, tk Tokens) { // 4
217 t.Err = Error{
218 Err: ErrInvalidFunction,
219 Parsing: "FunctionDeclaration",
220 Token: tk[1],
221 }
222 }},
223 {"function*", func(t *test, tk Tokens) { // 5
224 t.Err = Error{
225 Err: ErrNoIdentifier,
226 Parsing: "FunctionDeclaration",
227 Token: tk[2],
228 }
229 }},
230 {"async function*", func(t *test, tk Tokens) { // 6
231 t.Err = Error{
232 Err: ErrNoIdentifier,
233 Parsing: "FunctionDeclaration",
234 Token: tk[4],
235 }
236 }},
237 {"function", func(t *test, tk Tokens) { // 7
238 t.Def = true
239 t.Err = Error{
240 Err: Error{
241 Err: ErrMissingOpeningParenthesis,
242 Parsing: "FormalParameters",
243 Token: tk[1],
244 },
245 Parsing: "FunctionDeclaration",
246 Token: tk[1],
247 }
248 }},
249 {"function\na", func(t *test, tk Tokens) { // 8
250 t.Err = Error{
251 Err: Error{
252 Err: ErrMissingOpeningParenthesis,
253 Parsing: "FormalParameters",
254 Token: tk[3],
255 },
256 Parsing: "FunctionDeclaration",
257 Token: tk[3],
258 }
259 }},
260 {"function\na\n()", func(t *test, tk Tokens) { // 9
261 t.Err = Error{
262 Err: Error{
263 Err: ErrMissingOpeningBrace,
264 Parsing: "Block",
265 Token: tk[6],
266 },
267 Parsing: "FunctionDeclaration",
268 Token: tk[6],
269 }
270 }},
271 {"function\na\n()\n{}", func(t *test, tk Tokens) { // 10
272 t.Output = FunctionDeclaration{
273 BindingIdentifier: &tk[2],
274 FormalParameters: FormalParameters{
275 Tokens: tk[4:6],
276 },
277 FunctionBody: Block{
278 Tokens: tk[7:9],
279 },
280 Tokens: tk[:9],
281 }
282 }},
283 {"async function\na\n()\n{}", func(t *test, tk Tokens) { // 11
284 t.Output = FunctionDeclaration{
285 Type: FunctionAsync,
286 BindingIdentifier: &tk[4],
287 FormalParameters: FormalParameters{
288 Tokens: tk[6:8],
289 },
290 FunctionBody: Block{
291 Tokens: tk[9:11],
292 },
293 Tokens: tk[:11],
294 }
295 }},
296 {"function\n*\na\n()\n{}", func(t *test, tk Tokens) { // 12
297 t.Output = FunctionDeclaration{
298 Type: FunctionGenerator,
299 BindingIdentifier: &tk[4],
300 FormalParameters: FormalParameters{
301 Tokens: tk[6:8],
302 },
303 FunctionBody: Block{
304 Tokens: tk[9:11],
305 },
306 Tokens: tk[:11],
307 }
308 }},
309 {"async function\n*\na\n()\n{}", func(t *test, tk Tokens) { // 13
310 t.Output = FunctionDeclaration{
311 Type: FunctionAsyncGenerator,
312 BindingIdentifier: &tk[6],
313 FormalParameters: FormalParameters{
314 Tokens: tk[8:10],
315 },
316 FunctionBody: Block{
317 Tokens: tk[11:13],
318 },
319 Tokens: tk[:13],
320 }
321 }},
322 {"function\na\n()\n{}", func(t *test, tk Tokens) { // 14
323 t.Def = true
324 t.Output = FunctionDeclaration{
325 BindingIdentifier: &tk[2],
326 FormalParameters: FormalParameters{
327 Tokens: tk[4:6],
328 },
329 FunctionBody: Block{
330 Tokens: tk[7:9],
331 },
332 Tokens: tk[:9],
333 }
334 }},
335 {"async function\na\n()\n{}", func(t *test, tk Tokens) { // 15
336 t.Def = true
337 t.Output = FunctionDeclaration{
338 Type: FunctionAsync,
339 BindingIdentifier: &tk[4],
340 FormalParameters: FormalParameters{
341 Tokens: tk[6:8],
342 },
343 FunctionBody: Block{
344 Tokens: tk[9:11],
345 },
346 Tokens: tk[:11],
347 }
348 }},
349 {"function\n*\na\n()\n{}", func(t *test, tk Tokens) { // 16
350 t.Def = true
351 t.Output = FunctionDeclaration{
352 Type: FunctionGenerator,
353 BindingIdentifier: &tk[4],
354 FormalParameters: FormalParameters{
355 Tokens: tk[6:8],
356 },
357 FunctionBody: Block{
358 Tokens: tk[9:11],
359 },
360 Tokens: tk[:11],
361 }
362 }},
363 {"async function\n*\na\n()\n{}", func(t *test, tk Tokens) { // 17
364 t.Def = true
365 t.Output = FunctionDeclaration{
366 Type: FunctionAsyncGenerator,
367 BindingIdentifier: &tk[6],
368 FormalParameters: FormalParameters{
369 Tokens: tk[8:10],
370 },
371 FunctionBody: Block{
372 Tokens: tk[11:13],
373 },
374 Tokens: tk[:13],
375 }
376 }},
377 {"function\n()\n{}", func(t *test, tk Tokens) { // 18
378 t.Def = true
379 t.Output = FunctionDeclaration{
380 FormalParameters: FormalParameters{
381 Tokens: tk[2:4],
382 },
383 FunctionBody: Block{
384 Tokens: tk[5:7],
385 },
386 Tokens: tk[:7],
387 }
388 }},
389 {"async function\n()\n{}", func(t *test, tk Tokens) { // 19
390 t.Def = true
391 t.Output = FunctionDeclaration{
392 Type: FunctionAsync,
393 FormalParameters: FormalParameters{
394 Tokens: tk[4:6],
395 },
396 FunctionBody: Block{
397 Tokens: tk[7:9],
398 },
399 Tokens: tk[:9],
400 }
401 }},
402 {"function\n*\n()\n{}", func(t *test, tk Tokens) { // 20
403 t.Def = true
404 t.Output = FunctionDeclaration{
405 Type: FunctionGenerator,
406 FormalParameters: FormalParameters{
407 Tokens: tk[4:6],
408 },
409 FunctionBody: Block{
410 Tokens: tk[7:9],
411 },
412 Tokens: tk[:9],
413 }
414 }},
415 {"async function\n*\n()\n{}", func(t *test, tk Tokens) { // 21
416 t.Def = true
417 t.Output = FunctionDeclaration{
418 Type: FunctionAsyncGenerator,
419 FormalParameters: FormalParameters{
420 Tokens: tk[6:8],
421 },
422 FunctionBody: Block{
423 Tokens: tk[9:11],
424 },
425 Tokens: tk[:11],
426 }
427 }},
428 }, func(t *test) (Type, error) {
429 var fd FunctionDeclaration
430 err := fd.parse(&t.Tokens, t.Yield, t.Await, t.Def)
431 return fd, err
432 })
433 }
434
435 func TestFormalParameters(t *testing.T) {
436 doTests(t, []sourceFn{
437 {``, func(t *test, tk Tokens) { // 1
438 t.Err = Error{
439 Err: ErrMissingOpeningParenthesis,
440 Parsing: "FormalParameters",
441 Token: tk[0],
442 }
443 }},
444 {"(\n)", func(t *test, tk Tokens) { // 2
445 t.Output = FormalParameters{
446 Tokens: tk[:3],
447 }
448 }},
449 {"(\n...\n)", func(t *test, tk Tokens) { // 3
450 t.Err = Error{
451 Err: ErrNoIdentifier,
452 Parsing: "FormalParameters",
453 Token: tk[4],
454 }
455 }},
456 {"(\n...\na\n)", func(t *test, tk Tokens) { // 4
457 t.Output = FormalParameters{
458 BindingIdentifier: &tk[4],
459 Tokens: tk[:7],
460 }
461 }},
462 {"(\n...\na\nb)", func(t *test, tk Tokens) { // 5
463 t.Err = Error{
464 Err: ErrMissingClosingParenthesis,
465 Parsing: "FormalParameters",
466 Token: tk[6],
467 }
468 }},
469 {"(\n,)", func(t *test, tk Tokens) { // 6
470 t.Err = Error{
471 Err: Error{
472 Err: ErrNoIdentifier,
473 Parsing: "BindingElement",
474 Token: tk[2],
475 },
476 Parsing: "FormalParameters",
477 Token: tk[2],
478 }
479 }},
480 {"(\na\n)", func(t *test, tk Tokens) { // 7
481 t.Output = FormalParameters{
482 FormalParameterList: []BindingElement{
483 {
484 SingleNameBinding: &tk[2],
485 Tokens: tk[2:3],
486 },
487 },
488 Tokens: tk[:5],
489 }
490 }},
491 {"(\na\nb)", func(t *test, tk Tokens) { // 8
492 t.Err = Error{
493 Err: ErrMissingComma,
494 Parsing: "FormalParameters",
495 Token: tk[4],
496 }
497 }},
498 {"(\na\n,\nb\n)", func(t *test, tk Tokens) { // 9
499 t.Output = FormalParameters{
500 FormalParameterList: []BindingElement{
501 {
502 SingleNameBinding: &tk[2],
503 Tokens: tk[2:3],
504 },
505 {
506 SingleNameBinding: &tk[6],
507 Tokens: tk[6:7],
508 },
509 },
510 Tokens: tk[:9],
511 }
512 }},
513 {"(\na\n,\n...\nb\n)", func(t *test, tk Tokens) { // 10
514 t.Output = FormalParameters{
515 FormalParameterList: []BindingElement{
516 {
517 SingleNameBinding: &tk[2],
518 Tokens: tk[2:3],
519 },
520 },
521 BindingIdentifier: &tk[8],
522 Tokens: tk[:11],
523 }
524 }},
525 {"(...[])", func(t *test, tk Tokens) { // 11
526 t.Output = FormalParameters{
527 ArrayBindingPattern: &ArrayBindingPattern{
528 Tokens: tk[2:4],
529 },
530 Tokens: tk[:5],
531 }
532 }},
533 {"(...{})", func(t *test, tk Tokens) { // 12
534 t.Output = FormalParameters{
535 ObjectBindingPattern: &ObjectBindingPattern{
536 Tokens: tk[2:4],
537 },
538 Tokens: tk[:5],
539 }
540 }},
541 {`(...[!])`, func(t *test, tk Tokens) { // 13
542 t.Err = Error{
543 Err: Error{
544 Err: Error{
545 Err: ErrNoIdentifier,
546 Parsing: "BindingElement",
547 Token: tk[3],
548 },
549 Parsing: "ArrayBindingPattern",
550 Token: tk[3],
551 },
552 Parsing: "FormalParameters",
553 Token: tk[2],
554 }
555 }},
556 {`(...{!})`, func(t *test, tk Tokens) { // 14
557 t.Err = Error{
558 Err: Error{
559 Err: Error{
560 Err: Error{
561 Err: ErrInvalidPropertyName,
562 Parsing: "PropertyName",
563 Token: tk[3],
564 },
565 Parsing: "BindingProperty",
566 Token: tk[3],
567 },
568 Parsing: "ObjectBindingPattern",
569 Token: tk[3],
570 },
571 Parsing: "FormalParameters",
572 Token: tk[2],
573 }
574 }},
575 }, func(t *test) (Type, error) {
576 var fp FormalParameters
577 err := fp.parse(&t.Tokens, t.Yield, t.Await)
578 return fp, err
579 })
580 }
581
582 func TestBindingElement(t *testing.T) {
583 doTests(t, []sourceFn{
584 {``, func(t *test, tk Tokens) { // 1
585 t.Err = Error{
586 Err: ErrNoIdentifier,
587 Parsing: "BindingElement",
588 Token: tk[0],
589 }
590 }},
591 {`a`, func(t *test, tk Tokens) { // 2
592 t.Output = BindingElement{
593 SingleNameBinding: &tk[0],
594 Tokens: tk[:1],
595 }
596 }},
597 {"a\n=\n1", func(t *test, tk Tokens) { // 3
598 lit1 := makeConditionLiteral(tk, 4)
599 t.Output = BindingElement{
600 SingleNameBinding: &tk[0],
601 Initializer: &AssignmentExpression{
602 ConditionalExpression: &lit1,
603 Tokens: tk[4:5],
604 },
605 Tokens: tk[:5],
606 }
607 }},
608 {"[a]\n=\n", func(t *test, tk Tokens) { // 4
609 t.Err = Error{
610 Err: assignmentError(tk[6]),
611 Parsing: "BindingElement",
612 Token: tk[6],
613 }
614 }},
615 {"[]", func(t *test, tk Tokens) { // 5
616 t.Output = BindingElement{
617 ArrayBindingPattern: &ArrayBindingPattern{
618 Tokens: tk[:2],
619 },
620 Tokens: tk[:2],
621 }
622 }},
623 {"[]\n=\na", func(t *test, tk Tokens) { // 6
624 litA := makeConditionLiteral(tk, 5)
625 t.Output = BindingElement{
626 ArrayBindingPattern: &ArrayBindingPattern{
627 Tokens: tk[:2],
628 },
629 Initializer: &AssignmentExpression{
630 ConditionalExpression: &litA,
631 Tokens: tk[5:6],
632 },
633 Tokens: tk[:6],
634 }
635 }},
636 {"{a}\n=\n", func(t *test, tk Tokens) { // 7
637 t.Err = Error{
638 Err: assignmentError(tk[6]),
639 Parsing: "BindingElement",
640 Token: tk[6],
641 }
642 }},
643 {"{}", func(t *test, tk Tokens) { // 8
644 t.Output = BindingElement{
645 ObjectBindingPattern: &ObjectBindingPattern{
646 Tokens: tk[:2],
647 },
648 Tokens: tk[:2],
649 }
650 }},
651 {"{}\n=\na", func(t *test, tk Tokens) { // 9
652 litA := makeConditionLiteral(tk, 5)
653 t.Output = BindingElement{
654 ObjectBindingPattern: &ObjectBindingPattern{
655 Tokens: tk[:2],
656 },
657 Initializer: &AssignmentExpression{
658 ConditionalExpression: &litA,
659 Tokens: tk[5:6],
660 },
661 Tokens: tk[:6],
662 }
663 }},
664 {`[!]`, func(t *test, tk Tokens) { // 10
665 t.Err = Error{
666 Err: Error{
667 Err: Error{
668 Err: ErrNoIdentifier,
669 Parsing: "BindingElement",
670 Token: tk[1],
671 },
672 Parsing: "ArrayBindingPattern",
673 Token: tk[1],
674 },
675 Parsing: "BindingElement",
676 Token: tk[0],
677 }
678 }},
679 {`{!}`, func(t *test, tk Tokens) { // 11
680 t.Err = Error{
681 Err: Error{
682 Err: Error{
683 Err: Error{
684 Err: ErrInvalidPropertyName,
685 Parsing: "PropertyName",
686 Token: tk[1],
687 },
688 Parsing: "BindingProperty",
689 Token: tk[1],
690 },
691 Parsing: "ObjectBindingPattern",
692 Token: tk[1],
693 },
694 Parsing: "BindingElement",
695 Token: tk[0],
696 }
697 }},
698 }, func(t *test) (Type, error) {
699 var be BindingElement
700 err := be.parse(&t.Tokens, nil, t.Yield, t.Await)
701 return be, err
702 })
703 }
704