hphp/hack/src/parser/ocaml_syntax_generated.rs

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