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