1 package javascript 2 3 import ( 4 "testing" 5 ) 6 7 func TestClassDeclarationOld(t *testing.T) { 8 doTests(t, []sourceFn{ 9 {`class myClass{}`, func(t *test, tk Tokens) { // 1 10 t.Output = ClassDeclaration{ 11 BindingIdentifier: &tk[2], 12 Tokens: tk[:5], 13 } 14 }}, 15 {`class myClass extends OtherClass{}`, func(t *test, tk Tokens) { // 2 16 t.Output = ClassDeclaration{ 17 BindingIdentifier: &tk[2], 18 ClassHeritage: &LeftHandSideExpression{ 19 NewExpression: &NewExpression{ 20 MemberExpression: MemberExpression{ 21 PrimaryExpression: &PrimaryExpression{ 22 IdentifierReference: &tk[6], 23 Tokens: tk[6:7], 24 }, 25 Tokens: tk[6:7], 26 }, 27 Tokens: tk[6:7], 28 }, 29 Tokens: tk[6:7], 30 }, 31 Tokens: tk[:9], 32 } 33 }}, 34 {`class myClass {constructor(){}}`, func(t *test, tk Tokens) { // 3 35 t.Output = ClassDeclaration{ 36 BindingIdentifier: &tk[2], 37 ClassBody: []ClassElement{ 38 { 39 MethodDefinition: &MethodDefinition{ 40 ClassElementName: ClassElementName{ 41 PropertyName: &PropertyName{ 42 LiteralPropertyName: &tk[5], 43 Tokens: tk[5:6], 44 }, 45 Tokens: tk[5:6], 46 }, 47 Params: FormalParameters{ 48 Tokens: tk[6:8], 49 }, 50 FunctionBody: Block{ 51 Tokens: tk[8:10], 52 }, 53 Tokens: tk[5:10], 54 }, 55 Tokens: tk[5:10], 56 }, 57 }, 58 Tokens: tk[:11], 59 } 60 }}, 61 {`class myClass {method(arg1, arg2){}}`, func(t *test, tk Tokens) { // 4 62 t.Output = ClassDeclaration{ 63 BindingIdentifier: &tk[2], 64 ClassBody: []ClassElement{ 65 { 66 MethodDefinition: &MethodDefinition{ 67 ClassElementName: ClassElementName{ 68 PropertyName: &PropertyName{ 69 LiteralPropertyName: &tk[5], 70 Tokens: tk[5:6], 71 }, 72 Tokens: tk[5:6], 73 }, 74 Params: FormalParameters{ 75 FormalParameterList: []BindingElement{ 76 { 77 SingleNameBinding: &tk[7], 78 Tokens: tk[7:8], 79 }, 80 { 81 SingleNameBinding: &tk[10], 82 Tokens: tk[10:11], 83 }, 84 }, 85 Tokens: tk[6:12], 86 }, 87 FunctionBody: Block{ 88 Tokens: tk[12:14], 89 }, 90 Tokens: tk[5:14], 91 }, 92 Tokens: tk[5:14], 93 }, 94 }, 95 Tokens: tk[:15], 96 } 97 }}, 98 {`class myClass {set method(args){}}`, func(t *test, tk Tokens) { // 5 99 t.Output = ClassDeclaration{ 100 BindingIdentifier: &tk[2], 101 ClassBody: []ClassElement{ 102 { 103 MethodDefinition: &MethodDefinition{ 104 Type: MethodSetter, 105 ClassElementName: ClassElementName{ 106 PropertyName: &PropertyName{ 107 LiteralPropertyName: &tk[7], 108 Tokens: tk[7:8], 109 }, 110 Tokens: tk[7:8], 111 }, 112 Params: FormalParameters{ 113 FormalParameterList: []BindingElement{ 114 { 115 SingleNameBinding: &tk[9], 116 Tokens: tk[9:10], 117 }, 118 }, 119 Tokens: tk[8:11], 120 }, 121 FunctionBody: Block{ 122 Tokens: tk[11:13], 123 }, 124 Tokens: tk[5:13], 125 }, 126 Tokens: tk[5:13], 127 }, 128 }, 129 Tokens: tk[:14], 130 } 131 }}, 132 {`class myClass {get value(){}}`, func(t *test, tk Tokens) { // 6 133 t.Output = ClassDeclaration{ 134 BindingIdentifier: &tk[2], 135 ClassBody: []ClassElement{ 136 { 137 MethodDefinition: &MethodDefinition{ 138 Type: MethodGetter, 139 ClassElementName: ClassElementName{ 140 PropertyName: &PropertyName{ 141 LiteralPropertyName: &tk[7], 142 Tokens: tk[7:8], 143 }, 144 Tokens: tk[7:8], 145 }, 146 Params: FormalParameters{ 147 Tokens: tk[8:10], 148 }, 149 FunctionBody: Block{ 150 Tokens: tk[10:12], 151 }, 152 Tokens: tk[5:12], 153 }, 154 Tokens: tk[5:12], 155 }, 156 }, 157 Tokens: tk[:13], 158 } 159 }}, 160 {`class myClass { 161 get value(){} 162 set value(v){} 163 static hello(){} 164 }`, func(t *test, tk Tokens) { // 7 165 t.Output = ClassDeclaration{ 166 BindingIdentifier: &tk[2], 167 ClassBody: []ClassElement{ 168 { 169 MethodDefinition: &MethodDefinition{ 170 Type: MethodGetter, 171 ClassElementName: ClassElementName{ 172 PropertyName: &PropertyName{ 173 LiteralPropertyName: &tk[9], 174 Tokens: tk[9:10], 175 }, 176 Tokens: tk[9:10], 177 }, 178 Params: FormalParameters{ 179 Tokens: tk[10:12], 180 }, 181 FunctionBody: Block{ 182 Tokens: tk[12:14], 183 }, 184 Tokens: tk[7:14], 185 }, 186 Tokens: tk[7:14], 187 }, 188 { 189 MethodDefinition: &MethodDefinition{ 190 Type: MethodSetter, 191 ClassElementName: ClassElementName{ 192 PropertyName: &PropertyName{ 193 LiteralPropertyName: &tk[18], 194 Tokens: tk[18:19], 195 }, 196 Tokens: tk[18:19], 197 }, 198 Params: FormalParameters{ 199 FormalParameterList: []BindingElement{ 200 { 201 SingleNameBinding: &tk[20], 202 Tokens: tk[20:21], 203 }, 204 }, 205 Tokens: tk[19:22], 206 }, 207 FunctionBody: Block{ 208 Tokens: tk[22:24], 209 }, 210 Tokens: tk[16:24], 211 }, 212 Tokens: tk[16:24], 213 }, 214 { 215 Static: true, 216 MethodDefinition: &MethodDefinition{ 217 ClassElementName: ClassElementName{ 218 PropertyName: &PropertyName{ 219 LiteralPropertyName: &tk[28], 220 Tokens: tk[28:29], 221 }, 222 Tokens: tk[28:29], 223 }, 224 Params: FormalParameters{ 225 Tokens: tk[29:31], 226 }, 227 FunctionBody: Block{ 228 Tokens: tk[31:33], 229 }, 230 Tokens: tk[28:33], 231 }, 232 Tokens: tk[26:33], 233 }, 234 }, 235 Tokens: tk[:35], 236 } 237 }}, 238 {`class{}`, func(t *test, tk Tokens) { // 8 239 t.Err = Error{ 240 Err: ErrNoIdentifier, 241 Parsing: "ClassDeclaration", 242 Token: tk[1], 243 } 244 }}, 245 {`class{}`, func(t *test, tk Tokens) { // 9 246 t.Def = true 247 t.Output = ClassDeclaration{ 248 Tokens: tk[:3], 249 } 250 }}, 251 {`class beep`, func(t *test, tk Tokens) { // 10 252 t.Err = Error{ 253 Err: ErrMissingOpeningBrace, 254 Parsing: "ClassDeclaration", 255 Token: tk[3], 256 } 257 }}, 258 }, func(t *test) (Type, error) { 259 var cd ClassDeclaration 260 err := cd.parse(&t.Tokens, t.Yield, t.Await, t.Def) 261 return cd, err 262 }) 263 } 264 265 func TestClassDeclaration(t *testing.T) { 266 doTests(t, []sourceFn{ 267 {``, func(t *test, tk Tokens) { // 1 268 t.Err = Error{ 269 Err: ErrInvalidClassDeclaration, 270 Parsing: "ClassDeclaration", 271 Token: tk[0], 272 } 273 }}, 274 {"class\n", func(t *test, tk Tokens) { // 2 275 t.Err = Error{ 276 Err: ErrNoIdentifier, 277 Parsing: "ClassDeclaration", 278 Token: tk[2], 279 } 280 }}, 281 {"class\n", func(t *test, tk Tokens) { // 3 282 t.Err = Error{ 283 Err: ErrMissingOpeningBrace, 284 Parsing: "ClassDeclaration", 285 Token: tk[2], 286 } 287 t.Def = true 288 }}, 289 {"class\na", func(t *test, tk Tokens) { // 4 290 t.Err = Error{ 291 Err: ErrMissingOpeningBrace, 292 Parsing: "ClassDeclaration", 293 Token: tk[3], 294 } 295 }}, 296 {"class\na\nextends\n", func(t *test, tk Tokens) { // 5 297 t.Err = Error{ 298 Err: Error{ 299 Err: Error{ 300 Err: Error{ 301 Err: Error{ 302 Err: ErrNoIdentifier, 303 Parsing: "PrimaryExpression", 304 Token: tk[6], 305 }, 306 Parsing: "MemberExpression", 307 Token: tk[6], 308 }, 309 Parsing: "NewExpression", 310 Token: tk[6], 311 }, 312 Parsing: "LeftHandSideExpression", 313 Token: tk[6], 314 }, 315 Parsing: "ClassDeclaration", 316 Token: tk[6], 317 } 318 }}, 319 {"class\nextends\n", func(t *test, tk Tokens) { // 6 320 t.Err = Error{ 321 Err: Error{ 322 Err: Error{ 323 Err: Error{ 324 Err: Error{ 325 Err: ErrNoIdentifier, 326 Parsing: "PrimaryExpression", 327 Token: tk[4], 328 }, 329 Parsing: "MemberExpression", 330 Token: tk[4], 331 }, 332 Parsing: "NewExpression", 333 Token: tk[4], 334 }, 335 Parsing: "LeftHandSideExpression", 336 Token: tk[4], 337 }, 338 Parsing: "ClassDeclaration", 339 Token: tk[4], 340 } 341 t.Def = true 342 }}, 343 {"class\na\nextends\nb\n", func(t *test, tk Tokens) { // 7 344 t.Err = Error{ 345 Err: ErrMissingOpeningBrace, 346 Parsing: "ClassDeclaration", 347 Token: tk[8], 348 } 349 }}, 350 {"class\na\n{\n}", func(t *test, tk Tokens) { // 8 351 t.Output = ClassDeclaration{ 352 BindingIdentifier: &tk[2], 353 Tokens: tk[:7], 354 } 355 }}, 356 {"class\na\nextends\nb\n{\n}", func(t *test, tk Tokens) { // 9 357 t.Output = ClassDeclaration{ 358 BindingIdentifier: &tk[2], 359 ClassHeritage: &LeftHandSideExpression{ 360 NewExpression: &NewExpression{ 361 MemberExpression: MemberExpression{ 362 PrimaryExpression: &PrimaryExpression{ 363 IdentifierReference: &tk[6], 364 Tokens: tk[6:7], 365 }, 366 Tokens: tk[6:7], 367 }, 368 Tokens: tk[6:7], 369 }, 370 Tokens: tk[6:7], 371 }, 372 Tokens: tk[:11], 373 } 374 }}, 375 {"class\nextends\na\n{\n}", func(t *test, tk Tokens) { // 10 376 t.Output = ClassDeclaration{ 377 ClassHeritage: &LeftHandSideExpression{ 378 NewExpression: &NewExpression{ 379 MemberExpression: MemberExpression{ 380 PrimaryExpression: &PrimaryExpression{ 381 IdentifierReference: &tk[4], 382 Tokens: tk[4:5], 383 }, 384 Tokens: tk[4:5], 385 }, 386 Tokens: tk[4:5], 387 }, 388 Tokens: tk[4:5], 389 }, 390 Tokens: tk[:9], 391 } 392 t.Def = true 393 }}, 394 {"class\na\n{\n}", func(t *test, tk Tokens) { // 11 395 t.Output = ClassDeclaration{ 396 BindingIdentifier: &tk[2], 397 Tokens: tk[:7], 398 } 399 t.Def = true 400 }}, 401 {"class\na\n{\n;\n}", func(t *test, tk Tokens) { // 12 402 t.Output = ClassDeclaration{ 403 BindingIdentifier: &tk[2], 404 Tokens: tk[:9], 405 } 406 t.Def = true 407 }}, 408 {"class\n{\n}", func(t *test, tk Tokens) { // 13 409 t.Output = ClassDeclaration{ 410 Tokens: tk[:5], 411 } 412 t.Def = true 413 }}, 414 {"class\n{\n;\n}", func(t *test, tk Tokens) { // 14 415 t.Output = ClassDeclaration{ 416 Tokens: tk[:7], 417 } 418 t.Def = true 419 }}, 420 {"class\na\n{\nb(){}\n}", func(t *test, tk Tokens) { // 15 421 t.Output = ClassDeclaration{ 422 BindingIdentifier: &tk[2], 423 ClassBody: []ClassElement{ 424 { 425 MethodDefinition: &MethodDefinition{ 426 ClassElementName: ClassElementName{ 427 PropertyName: &PropertyName{ 428 LiteralPropertyName: &tk[6], 429 Tokens: tk[6:7], 430 }, 431 Tokens: tk[6:7], 432 }, 433 Params: FormalParameters{ 434 Tokens: tk[7:9], 435 }, 436 FunctionBody: Block{ 437 Tokens: tk[9:11], 438 }, 439 Tokens: tk[6:11], 440 }, 441 Tokens: tk[6:11], 442 }, 443 }, 444 Tokens: tk[:13], 445 } 446 }}, 447 {"class\na\n{\n;\na(){}\n;\n}", func(t *test, tk Tokens) { // 16 448 t.Output = ClassDeclaration{ 449 BindingIdentifier: &tk[2], 450 ClassBody: []ClassElement{ 451 { 452 MethodDefinition: &MethodDefinition{ 453 ClassElementName: ClassElementName{ 454 PropertyName: &PropertyName{ 455 LiteralPropertyName: &tk[8], 456 Tokens: tk[8:9], 457 }, 458 Tokens: tk[8:9], 459 }, 460 Params: FormalParameters{ 461 Tokens: tk[9:11], 462 }, 463 FunctionBody: Block{ 464 Tokens: tk[11:13], 465 }, 466 Tokens: tk[8:13], 467 }, 468 Tokens: tk[8:13], 469 }, 470 }, 471 Tokens: tk[:17], 472 } 473 }}, 474 {"class\na\n{\na(){}\nb(){}\n}", func(t *test, tk Tokens) { // 17 475 t.Output = ClassDeclaration{ 476 BindingIdentifier: &tk[2], 477 ClassBody: []ClassElement{ 478 { 479 MethodDefinition: &MethodDefinition{ 480 ClassElementName: ClassElementName{ 481 PropertyName: &PropertyName{ 482 LiteralPropertyName: &tk[6], 483 Tokens: tk[6:7], 484 }, 485 Tokens: tk[6:7], 486 }, 487 Params: FormalParameters{ 488 Tokens: tk[7:9], 489 }, 490 FunctionBody: Block{ 491 Tokens: tk[9:11], 492 }, 493 Tokens: tk[6:11], 494 }, 495 Tokens: tk[6:11], 496 }, 497 { 498 MethodDefinition: &MethodDefinition{ 499 ClassElementName: ClassElementName{ 500 PropertyName: &PropertyName{ 501 LiteralPropertyName: &tk[12], 502 Tokens: tk[12:13], 503 }, 504 Tokens: tk[12:13], 505 }, 506 Params: FormalParameters{ 507 Tokens: tk[13:15], 508 }, 509 FunctionBody: Block{ 510 Tokens: tk[15:17], 511 }, 512 Tokens: tk[12:17], 513 }, 514 Tokens: tk[12:17], 515 }, 516 }, 517 Tokens: tk[:19], 518 } 519 }}, 520 {"class\na\n{\n;\na(){}\n;\nb(){}\n;\n}", func(t *test, tk Tokens) { // 18 521 t.Output = ClassDeclaration{ 522 BindingIdentifier: &tk[2], 523 ClassBody: []ClassElement{ 524 { 525 MethodDefinition: &MethodDefinition{ 526 ClassElementName: ClassElementName{ 527 PropertyName: &PropertyName{ 528 LiteralPropertyName: &tk[8], 529 Tokens: tk[8:9], 530 }, 531 Tokens: tk[8:9], 532 }, 533 Params: FormalParameters{ 534 Tokens: tk[9:11], 535 }, 536 FunctionBody: Block{ 537 Tokens: tk[11:13], 538 }, 539 Tokens: tk[8:13], 540 }, 541 Tokens: tk[8:13], 542 }, 543 { 544 MethodDefinition: &MethodDefinition{ 545 ClassElementName: ClassElementName{ 546 PropertyName: &PropertyName{ 547 LiteralPropertyName: &tk[16], 548 Tokens: tk[16:17], 549 }, 550 Tokens: tk[16:17], 551 }, 552 Params: FormalParameters{ 553 Tokens: tk[17:19], 554 }, 555 FunctionBody: Block{ 556 Tokens: tk[19:21], 557 }, 558 Tokens: tk[16:21], 559 }, 560 Tokens: tk[16:21], 561 }, 562 }, 563 Tokens: tk[:25], 564 } 565 }}, 566 {"class a {static b() {} }", func(t *test, tk Tokens) { // 19 567 t.Output = ClassDeclaration{ 568 BindingIdentifier: &tk[2], 569 ClassBody: []ClassElement{ 570 { 571 Static: true, 572 MethodDefinition: &MethodDefinition{ 573 ClassElementName: ClassElementName{ 574 PropertyName: &PropertyName{ 575 LiteralPropertyName: &tk[7], 576 Tokens: tk[7:8], 577 }, 578 Tokens: tk[7:8], 579 }, 580 Params: FormalParameters{ 581 Tokens: tk[8:10], 582 }, 583 FunctionBody: Block{ 584 Tokens: tk[11:13], 585 }, 586 Tokens: tk[7:13], 587 }, 588 Tokens: tk[5:13], 589 }, 590 }, 591 Tokens: tk[:15], 592 } 593 }}, 594 {"class a {static [\"b\"]() {} }", func(t *test, tk Tokens) { // 20 595 t.Output = ClassDeclaration{ 596 BindingIdentifier: &tk[2], 597 ClassBody: []ClassElement{ 598 { 599 Static: true, 600 MethodDefinition: &MethodDefinition{ 601 ClassElementName: ClassElementName{ 602 PropertyName: &PropertyName{ 603 ComputedPropertyName: &AssignmentExpression{ 604 ConditionalExpression: WrapConditional(&PrimaryExpression{ 605 Literal: &tk[8], 606 Tokens: tk[8:9], 607 }), 608 Tokens: tk[8:9], 609 }, 610 Tokens: tk[7:10], 611 }, 612 Tokens: tk[7:10], 613 }, 614 Params: FormalParameters{ 615 Tokens: tk[10:12], 616 }, 617 FunctionBody: Block{ 618 Tokens: tk[13:15], 619 }, 620 Tokens: tk[7:15], 621 }, 622 Tokens: tk[5:15], 623 }, 624 }, 625 Tokens: tk[:17], 626 } 627 }}, 628 {"class a {static #b() {} }", func(t *test, tk Tokens) { // 21 629 t.Output = ClassDeclaration{ 630 BindingIdentifier: &tk[2], 631 ClassBody: []ClassElement{ 632 { 633 Static: true, 634 MethodDefinition: &MethodDefinition{ 635 ClassElementName: ClassElementName{ 636 PrivateIdentifier: &tk[7], 637 Tokens: tk[7:8], 638 }, 639 Params: FormalParameters{ 640 Tokens: tk[8:10], 641 }, 642 FunctionBody: Block{ 643 Tokens: tk[11:13], 644 }, 645 Tokens: tk[7:13], 646 }, 647 Tokens: tk[5:13], 648 }, 649 }, 650 Tokens: tk[:15], 651 } 652 }}, 653 {"class a {static b}", func(t *test, tk Tokens) { // 22 654 t.Output = ClassDeclaration{ 655 BindingIdentifier: &tk[2], 656 ClassBody: []ClassElement{ 657 { 658 Static: true, 659 FieldDefinition: &FieldDefinition{ 660 ClassElementName: ClassElementName{ 661 PropertyName: &PropertyName{ 662 LiteralPropertyName: &tk[7], 663 Tokens: tk[7:8], 664 }, 665 Tokens: tk[7:8], 666 }, 667 Tokens: tk[7:8], 668 }, 669 Tokens: tk[5:8], 670 }, 671 }, 672 Tokens: tk[:9], 673 } 674 }}, 675 {"class a {static b = 1}", func(t *test, tk Tokens) { // 23 676 t.Output = ClassDeclaration{ 677 BindingIdentifier: &tk[2], 678 ClassBody: []ClassElement{ 679 { 680 Static: true, 681 FieldDefinition: &FieldDefinition{ 682 ClassElementName: ClassElementName{ 683 PropertyName: &PropertyName{ 684 LiteralPropertyName: &tk[7], 685 Tokens: tk[7:8], 686 }, 687 Tokens: tk[7:8], 688 }, 689 Initializer: &AssignmentExpression{ 690 ConditionalExpression: WrapConditional(&PrimaryExpression{ 691 Literal: &tk[11], 692 Tokens: tk[11:12], 693 }), 694 Tokens: tk[11:12], 695 }, 696 Tokens: tk[7:12], 697 }, 698 Tokens: tk[5:12], 699 }, 700 }, 701 Tokens: tk[:13], 702 } 703 }}, 704 {"class a {static [b]}", func(t *test, tk Tokens) { // 24 705 t.Output = ClassDeclaration{ 706 BindingIdentifier: &tk[2], 707 ClassBody: []ClassElement{ 708 { 709 Static: true, 710 FieldDefinition: &FieldDefinition{ 711 ClassElementName: ClassElementName{ 712 PropertyName: &PropertyName{ 713 ComputedPropertyName: &AssignmentExpression{ 714 ConditionalExpression: WrapConditional(&PrimaryExpression{ 715 IdentifierReference: &tk[8], 716 Tokens: tk[8:9], 717 }), 718 Tokens: tk[8:9], 719 }, 720 Tokens: tk[7:10], 721 }, 722 Tokens: tk[7:10], 723 }, 724 Tokens: tk[7:10], 725 }, 726 Tokens: tk[5:10], 727 }, 728 }, 729 Tokens: tk[:11], 730 } 731 }}, 732 {"class a {static [b] = 1}", func(t *test, tk Tokens) { // 25 733 t.Output = ClassDeclaration{ 734 BindingIdentifier: &tk[2], 735 ClassBody: []ClassElement{ 736 { 737 Static: true, 738 FieldDefinition: &FieldDefinition{ 739 ClassElementName: ClassElementName{ 740 PropertyName: &PropertyName{ 741 ComputedPropertyName: &AssignmentExpression{ 742 ConditionalExpression: WrapConditional(&PrimaryExpression{ 743 IdentifierReference: &tk[8], 744 Tokens: tk[8:9], 745 }), 746 Tokens: tk[8:9], 747 }, 748 Tokens: tk[7:10], 749 }, 750 Tokens: tk[7:10], 751 }, 752 Initializer: &AssignmentExpression{ 753 ConditionalExpression: WrapConditional(&PrimaryExpression{ 754 Literal: &tk[13], 755 Tokens: tk[13:14], 756 }), 757 Tokens: tk[13:14], 758 }, 759 Tokens: tk[7:14], 760 }, 761 Tokens: tk[5:14], 762 }, 763 }, 764 Tokens: tk[:15], 765 } 766 }}, 767 {"class a {static #b}", func(t *test, tk Tokens) { // 26 768 t.Output = ClassDeclaration{ 769 BindingIdentifier: &tk[2], 770 ClassBody: []ClassElement{ 771 { 772 Static: true, 773 FieldDefinition: &FieldDefinition{ 774 ClassElementName: ClassElementName{ 775 PrivateIdentifier: &tk[7], 776 Tokens: tk[7:8], 777 }, 778 Tokens: tk[7:8], 779 }, 780 Tokens: tk[5:8], 781 }, 782 }, 783 Tokens: tk[:9], 784 } 785 }}, 786 {"class a {static #b = 1}", func(t *test, tk Tokens) { // 27 787 t.Output = ClassDeclaration{ 788 BindingIdentifier: &tk[2], 789 ClassBody: []ClassElement{ 790 { 791 Static: true, 792 FieldDefinition: &FieldDefinition{ 793 ClassElementName: ClassElementName{ 794 PrivateIdentifier: &tk[7], 795 Tokens: tk[7:8], 796 }, 797 Initializer: &AssignmentExpression{ 798 ConditionalExpression: WrapConditional(&PrimaryExpression{ 799 Literal: &tk[11], 800 Tokens: tk[11:12], 801 }), 802 Tokens: tk[11:12], 803 }, 804 Tokens: tk[7:12], 805 }, 806 Tokens: tk[5:12], 807 }, 808 }, 809 Tokens: tk[:13], 810 } 811 }}, 812 {"class a {static b;}", func(t *test, tk Tokens) { // 28 813 t.Output = ClassDeclaration{ 814 BindingIdentifier: &tk[2], 815 ClassBody: []ClassElement{ 816 { 817 Static: true, 818 FieldDefinition: &FieldDefinition{ 819 ClassElementName: ClassElementName{ 820 PropertyName: &PropertyName{ 821 LiteralPropertyName: &tk[7], 822 Tokens: tk[7:8], 823 }, 824 Tokens: tk[7:8], 825 }, 826 Tokens: tk[7:8], 827 }, 828 Tokens: tk[5:9], 829 }, 830 }, 831 Tokens: tk[:10], 832 } 833 }}, 834 {"class a {static b = 1 ;}", func(t *test, tk Tokens) { // 29 835 t.Output = ClassDeclaration{ 836 BindingIdentifier: &tk[2], 837 ClassBody: []ClassElement{ 838 { 839 Static: true, 840 FieldDefinition: &FieldDefinition{ 841 ClassElementName: ClassElementName{ 842 PropertyName: &PropertyName{ 843 LiteralPropertyName: &tk[7], 844 Tokens: tk[7:8], 845 }, 846 Tokens: tk[7:8], 847 }, 848 Initializer: &AssignmentExpression{ 849 ConditionalExpression: WrapConditional(&PrimaryExpression{ 850 Literal: &tk[11], 851 Tokens: tk[11:12], 852 }), 853 Tokens: tk[11:12], 854 }, 855 Tokens: tk[7:12], 856 }, 857 Tokens: tk[5:14], 858 }, 859 }, 860 Tokens: tk[:15], 861 } 862 }}, 863 {"class a {static [b]\n;}", func(t *test, tk Tokens) { // 30 864 t.Output = ClassDeclaration{ 865 BindingIdentifier: &tk[2], 866 ClassBody: []ClassElement{ 867 { 868 Static: true, 869 FieldDefinition: &FieldDefinition{ 870 ClassElementName: ClassElementName{ 871 PropertyName: &PropertyName{ 872 ComputedPropertyName: &AssignmentExpression{ 873 ConditionalExpression: WrapConditional(&PrimaryExpression{ 874 IdentifierReference: &tk[8], 875 Tokens: tk[8:9], 876 }), 877 Tokens: tk[8:9], 878 }, 879 Tokens: tk[7:10], 880 }, 881 Tokens: tk[7:10], 882 }, 883 Tokens: tk[7:10], 884 }, 885 Tokens: tk[5:12], 886 }, 887 }, 888 Tokens: tk[:13], 889 } 890 }}, 891 {"class a {static [b] = 1;;}", func(t *test, tk Tokens) { // 31 892 t.Output = ClassDeclaration{ 893 BindingIdentifier: &tk[2], 894 ClassBody: []ClassElement{ 895 { 896 Static: true, 897 FieldDefinition: &FieldDefinition{ 898 ClassElementName: ClassElementName{ 899 PropertyName: &PropertyName{ 900 ComputedPropertyName: &AssignmentExpression{ 901 ConditionalExpression: WrapConditional(&PrimaryExpression{ 902 IdentifierReference: &tk[8], 903 Tokens: tk[8:9], 904 }), 905 Tokens: tk[8:9], 906 }, 907 Tokens: tk[7:10], 908 }, 909 Tokens: tk[7:10], 910 }, 911 Initializer: &AssignmentExpression{ 912 ConditionalExpression: WrapConditional(&PrimaryExpression{ 913 Literal: &tk[13], 914 Tokens: tk[13:14], 915 }), 916 Tokens: tk[13:14], 917 }, 918 Tokens: tk[7:14], 919 }, 920 Tokens: tk[5:15], 921 }, 922 }, 923 Tokens: tk[:17], 924 } 925 }}, 926 {"class a {static #b \n;}", func(t *test, tk Tokens) { // 32 927 t.Output = ClassDeclaration{ 928 BindingIdentifier: &tk[2], 929 ClassBody: []ClassElement{ 930 { 931 Static: true, 932 FieldDefinition: &FieldDefinition{ 933 ClassElementName: ClassElementName{ 934 PrivateIdentifier: &tk[7], 935 Tokens: tk[7:8], 936 }, 937 Tokens: tk[7:8], 938 }, 939 Tokens: tk[5:11], 940 }, 941 }, 942 Tokens: tk[:12], 943 } 944 }}, 945 {"class a {static #b = 1\n ;}", func(t *test, tk Tokens) { // 33 946 t.Output = ClassDeclaration{ 947 BindingIdentifier: &tk[2], 948 ClassBody: []ClassElement{ 949 { 950 Static: true, 951 FieldDefinition: &FieldDefinition{ 952 ClassElementName: ClassElementName{ 953 PrivateIdentifier: &tk[7], 954 Tokens: tk[7:8], 955 }, 956 Initializer: &AssignmentExpression{ 957 ConditionalExpression: WrapConditional(&PrimaryExpression{ 958 Literal: &tk[11], 959 Tokens: tk[11:12], 960 }), 961 Tokens: tk[11:12], 962 }, 963 Tokens: tk[7:12], 964 }, 965 Tokens: tk[5:15], 966 }, 967 }, 968 Tokens: tk[:16], 969 } 970 }}, 971 {"class a {static () {}}", func(t *test, tk Tokens) { // 34 972 t.Output = ClassDeclaration{ 973 BindingIdentifier: &tk[2], 974 ClassBody: []ClassElement{ 975 { 976 MethodDefinition: &MethodDefinition{ 977 ClassElementName: ClassElementName{ 978 PropertyName: &PropertyName{ 979 LiteralPropertyName: &tk[5], 980 Tokens: tk[5:6], 981 }, 982 Tokens: tk[5:6], 983 }, 984 Params: FormalParameters{ 985 Tokens: tk[7:9], 986 }, 987 FunctionBody: Block{ 988 Tokens: tk[10:12], 989 }, 990 Tokens: tk[5:12], 991 }, 992 Tokens: tk[5:12], 993 }, 994 }, 995 Tokens: tk[:13], 996 } 997 }}, 998 {"class a {static}", func(t *test, tk Tokens) { // 35 999 t.Output = ClassDeclaration{ 1000 BindingIdentifier: &tk[2], 1001 ClassBody: []ClassElement{ 1002 { 1003 FieldDefinition: &FieldDefinition{ 1004 ClassElementName: ClassElementName{ 1005 PropertyName: &PropertyName{ 1006 LiteralPropertyName: &tk[5], 1007 Tokens: tk[5:6], 1008 }, 1009 Tokens: tk[5:6], 1010 }, 1011 Tokens: tk[5:6], 1012 }, 1013 Tokens: tk[5:6], 1014 }, 1015 }, 1016 Tokens: tk[:7], 1017 } 1018 }}, 1019 {"class a {static = 1}", func(t *test, tk Tokens) { // 36 1020 t.Output = ClassDeclaration{ 1021 BindingIdentifier: &tk[2], 1022 ClassBody: []ClassElement{ 1023 { 1024 FieldDefinition: &FieldDefinition{ 1025 ClassElementName: ClassElementName{ 1026 PropertyName: &PropertyName{ 1027 LiteralPropertyName: &tk[5], 1028 Tokens: tk[5:6], 1029 }, 1030 Tokens: tk[5:6], 1031 }, 1032 Initializer: &AssignmentExpression{ 1033 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1034 Literal: &tk[9], 1035 Tokens: tk[9:10], 1036 }), 1037 Tokens: tk[9:10], 1038 }, 1039 Tokens: tk[5:10], 1040 }, 1041 Tokens: tk[5:10], 1042 }, 1043 }, 1044 Tokens: tk[:11], 1045 } 1046 }}, 1047 {"class a {static\n;}", func(t *test, tk Tokens) { // 37 1048 t.Output = ClassDeclaration{ 1049 BindingIdentifier: &tk[2], 1050 ClassBody: []ClassElement{ 1051 { 1052 FieldDefinition: &FieldDefinition{ 1053 ClassElementName: ClassElementName{ 1054 PropertyName: &PropertyName{ 1055 LiteralPropertyName: &tk[5], 1056 Tokens: tk[5:6], 1057 }, 1058 Tokens: tk[5:6], 1059 }, 1060 Tokens: tk[5:6], 1061 }, 1062 Tokens: tk[5:8], 1063 }, 1064 }, 1065 Tokens: tk[:9], 1066 } 1067 }}, 1068 {"class a {static = 1\n;}", func(t *test, tk Tokens) { // 38 1069 t.Output = ClassDeclaration{ 1070 BindingIdentifier: &tk[2], 1071 ClassBody: []ClassElement{ 1072 { 1073 FieldDefinition: &FieldDefinition{ 1074 ClassElementName: ClassElementName{ 1075 PropertyName: &PropertyName{ 1076 LiteralPropertyName: &tk[5], 1077 Tokens: tk[5:6], 1078 }, 1079 Tokens: tk[5:6], 1080 }, 1081 Initializer: &AssignmentExpression{ 1082 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1083 Literal: &tk[9], 1084 Tokens: tk[9:10], 1085 }), 1086 Tokens: tk[9:10], 1087 }, 1088 Tokens: tk[5:10], 1089 }, 1090 Tokens: tk[5:12], 1091 }, 1092 }, 1093 Tokens: tk[:13], 1094 } 1095 }}, 1096 {"class a {static\n{}}", func(t *test, tk Tokens) { // 39 1097 t.Output = ClassDeclaration{ 1098 BindingIdentifier: &tk[2], 1099 ClassBody: []ClassElement{ 1100 { 1101 Static: true, 1102 ClassStaticBlock: &Block{ 1103 Tokens: tk[7:9], 1104 }, 1105 Tokens: tk[5:9], 1106 }, 1107 }, 1108 Tokens: tk[:10], 1109 } 1110 }}, 1111 {"class a {static{b;c}}", func(t *test, tk Tokens) { // 40 1112 t.Output = ClassDeclaration{ 1113 BindingIdentifier: &tk[2], 1114 ClassBody: []ClassElement{ 1115 { 1116 Static: true, 1117 ClassStaticBlock: &Block{ 1118 StatementList: []StatementListItem{ 1119 { 1120 Statement: &Statement{ 1121 ExpressionStatement: &Expression{ 1122 Expressions: []AssignmentExpression{ 1123 { 1124 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1125 IdentifierReference: &tk[7], 1126 Tokens: tk[7:8], 1127 }), 1128 Tokens: tk[7:8], 1129 }, 1130 }, 1131 Tokens: tk[7:8], 1132 }, 1133 Tokens: tk[7:9], 1134 }, 1135 Tokens: tk[7:9], 1136 }, 1137 { 1138 Statement: &Statement{ 1139 ExpressionStatement: &Expression{ 1140 Expressions: []AssignmentExpression{ 1141 { 1142 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1143 IdentifierReference: &tk[9], 1144 Tokens: tk[9:10], 1145 }), 1146 Tokens: tk[9:10], 1147 }, 1148 }, 1149 Tokens: tk[9:10], 1150 }, 1151 Tokens: tk[9:10], 1152 }, 1153 Tokens: tk[9:10], 1154 }, 1155 }, 1156 Tokens: tk[6:11], 1157 }, 1158 Tokens: tk[5:11], 1159 }, 1160 }, 1161 Tokens: tk[:12], 1162 } 1163 }}, 1164 {"class a {static async}", func(t *test, tk Tokens) { // 41 1165 t.Output = ClassDeclaration{ 1166 BindingIdentifier: &tk[2], 1167 ClassBody: []ClassElement{ 1168 { 1169 Static: true, 1170 FieldDefinition: &FieldDefinition{ 1171 ClassElementName: ClassElementName{ 1172 PropertyName: &PropertyName{ 1173 LiteralPropertyName: &tk[7], 1174 Tokens: tk[7:8], 1175 }, 1176 Tokens: tk[7:8], 1177 }, 1178 Tokens: tk[7:8], 1179 }, 1180 Tokens: tk[5:8], 1181 }, 1182 }, 1183 Tokens: tk[:9], 1184 } 1185 }}, 1186 {"class a {static async;}", func(t *test, tk Tokens) { // 42 1187 t.Output = ClassDeclaration{ 1188 BindingIdentifier: &tk[2], 1189 ClassBody: []ClassElement{ 1190 { 1191 Static: true, 1192 FieldDefinition: &FieldDefinition{ 1193 ClassElementName: ClassElementName{ 1194 PropertyName: &PropertyName{ 1195 LiteralPropertyName: &tk[7], 1196 Tokens: tk[7:8], 1197 }, 1198 Tokens: tk[7:8], 1199 }, 1200 Tokens: tk[7:8], 1201 }, 1202 Tokens: tk[5:9], 1203 }, 1204 }, 1205 Tokens: tk[:10], 1206 } 1207 }}, 1208 {"class a {static async\n= 1}", func(t *test, tk Tokens) { // 43 1209 t.Output = ClassDeclaration{ 1210 BindingIdentifier: &tk[2], 1211 ClassBody: []ClassElement{ 1212 { 1213 Static: true, 1214 FieldDefinition: &FieldDefinition{ 1215 ClassElementName: ClassElementName{ 1216 PropertyName: &PropertyName{ 1217 LiteralPropertyName: &tk[7], 1218 Tokens: tk[7:8], 1219 }, 1220 Tokens: tk[7:8], 1221 }, 1222 Initializer: &AssignmentExpression{ 1223 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1224 Literal: &tk[11], 1225 Tokens: tk[11:12], 1226 }), 1227 Tokens: tk[11:12], 1228 }, 1229 Tokens: tk[7:12], 1230 }, 1231 Tokens: tk[5:12], 1232 }, 1233 }, 1234 Tokens: tk[:13], 1235 } 1236 }}, 1237 {"class a {static async = 1;}", func(t *test, tk Tokens) { // 44 1238 t.Output = ClassDeclaration{ 1239 BindingIdentifier: &tk[2], 1240 ClassBody: []ClassElement{ 1241 { 1242 Static: true, 1243 FieldDefinition: &FieldDefinition{ 1244 ClassElementName: ClassElementName{ 1245 PropertyName: &PropertyName{ 1246 LiteralPropertyName: &tk[7], 1247 Tokens: tk[7:8], 1248 }, 1249 Tokens: tk[7:8], 1250 }, 1251 Initializer: &AssignmentExpression{ 1252 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1253 Literal: &tk[11], 1254 Tokens: tk[11:12], 1255 }), 1256 Tokens: tk[11:12], 1257 }, 1258 Tokens: tk[7:12], 1259 }, 1260 Tokens: tk[5:13], 1261 }, 1262 }, 1263 Tokens: tk[:14], 1264 } 1265 }}, 1266 {"class a {static\n*\nb() {}}", func(t *test, tk Tokens) { // 45 1267 t.Output = ClassDeclaration{ 1268 BindingIdentifier: &tk[2], 1269 ClassBody: []ClassElement{ 1270 { 1271 Static: true, 1272 MethodDefinition: &MethodDefinition{ 1273 Type: MethodGenerator, 1274 ClassElementName: ClassElementName{ 1275 PropertyName: &PropertyName{ 1276 LiteralPropertyName: &tk[9], 1277 Tokens: tk[9:10], 1278 }, 1279 Tokens: tk[9:10], 1280 }, 1281 Params: FormalParameters{ 1282 Tokens: tk[10:12], 1283 }, 1284 FunctionBody: Block{ 1285 Tokens: tk[13:15], 1286 }, 1287 Tokens: tk[7:15], 1288 }, 1289 Tokens: tk[5:15], 1290 }, 1291 }, 1292 Tokens: tk[:16], 1293 } 1294 }}, 1295 {"class a {static * async() {}}", func(t *test, tk Tokens) { // 46 1296 t.Output = ClassDeclaration{ 1297 BindingIdentifier: &tk[2], 1298 ClassBody: []ClassElement{ 1299 { 1300 Static: true, 1301 MethodDefinition: &MethodDefinition{ 1302 Type: MethodGenerator, 1303 ClassElementName: ClassElementName{ 1304 PropertyName: &PropertyName{ 1305 LiteralPropertyName: &tk[9], 1306 Tokens: tk[9:10], 1307 }, 1308 Tokens: tk[9:10], 1309 }, 1310 Params: FormalParameters{ 1311 Tokens: tk[10:12], 1312 }, 1313 FunctionBody: Block{ 1314 Tokens: tk[13:15], 1315 }, 1316 Tokens: tk[7:15], 1317 }, 1318 Tokens: tk[5:15], 1319 }, 1320 }, 1321 Tokens: tk[:16], 1322 } 1323 }}, 1324 {"class a {static\n* get() {}}", func(t *test, tk Tokens) { // 47 1325 t.Output = ClassDeclaration{ 1326 BindingIdentifier: &tk[2], 1327 ClassBody: []ClassElement{ 1328 { 1329 Static: true, 1330 MethodDefinition: &MethodDefinition{ 1331 Type: MethodGenerator, 1332 ClassElementName: ClassElementName{ 1333 PropertyName: &PropertyName{ 1334 LiteralPropertyName: &tk[9], 1335 Tokens: tk[9:10], 1336 }, 1337 Tokens: tk[9:10], 1338 }, 1339 Params: FormalParameters{ 1340 Tokens: tk[10:12], 1341 }, 1342 FunctionBody: Block{ 1343 Tokens: tk[13:15], 1344 }, 1345 Tokens: tk[7:15], 1346 }, 1347 Tokens: tk[5:15], 1348 }, 1349 }, 1350 Tokens: tk[:16], 1351 } 1352 }}, 1353 {"class a {static *\nset() {}}", func(t *test, tk Tokens) { // 48 1354 t.Output = ClassDeclaration{ 1355 BindingIdentifier: &tk[2], 1356 ClassBody: []ClassElement{ 1357 { 1358 Static: true, 1359 MethodDefinition: &MethodDefinition{ 1360 Type: MethodGenerator, 1361 ClassElementName: ClassElementName{ 1362 PropertyName: &PropertyName{ 1363 LiteralPropertyName: &tk[9], 1364 Tokens: tk[9:10], 1365 }, 1366 Tokens: tk[9:10], 1367 }, 1368 Params: FormalParameters{ 1369 Tokens: tk[10:12], 1370 }, 1371 FunctionBody: Block{ 1372 Tokens: tk[13:15], 1373 }, 1374 Tokens: tk[7:15], 1375 }, 1376 Tokens: tk[5:15], 1377 }, 1378 }, 1379 Tokens: tk[:16], 1380 } 1381 }}, 1382 {"class a {static\nasync *\nb() {}}", func(t *test, tk Tokens) { // 49 1383 t.Output = ClassDeclaration{ 1384 BindingIdentifier: &tk[2], 1385 ClassBody: []ClassElement{ 1386 { 1387 Static: true, 1388 MethodDefinition: &MethodDefinition{ 1389 Type: MethodAsyncGenerator, 1390 ClassElementName: ClassElementName{ 1391 PropertyName: &PropertyName{ 1392 LiteralPropertyName: &tk[11], 1393 Tokens: tk[11:12], 1394 }, 1395 Tokens: tk[11:12], 1396 }, 1397 Params: FormalParameters{ 1398 Tokens: tk[12:14], 1399 }, 1400 FunctionBody: Block{ 1401 Tokens: tk[15:17], 1402 }, 1403 Tokens: tk[7:17], 1404 }, 1405 Tokens: tk[5:17], 1406 }, 1407 }, 1408 Tokens: tk[:18], 1409 } 1410 }}, 1411 {"class a {static async * async() {}}", func(t *test, tk Tokens) { // 50 1412 t.Output = ClassDeclaration{ 1413 BindingIdentifier: &tk[2], 1414 ClassBody: []ClassElement{ 1415 { 1416 Static: true, 1417 MethodDefinition: &MethodDefinition{ 1418 Type: MethodAsyncGenerator, 1419 ClassElementName: ClassElementName{ 1420 PropertyName: &PropertyName{ 1421 LiteralPropertyName: &tk[11], 1422 Tokens: tk[11:12], 1423 }, 1424 Tokens: tk[11:12], 1425 }, 1426 Params: FormalParameters{ 1427 Tokens: tk[12:14], 1428 }, 1429 FunctionBody: Block{ 1430 Tokens: tk[15:17], 1431 }, 1432 Tokens: tk[7:17], 1433 }, 1434 Tokens: tk[5:17], 1435 }, 1436 }, 1437 Tokens: tk[:18], 1438 } 1439 }}, 1440 {"class a {static\nasync * get() {}}", func(t *test, tk Tokens) { // 51 1441 t.Output = ClassDeclaration{ 1442 BindingIdentifier: &tk[2], 1443 ClassBody: []ClassElement{ 1444 { 1445 Static: true, 1446 MethodDefinition: &MethodDefinition{ 1447 Type: MethodAsyncGenerator, 1448 ClassElementName: ClassElementName{ 1449 PropertyName: &PropertyName{ 1450 LiteralPropertyName: &tk[11], 1451 Tokens: tk[11:12], 1452 }, 1453 Tokens: tk[11:12], 1454 }, 1455 Params: FormalParameters{ 1456 Tokens: tk[12:14], 1457 }, 1458 FunctionBody: Block{ 1459 Tokens: tk[15:17], 1460 }, 1461 Tokens: tk[7:17], 1462 }, 1463 Tokens: tk[5:17], 1464 }, 1465 }, 1466 Tokens: tk[:18], 1467 } 1468 }}, 1469 {"class a {static async #b(){}}", func(t *test, tk Tokens) { // 52 1470 t.Output = ClassDeclaration{ 1471 BindingIdentifier: &tk[2], 1472 ClassBody: []ClassElement{ 1473 { 1474 Static: true, 1475 MethodDefinition: &MethodDefinition{ 1476 Type: MethodAsync, 1477 ClassElementName: ClassElementName{ 1478 PrivateIdentifier: &tk[9], 1479 Tokens: tk[9:10], 1480 }, 1481 Params: FormalParameters{ 1482 Tokens: tk[10:12], 1483 }, 1484 FunctionBody: Block{ 1485 Tokens: tk[12:14], 1486 }, 1487 Tokens: tk[7:14], 1488 }, 1489 Tokens: tk[5:14], 1490 }, 1491 }, 1492 Tokens: tk[:15], 1493 } 1494 }}, 1495 {"class a {static async*#b(){}}", func(t *test, tk Tokens) { // 53 1496 t.Output = ClassDeclaration{ 1497 BindingIdentifier: &tk[2], 1498 ClassBody: []ClassElement{ 1499 { 1500 Static: true, 1501 MethodDefinition: &MethodDefinition{ 1502 Type: MethodAsyncGenerator, 1503 ClassElementName: ClassElementName{ 1504 PrivateIdentifier: &tk[9], 1505 Tokens: tk[9:10], 1506 }, 1507 Params: FormalParameters{ 1508 Tokens: tk[10:12], 1509 }, 1510 FunctionBody: Block{ 1511 Tokens: tk[12:14], 1512 }, 1513 Tokens: tk[7:14], 1514 }, 1515 Tokens: tk[5:14], 1516 }, 1517 }, 1518 Tokens: tk[:15], 1519 } 1520 }}, 1521 {"class a {static\nget\nb()\n{}}", func(t *test, tk Tokens) { // 54 1522 t.Output = ClassDeclaration{ 1523 BindingIdentifier: &tk[2], 1524 ClassBody: []ClassElement{ 1525 { 1526 Static: true, 1527 MethodDefinition: &MethodDefinition{ 1528 Type: MethodGetter, 1529 ClassElementName: ClassElementName{ 1530 PropertyName: &PropertyName{ 1531 LiteralPropertyName: &tk[9], 1532 Tokens: tk[9:10], 1533 }, 1534 Tokens: tk[9:10], 1535 }, 1536 Params: FormalParameters{ 1537 Tokens: tk[10:12], 1538 }, 1539 FunctionBody: Block{ 1540 Tokens: tk[13:15], 1541 }, 1542 Tokens: tk[7:15], 1543 }, 1544 Tokens: tk[5:15], 1545 }, 1546 }, 1547 Tokens: tk[:16], 1548 } 1549 }}, 1550 {"class a {static\nset\nb(c)\n{}}", func(t *test, tk Tokens) { // 55 1551 t.Output = ClassDeclaration{ 1552 BindingIdentifier: &tk[2], 1553 ClassBody: []ClassElement{ 1554 { 1555 Static: true, 1556 MethodDefinition: &MethodDefinition{ 1557 Type: MethodSetter, 1558 ClassElementName: ClassElementName{ 1559 PropertyName: &PropertyName{ 1560 LiteralPropertyName: &tk[9], 1561 Tokens: tk[9:10], 1562 }, 1563 Tokens: tk[9:10], 1564 }, 1565 Params: FormalParameters{ 1566 FormalParameterList: []BindingElement{ 1567 { 1568 SingleNameBinding: &tk[11], 1569 Tokens: tk[11:12], 1570 }, 1571 }, 1572 Tokens: tk[10:13], 1573 }, 1574 FunctionBody: Block{ 1575 Tokens: tk[14:16], 1576 }, 1577 Tokens: tk[7:16], 1578 }, 1579 Tokens: tk[5:16], 1580 }, 1581 }, 1582 Tokens: tk[:17], 1583 } 1584 }}, 1585 {"class a {static\nget\n#b()\n{}}", func(t *test, tk Tokens) { // 56 1586 t.Output = ClassDeclaration{ 1587 BindingIdentifier: &tk[2], 1588 ClassBody: []ClassElement{ 1589 { 1590 Static: true, 1591 MethodDefinition: &MethodDefinition{ 1592 Type: MethodGetter, 1593 ClassElementName: ClassElementName{ 1594 PrivateIdentifier: &tk[9], 1595 Tokens: tk[9:10], 1596 }, 1597 Params: FormalParameters{ 1598 Tokens: tk[10:12], 1599 }, 1600 FunctionBody: Block{ 1601 Tokens: tk[13:15], 1602 }, 1603 Tokens: tk[7:15], 1604 }, 1605 Tokens: tk[5:15], 1606 }, 1607 }, 1608 Tokens: tk[:16], 1609 } 1610 }}, 1611 {"class a {static\nset\n#b(c)\n{}}", func(t *test, tk Tokens) { // 57 1612 t.Output = ClassDeclaration{ 1613 BindingIdentifier: &tk[2], 1614 ClassBody: []ClassElement{ 1615 { 1616 Static: true, 1617 MethodDefinition: &MethodDefinition{ 1618 Type: MethodSetter, 1619 ClassElementName: ClassElementName{ 1620 PrivateIdentifier: &tk[9], 1621 Tokens: tk[9:10], 1622 }, 1623 Params: FormalParameters{ 1624 FormalParameterList: []BindingElement{ 1625 { 1626 SingleNameBinding: &tk[11], 1627 Tokens: tk[11:12], 1628 }, 1629 }, 1630 Tokens: tk[10:13], 1631 }, 1632 FunctionBody: Block{ 1633 Tokens: tk[14:16], 1634 }, 1635 Tokens: tk[7:16], 1636 }, 1637 Tokens: tk[5:16], 1638 }, 1639 }, 1640 Tokens: tk[:17], 1641 } 1642 }}, 1643 {"class a {static\nget}", func(t *test, tk Tokens) { // 58 1644 t.Output = ClassDeclaration{ 1645 BindingIdentifier: &tk[2], 1646 ClassBody: []ClassElement{ 1647 { 1648 Static: true, 1649 FieldDefinition: &FieldDefinition{ 1650 ClassElementName: ClassElementName{ 1651 PropertyName: &PropertyName{ 1652 LiteralPropertyName: &tk[7], 1653 Tokens: tk[7:8], 1654 }, 1655 Tokens: tk[7:8], 1656 }, 1657 Tokens: tk[7:8], 1658 }, 1659 Tokens: tk[5:8], 1660 }, 1661 }, 1662 Tokens: tk[:9], 1663 } 1664 }}, 1665 {"class a {static\nset}", func(t *test, tk Tokens) { // 59 1666 t.Output = ClassDeclaration{ 1667 BindingIdentifier: &tk[2], 1668 ClassBody: []ClassElement{ 1669 { 1670 Static: true, 1671 FieldDefinition: &FieldDefinition{ 1672 ClassElementName: ClassElementName{ 1673 PropertyName: &PropertyName{ 1674 LiteralPropertyName: &tk[7], 1675 Tokens: tk[7:8], 1676 }, 1677 Tokens: tk[7:8], 1678 }, 1679 Tokens: tk[7:8], 1680 }, 1681 Tokens: tk[5:8], 1682 }, 1683 }, 1684 Tokens: tk[:9], 1685 } 1686 }}, 1687 {"class a {static\nget\n= 1}", func(t *test, tk Tokens) { // 60 1688 t.Output = ClassDeclaration{ 1689 BindingIdentifier: &tk[2], 1690 ClassBody: []ClassElement{ 1691 { 1692 Static: true, 1693 FieldDefinition: &FieldDefinition{ 1694 ClassElementName: ClassElementName{ 1695 PropertyName: &PropertyName{ 1696 LiteralPropertyName: &tk[7], 1697 Tokens: tk[7:8], 1698 }, 1699 Tokens: tk[7:8], 1700 }, 1701 Initializer: &AssignmentExpression{ 1702 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1703 Literal: &tk[11], 1704 Tokens: tk[11:12], 1705 }), 1706 Tokens: tk[11:12], 1707 }, 1708 Tokens: tk[7:12], 1709 }, 1710 Tokens: tk[5:12], 1711 }, 1712 }, 1713 Tokens: tk[:13], 1714 } 1715 }}, 1716 {"class a {static\nset\n= 1}", func(t *test, tk Tokens) { // 61 1717 t.Output = ClassDeclaration{ 1718 BindingIdentifier: &tk[2], 1719 ClassBody: []ClassElement{ 1720 { 1721 Static: true, 1722 FieldDefinition: &FieldDefinition{ 1723 ClassElementName: ClassElementName{ 1724 PropertyName: &PropertyName{ 1725 LiteralPropertyName: &tk[7], 1726 Tokens: tk[7:8], 1727 }, 1728 Tokens: tk[7:8], 1729 }, 1730 Initializer: &AssignmentExpression{ 1731 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1732 Literal: &tk[11], 1733 Tokens: tk[11:12], 1734 }), 1735 Tokens: tk[11:12], 1736 }, 1737 Tokens: tk[7:12], 1738 }, 1739 Tokens: tk[5:12], 1740 }, 1741 }, 1742 Tokens: tk[:13], 1743 } 1744 }}, 1745 {"class a {#b() {} }", func(t *test, tk Tokens) { // 62 1746 t.Output = ClassDeclaration{ 1747 BindingIdentifier: &tk[2], 1748 ClassBody: []ClassElement{ 1749 { 1750 MethodDefinition: &MethodDefinition{ 1751 ClassElementName: ClassElementName{ 1752 PrivateIdentifier: &tk[5], 1753 Tokens: tk[5:6], 1754 }, 1755 Params: FormalParameters{ 1756 Tokens: tk[6:8], 1757 }, 1758 FunctionBody: Block{ 1759 Tokens: tk[9:11], 1760 }, 1761 Tokens: tk[5:11], 1762 }, 1763 Tokens: tk[5:11], 1764 }, 1765 }, 1766 Tokens: tk[:13], 1767 } 1768 }}, 1769 {"class a {b}", func(t *test, tk Tokens) { // 63 1770 t.Output = ClassDeclaration{ 1771 BindingIdentifier: &tk[2], 1772 ClassBody: []ClassElement{ 1773 { 1774 FieldDefinition: &FieldDefinition{ 1775 ClassElementName: ClassElementName{ 1776 PropertyName: &PropertyName{ 1777 LiteralPropertyName: &tk[5], 1778 Tokens: tk[5:6], 1779 }, 1780 Tokens: tk[5:6], 1781 }, 1782 Tokens: tk[5:6], 1783 }, 1784 Tokens: tk[5:6], 1785 }, 1786 }, 1787 Tokens: tk[:7], 1788 } 1789 }}, 1790 {"class a {b = 1}", func(t *test, tk Tokens) { // 64 1791 t.Output = ClassDeclaration{ 1792 BindingIdentifier: &tk[2], 1793 ClassBody: []ClassElement{ 1794 { 1795 FieldDefinition: &FieldDefinition{ 1796 ClassElementName: ClassElementName{ 1797 PropertyName: &PropertyName{ 1798 LiteralPropertyName: &tk[5], 1799 Tokens: tk[5:6], 1800 }, 1801 Tokens: tk[5:6], 1802 }, 1803 Initializer: &AssignmentExpression{ 1804 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1805 Literal: &tk[9], 1806 Tokens: tk[9:10], 1807 }), 1808 Tokens: tk[9:10], 1809 }, 1810 Tokens: tk[5:10], 1811 }, 1812 Tokens: tk[5:10], 1813 }, 1814 }, 1815 Tokens: tk[:11], 1816 } 1817 }}, 1818 {"class a {#b}", func(t *test, tk Tokens) { // 65 1819 t.Output = ClassDeclaration{ 1820 BindingIdentifier: &tk[2], 1821 ClassBody: []ClassElement{ 1822 { 1823 FieldDefinition: &FieldDefinition{ 1824 ClassElementName: ClassElementName{ 1825 PrivateIdentifier: &tk[5], 1826 Tokens: tk[5:6], 1827 }, 1828 Tokens: tk[5:6], 1829 }, 1830 Tokens: tk[5:6], 1831 }, 1832 }, 1833 Tokens: tk[:7], 1834 } 1835 }}, 1836 {"class a {#b = 1}", func(t *test, tk Tokens) { // 66 1837 t.Output = ClassDeclaration{ 1838 BindingIdentifier: &tk[2], 1839 ClassBody: []ClassElement{ 1840 { 1841 FieldDefinition: &FieldDefinition{ 1842 ClassElementName: ClassElementName{ 1843 PrivateIdentifier: &tk[5], 1844 Tokens: tk[5:6], 1845 }, 1846 Initializer: &AssignmentExpression{ 1847 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1848 Literal: &tk[9], 1849 Tokens: tk[9:10], 1850 }), 1851 Tokens: tk[9:10], 1852 }, 1853 Tokens: tk[5:10], 1854 }, 1855 Tokens: tk[5:10], 1856 }, 1857 }, 1858 Tokens: tk[:11], 1859 } 1860 }}, 1861 {"class a {[b]\n;}", func(t *test, tk Tokens) { // 67 1862 t.Output = ClassDeclaration{ 1863 BindingIdentifier: &tk[2], 1864 ClassBody: []ClassElement{ 1865 { 1866 FieldDefinition: &FieldDefinition{ 1867 ClassElementName: ClassElementName{ 1868 PropertyName: &PropertyName{ 1869 ComputedPropertyName: &AssignmentExpression{ 1870 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1871 IdentifierReference: &tk[6], 1872 Tokens: tk[6:7], 1873 }), 1874 Tokens: tk[6:7], 1875 }, 1876 Tokens: tk[5:8], 1877 }, 1878 Tokens: tk[5:8], 1879 }, 1880 Tokens: tk[5:8], 1881 }, 1882 Tokens: tk[5:10], 1883 }, 1884 }, 1885 Tokens: tk[:11], 1886 } 1887 }}, 1888 {"class a {[b] = 1;;}", func(t *test, tk Tokens) { // 68 1889 t.Output = ClassDeclaration{ 1890 BindingIdentifier: &tk[2], 1891 ClassBody: []ClassElement{ 1892 { 1893 FieldDefinition: &FieldDefinition{ 1894 ClassElementName: ClassElementName{ 1895 PropertyName: &PropertyName{ 1896 ComputedPropertyName: &AssignmentExpression{ 1897 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1898 IdentifierReference: &tk[6], 1899 Tokens: tk[6:7], 1900 }), 1901 Tokens: tk[6:7], 1902 }, 1903 Tokens: tk[5:8], 1904 }, 1905 Tokens: tk[5:8], 1906 }, 1907 Initializer: &AssignmentExpression{ 1908 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1909 Literal: &tk[11], 1910 Tokens: tk[11:12], 1911 }), 1912 Tokens: tk[11:12], 1913 }, 1914 Tokens: tk[5:12], 1915 }, 1916 Tokens: tk[5:13], 1917 }, 1918 }, 1919 Tokens: tk[:15], 1920 } 1921 }}, 1922 {"class a {#b \n;}", func(t *test, tk Tokens) { // 69 1923 t.Output = ClassDeclaration{ 1924 BindingIdentifier: &tk[2], 1925 ClassBody: []ClassElement{ 1926 { 1927 FieldDefinition: &FieldDefinition{ 1928 ClassElementName: ClassElementName{ 1929 PrivateIdentifier: &tk[5], 1930 Tokens: tk[5:6], 1931 }, 1932 Tokens: tk[5:6], 1933 }, 1934 Tokens: tk[5:9], 1935 }, 1936 }, 1937 Tokens: tk[:10], 1938 } 1939 }}, 1940 {"class a {#b = 1\n ;}", func(t *test, tk Tokens) { // 70 1941 t.Output = ClassDeclaration{ 1942 BindingIdentifier: &tk[2], 1943 ClassBody: []ClassElement{ 1944 { 1945 FieldDefinition: &FieldDefinition{ 1946 ClassElementName: ClassElementName{ 1947 PrivateIdentifier: &tk[5], 1948 Tokens: tk[5:6], 1949 }, 1950 Initializer: &AssignmentExpression{ 1951 ConditionalExpression: WrapConditional(&PrimaryExpression{ 1952 Literal: &tk[9], 1953 Tokens: tk[9:10], 1954 }), 1955 Tokens: tk[9:10], 1956 }, 1957 Tokens: tk[5:10], 1958 }, 1959 Tokens: tk[5:13], 1960 }, 1961 }, 1962 Tokens: tk[:14], 1963 } 1964 }}, 1965 {"class a {async}", func(t *test, tk Tokens) { // 71 1966 t.Output = ClassDeclaration{ 1967 BindingIdentifier: &tk[2], 1968 ClassBody: []ClassElement{ 1969 { 1970 FieldDefinition: &FieldDefinition{ 1971 ClassElementName: ClassElementName{ 1972 PropertyName: &PropertyName{ 1973 LiteralPropertyName: &tk[5], 1974 Tokens: tk[5:6], 1975 }, 1976 Tokens: tk[5:6], 1977 }, 1978 Tokens: tk[5:6], 1979 }, 1980 Tokens: tk[5:6], 1981 }, 1982 }, 1983 Tokens: tk[:7], 1984 } 1985 }}, 1986 {"class a {async\n= 1}", func(t *test, tk Tokens) { // 72 1987 t.Output = ClassDeclaration{ 1988 BindingIdentifier: &tk[2], 1989 ClassBody: []ClassElement{ 1990 { 1991 FieldDefinition: &FieldDefinition{ 1992 ClassElementName: ClassElementName{ 1993 PropertyName: &PropertyName{ 1994 LiteralPropertyName: &tk[5], 1995 Tokens: tk[5:6], 1996 }, 1997 Tokens: tk[5:6], 1998 }, 1999 Initializer: &AssignmentExpression{ 2000 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2001 Literal: &tk[9], 2002 Tokens: tk[9:10], 2003 }), 2004 Tokens: tk[9:10], 2005 }, 2006 Tokens: tk[5:10], 2007 }, 2008 Tokens: tk[5:10], 2009 }, 2010 }, 2011 Tokens: tk[:11], 2012 } 2013 }}, 2014 {"class a {async = 1;}", func(t *test, tk Tokens) { // 73 2015 t.Output = ClassDeclaration{ 2016 BindingIdentifier: &tk[2], 2017 ClassBody: []ClassElement{ 2018 { 2019 FieldDefinition: &FieldDefinition{ 2020 ClassElementName: ClassElementName{ 2021 PropertyName: &PropertyName{ 2022 LiteralPropertyName: &tk[5], 2023 Tokens: tk[5:6], 2024 }, 2025 Tokens: tk[5:6], 2026 }, 2027 Initializer: &AssignmentExpression{ 2028 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2029 Literal: &tk[9], 2030 Tokens: tk[9:10], 2031 }), 2032 Tokens: tk[9:10], 2033 }, 2034 Tokens: tk[5:10], 2035 }, 2036 Tokens: tk[5:11], 2037 }, 2038 }, 2039 Tokens: tk[:12], 2040 } 2041 }}, 2042 {"class a {*\nb() {}}", func(t *test, tk Tokens) { // 74 2043 t.Output = ClassDeclaration{ 2044 BindingIdentifier: &tk[2], 2045 ClassBody: []ClassElement{ 2046 { 2047 MethodDefinition: &MethodDefinition{ 2048 Type: MethodGenerator, 2049 ClassElementName: ClassElementName{ 2050 PropertyName: &PropertyName{ 2051 LiteralPropertyName: &tk[7], 2052 Tokens: tk[7:8], 2053 }, 2054 Tokens: tk[7:8], 2055 }, 2056 Params: FormalParameters{ 2057 Tokens: tk[8:10], 2058 }, 2059 FunctionBody: Block{ 2060 Tokens: tk[11:13], 2061 }, 2062 Tokens: tk[5:13], 2063 }, 2064 Tokens: tk[5:13], 2065 }, 2066 }, 2067 Tokens: tk[:14], 2068 } 2069 }}, 2070 {"class a {* async() {}}", func(t *test, tk Tokens) { // 75 2071 t.Output = ClassDeclaration{ 2072 BindingIdentifier: &tk[2], 2073 ClassBody: []ClassElement{ 2074 { 2075 MethodDefinition: &MethodDefinition{ 2076 Type: MethodGenerator, 2077 ClassElementName: ClassElementName{ 2078 PropertyName: &PropertyName{ 2079 LiteralPropertyName: &tk[7], 2080 Tokens: tk[7:8], 2081 }, 2082 Tokens: tk[7:8], 2083 }, 2084 Params: FormalParameters{ 2085 Tokens: tk[8:10], 2086 }, 2087 FunctionBody: Block{ 2088 Tokens: tk[11:13], 2089 }, 2090 Tokens: tk[5:13], 2091 }, 2092 Tokens: tk[5:13], 2093 }, 2094 }, 2095 Tokens: tk[:14], 2096 } 2097 }}, 2098 {"class a {* get() {}}", func(t *test, tk Tokens) { // 76 2099 t.Output = ClassDeclaration{ 2100 BindingIdentifier: &tk[2], 2101 ClassBody: []ClassElement{ 2102 { 2103 MethodDefinition: &MethodDefinition{ 2104 Type: MethodGenerator, 2105 ClassElementName: ClassElementName{ 2106 PropertyName: &PropertyName{ 2107 LiteralPropertyName: &tk[7], 2108 Tokens: tk[7:8], 2109 }, 2110 Tokens: tk[7:8], 2111 }, 2112 Params: FormalParameters{ 2113 Tokens: tk[8:10], 2114 }, 2115 FunctionBody: Block{ 2116 Tokens: tk[11:13], 2117 }, 2118 Tokens: tk[5:13], 2119 }, 2120 Tokens: tk[5:13], 2121 }, 2122 }, 2123 Tokens: tk[:14], 2124 } 2125 }}, 2126 {"class a {*\nset() {}}", func(t *test, tk Tokens) { // 77 2127 t.Output = ClassDeclaration{ 2128 BindingIdentifier: &tk[2], 2129 ClassBody: []ClassElement{ 2130 { 2131 MethodDefinition: &MethodDefinition{ 2132 Type: MethodGenerator, 2133 ClassElementName: ClassElementName{ 2134 PropertyName: &PropertyName{ 2135 LiteralPropertyName: &tk[7], 2136 Tokens: tk[7:8], 2137 }, 2138 Tokens: tk[7:8], 2139 }, 2140 Params: FormalParameters{ 2141 Tokens: tk[8:10], 2142 }, 2143 FunctionBody: Block{ 2144 Tokens: tk[11:13], 2145 }, 2146 Tokens: tk[5:13], 2147 }, 2148 Tokens: tk[5:13], 2149 }, 2150 }, 2151 Tokens: tk[:14], 2152 } 2153 }}, 2154 {"class a {async *\nb() {}}", func(t *test, tk Tokens) { // 78 2155 t.Output = ClassDeclaration{ 2156 BindingIdentifier: &tk[2], 2157 ClassBody: []ClassElement{ 2158 { 2159 MethodDefinition: &MethodDefinition{ 2160 Type: MethodAsyncGenerator, 2161 ClassElementName: ClassElementName{ 2162 PropertyName: &PropertyName{ 2163 LiteralPropertyName: &tk[9], 2164 Tokens: tk[9:10], 2165 }, 2166 Tokens: tk[9:10], 2167 }, 2168 Params: FormalParameters{ 2169 Tokens: tk[10:12], 2170 }, 2171 FunctionBody: Block{ 2172 Tokens: tk[13:15], 2173 }, 2174 Tokens: tk[5:15], 2175 }, 2176 Tokens: tk[5:15], 2177 }, 2178 }, 2179 Tokens: tk[:16], 2180 } 2181 }}, 2182 {"class a {async * async() {}}", func(t *test, tk Tokens) { // 79 2183 t.Output = ClassDeclaration{ 2184 BindingIdentifier: &tk[2], 2185 ClassBody: []ClassElement{ 2186 { 2187 MethodDefinition: &MethodDefinition{ 2188 Type: MethodAsyncGenerator, 2189 ClassElementName: ClassElementName{ 2190 PropertyName: &PropertyName{ 2191 LiteralPropertyName: &tk[9], 2192 Tokens: tk[9:10], 2193 }, 2194 Tokens: tk[9:10], 2195 }, 2196 Params: FormalParameters{ 2197 Tokens: tk[10:12], 2198 }, 2199 FunctionBody: Block{ 2200 Tokens: tk[13:15], 2201 }, 2202 Tokens: tk[5:15], 2203 }, 2204 Tokens: tk[5:15], 2205 }, 2206 }, 2207 Tokens: tk[:16], 2208 } 2209 }}, 2210 {"class a {async * get() {}}", func(t *test, tk Tokens) { // 80 2211 t.Output = ClassDeclaration{ 2212 BindingIdentifier: &tk[2], 2213 ClassBody: []ClassElement{ 2214 { 2215 MethodDefinition: &MethodDefinition{ 2216 Type: MethodAsyncGenerator, 2217 ClassElementName: ClassElementName{ 2218 PropertyName: &PropertyName{ 2219 LiteralPropertyName: &tk[9], 2220 Tokens: tk[9:10], 2221 }, 2222 Tokens: tk[9:10], 2223 }, 2224 Params: FormalParameters{ 2225 Tokens: tk[10:12], 2226 }, 2227 FunctionBody: Block{ 2228 Tokens: tk[13:15], 2229 }, 2230 Tokens: tk[5:15], 2231 }, 2232 Tokens: tk[5:15], 2233 }, 2234 }, 2235 Tokens: tk[:16], 2236 } 2237 }}, 2238 {"class a {async #b(){}}", func(t *test, tk Tokens) { // 81 2239 t.Output = ClassDeclaration{ 2240 BindingIdentifier: &tk[2], 2241 ClassBody: []ClassElement{ 2242 { 2243 MethodDefinition: &MethodDefinition{ 2244 Type: MethodAsync, 2245 ClassElementName: ClassElementName{ 2246 PrivateIdentifier: &tk[7], 2247 Tokens: tk[7:8], 2248 }, 2249 Params: FormalParameters{ 2250 Tokens: tk[8:10], 2251 }, 2252 FunctionBody: Block{ 2253 Tokens: tk[10:12], 2254 }, 2255 Tokens: tk[5:12], 2256 }, 2257 Tokens: tk[5:12], 2258 }, 2259 }, 2260 Tokens: tk[:13], 2261 } 2262 }}, 2263 {"class a {async*#b(){}}", func(t *test, tk Tokens) { // 82 2264 t.Output = ClassDeclaration{ 2265 BindingIdentifier: &tk[2], 2266 ClassBody: []ClassElement{ 2267 { 2268 MethodDefinition: &MethodDefinition{ 2269 Type: MethodAsyncGenerator, 2270 ClassElementName: ClassElementName{ 2271 PrivateIdentifier: &tk[7], 2272 Tokens: tk[7:8], 2273 }, 2274 Params: FormalParameters{ 2275 Tokens: tk[8:10], 2276 }, 2277 FunctionBody: Block{ 2278 Tokens: tk[10:12], 2279 }, 2280 Tokens: tk[5:12], 2281 }, 2282 Tokens: tk[5:12], 2283 }, 2284 }, 2285 Tokens: tk[:13], 2286 } 2287 }}, 2288 {"class a {get\nb()\n{}}", func(t *test, tk Tokens) { // 83 2289 t.Output = ClassDeclaration{ 2290 BindingIdentifier: &tk[2], 2291 ClassBody: []ClassElement{ 2292 { 2293 MethodDefinition: &MethodDefinition{ 2294 Type: MethodGetter, 2295 ClassElementName: ClassElementName{ 2296 PropertyName: &PropertyName{ 2297 LiteralPropertyName: &tk[7], 2298 Tokens: tk[7:8], 2299 }, 2300 Tokens: tk[7:8], 2301 }, 2302 Params: FormalParameters{ 2303 Tokens: tk[8:10], 2304 }, 2305 FunctionBody: Block{ 2306 Tokens: tk[11:13], 2307 }, 2308 Tokens: tk[5:13], 2309 }, 2310 Tokens: tk[5:13], 2311 }, 2312 }, 2313 Tokens: tk[:14], 2314 } 2315 }}, 2316 {"class a {set\nb(c)\n{}}", func(t *test, tk Tokens) { // 84 2317 t.Output = ClassDeclaration{ 2318 BindingIdentifier: &tk[2], 2319 ClassBody: []ClassElement{ 2320 { 2321 MethodDefinition: &MethodDefinition{ 2322 Type: MethodSetter, 2323 ClassElementName: ClassElementName{ 2324 PropertyName: &PropertyName{ 2325 LiteralPropertyName: &tk[7], 2326 Tokens: tk[7:8], 2327 }, 2328 Tokens: tk[7:8], 2329 }, 2330 Params: FormalParameters{ 2331 FormalParameterList: []BindingElement{ 2332 { 2333 SingleNameBinding: &tk[9], 2334 Tokens: tk[9:10], 2335 }, 2336 }, 2337 Tokens: tk[8:11], 2338 }, 2339 FunctionBody: Block{ 2340 Tokens: tk[12:14], 2341 }, 2342 Tokens: tk[5:14], 2343 }, 2344 Tokens: tk[5:14], 2345 }, 2346 }, 2347 Tokens: tk[:15], 2348 } 2349 }}, 2350 {"class a {get\n#b()\n{}}", func(t *test, tk Tokens) { // 85 2351 t.Output = ClassDeclaration{ 2352 BindingIdentifier: &tk[2], 2353 ClassBody: []ClassElement{ 2354 { 2355 MethodDefinition: &MethodDefinition{ 2356 Type: MethodGetter, 2357 ClassElementName: ClassElementName{ 2358 PrivateIdentifier: &tk[7], 2359 Tokens: tk[7:8], 2360 }, 2361 Params: FormalParameters{ 2362 Tokens: tk[8:10], 2363 }, 2364 FunctionBody: Block{ 2365 Tokens: tk[11:13], 2366 }, 2367 Tokens: tk[5:13], 2368 }, 2369 Tokens: tk[5:13], 2370 }, 2371 }, 2372 Tokens: tk[:14], 2373 } 2374 }}, 2375 {"class a {set\n#b(c)\n{}}", func(t *test, tk Tokens) { // 86 2376 t.Output = ClassDeclaration{ 2377 BindingIdentifier: &tk[2], 2378 ClassBody: []ClassElement{ 2379 { 2380 MethodDefinition: &MethodDefinition{ 2381 Type: MethodSetter, 2382 ClassElementName: ClassElementName{ 2383 PrivateIdentifier: &tk[7], 2384 Tokens: tk[7:8], 2385 }, 2386 Params: FormalParameters{ 2387 FormalParameterList: []BindingElement{ 2388 { 2389 SingleNameBinding: &tk[9], 2390 Tokens: tk[9:10], 2391 }, 2392 }, 2393 Tokens: tk[8:11], 2394 }, 2395 FunctionBody: Block{ 2396 Tokens: tk[12:14], 2397 }, 2398 Tokens: tk[5:14], 2399 }, 2400 Tokens: tk[5:14], 2401 }, 2402 }, 2403 Tokens: tk[:15], 2404 } 2405 }}, 2406 {"class a {get}", func(t *test, tk Tokens) { // 87 2407 t.Output = ClassDeclaration{ 2408 BindingIdentifier: &tk[2], 2409 ClassBody: []ClassElement{ 2410 { 2411 FieldDefinition: &FieldDefinition{ 2412 ClassElementName: ClassElementName{ 2413 PropertyName: &PropertyName{ 2414 LiteralPropertyName: &tk[5], 2415 Tokens: tk[5:6], 2416 }, 2417 Tokens: tk[5:6], 2418 }, 2419 Tokens: tk[5:6], 2420 }, 2421 Tokens: tk[5:6], 2422 }, 2423 }, 2424 Tokens: tk[:7], 2425 } 2426 }}, 2427 {"class a {set}", func(t *test, tk Tokens) { // 88 2428 t.Output = ClassDeclaration{ 2429 BindingIdentifier: &tk[2], 2430 ClassBody: []ClassElement{ 2431 { 2432 FieldDefinition: &FieldDefinition{ 2433 ClassElementName: ClassElementName{ 2434 PropertyName: &PropertyName{ 2435 LiteralPropertyName: &tk[5], 2436 Tokens: tk[5:6], 2437 }, 2438 Tokens: tk[5:6], 2439 }, 2440 Tokens: tk[5:6], 2441 }, 2442 Tokens: tk[5:6], 2443 }, 2444 }, 2445 Tokens: tk[:7], 2446 } 2447 }}, 2448 {"class a {get\n= 1}", func(t *test, tk Tokens) { // 89 2449 t.Output = ClassDeclaration{ 2450 BindingIdentifier: &tk[2], 2451 ClassBody: []ClassElement{ 2452 { 2453 FieldDefinition: &FieldDefinition{ 2454 ClassElementName: ClassElementName{ 2455 PropertyName: &PropertyName{ 2456 LiteralPropertyName: &tk[5], 2457 Tokens: tk[5:6], 2458 }, 2459 Tokens: tk[5:6], 2460 }, 2461 Initializer: &AssignmentExpression{ 2462 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2463 Literal: &tk[9], 2464 Tokens: tk[9:10], 2465 }), 2466 Tokens: tk[9:10], 2467 }, 2468 Tokens: tk[5:10], 2469 }, 2470 Tokens: tk[5:10], 2471 }, 2472 }, 2473 Tokens: tk[:11], 2474 } 2475 }}, 2476 {"class a {set\n= 1}", func(t *test, tk Tokens) { // 90 2477 t.Output = ClassDeclaration{ 2478 BindingIdentifier: &tk[2], 2479 ClassBody: []ClassElement{ 2480 { 2481 FieldDefinition: &FieldDefinition{ 2482 ClassElementName: ClassElementName{ 2483 PropertyName: &PropertyName{ 2484 LiteralPropertyName: &tk[5], 2485 Tokens: tk[5:6], 2486 }, 2487 Tokens: tk[5:6], 2488 }, 2489 Initializer: &AssignmentExpression{ 2490 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2491 Literal: &tk[9], 2492 Tokens: tk[9:10], 2493 }), 2494 Tokens: tk[9:10], 2495 }, 2496 Tokens: tk[5:10], 2497 }, 2498 Tokens: tk[5:10], 2499 }, 2500 }, 2501 Tokens: tk[:11], 2502 } 2503 }}, 2504 {"class a {set = 1\n#set = 2;a\n=\n3\nb = 4;;static async c(){}static\nasync d(){}#e(){}static{}#f=5;g=6\nh=7;i\n[j]}", func(t *test, tk Tokens) { // 91 2505 t.Output = ClassDeclaration{ 2506 BindingIdentifier: &tk[2], 2507 ClassBody: []ClassElement{ 2508 { 2509 FieldDefinition: &FieldDefinition{ 2510 ClassElementName: ClassElementName{ 2511 PropertyName: &PropertyName{ 2512 LiteralPropertyName: &tk[5], 2513 Tokens: tk[5:6], 2514 }, 2515 Tokens: tk[5:6], 2516 }, 2517 Initializer: &AssignmentExpression{ 2518 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2519 Literal: &tk[9], 2520 Tokens: tk[9:10], 2521 }), 2522 Tokens: tk[9:10], 2523 }, 2524 Tokens: tk[5:10], 2525 }, 2526 Tokens: tk[5:10], 2527 }, 2528 { 2529 FieldDefinition: &FieldDefinition{ 2530 ClassElementName: ClassElementName{ 2531 PrivateIdentifier: &tk[11], 2532 Tokens: tk[11:12], 2533 }, 2534 Initializer: &AssignmentExpression{ 2535 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2536 Literal: &tk[15], 2537 Tokens: tk[15:16], 2538 }), 2539 Tokens: tk[15:16], 2540 }, 2541 Tokens: tk[11:16], 2542 }, 2543 Tokens: tk[11:17], 2544 }, 2545 { 2546 FieldDefinition: &FieldDefinition{ 2547 ClassElementName: ClassElementName{ 2548 PropertyName: &PropertyName{ 2549 LiteralPropertyName: &tk[17], 2550 Tokens: tk[17:18], 2551 }, 2552 Tokens: tk[17:18], 2553 }, 2554 Initializer: &AssignmentExpression{ 2555 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2556 Literal: &tk[21], 2557 Tokens: tk[21:22], 2558 }), 2559 Tokens: tk[21:22], 2560 }, 2561 Tokens: tk[17:22], 2562 }, 2563 Tokens: tk[17:22], 2564 }, 2565 { 2566 FieldDefinition: &FieldDefinition{ 2567 ClassElementName: ClassElementName{ 2568 PropertyName: &PropertyName{ 2569 LiteralPropertyName: &tk[23], 2570 Tokens: tk[23:24], 2571 }, 2572 Tokens: tk[23:24], 2573 }, 2574 Initializer: &AssignmentExpression{ 2575 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2576 Literal: &tk[27], 2577 Tokens: tk[27:28], 2578 }), 2579 Tokens: tk[27:28], 2580 }, 2581 Tokens: tk[23:28], 2582 }, 2583 Tokens: tk[23:29], 2584 }, 2585 { 2586 Static: true, 2587 MethodDefinition: &MethodDefinition{ 2588 Type: MethodAsync, 2589 ClassElementName: ClassElementName{ 2590 PropertyName: &PropertyName{ 2591 LiteralPropertyName: &tk[34], 2592 Tokens: tk[34:35], 2593 }, 2594 Tokens: tk[34:35], 2595 }, 2596 Params: FormalParameters{ 2597 Tokens: tk[35:37], 2598 }, 2599 FunctionBody: Block{ 2600 Tokens: tk[37:39], 2601 }, 2602 Tokens: tk[32:39], 2603 }, 2604 Tokens: tk[30:39], 2605 }, 2606 { 2607 Static: true, 2608 MethodDefinition: &MethodDefinition{ 2609 Type: MethodAsync, 2610 ClassElementName: ClassElementName{ 2611 PropertyName: &PropertyName{ 2612 LiteralPropertyName: &tk[43], 2613 Tokens: tk[43:44], 2614 }, 2615 Tokens: tk[43:44], 2616 }, 2617 Params: FormalParameters{ 2618 Tokens: tk[44:46], 2619 }, 2620 FunctionBody: Block{ 2621 Tokens: tk[46:48], 2622 }, 2623 Tokens: tk[41:48], 2624 }, 2625 Tokens: tk[39:48], 2626 }, 2627 { 2628 MethodDefinition: &MethodDefinition{ 2629 ClassElementName: ClassElementName{ 2630 PrivateIdentifier: &tk[48], 2631 Tokens: tk[48:49], 2632 }, 2633 Params: FormalParameters{ 2634 Tokens: tk[49:51], 2635 }, 2636 FunctionBody: Block{ 2637 Tokens: tk[51:53], 2638 }, 2639 Tokens: tk[48:53], 2640 }, 2641 Tokens: tk[48:53], 2642 }, 2643 { 2644 Static: true, 2645 ClassStaticBlock: &Block{ 2646 Tokens: tk[54:56], 2647 }, 2648 Tokens: tk[53:56], 2649 }, 2650 { 2651 FieldDefinition: &FieldDefinition{ 2652 ClassElementName: ClassElementName{ 2653 PrivateIdentifier: &tk[56], 2654 Tokens: tk[56:57], 2655 }, 2656 Initializer: &AssignmentExpression{ 2657 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2658 Literal: &tk[58], 2659 Tokens: tk[58:59], 2660 }), 2661 Tokens: tk[58:59], 2662 }, 2663 Tokens: tk[56:59], 2664 }, 2665 Tokens: tk[56:60], 2666 }, 2667 { 2668 FieldDefinition: &FieldDefinition{ 2669 ClassElementName: ClassElementName{ 2670 PropertyName: &PropertyName{ 2671 LiteralPropertyName: &tk[60], 2672 Tokens: tk[60:61], 2673 }, 2674 Tokens: tk[60:61], 2675 }, 2676 Initializer: &AssignmentExpression{ 2677 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2678 Literal: &tk[62], 2679 Tokens: tk[62:63], 2680 }), 2681 Tokens: tk[62:63], 2682 }, 2683 Tokens: tk[60:63], 2684 }, 2685 Tokens: tk[60:63], 2686 }, 2687 { 2688 FieldDefinition: &FieldDefinition{ 2689 ClassElementName: ClassElementName{ 2690 PropertyName: &PropertyName{ 2691 LiteralPropertyName: &tk[64], 2692 Tokens: tk[64:65], 2693 }, 2694 Tokens: tk[64:65], 2695 }, 2696 Initializer: &AssignmentExpression{ 2697 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2698 Literal: &tk[66], 2699 Tokens: tk[66:67], 2700 }), 2701 Tokens: tk[66:67], 2702 }, 2703 Tokens: tk[64:67], 2704 }, 2705 Tokens: tk[64:68], 2706 }, 2707 { 2708 FieldDefinition: &FieldDefinition{ 2709 ClassElementName: ClassElementName{ 2710 PropertyName: &PropertyName{ 2711 LiteralPropertyName: &tk[68], 2712 Tokens: tk[68:69], 2713 }, 2714 Tokens: tk[68:69], 2715 }, 2716 Tokens: tk[68:69], 2717 }, 2718 Tokens: tk[68:69], 2719 }, 2720 { 2721 FieldDefinition: &FieldDefinition{ 2722 ClassElementName: ClassElementName{ 2723 PropertyName: &PropertyName{ 2724 ComputedPropertyName: &AssignmentExpression{ 2725 ConditionalExpression: WrapConditional(&PrimaryExpression{ 2726 IdentifierReference: &tk[71], 2727 Tokens: tk[71:72], 2728 }), 2729 Tokens: tk[71:72], 2730 }, 2731 Tokens: tk[70:73], 2732 }, 2733 Tokens: tk[70:73], 2734 }, 2735 Tokens: tk[70:73], 2736 }, 2737 Tokens: tk[70:73], 2738 }, 2739 }, 2740 Tokens: tk[:74], 2741 } 2742 }}, 2743 {"class a {static{function}}", func(t *test, tk Tokens) { // 92 2744 t.Err = Error{ 2745 Err: Error{ 2746 Err: Error{ 2747 Err: Error{ 2748 Err: Error{ 2749 Err: ErrInvalidStatement, 2750 Parsing: "Statement", 2751 Token: tk[7], 2752 }, 2753 Parsing: "StatementListItem", 2754 Token: tk[7], 2755 }, 2756 Parsing: "Block", 2757 Token: tk[7], 2758 }, 2759 Parsing: "ClassElement", 2760 Token: tk[6], 2761 }, 2762 Parsing: "ClassDeclaration", 2763 Token: tk[5], 2764 } 2765 }}, 2766 {"class a {a b}", func(t *test, tk Tokens) { // 93 2767 t.Err = Error{ 2768 Err: Error{ 2769 Err: ErrMissingSemiColon, 2770 Parsing: "ClassElement", 2771 Token: tk[7], 2772 }, 2773 Parsing: "ClassDeclaration", 2774 Token: tk[5], 2775 } 2776 }}, 2777 {"class a {a/* */b}", func(t *test, tk Tokens) { // 94 2778 t.Err = Error{ 2779 Err: Error{ 2780 Err: ErrMissingSemiColon, 2781 Parsing: "ClassElement", 2782 Token: tk[7], 2783 }, 2784 Parsing: "ClassDeclaration", 2785 Token: tk[5], 2786 } 2787 }}, 2788 {"class a {a/*\n*/b}", func(t *test, tk Tokens) { // 95 2789 t.Output = ClassDeclaration{ 2790 BindingIdentifier: &tk[2], 2791 ClassBody: []ClassElement{ 2792 { 2793 FieldDefinition: &FieldDefinition{ 2794 ClassElementName: ClassElementName{ 2795 PropertyName: &PropertyName{ 2796 LiteralPropertyName: &tk[5], 2797 Tokens: tk[5:6], 2798 }, 2799 Tokens: tk[5:6], 2800 }, 2801 Tokens: tk[5:6], 2802 }, 2803 Tokens: tk[5:6], 2804 }, 2805 { 2806 FieldDefinition: &FieldDefinition{ 2807 ClassElementName: ClassElementName{ 2808 PropertyName: &PropertyName{ 2809 LiteralPropertyName: &tk[7], 2810 Tokens: tk[7:8], 2811 }, 2812 Tokens: tk[7:8], 2813 }, 2814 Tokens: tk[7:8], 2815 }, 2816 Tokens: tk[7:8], 2817 }, 2818 }, 2819 Tokens: tk[:9], 2820 } 2821 }}, 2822 {"class a {a//\nc}", func(t *test, tk Tokens) { // 96 2823 t.Output = ClassDeclaration{ 2824 BindingIdentifier: &tk[2], 2825 ClassBody: []ClassElement{ 2826 { 2827 FieldDefinition: &FieldDefinition{ 2828 ClassElementName: ClassElementName{ 2829 PropertyName: &PropertyName{ 2830 LiteralPropertyName: &tk[5], 2831 Tokens: tk[5:6], 2832 }, 2833 Tokens: tk[5:6], 2834 }, 2835 Tokens: tk[5:6], 2836 }, 2837 Tokens: tk[5:6], 2838 }, 2839 { 2840 FieldDefinition: &FieldDefinition{ 2841 ClassElementName: ClassElementName{ 2842 PropertyName: &PropertyName{ 2843 LiteralPropertyName: &tk[8], 2844 Tokens: tk[8:9], 2845 }, 2846 Tokens: tk[8:9], 2847 }, 2848 Tokens: tk[8:9], 2849 }, 2850 Tokens: tk[8:9], 2851 }, 2852 }, 2853 Tokens: tk[:10], 2854 } 2855 }}, 2856 {"class a {b()}", func(t *test, tk Tokens) { // 97 2857 t.Err = Error{ 2858 Err: Error{ 2859 Err: Error{ 2860 Err: Error{ 2861 Err: ErrMissingOpeningBrace, 2862 Parsing: "Block", 2863 Token: tk[8], 2864 }, 2865 Parsing: "MethodDefinition", 2866 Token: tk[8], 2867 }, 2868 Parsing: "ClassElement", 2869 Token: tk[5], 2870 }, 2871 Parsing: "ClassDeclaration", 2872 Token: tk[5], 2873 } 2874 }}, 2875 {"class a {+}", func(t *test, tk Tokens) { // 98 2876 t.Err = Error{ 2877 Err: Error{ 2878 Err: Error{ 2879 Err: Error{ 2880 Err: ErrInvalidPropertyName, 2881 Parsing: "PropertyName", 2882 Token: tk[5], 2883 }, 2884 Parsing: "ClassElementName", 2885 Token: tk[5], 2886 }, 2887 Parsing: "ClassElement", 2888 Token: tk[5], 2889 }, 2890 Parsing: "ClassDeclaration", 2891 Token: tk[5], 2892 } 2893 }}, 2894 {"class a {b = +}", func(t *test, tk Tokens) { // 99 2895 t.Err = Error{ 2896 Err: Error{ 2897 Err: Error{ 2898 Err: Error{ 2899 Err: Error{ 2900 Err: Error{ 2901 Err: Error{ 2902 Err: Error{ 2903 Err: Error{ 2904 Err: Error{ 2905 Err: Error{ 2906 Err: Error{ 2907 Err: Error{ 2908 Err: Error{ 2909 Err: Error{ 2910 Err: Error{ 2911 Err: Error{ 2912 Err: Error{ 2913 Err: Error{ 2914 Err: Error{ 2915 Err: Error{ 2916 Err: Error{ 2917 Err: ErrNoIdentifier, 2918 Parsing: "PrimaryExpression", 2919 Token: tk[10], 2920 }, 2921 Parsing: "MemberExpression", 2922 Token: tk[10], 2923 }, 2924 Parsing: "NewExpression", 2925 Token: tk[10], 2926 }, 2927 Parsing: "LeftHandSideExpression", 2928 Token: tk[10], 2929 }, 2930 Parsing: "UpdateExpression", 2931 Token: tk[10], 2932 }, 2933 Parsing: "UnaryExpression", 2934 Token: tk[10], 2935 }, 2936 Parsing: "ExponentiationExpression", 2937 Token: tk[9], 2938 }, 2939 Parsing: "MultiplicativeExpression", 2940 Token: tk[9], 2941 }, 2942 Parsing: "AdditiveExpression", 2943 Token: tk[9], 2944 }, 2945 Parsing: "ShiftExpression", 2946 Token: tk[9], 2947 }, 2948 Parsing: "RelationalExpression", 2949 Token: tk[9], 2950 }, 2951 Parsing: "EqualityExpression", 2952 Token: tk[9], 2953 }, 2954 Parsing: "BitwiseANDExpression", 2955 Token: tk[9], 2956 }, 2957 Parsing: "BitwiseXORExpression", 2958 Token: tk[9], 2959 }, 2960 Parsing: "BitwiseORExpression", 2961 Token: tk[9], 2962 }, 2963 Parsing: "LogicalANDExpression", 2964 Token: tk[9], 2965 }, 2966 Parsing: "LogicalORExpression", 2967 Token: tk[9], 2968 }, 2969 Parsing: "ConditionalExpression", 2970 Token: tk[9], 2971 }, 2972 Parsing: "AssignmentExpression", 2973 Token: tk[9], 2974 }, 2975 Parsing: "FieldDefinition", 2976 Token: tk[9], 2977 }, 2978 Parsing: "ClassElement", 2979 Token: tk[5], 2980 }, 2981 Parsing: "ClassDeclaration", 2982 Token: tk[5], 2983 } 2984 }}, 2985 }, func(t *test) (Type, error) { 2986 var cd ClassDeclaration 2987 err := cd.parse(&t.Tokens, t.Yield, t.Await, t.Def) 2988 return cd, err 2989 }) 2990 } 2991 2992 func TestMethodDefinition(t *testing.T) { 2993 doTests(t, []sourceFn{ 2994 {``, func(t *test, tk Tokens) { // 1 2995 t.Err = Error{ 2996 Err: Error{ 2997 Err: Error{ 2998 Err: ErrInvalidPropertyName, 2999 Parsing: "PropertyName", 3000 Token: tk[0], 3001 }, 3002 Parsing: "ClassElementName", 3003 Token: tk[0], 3004 }, 3005 Parsing: "MethodDefinition", 3006 Token: tk[0], 3007 } 3008 }}, 3009 {"get\n", func(t *test, tk Tokens) { // 2 3010 t.Err = Error{ 3011 Err: Error{ 3012 Err: Error{ 3013 Err: ErrInvalidPropertyName, 3014 Parsing: "PropertyName", 3015 Token: tk[2], 3016 }, 3017 Parsing: "ClassElementName", 3018 Token: tk[2], 3019 }, 3020 Parsing: "MethodDefinition", 3021 Token: tk[2], 3022 } 3023 }}, 3024 {"set\n", func(t *test, tk Tokens) { // 3 3025 t.Err = Error{ 3026 Err: Error{ 3027 Err: Error{ 3028 Err: ErrInvalidPropertyName, 3029 Parsing: "PropertyName", 3030 Token: tk[2], 3031 }, 3032 Parsing: "ClassElementName", 3033 Token: tk[2], 3034 }, 3035 Parsing: "MethodDefinition", 3036 Token: tk[2], 3037 } 3038 }}, 3039 {"get\na\n", func(t *test, tk Tokens) { // 4 3040 t.Err = Error{ 3041 Err: ErrMissingOpeningParenthesis, 3042 Parsing: "MethodDefinition", 3043 Token: tk[4], 3044 } 3045 }}, 3046 {"a\n", func(t *test, tk Tokens) { // 5 3047 t.Err = Error{ 3048 Err: Error{ 3049 Err: ErrMissingOpeningParenthesis, 3050 Parsing: "FormalParameters", 3051 Token: tk[2], 3052 }, 3053 Parsing: "MethodDefinition", 3054 Token: tk[2], 3055 } 3056 }}, 3057 {"get\na\n(\na\n)", func(t *test, tk Tokens) { // 6 3058 t.Err = Error{ 3059 Err: ErrMissingClosingParenthesis, 3060 Parsing: "MethodDefinition", 3061 Token: tk[6], 3062 } 3063 }}, 3064 {"get\na\n(\n)\n", func(t *test, tk Tokens) { // 7 3065 t.Err = Error{ 3066 Err: Error{ 3067 Err: ErrMissingOpeningBrace, 3068 Parsing: "Block", 3069 Token: tk[8], 3070 }, 3071 Parsing: "MethodDefinition", 3072 Token: tk[8], 3073 } 3074 }}, 3075 {"set\na\n(\n)", func(t *test, tk Tokens) { // 8 3076 t.Err = Error{ 3077 Err: Error{ 3078 Err: ErrNoIdentifier, 3079 Parsing: "BindingElement", 3080 Token: tk[6], 3081 }, 3082 Parsing: "MethodDefinition", 3083 Token: tk[4], 3084 } 3085 }}, 3086 {"set\na\n(\nb\n)\n", func(t *test, tk Tokens) { // 9 3087 t.Err = Error{ 3088 Err: Error{ 3089 Err: ErrMissingOpeningBrace, 3090 Parsing: "Block", 3091 Token: tk[10], 3092 }, 3093 Parsing: "MethodDefinition", 3094 Token: tk[10], 3095 } 3096 }}, 3097 {"get\na\n(\n)\n{}", func(t *test, tk Tokens) { // 10 3098 t.Output = MethodDefinition{ 3099 Type: MethodGetter, 3100 ClassElementName: ClassElementName{ 3101 PropertyName: &PropertyName{ 3102 LiteralPropertyName: &tk[2], 3103 Tokens: tk[2:3], 3104 }, 3105 Tokens: tk[2:3], 3106 }, 3107 Params: FormalParameters{ 3108 Tokens: tk[4:7], 3109 }, 3110 FunctionBody: Block{ 3111 Tokens: tk[8:10], 3112 }, 3113 Tokens: tk[:10], 3114 } 3115 }}, 3116 {"set\na\n(\nb\n)\n{}", func(t *test, tk Tokens) { // 11 3117 t.Output = MethodDefinition{ 3118 Type: MethodSetter, 3119 ClassElementName: ClassElementName{ 3120 PropertyName: &PropertyName{ 3121 LiteralPropertyName: &tk[2], 3122 Tokens: tk[2:3], 3123 }, 3124 Tokens: tk[2:3], 3125 }, 3126 Params: FormalParameters{ 3127 FormalParameterList: []BindingElement{ 3128 { 3129 SingleNameBinding: &tk[6], 3130 Tokens: tk[6:7], 3131 }, 3132 }, 3133 Tokens: tk[4:9], 3134 }, 3135 FunctionBody: Block{ 3136 Tokens: tk[10:12], 3137 }, 3138 Tokens: tk[:12], 3139 } 3140 }}, 3141 {"a\n", func(t *test, tk Tokens) { // 12 3142 t.Err = Error{ 3143 Err: Error{ 3144 Err: ErrMissingOpeningParenthesis, 3145 Parsing: "FormalParameters", 3146 Token: tk[2], 3147 }, 3148 Parsing: "MethodDefinition", 3149 Token: tk[2], 3150 } 3151 }}, 3152 {"get\n()", func(t *test, tk Tokens) { // 13 3153 t.Err = Error{ 3154 Err: Error{ 3155 Err: ErrMissingOpeningBrace, 3156 Parsing: "Block", 3157 Token: tk[4], 3158 }, 3159 Parsing: "MethodDefinition", 3160 Token: tk[4], 3161 } 3162 }}, 3163 {"set\n()", func(t *test, tk Tokens) { // 14 3164 t.Err = Error{ 3165 Err: Error{ 3166 Err: ErrMissingOpeningBrace, 3167 Parsing: "Block", 3168 Token: tk[4], 3169 }, 3170 Parsing: "MethodDefinition", 3171 Token: tk[4], 3172 } 3173 }}, 3174 {"a\n(\n)\n", func(t *test, tk Tokens) { // 15 3175 t.Err = Error{ 3176 Err: Error{ 3177 Err: ErrMissingOpeningBrace, 3178 Parsing: "Block", 3179 Token: tk[6], 3180 }, 3181 Parsing: "MethodDefinition", 3182 Token: tk[6], 3183 } 3184 }}, 3185 {"a\n(\nb\n)\n", func(t *test, tk Tokens) { // 16 3186 t.Err = Error{ 3187 Err: Error{ 3188 Err: ErrMissingOpeningBrace, 3189 Parsing: "Block", 3190 Token: tk[8], 3191 }, 3192 Parsing: "MethodDefinition", 3193 Token: tk[8], 3194 } 3195 }}, 3196 {"a\n(\nb\n,\nc\n)\n", func(t *test, tk Tokens) { // 17 3197 t.Err = Error{ 3198 Err: Error{ 3199 Err: ErrMissingOpeningBrace, 3200 Parsing: "Block", 3201 Token: tk[12], 3202 }, 3203 Parsing: "MethodDefinition", 3204 Token: tk[12], 3205 } 3206 }}, 3207 {"a\n(\n)\n{}", func(t *test, tk Tokens) { // 18 3208 t.Output = MethodDefinition{ 3209 ClassElementName: ClassElementName{ 3210 PropertyName: &PropertyName{ 3211 LiteralPropertyName: &tk[0], 3212 Tokens: tk[:1], 3213 }, 3214 Tokens: tk[:1], 3215 }, 3216 Params: FormalParameters{ 3217 Tokens: tk[2:5], 3218 }, 3219 FunctionBody: Block{ 3220 Tokens: tk[6:8], 3221 }, 3222 Tokens: tk[:8], 3223 } 3224 }}, 3225 {"a\n(\nb\n)\n{}", func(t *test, tk Tokens) { // 19 3226 t.Output = MethodDefinition{ 3227 ClassElementName: ClassElementName{ 3228 PropertyName: &PropertyName{ 3229 LiteralPropertyName: &tk[0], 3230 Tokens: tk[:1], 3231 }, 3232 Tokens: tk[:1], 3233 }, 3234 Params: FormalParameters{ 3235 FormalParameterList: []BindingElement{ 3236 { 3237 SingleNameBinding: &tk[4], 3238 Tokens: tk[4:5], 3239 }, 3240 }, 3241 Tokens: tk[2:7], 3242 }, 3243 FunctionBody: Block{ 3244 Tokens: tk[8:10], 3245 }, 3246 Tokens: tk[:10], 3247 } 3248 }}, 3249 {"a\n(\nb\n,\nc\n)\n{}", func(t *test, tk Tokens) { // 20 3250 t.Output = MethodDefinition{ 3251 ClassElementName: ClassElementName{ 3252 PropertyName: &PropertyName{ 3253 LiteralPropertyName: &tk[0], 3254 Tokens: tk[:1], 3255 }, 3256 Tokens: tk[:1], 3257 }, 3258 Params: FormalParameters{ 3259 FormalParameterList: []BindingElement{ 3260 { 3261 SingleNameBinding: &tk[4], 3262 Tokens: tk[4:5], 3263 }, 3264 { 3265 SingleNameBinding: &tk[8], 3266 Tokens: tk[8:9], 3267 }, 3268 }, 3269 Tokens: tk[2:11], 3270 }, 3271 FunctionBody: Block{ 3272 Tokens: tk[12:14], 3273 }, 3274 Tokens: tk[:14], 3275 } 3276 }}, 3277 {"async a\n(\n)\n{}", func(t *test, tk Tokens) { // 21 3278 t.Output = MethodDefinition{ 3279 Type: MethodAsync, 3280 ClassElementName: ClassElementName{ 3281 PropertyName: &PropertyName{ 3282 LiteralPropertyName: &tk[2], 3283 Tokens: tk[2:3], 3284 }, 3285 Tokens: tk[2:3], 3286 }, 3287 Params: FormalParameters{ 3288 Tokens: tk[4:7], 3289 }, 3290 FunctionBody: Block{ 3291 Tokens: tk[8:10], 3292 }, 3293 Tokens: tk[:10], 3294 } 3295 }}, 3296 {"*\na\n(\n)\n{}", func(t *test, tk Tokens) { // 22 3297 t.Output = MethodDefinition{ 3298 Type: MethodGenerator, 3299 ClassElementName: ClassElementName{ 3300 PropertyName: &PropertyName{ 3301 LiteralPropertyName: &tk[2], 3302 Tokens: tk[2:3], 3303 }, 3304 Tokens: tk[2:3], 3305 }, 3306 Params: FormalParameters{ 3307 Tokens: tk[4:7], 3308 }, 3309 FunctionBody: Block{ 3310 Tokens: tk[8:10], 3311 }, 3312 Tokens: tk[:10], 3313 } 3314 }}, 3315 {"async *\na\n(\n)\n{}", func(t *test, tk Tokens) { // 23 3316 t.Output = MethodDefinition{ 3317 Type: MethodAsyncGenerator, 3318 ClassElementName: ClassElementName{ 3319 PropertyName: &PropertyName{ 3320 LiteralPropertyName: &tk[4], 3321 Tokens: tk[4:5], 3322 }, 3323 Tokens: tk[4:5], 3324 }, 3325 Params: FormalParameters{ 3326 Tokens: tk[6:9], 3327 }, 3328 FunctionBody: Block{ 3329 Tokens: tk[10:12], 3330 }, 3331 Tokens: tk[:12], 3332 } 3333 }}, 3334 {"async\n(){}", func(t *test, tk Tokens) { // 24 3335 t.Output = MethodDefinition{ 3336 ClassElementName: ClassElementName{ 3337 PropertyName: &PropertyName{ 3338 LiteralPropertyName: &tk[0], 3339 Tokens: tk[:1], 3340 }, 3341 Tokens: tk[:1], 3342 }, 3343 Params: FormalParameters{ 3344 Tokens: tk[2:4], 3345 }, 3346 FunctionBody: Block{ 3347 Tokens: tk[4:6], 3348 }, 3349 Tokens: tk[:6], 3350 } 3351 }}, 3352 {"set a b", func(t *test, tk Tokens) { // 25 3353 t.Err = Error{ 3354 Err: ErrMissingOpeningParenthesis, 3355 Parsing: "MethodDefinition", 3356 Token: tk[4], 3357 } 3358 }}, 3359 {"set a(b+c)", func(t *test, tk Tokens) { // 26 3360 t.Err = Error{ 3361 Err: ErrMissingClosingParenthesis, 3362 Parsing: "MethodDefinition", 3363 Token: tk[5], 3364 } 3365 }}, 3366 {"get(){}", func(t *test, tk Tokens) { // 27 3367 t.Output = MethodDefinition{ 3368 ClassElementName: ClassElementName{ 3369 PropertyName: &PropertyName{ 3370 LiteralPropertyName: &tk[0], 3371 Tokens: tk[:1], 3372 }, 3373 Tokens: tk[:1], 3374 }, 3375 Params: FormalParameters{ 3376 Tokens: tk[1:3], 3377 }, 3378 FunctionBody: Block{ 3379 Tokens: tk[3:5], 3380 }, 3381 Tokens: tk[:5], 3382 } 3383 }}, 3384 }, func(t *test) (Type, error) { 3385 var md MethodDefinition 3386 err := md.parse(&t.Tokens, t.Yield, t.Await) 3387 return md, err 3388 }) 3389 } 3390 3391 func TestPropertyName(t *testing.T) { 3392 doTests(t, []sourceFn{ 3393 {``, func(t *test, tk Tokens) { // 1 3394 t.Err = Error{ 3395 Err: ErrInvalidPropertyName, 3396 Parsing: "PropertyName", 3397 Token: tk[0], 3398 } 3399 }}, 3400 {"[\n]", func(t *test, tk Tokens) { // 2 3401 t.Err = Error{ 3402 Err: assignmentError(tk[2]), 3403 Parsing: "PropertyName", 3404 Token: tk[2], 3405 } 3406 }}, 3407 {"[\na\n]", func(t *test, tk Tokens) { // 3 3408 litA := makeConditionLiteral(tk, 2) 3409 t.Output = PropertyName{ 3410 ComputedPropertyName: &AssignmentExpression{ 3411 ConditionalExpression: &litA, 3412 Tokens: tk[2:3], 3413 }, 3414 Tokens: tk[:5], 3415 } 3416 }}, 3417 {`a`, func(t *test, tk Tokens) { // 4 3418 t.Output = PropertyName{ 3419 LiteralPropertyName: &tk[0], 3420 Tokens: tk[:1], 3421 } 3422 }}, 3423 {`43`, func(t *test, tk Tokens) { // 5 3424 t.Output = PropertyName{ 3425 LiteralPropertyName: &tk[0], 3426 Tokens: tk[:1], 3427 } 3428 }}, 3429 {`"43"`, func(t *test, tk Tokens) { // 6 3430 t.Output = PropertyName{ 3431 LiteralPropertyName: &tk[0], 3432 Tokens: tk[:1], 3433 } 3434 }}, 3435 {`null`, func(t *test, tk Tokens) { // 7 3436 t.Err = Error{ 3437 Err: ErrInvalidPropertyName, 3438 Parsing: "PropertyName", 3439 Token: tk[0], 3440 } 3441 }}, 3442 {`[a, b]`, func(t *test, tk Tokens) { // 8 3443 t.Err = Error{ 3444 Err: ErrMissingClosingBracket, 3445 Parsing: "PropertyName", 3446 Token: tk[2], 3447 } 3448 }}, 3449 {`await`, func(t *test, tk Tokens) { // 9 3450 t.Output = PropertyName{ 3451 LiteralPropertyName: &tk[0], 3452 Tokens: tk[:1], 3453 } 3454 }}, 3455 }, func(t *test) (Type, error) { 3456 var pn PropertyName 3457 err := pn.parse(&t.Tokens, t.Yield, t.Await) 3458 return pn, err 3459 }) 3460 3461 } 3462