hphp/hack/src/parser/schema/schema_definition.ml

   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.
   7  *
   8  *)
   9
  10 type aggregate_type =
  11   | TopLevelDeclaration
  12   | Expression
  13   | Specifier
  14   | AttributeSpecification
  15   | Parameter
  16   | ClassBodyDeclaration
  17   | Statement
  18   | SwitchLabel
  19   | LambdaBody
  20   | ConstructorExpression
  21   | NamespaceInternals
  22   | XHPAttribute
  23   | ObjectCreationWhat
  24   | TODO
  25   | Name
  26   | PUMapping
  27   | PUField
  28
  29 type child_spec =
  30   | Token (* Special case, since it's so common, synonym of `Just "Token"` *)
  31   | Just of string
  32   | Aggregate of aggregate_type
  33   | ZeroOrMore of child_spec
  34   | ZeroOrOne of child_spec
  35
  36 type schema_node = {
  37   kind_name: string;
  38   type_name: string;
  39   func_name: string;
  40   description: string;
  41   prefix: string;
  42   aggregates: aggregate_type list;
  43   fields: (string * child_spec) list;
  44 }
  45
  46 let schema : schema_node list =
  47   [
  48     {
  49       kind_name = "EndOfFile";
  50       type_name = "end_of_file";
  51       func_name = "end_of_file";
  52       description = "end_of_file";
  53       prefix = "end_of_file";
  54       aggregates = [TopLevelDeclaration; TODO];
  55       fields = [("token", Token)];
  56     };
  57     {
  58       kind_name = "Script";
  59       type_name = "script";
  60       func_name = "script";
  61       description = "script";
  62       prefix = "script";
  63       aggregates = [];
  64       fields = [("declarations", ZeroOrMore (Aggregate TopLevelDeclaration))];
  65     };
  66     {
  67       kind_name = "QualifiedName";
  68       type_name = "qualified_name";
  69       func_name = "qualified_name";
  70       description = "qualified_name";
  71       prefix = "qualified_name";
  72       aggregates = [Name];
  73       fields = [("parts", ZeroOrMore Token)];
  74     };
  75     {
  76       kind_name = "SimpleTypeSpecifier";
  77       type_name = "simple_type_specifier";
  78       func_name = "simple_type_specifier";
  79       description = "simple_type_specifier";
  80       prefix = "simple_type";
  81       aggregates = [Specifier];
  82       fields = [("specifier", Aggregate Name)];
  83     };
  84     {
  85       kind_name = "LiteralExpression";
  86       type_name = "literal_expression";
  87       func_name = "literal_expression";
  88       description = "literal";
  89       prefix = "literal";
  90       aggregates = [Expression; ConstructorExpression; LambdaBody];
  91       fields = [("expression", ZeroOrMore (Aggregate Expression))];
  92     };
  93     {
  94       kind_name = "PrefixedStringExpression";
  95       type_name = "prefixed_string_expression";
  96       func_name = "prefixed_string_expression";
  97       description = "prefixed_string";
  98       prefix = "prefixed_string";
  99       aggregates = [Expression; ConstructorExpression; LambdaBody];
 100       fields = [("name", Token); ("str", Token)];
 101     };
 102     {
 103       kind_name = "VariableExpression";
 104       type_name = "variable_expression";
 105       func_name = "variable_expression";
 106       description = "variable";
 107       prefix = "variable";
 108       aggregates = [Expression; ConstructorExpression; LambdaBody];
 109       fields = [("expression", Token)];
 110     };
 111     {
 112       kind_name = "PipeVariableExpression";
 113       type_name = "pipe_variable_expression";
 114       func_name = "pipe_variable_expression";
 115       description = "pipe_variable";
 116       prefix = "pipe_variable";
 117       aggregates = [Expression; ConstructorExpression; LambdaBody];
 118       fields = [("expression", Token)];
 119     };
 120     {
 121       kind_name = "FileAttributeSpecification";
 122       type_name = "file_attribute_specification";
 123       func_name = "file_attribute_specification";
 124       description = "file_attribute_specification";
 125       prefix = "file_attribute_specification";
 126       aggregates = [TopLevelDeclaration];
 127       fields =
 128         [
 129           ("left_double_angle", Token);
 130           ("keyword", Token);
 131           ("colon", Token);
 132           ("attributes", ZeroOrMore (Just "ConstructorCall"));
 133           ("right_double_angle", Token);
 134         ];
 135     }
 136     (* TODO: Make all uses of attribute_spec consistent in the API. *);
 137     {
 138       kind_name = "EnumDeclaration";
 139       type_name = "enum_declaration";
 140       func_name = "enum_declaration";
 141       description = "enum_declaration";
 142       prefix = "enum";
 143       aggregates = [TopLevelDeclaration];
 144       fields =
 145         [
 146           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
 147           ("keyword", Token);
 148           ("name", Token);
 149           ("colon", Token);
 150           ("base", Aggregate Specifier);
 151           ("type", ZeroOrOne (Just "TypeConstraint"));
 152           ("left_brace", Token);
 153           ("enumerators", ZeroOrMore (Just "Enumerator"));
 154           ("right_brace", Token);
 155         ];
 156     };
 157     {
 158       kind_name = "Enumerator";
 159       type_name = "enumerator";
 160       func_name = "enumerator";
 161       description = "enumerator";
 162       prefix = "enumerator";
 163       aggregates = [];
 164       fields =
 165         [
 166           ("name", Token);
 167           ("equal", Token);
 168           ("value", Aggregate Expression);
 169           ("semicolon", Token);
 170         ];
 171     };
 172     {
 173       kind_name = "RecordDeclaration";
 174       type_name = "record_declaration";
 175       func_name = "record_declaration";
 176       description = "record_declaration";
 177       prefix = "record";
 178       aggregates = [TopLevelDeclaration];
 179       fields =
 180         [
 181           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
 182           ("modifier", Token);
 183           ("keyword", Token);
 184           ("name", Token);
 185           ("extends_keyword", ZeroOrOne Token);
 186           ("extends_opt", ZeroOrOne (Just "TypeConstraint"));
 187           ("left_brace", Token);
 188           ("fields", ZeroOrMore (Just "RecordField"));
 189           ("right_brace", Token);
 190         ];
 191     };
 192     {
 193       kind_name = "RecordField";
 194       type_name = "record_field";
 195       func_name = "record_field";
 196       description = "record_field";
 197       prefix = "record_field";
 198       aggregates = [];
 199       fields =
 200         [
 201           ("type", Just "TypeConstraint");
 202           ("name", Token);
 203           ("init", ZeroOrOne (Just "SimpleInitializer"));
 204           ("semi", Token);
 205         ];
 206     };
 207     {
 208       kind_name = "AliasDeclaration";
 209       type_name = "alias_declaration";
 210       func_name = "alias_declaration";
 211       description = "alias_declaration";
 212       prefix = "alias";
 213       aggregates = [TopLevelDeclaration];
 214       fields =
 215         [
 216           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
 217           ("keyword", Token);
 218           ("name", ZeroOrOne Token);
 219           ("generic_parameter", ZeroOrOne (Just "TypeParameters"));
 220           ("constraint", ZeroOrOne (Just "TypeConstraint"));
 221           ("equal", ZeroOrOne Token);
 222           ("type", Aggregate Specifier);
 223           ("semicolon", Token);
 224         ];
 225     };
 226     {
 227       kind_name = "PropertyDeclaration";
 228       type_name = "property_declaration";
 229       func_name = "property_declaration";
 230       description = "property_declaration";
 231       prefix = "property";
 232       aggregates = [ClassBodyDeclaration];
 233       fields =
 234         [
 235           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
 236           ("modifiers", ZeroOrMore Token);
 237           ("type", ZeroOrOne (Aggregate Specifier));
 238           ("declarators", ZeroOrMore (Just "PropertyDeclarator"));
 239           ("semicolon", Token);
 240         ];
 241     };
 242     {
 243       kind_name = "PropertyDeclarator";
 244       type_name = "property_declarator";
 245       func_name = "property_declarator";
 246       description = "property_declarator";
 247       prefix = "property";
 248       aggregates = [];
 249       fields =
 250         [("name", Token); ("initializer", ZeroOrOne (Just "SimpleInitializer"))];
 251     };
 252     {
 253       kind_name = "NamespaceDeclaration";
 254       type_name = "namespace_declaration";
 255       func_name = "namespace_declaration";
 256       description = "namespace_declaration";
 257       prefix = "namespace";
 258       aggregates = [TopLevelDeclaration];
 259       fields =
 260         [
 261           ("header", Just "NamespaceDeclarationHeader");
 262           ("body", Aggregate NamespaceInternals);
 263         ];
 264     };
 265     {
 266       kind_name = "NamespaceDeclarationHeader";
 267       type_name = "namespace_declaration_header";
 268       func_name = "namespace_declaration_header";
 269       description = "namespace_declaration_header";
 270       prefix = "namespace";
 271       aggregates = [TopLevelDeclaration];
 272       fields = [("keyword", Token); ("name", ZeroOrOne (Aggregate Name))];
 273     };
 274     {
 275       kind_name = "NamespaceBody";
 276       type_name = "namespace_body";
 277       func_name = "namespace_body";
 278       description = "namespace_body";
 279       prefix = "namespace";
 280       aggregates = [NamespaceInternals];
 281       fields =
 282         [
 283           ("left_brace", Token);
 284           ("declarations", ZeroOrMore (Aggregate TopLevelDeclaration));
 285           ("right_brace", Token);
 286         ];
 287     };
 288     {
 289       kind_name = "NamespaceEmptyBody";
 290       type_name = "namespace_empty_body";
 291       func_name = "namespace_empty_body";
 292       description = "namespace_empty_body";
 293       prefix = "namespace";
 294       aggregates = [NamespaceInternals];
 295       fields = [("semicolon", Token)];
 296     };
 297     {
 298       kind_name = "NamespaceUseDeclaration";
 299       type_name = "namespace_use_declaration";
 300       func_name = "namespace_use_declaration";
 301       description = "namespace_use_declaration";
 302       prefix = "namespace_use";
 303       aggregates = [TopLevelDeclaration];
 304       fields =
 305         [
 306           ("keyword", Token);
 307           ("kind", ZeroOrOne Token);
 308           ("clauses", ZeroOrMore (ZeroOrOne (Just "NamespaceUseClause")));
 309           ("semicolon", ZeroOrOne Token);
 310         ];
 311     };
 312     {
 313       kind_name = "NamespaceGroupUseDeclaration";
 314       type_name = "namespace_group_use_declaration";
 315       func_name = "namespace_group_use_declaration";
 316       description = "namespace_group_use_declaration";
 317       prefix = "namespace_group_use";
 318       aggregates = [TopLevelDeclaration];
 319       fields =
 320         [
 321           ("keyword", Token);
 322           ("kind", ZeroOrOne Token);
 323           ("prefix", Aggregate Name);
 324           ("left_brace", Token);
 325           ("clauses", ZeroOrMore (Just "NamespaceUseClause"));
 326           ("right_brace", Token);
 327           ("semicolon", Token);
 328         ];
 329     };
 330     {
 331       kind_name = "NamespaceUseClause";
 332       type_name = "namespace_use_clause";
 333       func_name = "namespace_use_clause";
 334       description = "namespace_use_clause";
 335       prefix = "namespace_use";
 336       aggregates = [];
 337       fields =
 338         [
 339           ("clause_kind", ZeroOrOne Token);
 340           ("name", Aggregate Name);
 341           ("as", ZeroOrOne Token);
 342           ("alias", ZeroOrOne Token);
 343         ];
 344     };
 345     {
 346       kind_name = "FunctionDeclaration";
 347       type_name = "function_declaration";
 348       func_name = "function_declaration";
 349       description = "function_declaration";
 350       prefix = "function";
 351       aggregates = [TopLevelDeclaration];
 352       fields =
 353         [
 354           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
 355           ("declaration_header", Just "FunctionDeclarationHeader");
 356           ("body", Just "CompoundStatement");
 357         ];
 358     };
 359     {
 360       kind_name = "FunctionDeclarationHeader";
 361       type_name = "function_declaration_header";
 362       func_name = "function_declaration_header";
 363       description = "function_declaration_header";
 364       prefix = "function";
 365       aggregates = [];
 366       fields =
 367         [
 368           ("modifiers", ZeroOrMore Token);
 369           ("keyword", Token);
 370           ("name", Token);
 371           ("type_parameter_list", ZeroOrOne (Just "TypeParameters"));
 372           ("left_paren", Token);
 373           ("parameter_list", ZeroOrMore (ZeroOrOne (Aggregate Parameter)));
 374           ("right_paren", Token);
 375           ("colon", ZeroOrOne Token);
 376           ("type", ZeroOrOne (Just "AttributizedSpecifier"));
 377           ("where_clause", ZeroOrOne (Just "WhereClause"));
 378         ];
 379     };
 380     {
 381       kind_name = "WhereClause";
 382       type_name = "where_clause";
 383       func_name = "where_clause";
 384       description = "where_clause";
 385       prefix = "where_clause";
 386       aggregates = [];
 387       fields =
 388         [
 389           ("keyword", Token);
 390           ("constraints", ZeroOrMore (Just "WhereConstraint"));
 391         ];
 392     };
 393     {
 394       kind_name = "WhereConstraint";
 395       type_name = "where_constraint";
 396       func_name = "where_constraint";
 397       description = "where_constraint";
 398       prefix = "where_constraint";
 399       aggregates = [];
 400       fields =
 401         [
 402           ("left_type", Aggregate Specifier);
 403           ("operator", Token);
 404           ("right_type", Aggregate Specifier);
 405         ];
 406     };
 407     {
 408       kind_name = "MethodishDeclaration";
 409       type_name = "methodish_declaration";
 410       func_name = "methodish_declaration";
 411       description = "methodish_declaration";
 412       prefix = "methodish";
 413       aggregates = [ClassBodyDeclaration];
 414       fields =
 415         [
 416           ("attribute", ZeroOrOne (Aggregate AttributeSpecification));
 417           ("function_decl_header", Just "FunctionDeclarationHeader");
 418           ("function_body", ZeroOrOne (Just "CompoundStatement"));
 419           ("semicolon", ZeroOrOne Token);
 420         ];
 421     };
 422     {
 423       kind_name = "MethodishTraitResolution";
 424       type_name = "methodish_trait_resolution";
 425       func_name = "methodish_trait_resolution";
 426       description = "methodish_trait_resolution";
 427       prefix = "methodish_trait";
 428       aggregates = [ClassBodyDeclaration];
 429       fields =
 430         [
 431           ("attribute", ZeroOrOne (Aggregate AttributeSpecification));
 432           ("function_decl_header", Just "FunctionDeclarationHeader");
 433           ("equal", Token);
 434           ("name", Aggregate Specifier);
 435           ("semicolon", Token);
 436         ];
 437     };
 438     {
 439       kind_name = "ClassishDeclaration";
 440       type_name = "classish_declaration";
 441       func_name = "classish_declaration";
 442       description = "classish_declaration";
 443       prefix = "classish";
 444       aggregates = [TopLevelDeclaration];
 445       fields =
 446         [
 447           ("attribute", ZeroOrOne (Aggregate AttributeSpecification));
 448           ("modifiers", ZeroOrMore Token);
 449           ("xhp", ZeroOrOne Token);
 450           ("keyword", Token);
 451           ("name", Token);
 452           ("type_parameters", ZeroOrOne (Just "TypeParameters"));
 453           ("extends_keyword", ZeroOrOne Token);
 454           ("extends_list", ZeroOrMore (Aggregate Specifier));
 455           ("implements_keyword", ZeroOrOne Token);
 456           ("implements_list", ZeroOrMore (Aggregate Specifier));
 457           ("where_clause", ZeroOrOne (Just "WhereClause"));
 458           ("body", Just "ClassishBody");
 459         ];
 460     };
 461     {
 462       kind_name = "ClassishBody";
 463       type_name = "classish_body";
 464       func_name = "classish_body";
 465       description = "classish_body";
 466       prefix = "classish_body";
 467       aggregates = [];
 468       fields =
 469         [
 470           ("left_brace", Token);
 471           ("elements", ZeroOrMore (Aggregate ClassBodyDeclaration));
 472           ("right_brace", Token);
 473         ];
 474     };
 475     {
 476       kind_name = "TraitUsePrecedenceItem";
 477       type_name = "trait_use_precedence_item";
 478       func_name = "trait_use_precedence_item";
 479       description = "trait_use_precedence_item";
 480       prefix = "trait_use_precedence_item";
 481       aggregates = [];
 482       fields =
 483         [
 484           ("name", Aggregate Specifier);
 485           ("keyword", Token);
 486           ("removed_names", ZeroOrMore (Aggregate Specifier));
 487         ];
 488     };
 489     {
 490       kind_name = "TraitUseAliasItem";
 491       type_name = "trait_use_alias_item";
 492       func_name = "trait_use_alias_item";
 493       description = "trait_use_alias_item";
 494       prefix = "trait_use_alias_item";
 495       aggregates = [];
 496       fields =
 497         [
 498           ("aliasing_name", Aggregate Specifier);
 499           ("keyword", Token);
 500           ("modifiers", ZeroOrMore Token);
 501           ("aliased_name", ZeroOrOne (Aggregate Specifier));
 502         ];
 503     };
 504     {
 505       kind_name = "TraitUseConflictResolution";
 506       type_name = "trait_use_conflict_resolution";
 507       func_name = "trait_use_conflict_resolution";
 508       description = "trait_use_conflict_resolution";
 509       prefix = "trait_use_conflict_resolution";
 510       aggregates = [];
 511       fields =
 512         [
 513           ("keyword", Token);
 514           ("names", ZeroOrMore (Aggregate Specifier));
 515           ("left_brace", Token);
 516           ("clauses", ZeroOrMore (Aggregate Specifier));
 517           ("right_brace", Token);
 518         ];
 519     };
 520     {
 521       kind_name = "TraitUse";
 522       type_name = "trait_use";
 523       func_name = "trait_use";
 524       description = "trait_use";
 525       prefix = "trait_use";
 526       aggregates = [];
 527       fields =
 528         [
 529           ("keyword", Token);
 530           ("names", ZeroOrMore (Aggregate Specifier));
 531           ("semicolon", ZeroOrOne Token);
 532         ];
 533     };
 534     {
 535       kind_name = "RequireClause";
 536       type_name = "require_clause";
 537       func_name = "require_clause";
 538       description = "require_clause";
 539       prefix = "require";
 540       aggregates = [ClassBodyDeclaration];
 541       fields =
 542         [
 543           ("keyword", Token);
 544           ("kind", Token);
 545           ("name", Aggregate Specifier);
 546           ("semicolon", Token);
 547         ];
 548     };
 549     {
 550       kind_name = "ConstDeclaration";
 551       type_name = "const_declaration";
 552       func_name = "const_declaration";
 553       description = "const_declaration";
 554       prefix = "const";
 555       aggregates = [ClassBodyDeclaration; TopLevelDeclaration];
 556       fields =
 557         [
 558           ("modifiers", ZeroOrMore Token);
 559           ("keyword", Token);
 560           ("type_specifier", ZeroOrOne (Aggregate Specifier));
 561           ("declarators", ZeroOrMore (Just "ConstantDeclarator"));
 562           ("semicolon", Token);
 563         ];
 564     };
 565     {
 566       kind_name = "ConstantDeclarator";
 567       type_name = "constant_declarator";
 568       func_name = "constant_declarator";
 569       description = "constant_declarator";
 570       prefix = "constant_declarator";
 571       aggregates = [];
 572       fields =
 573         [("name", Token); ("initializer", ZeroOrOne (Just "SimpleInitializer"))];
 574     };
 575     {
 576       kind_name = "TypeConstDeclaration";
 577       type_name = "type_const_declaration";
 578       func_name = "type_const_declaration";
 579       description = "type_const_declaration";
 580       prefix = "type_const";
 581       aggregates = [ClassBodyDeclaration];
 582       fields =
 583         [
 584           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
 585           ("modifiers", ZeroOrOne Token);
 586           ("keyword", Token);
 587           ("type_keyword", Token);
 588           ("name", Token);
 589           ("type_parameters", ZeroOrOne (Just "TypeParameters"));
 590           ("type_constraint", ZeroOrOne (Just "TypeConstraint"));
 591           ("equal", ZeroOrOne Token);
 592           ("type_specifier", ZeroOrOne (Aggregate Specifier));
 593           ("semicolon", Token);
 594         ];
 595     };
 596     {
 597       kind_name = "DecoratedExpression";
 598       type_name = "decorated_expression";
 599       func_name = "decorated_expression";
 600       description = "decorated_expression";
 601       prefix = "decorated_expression";
 602       aggregates = [Expression; ConstructorExpression; LambdaBody];
 603       fields = [("decorator", Token); ("expression", Aggregate Expression)];
 604     };
 605     {
 606       kind_name = "ParameterDeclaration";
 607       type_name = "parameter_declaration";
 608       func_name = "parameter_declaration";
 609       description = "parameter_declaration";
 610       prefix = "parameter";
 611       aggregates = [Parameter];
 612       fields =
 613         [
 614           ("attribute", ZeroOrOne (Aggregate AttributeSpecification));
 615           ("visibility", ZeroOrOne Token);
 616           ("call_convention", ZeroOrOne Token);
 617           ("type", ZeroOrOne (Aggregate Specifier));
 618           ("name", Aggregate Expression);
 619           ("default_value", ZeroOrOne (Just "SimpleInitializer"));
 620         ];
 621     };
 622     {
 623       kind_name = "VariadicParameter";
 624       type_name = "variadic_parameter";
 625       func_name = "variadic_parameter";
 626       description = "variadic_parameter";
 627       prefix = "variadic_parameter";
 628       aggregates = [Specifier; Parameter];
 629       fields =
 630         [
 631           ("call_convention", ZeroOrOne Token);
 632           ("type", ZeroOrOne (Just "SimpleTypeSpecifier"));
 633           ("ellipsis", Token);
 634         ];
 635     };
 636     {
 637       kind_name = "OldAttributeSpecification";
 638       type_name = "old_attribute_specification";
 639       func_name = "old_attribute_specification";
 640       description = "old_attribute_specification";
 641       prefix = "old_attribute_specification";
 642       aggregates = [AttributeSpecification];
 643       fields =
 644         [
 645           ("left_double_angle", Token);
 646           ("attributes", ZeroOrMore (Just "ConstructorCall"));
 647           ("right_double_angle", Token);
 648         ];
 649     };
 650     {
 651       kind_name = "AttributeSpecification";
 652       type_name = "attribute_specification";
 653       func_name = "attribute_specification";
 654       description = "attribute_specification";
 655       prefix = "attribute_specification";
 656       aggregates = [AttributeSpecification];
 657       fields = [("attributes", ZeroOrMore (Just "Attribute"))];
 658     };
 659     {
 660       kind_name = "Attribute";
 661       type_name = "attribute";
 662       func_name = "attribute";
 663       description = "attribute";
 664       prefix = "attribute";
 665       aggregates = [];
 666       fields = [("at", Token); ("attribute_name", Just "ConstructorCall")];
 667     };
 668     {
 669       kind_name = "InclusionExpression";
 670       type_name = "inclusion_expression";
 671       func_name = "inclusion_expression";
 672       description = "inclusion_expression";
 673       prefix = "inclusion";
 674       aggregates = [Expression; ConstructorExpression; LambdaBody];
 675       fields = [("require", Token); ("filename", Aggregate Expression)];
 676     };
 677     {
 678       kind_name = "InclusionDirective";
 679       type_name = "inclusion_directive";
 680       func_name = "inclusion_directive";
 681       description = "inclusion_directive";
 682       prefix = "inclusion";
 683       aggregates = [TopLevelDeclaration; Statement];
 684       fields =
 685         [("expression", Just "InclusionExpression"); ("semicolon", Token)];
 686     };
 687     {
 688       kind_name = "CompoundStatement";
 689       type_name = "compound_statement";
 690       func_name = "compound_statement";
 691       description = "compound_statement";
 692       prefix = "compound";
 693       aggregates = [TopLevelDeclaration; Statement; LambdaBody];
 694       fields =
 695         [
 696           ("left_brace", Token);
 697           ("statements", ZeroOrMore (Aggregate Statement));
 698           ("right_brace", Token);
 699         ];
 700     };
 701     {
 702       kind_name = "ExpressionStatement";
 703       type_name = "expression_statement";
 704       func_name = "expression_statement";
 705       description = "expression_statement";
 706       prefix = "expression_statement";
 707       aggregates = [TopLevelDeclaration; Statement];
 708       fields =
 709         [("expression", ZeroOrOne (Aggregate Expression)); ("semicolon", Token)];
 710     };
 711     {
 712       kind_name = "MarkupSection";
 713       type_name = "markup_section";
 714       func_name = "markup_section";
 715       description = "markup_section";
 716       prefix = "markup";
 717       aggregates = [TopLevelDeclaration; Statement];
 718       fields = [("text", Token); ("suffix", ZeroOrOne (Just "MarkupSuffix"))];
 719     };
 720     {
 721       kind_name = "MarkupSuffix";
 722       type_name = "markup_suffix";
 723       func_name = "markup_suffix";
 724       description = "markup_suffix";
 725       prefix = "markup_suffix";
 726       aggregates = [TopLevelDeclaration; Statement];
 727       fields = [("less_than_question", Token); ("name", ZeroOrOne Token)];
 728     };
 729     {
 730       kind_name = "UnsetStatement";
 731       type_name = "unset_statement";
 732       func_name = "unset_statement";
 733       description = "unset_statement";
 734       prefix = "unset";
 735       aggregates = [TopLevelDeclaration; Statement];
 736       fields =
 737         [
 738           ("keyword", Token);
 739           ("left_paren", Token);
 740           ("variables", ZeroOrMore (Aggregate Expression));
 741           ("right_paren", Token);
 742           ("semicolon", Token);
 743         ];
 744     };
 745     {
 746       kind_name = "UsingStatementBlockScoped";
 747       type_name = "using_statement_block_scoped";
 748       func_name = "using_statement_block_scoped";
 749       description = "using_statement_block_scoped";
 750       prefix = "using_block";
 751       aggregates = [TopLevelDeclaration; Statement];
 752       fields =
 753         [
 754           ("await_keyword", ZeroOrOne Token);
 755           ("using_keyword", Token);
 756           ("left_paren", Token);
 757           ("expressions", ZeroOrMore (Aggregate Expression));
 758           ("right_paren", Token);
 759           ("body", Aggregate Statement);
 760         ];
 761     };
 762     {
 763       kind_name = "UsingStatementFunctionScoped";
 764       type_name = "using_statement_function_scoped";
 765       func_name = "using_statement_function_scoped";
 766       description = "using_statement_function_scoped";
 767       prefix = "using_function";
 768       aggregates = [TopLevelDeclaration; Statement];
 769       fields =
 770         [
 771           ("await_keyword", ZeroOrOne Token);
 772           ("using_keyword", Token);
 773           ("expression", Aggregate Expression);
 774           ("semicolon", Token);
 775         ];
 776     };
 777     {
 778       kind_name = "WhileStatement";
 779       type_name = "while_statement";
 780       func_name = "while_statement";
 781       description = "while_statement";
 782       prefix = "while";
 783       aggregates = [TopLevelDeclaration; Statement];
 784       fields =
 785         [
 786           ("keyword", Token);
 787           ("left_paren", Token);
 788           ("condition", Aggregate Expression);
 789           ("right_paren", Token);
 790           ("body", Aggregate Statement);
 791         ];
 792     };
 793     {
 794       kind_name = "IfStatement";
 795       type_name = "if_statement";
 796       func_name = "if_statement";
 797       description = "if_statement";
 798       prefix = "if";
 799       aggregates = [TopLevelDeclaration; Statement];
 800       fields =
 801         [
 802           ("keyword", Token);
 803           ("left_paren", Token);
 804           ("condition", Aggregate Expression);
 805           ("right_paren", Token);
 806           ("statement", Aggregate Statement);
 807           ("elseif_clauses", ZeroOrMore (Just "ElseifClause"));
 808           ("else_clause", ZeroOrOne (Just "ElseClause"));
 809         ];
 810     };
 811     {
 812       kind_name = "ElseifClause";
 813       type_name = "elseif_clause";
 814       func_name = "elseif_clause";
 815       description = "elseif_clause";
 816       prefix = "elseif";
 817       aggregates = [];
 818       fields =
 819         [
 820           ("keyword", Token);
 821           ("left_paren", Token);
 822           ("condition", Aggregate Expression);
 823           ("right_paren", Token);
 824           ("statement", Aggregate Statement);
 825         ];
 826     };
 827     {
 828       kind_name = "ElseClause";
 829       type_name = "else_clause";
 830       func_name = "else_clause";
 831       description = "else_clause";
 832       prefix = "else";
 833       aggregates = [];
 834       fields = [("keyword", Token); ("statement", Aggregate Statement)];
 835     };
 836     {
 837       kind_name = "TryStatement";
 838       type_name = "try_statement";
 839       func_name = "try_statement";
 840       description = "try_statement";
 841       prefix = "try";
 842       aggregates = [TopLevelDeclaration; Statement];
 843       fields =
 844         [
 845           ("keyword", Token);
 846           ("compound_statement", Just "CompoundStatement");
 847           ("catch_clauses", ZeroOrMore (Just "CatchClause"));
 848           ("finally_clause", ZeroOrOne (Just "FinallyClause"));
 849         ];
 850     };
 851     {
 852       kind_name = "CatchClause";
 853       type_name = "catch_clause";
 854       func_name = "catch_clause";
 855       description = "catch_clause";
 856       prefix = "catch";
 857       aggregates = [];
 858       fields =
 859         [
 860           ("keyword", Token);
 861           ("left_paren", Token);
 862           ("type", Just "SimpleTypeSpecifier");
 863           ("variable", Token);
 864           ("right_paren", Token);
 865           ("body", Just "CompoundStatement");
 866         ];
 867     };
 868     {
 869       kind_name = "FinallyClause";
 870       type_name = "finally_clause";
 871       func_name = "finally_clause";
 872       description = "finally_clause";
 873       prefix = "finally";
 874       aggregates = [];
 875       fields = [("keyword", Token); ("body", Just "CompoundStatement")];
 876     };
 877     {
 878       kind_name = "DoStatement";
 879       type_name = "do_statement";
 880       func_name = "do_statement";
 881       description = "do_statement";
 882       prefix = "do";
 883       aggregates = [TopLevelDeclaration; Statement];
 884       fields =
 885         [
 886           ("keyword", Token);
 887           ("body", Aggregate Statement);
 888           ("while_keyword", Token);
 889           ("left_paren", Token);
 890           ("condition", Aggregate Expression);
 891           ("right_paren", Token);
 892           ("semicolon", Token);
 893         ];
 894     };
 895     {
 896       kind_name = "ForStatement";
 897       type_name = "for_statement";
 898       func_name = "for_statement";
 899       description = "for_statement";
 900       prefix = "for";
 901       aggregates = [TopLevelDeclaration; Statement];
 902       fields =
 903         [
 904           ("keyword", Token);
 905           ("left_paren", Token);
 906           ("initializer", ZeroOrMore (Aggregate Expression));
 907           ("first_semicolon", Token);
 908           ("control", ZeroOrMore (Aggregate Expression));
 909           ("second_semicolon", Token);
 910           ("end_of_loop", ZeroOrMore (Aggregate Expression));
 911           ("right_paren", Token);
 912           ("body", Aggregate Statement);
 913         ];
 914     };
 915     {
 916       kind_name = "ForeachStatement";
 917       type_name = "foreach_statement";
 918       func_name = "foreach_statement";
 919       description = "foreach_statement";
 920       prefix = "foreach";
 921       aggregates = [TopLevelDeclaration; Statement];
 922       fields =
 923         [
 924           ("keyword", Token);
 925           ("left_paren", Token);
 926           ("collection", Aggregate Expression);
 927           ("await_keyword", ZeroOrOne Token);
 928           ("as", Token);
 929           ("key", ZeroOrOne (Aggregate Expression));
 930           ("arrow", ZeroOrOne Token);
 931           ("value", Aggregate Expression);
 932           ("right_paren", Token);
 933           ("body", Aggregate Statement);
 934         ];
 935     };
 936     {
 937       kind_name = "SwitchStatement";
 938       type_name = "switch_statement";
 939       func_name = "switch_statement";
 940       description = "switch_statement";
 941       prefix = "switch";
 942       aggregates = [Statement];
 943       fields =
 944         [
 945           ("keyword", Token);
 946           ("left_paren", Token);
 947           ("expression", Aggregate Expression);
 948           ("right_paren", Token);
 949           ("left_brace", Token);
 950           ("sections", ZeroOrMore (Just "SwitchSection"));
 951           ("right_brace", Token);
 952         ];
 953     };
 954     {
 955       kind_name = "SwitchSection";
 956       type_name = "switch_section";
 957       func_name = "switch_section";
 958       description = "switch_section";
 959       prefix = "switch_section";
 960       aggregates = [];
 961       fields =
 962         [
 963           ("labels", ZeroOrMore (Aggregate SwitchLabel));
 964           ("statements", ZeroOrMore (Aggregate TopLevelDeclaration));
 965           ("fallthrough", ZeroOrOne (Just "SwitchFallthrough"));
 966         ];
 967     };
 968     {
 969       kind_name = "SwitchFallthrough";
 970       type_name = "switch_fallthrough";
 971       func_name = "switch_fallthrough";
 972       description = "switch_fallthrough";
 973       prefix = "fallthrough";
 974       aggregates = [TopLevelDeclaration; Statement];
 975       fields = [("keyword", Token); ("semicolon", Token)];
 976     };
 977     {
 978       kind_name = "CaseLabel";
 979       type_name = "case_label";
 980       func_name = "case_label";
 981       description = "case_label";
 982       prefix = "case";
 983       aggregates = [SwitchLabel];
 984       fields =
 985         [
 986           ("keyword", Token);
 987           ("expression", Aggregate Expression);
 988           ("colon", Token);
 989         ];
 990     };
 991     {
 992       kind_name = "DefaultLabel";
 993       type_name = "default_label";
 994       func_name = "default_label";
 995       description = "default_label";
 996       prefix = "default";
 997       aggregates = [SwitchLabel];
 998       fields = [("keyword", Token); ("colon", Token)];
 999     };
1000     {
1001       kind_name = "ReturnStatement";
1002       type_name = "return_statement";
1003       func_name = "return_statement";
1004       description = "return_statement";
1005       prefix = "return";
1006       aggregates = [TopLevelDeclaration; Statement];
1007       fields =
1008         [
1009           ("keyword", Token);
1010           ("expression", ZeroOrOne (Aggregate Expression));
1011           ("semicolon", ZeroOrOne Token);
1012         ];
1013     };
1014     {
1015       kind_name = "GotoLabel";
1016       type_name = "goto_label";
1017       func_name = "goto_label";
1018       description = "goto_label";
1019       prefix = "goto_label";
1020       aggregates = [TopLevelDeclaration; Statement];
1021       fields = [("name", Token); ("colon", Token)];
1022     };
1023     {
1024       kind_name = "GotoStatement";
1025       type_name = "goto_statement";
1026       func_name = "goto_statement";
1027       description = "goto_statement";
1028       prefix = "goto_statement";
1029       aggregates = [TopLevelDeclaration; Statement];
1030       fields = [("keyword", Token); ("label_name", Token); ("semicolon", Token)];
1031     };
1032     {
1033       kind_name = "ThrowStatement";
1034       type_name = "throw_statement";
1035       func_name = "throw_statement";
1036       description = "throw_statement";
1037       prefix = "throw";
1038       aggregates = [TopLevelDeclaration; Statement];
1039       fields =
1040         [
1041           ("keyword", Token);
1042           ("expression", Aggregate Expression);
1043           ("semicolon", Token);
1044         ];
1045     };
1046     {
1047       kind_name = "BreakStatement";
1048       type_name = "break_statement";
1049       func_name = "break_statement";
1050       description = "break_statement";
1051       prefix = "break";
1052       aggregates = [TopLevelDeclaration; Statement];
1053       fields = [("keyword", Token); ("semicolon", Token)];
1054     };
1055     {
1056       kind_name = "ContinueStatement";
1057       type_name = "continue_statement";
1058       func_name = "continue_statement";
1059       description = "continue_statement";
1060       prefix = "continue";
1061       aggregates = [TopLevelDeclaration; Statement];
1062       fields = [("keyword", Token); ("semicolon", Token)];
1063     };
1064     {
1065       kind_name = "EchoStatement";
1066       type_name = "echo_statement";
1067       func_name = "echo_statement";
1068       description = "echo_statement";
1069       prefix = "echo";
1070       aggregates = [TopLevelDeclaration; Statement];
1071       fields =
1072         [
1073           ("keyword", Token);
1074           ("expressions", ZeroOrMore (Aggregate Expression));
1075           ("semicolon", Token);
1076         ];
1077     };
1078     {
1079       kind_name = "ConcurrentStatement";
1080       type_name = "concurrent_statement";
1081       func_name = "concurrent_statement";
1082       description = "concurrent_statement";
1083       prefix = "concurrent";
1084       aggregates = [Statement];
1085       fields = [("keyword", Token); ("statement", Aggregate Statement)];
1086     };
1087     {
1088       kind_name = "SimpleInitializer";
1089       type_name = "simple_initializer";
1090       func_name = "simple_initializer";
1091       description = "simple_initializer";
1092       prefix = "simple_initializer";
1093       aggregates = [];
1094       fields = [("equal", Token); ("value", Aggregate Expression)];
1095     };
1096     {
1097       kind_name = "AnonymousClass";
1098       type_name = "anonymous_class";
1099       func_name = "anonymous_class";
1100       description = "anonymous_class";
1101       prefix = "anonymous_class";
1102       aggregates = [ObjectCreationWhat];
1103       fields =
1104         [
1105           ("class_keyword", Token);
1106           ("left_paren", ZeroOrOne Token);
1107           ("argument_list", ZeroOrMore (Aggregate Expression));
1108           ("right_paren", ZeroOrOne Token);
1109           ("extends_keyword", ZeroOrOne Token);
1110           ("extends_list", ZeroOrMore (Aggregate Specifier));
1111           ("implements_keyword", ZeroOrOne Token);
1112           ("implements_list", ZeroOrMore (Aggregate Specifier));
1113           ("body", Just "ClassishBody");
1114         ];
1115     };
1116     {
1117       kind_name = "AnonymousFunction";
1118       type_name = "anonymous_function";
1119       func_name = "anonymous_function";
1120       description = "anonymous_function";
1121       prefix = "anonymous";
1122       aggregates = [Expression; ConstructorExpression; LambdaBody];
1123       fields =
1124         [
1125           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
1126           ("static_keyword", ZeroOrOne Token);
1127           ("async_keyword", ZeroOrOne Token);
1128           ("function_keyword", Token);
1129           ("left_paren", Token);
1130           ("parameters", ZeroOrMore (Aggregate Parameter));
1131           ("right_paren", Token);
1132           ("colon", ZeroOrOne Token);
1133           ("type", ZeroOrOne (Aggregate Specifier));
1134           ("use", ZeroOrOne (Just "AnonymousFunctionUseClause"));
1135           ("body", Just "CompoundStatement");
1136         ];
1137     };
1138     {
1139       kind_name = "AnonymousFunctionUseClause";
1140       type_name = "anonymous_function_use_clause";
1141       func_name = "anonymous_function_use_clause";
1142       description = "anonymous_function_use_clause";
1143       prefix = "anonymous_use";
1144       aggregates = [];
1145       fields =
1146         [
1147           ("keyword", Token);
1148           ("left_paren", Token);
1149           ("variables", ZeroOrMore (Aggregate Expression));
1150           ("right_paren", Token);
1151         ];
1152     };
1153     {
1154       kind_name = "LambdaExpression";
1155       type_name = "lambda_expression";
1156       func_name = "lambda_expression";
1157       description = "lambda_expression";
1158       prefix = "lambda";
1159       aggregates = [Expression; ConstructorExpression; LambdaBody];
1160       fields =
1161         [
1162           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
1163           ("async", ZeroOrOne Token);
1164           ("signature", Aggregate Specifier);
1165           ("arrow", Token);
1166           ("body", Aggregate LambdaBody);
1167         ];
1168     };
1169     {
1170       kind_name = "LambdaSignature";
1171       type_name = "lambda_signature";
1172       func_name = "lambda_signature";
1173       description = "lambda_signature";
1174       prefix = "lambda";
1175       aggregates = [Specifier];
1176       fields =
1177         [
1178           ("left_paren", Token);
1179           ("parameters", ZeroOrMore (Aggregate Parameter));
1180           ("right_paren", Token);
1181           ("colon", ZeroOrOne Token);
1182           ("type", ZeroOrOne (Aggregate Specifier));
1183         ];
1184     };
1185     {
1186       kind_name = "CastExpression";
1187       type_name = "cast_expression";
1188       func_name = "cast_expression";
1189       description = "cast_expression";
1190       prefix = "cast";
1191       aggregates = [Expression; ConstructorExpression; LambdaBody];
1192       fields =
1193         [
1194           ("left_paren", Token);
1195           ("type", Token);
1196           ("right_paren", Token);
1197           ("operand", Aggregate Expression);
1198         ];
1199     };
1200     {
1201       kind_name = "ScopeResolutionExpression";
1202       type_name = "scope_resolution_expression";
1203       func_name = "scope_resolution_expression";
1204       description = "scope_resolution_expression";
1205       prefix = "scope_resolution";
1206       aggregates = [Expression; ConstructorExpression; LambdaBody];
1207       fields =
1208         [
1209           ("qualifier", Aggregate Expression);
1210           ("operator", Token);
1211           ("name", Aggregate Expression);
1212         ];
1213     };
1214     {
1215       kind_name = "MemberSelectionExpression";
1216       type_name = "member_selection_expression";
1217       func_name = "member_selection_expression";
1218       description = "member_selection_expression";
1219       prefix = "member";
1220       aggregates = [Expression; ConstructorExpression; LambdaBody];
1221       fields =
1222         [("object", Aggregate Expression); ("operator", Token); ("name", Token)];
1223     };
1224     {
1225       kind_name = "SafeMemberSelectionExpression";
1226       type_name = "safe_member_selection_expression";
1227       func_name = "safe_member_selection_expression";
1228       description = "safe_member_selection_expression";
1229       prefix = "safe_member";
1230       aggregates = [Expression; ConstructorExpression; LambdaBody];
1231       fields =
1232         [("object", Aggregate Expression); ("operator", Token); ("name", Token)];
1233     };
1234     {
1235       kind_name = "EmbeddedMemberSelectionExpression";
1236       type_name = "embedded_member_selection_expression";
1237       func_name = "embedded_member_selection_expression";
1238       description = "embedded_member_selection_expression";
1239       prefix = "embedded_member";
1240       aggregates = [Expression; ConstructorExpression; LambdaBody];
1241       fields =
1242         [
1243           ("object", Just "VariableExpression");
1244           ("operator", Token);
1245           ("name", Token);
1246         ];
1247     };
1248     {
1249       kind_name = "YieldExpression";
1250       type_name = "yield_expression";
1251       func_name = "yield_expression";
1252       description = "yield_expression";
1253       prefix = "yield";
1254       aggregates = [Expression; ConstructorExpression; LambdaBody];
1255       fields =
1256         [("keyword", Token); ("operand", Aggregate ConstructorExpression)];
1257     };
1258     {
1259       kind_name = "PrefixUnaryExpression";
1260       type_name = "prefix_unary_expression";
1261       func_name = "prefix_unary_expression";
1262       description = "prefix_unary_expression";
1263       prefix = "prefix_unary";
1264       aggregates = [Expression; ConstructorExpression; LambdaBody];
1265       fields = [("operator", Token); ("operand", Aggregate Expression)];
1266     };
1267     {
1268       kind_name = "PostfixUnaryExpression";
1269       type_name = "postfix_unary_expression";
1270       func_name = "postfix_unary_expression";
1271       description = "postfix_unary_expression";
1272       prefix = "postfix_unary";
1273       aggregates = [Expression; ConstructorExpression; LambdaBody];
1274       fields = [("operand", Aggregate Expression); ("operator", Token)];
1275     };
1276     {
1277       kind_name = "BinaryExpression";
1278       type_name = "binary_expression";
1279       func_name = "binary_expression";
1280       description = "binary_expression";
1281       prefix = "binary";
1282       aggregates = [Expression; ConstructorExpression; LambdaBody];
1283       fields =
1284         [
1285           ("left_operand", Aggregate Expression);
1286           ("operator", Token);
1287           ("right_operand", Aggregate Expression);
1288         ];
1289     };
1290     {
1291       kind_name = "IsExpression";
1292       type_name = "is_expression";
1293       func_name = "is_expression";
1294       description = "is_expression";
1295       prefix = "is";
1296       aggregates = [Expression; ConstructorExpression; LambdaBody];
1297       fields =
1298         [
1299           ("left_operand", Aggregate Expression);
1300           ("operator", Token);
1301           ("right_operand", Aggregate Specifier);
1302         ];
1303     };
1304     {
1305       kind_name = "AsExpression";
1306       type_name = "as_expression";
1307       func_name = "as_expression";
1308       description = "as_expression";
1309       prefix = "as";
1310       aggregates = [Expression; ConstructorExpression; LambdaBody];
1311       fields =
1312         [
1313           ("left_operand", Aggregate Expression);
1314           ("operator", Token);
1315           ("right_operand", Aggregate Specifier);
1316         ];
1317     };
1318     {
1319       kind_name = "NullableAsExpression";
1320       type_name = "nullable_as_expression";
1321       func_name = "nullable_as_expression";
1322       description = "nullable_as_expression";
1323       prefix = "nullable_as";
1324       aggregates = [Expression; ConstructorExpression; LambdaBody];
1325       fields =
1326         [
1327           ("left_operand", Aggregate Expression);
1328           ("operator", Token);
1329           ("right_operand", Aggregate Specifier);
1330         ];
1331     };
1332     {
1333       kind_name = "ConditionalExpression";
1334       type_name = "conditional_expression";
1335       func_name = "conditional_expression";
1336       description = "conditional_expression";
1337       prefix = "conditional";
1338       aggregates = [Expression; ConstructorExpression; LambdaBody];
1339       fields =
1340         [
1341           ("test", Aggregate Expression);
1342           ("question", Token);
1343           ("consequence", ZeroOrOne (Aggregate Expression));
1344           ("colon", Token);
1345           ("alternative", Aggregate Expression);
1346         ];
1347     };
1348     {
1349       kind_name = "EvalExpression";
1350       type_name = "eval_expression";
1351       func_name = "eval_expression";
1352       description = "eval_expression";
1353       prefix = "eval";
1354       aggregates = [Expression; ConstructorExpression; LambdaBody];
1355       fields =
1356         [
1357           ("keyword", Token);
1358           ("left_paren", Token);
1359           ("argument", Aggregate Expression);
1360           ("right_paren", Token);
1361         ];
1362     };
1363     {
1364       kind_name = "DefineExpression";
1365       type_name = "define_expression";
1366       func_name = "define_expression";
1367       description = "define_expression";
1368       prefix = "define";
1369       aggregates = [Expression; ConstructorExpression; LambdaBody];
1370       fields =
1371         [
1372           ("keyword", Token);
1373           ("left_paren", Token);
1374           ("argument_list", ZeroOrMore (Aggregate Expression));
1375           ("right_paren", Token);
1376         ];
1377     };
1378     {
1379       kind_name = "IssetExpression";
1380       type_name = "isset_expression";
1381       func_name = "isset_expression";
1382       description = "isset_expression";
1383       prefix = "isset";
1384       aggregates = [Expression; ConstructorExpression; LambdaBody];
1385       fields =
1386         [
1387           ("keyword", Token);
1388           ("left_paren", Token);
1389           ("argument_list", ZeroOrMore (Aggregate Expression));
1390           ("right_paren", Token);
1391         ];
1392     };
1393     {
1394       kind_name = "FunctionCallExpression";
1395       type_name = "function_call_expression";
1396       func_name = "function_call_expression";
1397       description = "function_call_expression";
1398       prefix = "function_call";
1399       aggregates = [Expression; ConstructorExpression; LambdaBody];
1400       fields =
1401         [
1402           ("receiver", Aggregate Expression);
1403           ("type_args", ZeroOrOne (Just "TypeArguments"));
1404           ("left_paren", Token);
1405           ("argument_list", ZeroOrMore (Aggregate Expression));
1406           ("right_paren", Token);
1407         ];
1408     };
1409     {
1410       kind_name = "FunctionPointerExpression";
1411       type_name = "function_pointer_expression";
1412       func_name = "function_pointer_expression";
1413       description = "function_pointer_expression";
1414       prefix = "function_pointer";
1415       aggregates = [Expression; ConstructorExpression; LambdaBody];
1416       fields =
1417         [
1418           ("receiver", Aggregate Expression); ("type_args", Just "TypeArguments");
1419         ];
1420     };
1421     {
1422       kind_name = "ParenthesizedExpression";
1423       type_name = "parenthesized_expression";
1424       func_name = "parenthesized_expression";
1425       description = "parenthesized_expression";
1426       prefix = "parenthesized_expression";
1427       aggregates = [Expression; ConstructorExpression; LambdaBody];
1428       fields =
1429         [
1430           ("left_paren", Token);
1431           ("expression", Aggregate Expression);
1432           ("right_paren", Token);
1433         ];
1434     };
1435     {
1436       kind_name = "BracedExpression";
1437       type_name = "braced_expression";
1438       func_name = "braced_expression";
1439       description = "braced_expression";
1440       prefix = "braced_expression";
1441       aggregates = [Expression; ConstructorExpression; LambdaBody];
1442       fields =
1443         [
1444           ("left_brace", Token);
1445           ("expression", Aggregate Expression);
1446           ("right_brace", Token);
1447         ];
1448     };
1449     {
1450       kind_name = "EmbeddedBracedExpression";
1451       type_name = "embedded_braced_expression";
1452       func_name = "embedded_braced_expression";
1453       description = "embedded_braced_expression";
1454       prefix = "embedded_braced_expression";
1455       aggregates = [Expression; ConstructorExpression; LambdaBody];
1456       fields =
1457         [
1458           ("left_brace", Token);
1459           ("expression", Aggregate Expression);
1460           ("right_brace", Token);
1461         ];
1462     };
1463     {
1464       kind_name = "ListExpression";
1465       type_name = "list_expression";
1466       func_name = "list_expression";
1467       description = "list_expression";
1468       prefix = "list";
1469       aggregates = [Expression; ConstructorExpression; LambdaBody];
1470       fields =
1471         [
1472           ("keyword", Token);
1473           ("left_paren", Token);
1474           ("members", ZeroOrMore (ZeroOrOne (Aggregate Expression)));
1475           ("right_paren", Token);
1476         ];
1477     };
1478     {
1479       kind_name = "CollectionLiteralExpression";
1480       type_name = "collection_literal_expression";
1481       func_name = "collection_literal_expression";
1482       description = "collection_literal_expression";
1483       prefix = "collection_literal";
1484       aggregates = [Expression; ConstructorExpression; LambdaBody];
1485       fields =
1486         [
1487           ("name", Aggregate Specifier);
1488           ("left_brace", Token);
1489           ("initializers", ZeroOrMore (Aggregate ConstructorExpression));
1490           ("right_brace", Token);
1491         ];
1492     };
1493     {
1494       kind_name = "ObjectCreationExpression";
1495       type_name = "object_creation_expression";
1496       func_name = "object_creation_expression";
1497       description = "object_creation_expression";
1498       prefix = "object_creation";
1499       aggregates = [Expression; ConstructorExpression; LambdaBody];
1500       fields =
1501         [("new_keyword", Token); ("object", Aggregate ObjectCreationWhat)];
1502     };
1503     {
1504       kind_name = "ConstructorCall";
1505       type_name = "constructor_call";
1506       func_name = "constructor_call";
1507       description = "constructor_call";
1508       prefix = "constructor_call";
1509       aggregates = [ObjectCreationWhat];
1510       fields =
1511         [
1512           ("type", Aggregate TODO);
1513           ("left_paren", ZeroOrOne Token);
1514           ("argument_list", ZeroOrMore (Aggregate Expression));
1515           ("right_paren", ZeroOrOne Token);
1516         ];
1517     };
1518     {
1519       kind_name = "RecordCreationExpression";
1520       type_name = "record_creation_expression";
1521       func_name = "record_creation_expression";
1522       description = "record_creation_expression";
1523       prefix = "record_creation";
1524       aggregates = [Expression; ConstructorExpression; LambdaBody];
1525       fields =
1526         [
1527           ("type", Aggregate TODO);
1528           ("left_bracket", Token);
1529           ("members", ZeroOrMore (Just "ElementInitializer"));
1530           ("right_bracket", Token);
1531         ];
1532     };
1533     {
1534       kind_name = "ArrayIntrinsicExpression";
1535       type_name = "array_intrinsic_expression";
1536       func_name = "array_intrinsic_expression";
1537       description = "array_intrinsic_expression";
1538       prefix = "array_intrinsic";
1539       aggregates = [Expression; ConstructorExpression; LambdaBody];
1540       fields =
1541         [
1542           ("keyword", Token);
1543           ("left_paren", Token);
1544           ("members", ZeroOrMore (Aggregate ConstructorExpression));
1545           ("right_paren", Token);
1546         ];
1547     };
1548     {
1549       kind_name = "DarrayIntrinsicExpression";
1550       type_name = "darray_intrinsic_expression";
1551       func_name = "darray_intrinsic_expression";
1552       description = "darray_intrinsic_expression";
1553       prefix = "darray_intrinsic";
1554       aggregates = [Expression; ConstructorExpression; LambdaBody];
1555       fields =
1556         [
1557           ("keyword", Token);
1558           ("explicit_type", ZeroOrOne (Just "TypeArguments"));
1559           ("left_bracket", Token);
1560           ("members", ZeroOrMore (Just "ElementInitializer"));
1561           ("right_bracket", Token);
1562         ];
1563     };
1564     {
1565       kind_name = "DictionaryIntrinsicExpression";
1566       type_name = "dictionary_intrinsic_expression";
1567       func_name = "dictionary_intrinsic_expression";
1568       description = "dictionary_intrinsic_expression";
1569       prefix = "dictionary_intrinsic";
1570       aggregates = [Expression; ConstructorExpression; LambdaBody];
1571       fields =
1572         [
1573           ("keyword", Token);
1574           ("explicit_type", ZeroOrOne (Just "TypeArguments"));
1575           ("left_bracket", Token);
1576           ("members", ZeroOrMore (Just "ElementInitializer"));
1577           ("right_bracket", Token);
1578         ];
1579     };
1580     {
1581       kind_name = "KeysetIntrinsicExpression";
1582       type_name = "keyset_intrinsic_expression";
1583       func_name = "keyset_intrinsic_expression";
1584       description = "keyset_intrinsic_expression";
1585       prefix = "keyset_intrinsic";
1586       aggregates = [Expression; ConstructorExpression; LambdaBody];
1587       fields =
1588         [
1589           ("keyword", Token);
1590           ("explicit_type", ZeroOrOne (Just "TypeArguments"));
1591           ("left_bracket", Token);
1592           ("members", ZeroOrMore (Aggregate Expression));
1593           ("right_bracket", Token);
1594         ];
1595     };
1596     {
1597       kind_name = "VarrayIntrinsicExpression";
1598       type_name = "varray_intrinsic_expression";
1599       func_name = "varray_intrinsic_expression";
1600       description = "varray_intrinsic_expression";
1601       prefix = "varray_intrinsic";
1602       aggregates = [Expression; ConstructorExpression; LambdaBody];
1603       fields =
1604         [
1605           ("keyword", Token);
1606           ("explicit_type", ZeroOrOne (Just "TypeArguments"));
1607           ("left_bracket", Token);
1608           ("members", ZeroOrMore (Aggregate Expression));
1609           ("right_bracket", Token);
1610         ];
1611     };
1612     {
1613       kind_name = "VectorIntrinsicExpression";
1614       type_name = "vector_intrinsic_expression";
1615       func_name = "vector_intrinsic_expression";
1616       description = "vector_intrinsic_expression";
1617       prefix = "vector_intrinsic";
1618       aggregates = [Expression; ConstructorExpression; LambdaBody];
1619       fields =
1620         [
1621           ("keyword", Token);
1622           ("explicit_type", ZeroOrOne (Just "TypeArguments"));
1623           ("left_bracket", Token);
1624           ("members", ZeroOrMore (Aggregate Expression));
1625           ("right_bracket", Token);
1626         ];
1627     };
1628     {
1629       kind_name = "ElementInitializer";
1630       type_name = "element_initializer";
1631       func_name = "element_initializer";
1632       description = "element_initializer";
1633       prefix = "element";
1634       aggregates = [ConstructorExpression];
1635       fields =
1636         [
1637           ("key", Aggregate Expression);
1638           ("arrow", Token);
1639           ("value", Aggregate Expression);
1640         ];
1641     };
1642     {
1643       kind_name = "SubscriptExpression";
1644       type_name = "subscript_expression";
1645       func_name = "subscript_expression";
1646       description = "subscript_expression";
1647       prefix = "subscript";
1648       aggregates = [Expression; ConstructorExpression; LambdaBody];
1649       fields =
1650         [
1651           ("receiver", Aggregate Expression);
1652           ("left_bracket", Token);
1653           ("index", ZeroOrOne (Aggregate Expression));
1654           ("right_bracket", Token);
1655         ];
1656     };
1657     {
1658       kind_name = "EmbeddedSubscriptExpression";
1659       type_name = "embedded_subscript_expression";
1660       func_name = "embedded_subscript_expression";
1661       description = "embedded_subscript_expression";
1662       prefix = "embedded_subscript";
1663       aggregates = [Expression; ConstructorExpression; LambdaBody];
1664       fields =
1665         [
1666           ("receiver", Just "VariableExpression");
1667           ("left_bracket", Token);
1668           ("index", Aggregate Expression);
1669           ("right_bracket", Token);
1670         ];
1671     };
1672     {
1673       kind_name = "AwaitableCreationExpression";
1674       type_name = "awaitable_creation_expression";
1675       func_name = "awaitable_creation_expression";
1676       description = "awaitable_creation_expression";
1677       prefix = "awaitable";
1678       aggregates = [Expression; ConstructorExpression; LambdaBody];
1679       fields =
1680         [
1681           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
1682           ("async", Token);
1683           ("compound_statement", Just "CompoundStatement");
1684         ];
1685     };
1686     {
1687       kind_name = "XHPChildrenDeclaration";
1688       type_name = "xhp_children_declaration";
1689       func_name = "xhp_children_declaration";
1690       description = "xhp_children_declaration";
1691       prefix = "xhp_children";
1692       aggregates = [ClassBodyDeclaration];
1693       fields =
1694         [
1695           ("keyword", Token);
1696           ("expression", Aggregate Expression);
1697           ("semicolon", Token);
1698         ];
1699     };
1700     {
1701       kind_name = "XHPChildrenParenthesizedList";
1702       type_name = "xhp_children_parenthesized_list";
1703       func_name = "xhp_children_parenthesized_list";
1704       description = "xhp_children_parenthesized_list";
1705       prefix = "xhp_children_list";
1706       aggregates = [Expression; ConstructorExpression; LambdaBody];
1707       fields =
1708         [
1709           ("left_paren", Token);
1710           ("xhp_children", ZeroOrMore (Aggregate Expression));
1711           ("right_paren", Token);
1712         ];
1713     };
1714     {
1715       kind_name = "XHPCategoryDeclaration";
1716       type_name = "xhp_category_declaration";
1717       func_name = "xhp_category_declaration";
1718       description = "xhp_category_declaration";
1719       prefix = "xhp_category";
1720       aggregates = [ClassBodyDeclaration];
1721       fields =
1722         [
1723           ("keyword", Token);
1724           ("categories", ZeroOrMore Token);
1725           ("semicolon", Token);
1726         ];
1727     };
1728     {
1729       kind_name = "XHPEnumType";
1730       type_name = "xhp_enum_type";
1731       func_name = "xhp_enum_type";
1732       description = "xhp_enum_type";
1733       prefix = "xhp_enum";
1734       aggregates = [Specifier];
1735       fields =
1736         [
1737           ("optional", ZeroOrOne Token);
1738           ("keyword", Token);
1739           ("left_brace", Token);
1740           ("values", ZeroOrMore (Just "LiteralExpression"));
1741           ("right_brace", Token);
1742         ];
1743     };
1744     {
1745       kind_name = "XHPLateinit";
1746       type_name = "xhp_lateinit";
1747       func_name = "xhp_lateinit";
1748       description = "xhp_lateinit";
1749       prefix = "xhp_lateinit";
1750       aggregates = [];
1751       fields = [("at", Token); ("keyword", Token)];
1752     };
1753     {
1754       kind_name = "XHPRequired";
1755       type_name = "xhp_required";
1756       func_name = "xhp_required";
1757       description = "xhp_required";
1758       prefix = "xhp_required";
1759       aggregates = [];
1760       fields = [("at", Token); ("keyword", Token)];
1761     };
1762     {
1763       kind_name = "XHPClassAttributeDeclaration";
1764       type_name = "xhp_class_attribute_declaration";
1765       func_name = "xhp_class_attribute_declaration";
1766       description = "xhp_class_attribute_declaration";
1767       prefix = "xhp_attribute";
1768       aggregates = [ClassBodyDeclaration];
1769       fields =
1770         [
1771           ("keyword", Token);
1772           ("attributes", ZeroOrMore (Aggregate TODO));
1773           ("semicolon", Token);
1774         ];
1775     };
1776     {
1777       kind_name = "XHPClassAttribute";
1778       type_name = "xhp_class_attribute";
1779       func_name = "xhp_class_attribute";
1780       description = "xhp_class_attribute";
1781       prefix = "xhp_attribute_decl";
1782       aggregates = [];
1783       fields =
1784         [
1785           ("type", Aggregate Specifier);
1786           ("name", Token);
1787           ("initializer", ZeroOrOne (Just "SimpleInitializer"));
1788           ("required", ZeroOrOne (Just "XHPRequired"));
1789         ];
1790     };
1791     {
1792       kind_name = "XHPSimpleClassAttribute";
1793       type_name = "xhp_simple_class_attribute";
1794       func_name = "xhp_simple_class_attribute";
1795       description = "xhp_simple_class_attribute";
1796       prefix = "xhp_simple_class_attribute";
1797       aggregates = [];
1798       fields = [("type", Just "SimpleTypeSpecifier")];
1799     };
1800     {
1801       kind_name = "XHPSimpleAttribute";
1802       type_name = "xhp_simple_attribute";
1803       func_name = "xhp_simple_attribute";
1804       description = "xhp_simple_attribute";
1805       prefix = "xhp_simple_attribute";
1806       aggregates = [XHPAttribute];
1807       fields =
1808         [
1809           ("name", Token); ("equal", Token); ("expression", Aggregate Expression);
1810         ];
1811     };
1812     {
1813       kind_name = "XHPSpreadAttribute";
1814       type_name = "xhp_spread_attribute";
1815       func_name = "xhp_spread_attribute";
1816       description = "xhp_spread_attribute";
1817       prefix = "xhp_spread_attribute";
1818       aggregates = [XHPAttribute];
1819       fields =
1820         [
1821           ("left_brace", Token);
1822           ("spread_operator", Token);
1823           ("expression", Aggregate Expression);
1824           ("right_brace", Token);
1825         ];
1826     };
1827     {
1828       kind_name = "XHPOpen";
1829       type_name = "xhp_open";
1830       func_name = "xhp_open";
1831       description = "xhp_open";
1832       prefix = "xhp_open";
1833       aggregates = [];
1834       fields =
1835         [
1836           ("left_angle", Token);
1837           ("name", Token);
1838           ("attributes", ZeroOrMore (Aggregate XHPAttribute));
1839           ("right_angle", Token);
1840         ];
1841     };
1842     {
1843       kind_name = "XHPExpression";
1844       type_name = "xhp_expression";
1845       func_name = "xhp_expression";
1846       description = "xhp_expression";
1847       prefix = "xhp";
1848       aggregates = [Expression; ConstructorExpression; LambdaBody];
1849       fields =
1850         [
1851           ("open", Just "XHPOpen");
1852           ("body", ZeroOrMore (Aggregate Expression));
1853           ("close", ZeroOrOne (Just "XHPClose"));
1854         ];
1855     };
1856     {
1857       kind_name = "XHPClose";
1858       type_name = "xhp_close";
1859       func_name = "xhp_close";
1860       description = "xhp_close";
1861       prefix = "xhp_close";
1862       aggregates = [];
1863       fields = [("left_angle", Token); ("name", Token); ("right_angle", Token)];
1864     };
1865     {
1866       kind_name = "TypeConstant";
1867       type_name = "type_constant";
1868       func_name = "type_constant";
1869       description = "type_constant";
1870       prefix = "type_constant";
1871       aggregates = [Statement];
1872       fields =
1873         [
1874           ("left_type", Aggregate Specifier);
1875           ("separator", Token);
1876           ("right_type", Token);
1877         ];
1878     };
1879     {
1880       kind_name = "PUAccess";
1881       type_name = "pu_access";
1882       func_name = "pu_access";
1883       description = "pu_access";
1884       prefix = "pu_access";
1885       aggregates = [Statement];
1886       fields =
1887         [
1888           ("left_type", Aggregate Specifier);
1889           ("separator", Token);
1890           ("right_type", Token);
1891         ];
1892     };
1893     {
1894       kind_name = "VectorTypeSpecifier";
1895       type_name = "vector_type_specifier";
1896       func_name = "vector_type_specifier";
1897       description = "vector_type_specifier";
1898       prefix = "vector_type";
1899       aggregates = [Specifier];
1900       fields =
1901         [
1902           ("keyword", Token);
1903           ("left_angle", Token);
1904           ("type", Aggregate Specifier);
1905           ("trailing_comma", ZeroOrOne Token);
1906           ("right_angle", Token);
1907         ];
1908     };
1909     {
1910       kind_name = "KeysetTypeSpecifier";
1911       type_name = "keyset_type_specifier";
1912       func_name = "keyset_type_specifier";
1913       description = "keyset_type_specifier";
1914       prefix = "keyset_type";
1915       aggregates = [Specifier];
1916       fields =
1917         [
1918           ("keyword", Token);
1919           ("left_angle", Token);
1920           ("type", Aggregate Specifier);
1921           ("trailing_comma", ZeroOrOne Token);
1922           ("right_angle", Token);
1923         ];
1924     };
1925     {
1926       kind_name = "TupleTypeExplicitSpecifier";
1927       type_name = "tuple_type_explicit_specifier";
1928       func_name = "tuple_type_explicit_specifier";
1929       description = "tuple_type_explicit_specifier";
1930       prefix = "tuple_type";
1931       aggregates = [Specifier];
1932       fields =
1933         [
1934           ("keyword", Token);
1935           ("left_angle", Token);
1936           ("types", Just "SimpleTypeSpecifier");
1937           ("right_angle", Token);
1938         ];
1939     };
1940     {
1941       kind_name = "VarrayTypeSpecifier";
1942       type_name = "varray_type_specifier";
1943       func_name = "varray_type_specifier";
1944       description = "varray_type_specifier";
1945       prefix = "varray";
1946       aggregates = [Specifier];
1947       fields =
1948         [
1949           ("keyword", Token);
1950           ("left_angle", Token);
1951           ("type", Just "SimpleTypeSpecifier");
1952           ("trailing_comma", ZeroOrOne Token);
1953           ("right_angle", Token);
1954         ];
1955     };
1956     {
1957       kind_name = "VectorArrayTypeSpecifier";
1958       type_name = "vector_array_type_specifier";
1959       func_name = "vector_array_type_specifier";
1960       description = "vector_array_type_specifier";
1961       prefix = "vector_array";
1962       aggregates = [Specifier];
1963       fields =
1964         [
1965           ("keyword", Token);
1966           ("left_angle", Token);
1967           ("type", Aggregate Specifier);
1968           ("right_angle", Token);
1969         ];
1970     };
1971     {
1972       kind_name = "TypeParameter";
1973       type_name = "type_parameter";
1974       func_name = "type_parameter";
1975       description = "type_parameter";
1976       prefix = "type";
1977       aggregates = [];
1978       fields =
1979         [
1980           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
1981           ("reified", ZeroOrOne Token);
1982           ("variance", ZeroOrOne Token);
1983           ("name", Token);
1984           ("param_params", ZeroOrOne (Just "TypeParameters"));
1985           ("constraints", ZeroOrMore (Just "TypeConstraint"));
1986         ];
1987     };
1988     {
1989       kind_name = "TypeConstraint";
1990       type_name = "type_constraint";
1991       func_name = "type_constraint";
1992       description = "type_constraint";
1993       prefix = "constraint";
1994       aggregates = [];
1995       fields = [("keyword", Token); ("type", Aggregate Specifier)];
1996     };
1997     {
1998       kind_name = "DarrayTypeSpecifier";
1999       type_name = "darray_type_specifier";
2000       func_name = "darray_type_specifier";
2001       description = "darray_type_specifier";
2002       prefix = "darray";
2003       aggregates = [Specifier];
2004       fields =
2005         [
2006           ("keyword", Token);
2007           ("left_angle", Token);
2008           ("key", Just "SimpleTypeSpecifier");
2009           ("comma", Token);
2010           ("value", Just "SimpleTypeSpecifier");
2011           ("trailing_comma", ZeroOrOne Token);
2012           ("right_angle", Token);
2013         ];
2014     };
2015     {
2016       kind_name = "MapArrayTypeSpecifier";
2017       type_name = "map_array_type_specifier";
2018       func_name = "map_array_type_specifier";
2019       description = "map_array_type_specifier";
2020       prefix = "map_array";
2021       aggregates = [Specifier];
2022       fields =
2023         [
2024           ("keyword", Token);
2025           ("left_angle", Token);
2026           ("key", Aggregate Specifier);
2027           ("comma", Token);
2028           ("value", Aggregate Specifier);
2029           ("right_angle", Token);
2030         ];
2031     };
2032     {
2033       kind_name = "DictionaryTypeSpecifier";
2034       type_name = "dictionary_type_specifier";
2035       func_name = "dictionary_type_specifier";
2036       description = "dictionary_type_specifier";
2037       prefix = "dictionary_type";
2038       aggregates = [Specifier];
2039       fields =
2040         [
2041           ("keyword", Token);
2042           ("left_angle", Token);
2043           ("members", ZeroOrMore (Aggregate Specifier));
2044           ("right_angle", Token);
2045         ];
2046     };
2047     {
2048       kind_name = "ClosureTypeSpecifier";
2049       type_name = "closure_type_specifier";
2050       func_name = "closure_type_specifier";
2051       description = "closure_type_specifier";
2052       prefix = "closure";
2053       aggregates = [Specifier];
2054       fields =
2055         [
2056           ("outer_left_paren", Token);
2057           ("function_keyword", Token);
2058           ("inner_left_paren", Token);
2059           ("parameter_list", ZeroOrMore (Just "ClosureParameterTypeSpecifier"));
2060           ("inner_right_paren", Token);
2061           ("colon", Token);
2062           ("return_type", Aggregate Specifier);
2063           ("outer_right_paren", Token);
2064         ];
2065     };
2066     {
2067       kind_name = "ClosureParameterTypeSpecifier";
2068       type_name = "closure_parameter_type_specifier";
2069       func_name = "closure_parameter_type_specifier";
2070       description = "closure_parameter_type_specifier";
2071       prefix = "closure_parameter";
2072       aggregates = [Specifier];
2073       fields =
2074         [("call_convention", ZeroOrOne Token); ("type", Aggregate Specifier)];
2075     };
2076     {
2077       kind_name = "ClassnameTypeSpecifier";
2078       type_name = "classname_type_specifier";
2079       func_name = "classname_type_specifier";
2080       description = "classname_type_specifier";
2081       prefix = "classname";
2082       aggregates = [Specifier];
2083       fields =
2084         [
2085           ("keyword", Token);
2086           ("left_angle", Token);
2087           ("type", Aggregate Specifier);
2088           ("trailing_comma", ZeroOrOne Token);
2089           ("right_angle", Token);
2090         ];
2091     };
2092     {
2093       kind_name = "FieldSpecifier";
2094       type_name = "field_specifier";
2095       func_name = "field_specifier";
2096       description = "field_specifier";
2097       prefix = "field";
2098       aggregates = [Specifier];
2099       fields =
2100         [
2101           ("question", ZeroOrOne Token);
2102           ("name", Aggregate Expression);
2103           ("arrow", Token);
2104           ("type", Aggregate Specifier);
2105         ];
2106     };
2107     {
2108       kind_name = "FieldInitializer";
2109       type_name = "field_initializer";
2110       func_name = "field_initializer";
2111       description = "field_initializer";
2112       prefix = "field_initializer";
2113       aggregates = [];
2114       fields =
2115         [
2116           ("name", Aggregate Expression);
2117           ("arrow", Token);
2118           ("value", Aggregate Expression);
2119         ];
2120     };
2121     {
2122       kind_name = "ShapeTypeSpecifier";
2123       type_name = "shape_type_specifier";
2124       func_name = "shape_type_specifier";
2125       description = "shape_type_specifier";
2126       prefix = "shape_type";
2127       aggregates = [Specifier];
2128       fields =
2129         [
2130           ("keyword", Token);
2131           ("left_paren", Token);
2132           ("fields", ZeroOrMore (Just "FieldSpecifier"));
2133           ("ellipsis", ZeroOrOne Token);
2134           ("right_paren", Token);
2135         ];
2136     };
2137     {
2138       kind_name = "ShapeExpression";
2139       type_name = "shape_expression";
2140       func_name = "shape_expression";
2141       description = "shape_expression";
2142       prefix = "shape_expression";
2143       aggregates = [Expression; ConstructorExpression; LambdaBody];
2144       fields =
2145         [
2146           ("keyword", Token);
2147           ("left_paren", Token);
2148           ("fields", ZeroOrMore (Just "FieldInitializer"));
2149           ("right_paren", Token);
2150         ];
2151     };
2152     {
2153       kind_name = "TupleExpression";
2154       type_name = "tuple_expression";
2155       func_name = "tuple_expression";
2156       description = "tuple_expression";
2157       prefix = "tuple_expression";
2158       aggregates = [Expression; ConstructorExpression; LambdaBody];
2159       fields =
2160         [
2161           ("keyword", Token);
2162           ("left_paren", Token);
2163           ("items", ZeroOrMore (Aggregate Expression));
2164           ("right_paren", Token);
2165         ];
2166     }
2167     (* TODO: Rename this; generic type specifiers are also used for
2168      * type-annotated method calls and for object creations with type annotations
2169      * This naming is now very misleading (e.g. class_type being any name).
2170      *);
2171     {
2172       kind_name = "GenericTypeSpecifier";
2173       type_name = "generic_type_specifier";
2174       func_name = "generic_type_specifier";
2175       description = "generic_type_specifier";
2176       prefix = "generic";
2177       aggregates = [Specifier];
2178       fields = [("class_type", Token); ("argument_list", Just "TypeArguments")];
2179     };
2180     {
2181       kind_name = "NullableTypeSpecifier";
2182       type_name = "nullable_type_specifier";
2183       func_name = "nullable_type_specifier";
2184       description = "nullable_type_specifier";
2185       prefix = "nullable";
2186       aggregates = [Specifier];
2187       fields = [("question", Token); ("type", Aggregate Specifier)];
2188     };
2189     {
2190       kind_name = "LikeTypeSpecifier";
2191       type_name = "like_type_specifier";
2192       func_name = "like_type_specifier";
2193       description = "like_type_specifier";
2194       prefix = "like";
2195       aggregates = [Specifier];
2196       fields = [("tilde", Token); ("type", Aggregate Specifier)];
2197     };
2198     {
2199       kind_name = "SoftTypeSpecifier";
2200       type_name = "soft_type_specifier";
2201       func_name = "soft_type_specifier";
2202       description = "soft_type_specifier";
2203       prefix = "soft";
2204       aggregates = [Specifier];
2205       fields = [("at", Token); ("type", Aggregate Specifier)];
2206     };
2207     {
2208       kind_name = "AttributizedSpecifier";
2209       type_name = "attributized_specifier";
2210       func_name = "attributized_specifier";
2211       description = "attributized_specifier";
2212       prefix = "attributized_specifier";
2213       aggregates = [];
2214       fields =
2215         [
2216           ("attribute_spec", ZeroOrOne (Aggregate AttributeSpecification));
2217           ("type", Aggregate Specifier);
2218         ];
2219     };
2220     {
2221       kind_name = "ReifiedTypeArgument";
2222       type_name = "reified_type_argument";
2223       func_name = "reified_type_argument";
2224       description = "reified_type_argument";
2225       prefix = "reified_type_argument";
2226       aggregates = [];
2227       fields = [("reified", Token); ("type", Aggregate Specifier)];
2228     };
2229     {
2230       kind_name = "TypeArguments";
2231       type_name = "type_arguments";
2232       func_name = "type_arguments";
2233       description = "type_arguments";
2234       prefix = "type_arguments";
2235       aggregates = [];
2236       fields =
2237         [
2238           ("left_angle", Token);
2239           ("types", ZeroOrMore (Just "AttributizedSpecifier"));
2240           ("right_angle", Token);
2241         ];
2242     };
2243     {
2244       kind_name = "TypeParameters";
2245       type_name = "type_parameters";
2246       func_name = "type_parameters";
2247       description = "type_parameters";
2248       prefix = "type_parameters";
2249       aggregates = [];
2250       fields =
2251         [
2252           ("left_angle", Token);
2253           ("parameters", ZeroOrMore (Just "TypeParameter"));
2254           ("right_angle", Token);
2255         ];
2256     };
2257     {
2258       kind_name = "TupleTypeSpecifier";
2259       type_name = "tuple_type_specifier";
2260       func_name = "tuple_type_specifier";
2261       description = "tuple_type_specifier";
2262       prefix = "tuple";
2263       aggregates = [Specifier];
2264       fields =
2265         [
2266           ("left_paren", Token);
2267           ("types", ZeroOrMore (ZeroOrOne (Aggregate Specifier)));
2268           ("right_paren", Token);
2269         ];
2270     };
2271     {
2272       kind_name = "UnionTypeSpecifier";
2273       type_name = "union_type_specifier";
2274       func_name = "union_type_specifier";
2275       description = "union_type_specifier";
2276       prefix = "union";
2277       aggregates = [Specifier];
2278       fields =
2279         [
2280           ("left_paren", Token);
2281           ("types", ZeroOrMore (ZeroOrOne (Aggregate Specifier)));
2282           ("right_paren", Token);
2283         ];
2284     };
2285     {
2286       kind_name = "IntersectionTypeSpecifier";
2287       type_name = "intersection_type_specifier";
2288       func_name = "intersection_type_specifier";
2289       description = "intersection_type_specifier";
2290       prefix = "intersection";
2291       aggregates = [Specifier];
2292       fields =
2293         [
2294           ("left_paren", Token);
2295           ("types", ZeroOrMore (ZeroOrOne (Aggregate Specifier)));
2296           ("right_paren", Token);
2297         ];
2298     };
2299     {
2300       kind_name = "ErrorSyntax";
2301       type_name = "error";
2302       func_name = "error";
2303       description = "error";
2304       prefix = "error";
2305       aggregates = [];
2306       fields = [("error", Just "error")];
2307     };
2308     {
2309       kind_name = "ListItem";
2310       type_name = "list_item";
2311       func_name = "list_item";
2312       description = "list_item";
2313       prefix = "list";
2314       aggregates = [];
2315       fields = [("item", Just "error"); ("separator", Token)];
2316     };
2317     {
2318       kind_name = "PocketAtomExpression";
2319       type_name = "pocket_atom_expression";
2320       func_name = "pocket_atom_expression";
2321       description = "pocket_atom";
2322       prefix = "pocket_atom";
2323       aggregates = [Expression];
2324       fields = [("glyph", Token); ("expression", Token)];
2325     }
2326     (* Syntax for Class:@Field::name where
2327      Class is the qualifier
2328      pu_operator must be :@
2329      Field is the field
2330      operator must be ::
2331      name is the name
2332   *);
2333     {
2334       kind_name = "PocketIdentifierExpression";
2335       type_name = "pocket_identifier_expression";
2336       func_name = "pocket_identifier_expression";
2337       description = "pocket_identifier";
2338       prefix = "pocket_identifier";
2339       aggregates = [Expression; ConstructorExpression; LambdaBody];
2340       fields =
2341         [
2342           ("qualifier", Aggregate Expression);
2343           ("pu_operator", Token);
2344           ("field", Aggregate Expression);
2345           ("operator", Token);
2346           ("name", Aggregate Expression);
2347         ];
2348     }
2349     (* PocketUniverse: because of the trailing ';' I didn't want to
2350    add the aggragte PUField to PocketAtomExpression, so I made the ( ... )
2351    part optional. It will be up to the parser to only parse the two
2352    possible syntax:
2353    :@A;
2354    :@A ( ... );
2355 *);
2356     {
2357       kind_name = "PocketAtomMappingDeclaration";
2358       type_name = "pocket_atom_mapping_declaration";
2359       func_name = "pocket_atom_mapping_declaration";
2360       description = "pocket_atom_mapping";
2361       prefix = "pocket_atom_mapping";
2362       aggregates = [PUField];
2363       fields =
2364         [
2365           ("glyph", Token);
2366           ("name", Aggregate Expression);
2367           ("left_paren", ZeroOrOne Token);
2368           ("mappings", ZeroOrMore (Aggregate PUMapping));
2369           ("right_paren", ZeroOrOne Token);
2370           ("semicolon", Token);
2371         ];
2372     };
2373     {
2374       kind_name = "PocketEnumDeclaration";
2375       type_name = "pocket_enum_declaration";
2376       func_name = "pocket_enum_declaration";
2377       description = "pocket_enum_declaration";
2378       prefix = "pocket_enum";
2379       aggregates = [ClassBodyDeclaration];
2380       fields =
2381         [
2382           ("attributes", ZeroOrOne (Aggregate AttributeSpecification));
2383           ("modifiers", ZeroOrMore Token);
2384           ("enum", Token);
2385           ("name", Token);
2386           ("left_brace", Token);
2387           ("fields", ZeroOrMore (Aggregate PUField));
2388           ("right_brace", Token);
2389         ];
2390     };
2391     {
2392       kind_name = "PocketFieldTypeExprDeclaration";
2393       type_name = "pocket_field_type_expr_declaration";
2394       func_name = "pocket_field_type_expr_declaration";
2395       description = "pocket_field_type_expr_declaration";
2396       prefix = "pocket_field_type_expr";
2397       aggregates = [PUField];
2398       fields =
2399         [
2400           ("case", Token);
2401           ("type", Aggregate Specifier);
2402           ("name", Aggregate Expression);
2403           ("semicolon", Token);
2404         ];
2405     };
2406     {
2407       kind_name = "PocketFieldTypeDeclaration";
2408       type_name = "pocket_field_type_declaration";
2409       func_name = "pocket_field_type_declaration";
2410       description = "pocket_field_type_declaration";
2411       prefix = "pocket_field_type";
2412       aggregates = [PUField];
2413       fields =
2414         [
2415           ("case", Token);
2416           ("type", Token);
2417           ("type_parameter", Just "TypeParameter");
2418           ("semicolon", Token);
2419         ];
2420     };
2421     {
2422       kind_name = "PocketMappingIdDeclaration";
2423       type_name = "pocket_mapping_id_declaration";
2424       func_name = "pocket_mapping_id_declaration";
2425       description = "pocket_mapping_id_declaration";
2426       prefix = "pocket_mapping_id";
2427       aggregates = [PUMapping];
2428       fields =
2429         [
2430           ("name", Aggregate Expression);
2431           ("initializer", Just "SimpleInitializer");
2432         ];
2433     };
2434     {
2435       kind_name = "PocketMappingTypeDeclaration";
2436       type_name = "pocket_mapping_type_declaration";
2437       func_name = "pocket_mapping_type_declaration";
2438       description = "pocket_mapping_type_declaration";
2439       prefix = "pocket_mapping_type";
2440       aggregates = [PUMapping];
2441       fields =
2442         [
2443           ("keyword", Token);
2444           ("name", Aggregate Expression);
2445           ("equal", Token);
2446           ("type", Aggregate Specifier);
2447         ];
2448     };
2449   ]
2450
2451 (******************************************************************************(
2452  * Utilities for aggregate types
2453 )******************************************************************************)
2454 let generated_aggregate_types =
2455   [
2456     TopLevelDeclaration;
2457     Expression;
2458     Specifier;
2459     Parameter;
2460     ClassBodyDeclaration;
2461     Statement;
2462     SwitchLabel;
2463     LambdaBody;
2464     ConstructorExpression;
2465     NamespaceInternals;
2466     XHPAttribute;
2467     ObjectCreationWhat;
2468     TODO;
2469     Name;
2470     PUField;
2471     PUMapping;
2472   ]
2473
2474 let string_of_aggregate_type = function
2475   | TopLevelDeclaration -> "TopLevelDeclaration"
2476   | Expression -> "Expression"
2477   | Specifier -> "Specifier"
2478   | Parameter -> "Parameter"
2479   | AttributeSpecification -> "AttributeSpecification"
2480   | ClassBodyDeclaration -> "ClassBodyDeclaration"
2481   | Statement -> "Statement"
2482   | SwitchLabel -> "SwitchLabel"
2483   | LambdaBody -> "LambdaBody"
2484   | ConstructorExpression -> "ConstructorExpression"
2485   | NamespaceInternals -> "NamespaceInternals"
2486   | XHPAttribute -> "XHPAttribute"
2487   | ObjectCreationWhat -> "ObjectCreationWhat"
2488   | TODO -> "TODO"
2489   | Name -> "Name"
2490   | PUField -> "PUField"
2491   | PUMapping -> "PUMapping"
2492
2493 module AggregateKey = struct
2494   type t = aggregate_type
2495
2496   let compare (x : t) (y : t) = compare x y
2497 end
2498
2499 module AggMap = WrappedMap.Make (AggregateKey)
2500
2501 let aggregation_of_top_level_declaration =
2502   List.filter (fun x -> List.mem TopLevelDeclaration x.aggregates) schema
2503
2504 let aggregation_of_expression =
2505   List.filter (fun x -> List.mem Expression x.aggregates) schema
2506
2507 let aggregation_of_specifier =
2508   List.filter (fun x -> List.mem Specifier x.aggregates) schema
2509
2510 let aggregation_of_parameter =
2511   List.filter (fun x -> List.mem Parameter x.aggregates) schema
2512
2513 let aggregation_of_attribute_specification =
2514   List.filter (fun x -> List.mem AttributeSpecification x.aggregates) schema
2515
2516 let aggregation_of_class_body_declaration =
2517   List.filter (fun x -> List.mem ClassBodyDeclaration x.aggregates) schema
2518
2519 let aggregation_of_statement =
2520   List.filter (fun x -> List.mem Statement x.aggregates) schema
2521
2522 let aggregation_of_switch_label =
2523   List.filter (fun x -> List.mem SwitchLabel x.aggregates) schema
2524
2525 let aggregation_of_lambda_body =
2526   List.filter (fun x -> List.mem LambdaBody x.aggregates) schema
2527
2528 let aggregation_of_constructor_expression =
2529   List.filter (fun x -> List.mem ConstructorExpression x.aggregates) schema
2530
2531 let aggregation_of_namespace_internals =
2532   List.filter (fun x -> List.mem NamespaceInternals x.aggregates) schema
2533
2534 let aggregation_of_xhp_attribute =
2535   List.filter (fun x -> List.mem XHPAttribute x.aggregates) schema
2536
2537 let aggregation_of_object_creation_what =
2538   List.filter (fun x -> List.mem ObjectCreationWhat x.aggregates) schema
2539
2540 let aggregation_of_todo_aggregate =
2541   List.filter (fun x -> List.mem TODO x.aggregates) schema
2542
2543 let aggregation_of_name_aggregate =
2544   List.filter (fun x -> List.mem Name x.aggregates) schema
2545
2546 let aggregation_of_pufield_aggregate =
2547   List.filter (fun x -> List.mem PUField x.aggregates) schema
2548
2549 let aggregation_of_pumapping_aggregate =
2550   List.filter (fun x -> List.mem PUMapping x.aggregates) schema
2551
2552 let aggregation_of = function
2553   | TopLevelDeclaration -> aggregation_of_top_level_declaration
2554   | Expression -> aggregation_of_expression
2555   | Specifier -> aggregation_of_specifier
2556   | Parameter -> aggregation_of_parameter
2557   | AttributeSpecification -> aggregation_of_attribute_specification
2558   | ClassBodyDeclaration -> aggregation_of_class_body_declaration
2559   | Statement -> aggregation_of_statement
2560   | SwitchLabel -> aggregation_of_switch_label
2561   | LambdaBody -> aggregation_of_lambda_body
2562   | ConstructorExpression -> aggregation_of_constructor_expression
2563   | NamespaceInternals -> aggregation_of_namespace_internals
2564   | XHPAttribute -> aggregation_of_xhp_attribute
2565   | ObjectCreationWhat -> aggregation_of_object_creation_what
2566   | TODO -> aggregation_of_todo_aggregate
2567   | Name -> aggregation_of_name_aggregate
2568   | PUField -> aggregation_of_pufield_aggregate
2569   | PUMapping -> aggregation_of_pumapping_aggregate
2570
2571 let aggregate_type_name = function
2572   | TopLevelDeclaration -> "top_level_declaration"
2573   | Expression -> "expression"
2574   | Specifier -> "specifier"
2575   | Parameter -> "parameter"
2576   | AttributeSpecification -> "attribute_specification"
2577   | ClassBodyDeclaration -> "class_body_declaration"
2578   | Statement -> "statement"
2579   | SwitchLabel -> "switch_label"
2580   | LambdaBody -> "lambda_body"
2581   | ConstructorExpression -> "constructor_expression"
2582   | NamespaceInternals -> "namespace_internals"
2583   | XHPAttribute -> "xhp_attribute"
2584   | ObjectCreationWhat -> "object_creation_what"
2585   | TODO -> "todo_aggregate"
2586   | Name -> "name_aggregate"
2587   | PUField -> "pufield_aggregate"
2588   | PUMapping -> "pumapping_aggregate"
2589
2590 let aggregate_type_pfx_trim = function
2591   | TopLevelDeclaration -> ("TLD", "\\(Declaration\\|Statement\\)$")
2592   | Expression -> ("Expr", "Expression$")
2593   | Specifier -> ("Spec", "\\(Type\\)?Specifier$")
2594   | Parameter -> ("Param", "")
2595   | AttributeSpecification -> ("AttrSpec", "")
2596   | ClassBodyDeclaration -> ("Body", "Declaration")
2597   | Statement -> ("Stmt", "Statement$")
2598   | SwitchLabel -> ("Switch", "Label$")
2599   | LambdaBody -> ("Lambda", "Expression$")
2600   | ConstructorExpression -> ("CExpr", "Expression$")
2601   | NamespaceInternals -> ("NSI", "")
2602   | XHPAttribute -> ("XHPAttr", "")
2603   | ObjectCreationWhat -> ("New", "")
2604   | TODO -> ("TODO", "")
2605   | Name -> ("Name", "")
2606   | PUField -> ("PocketField", "")
2607   | PUMapping -> ("PocketMapping", "")
2608
2609 (******************************************************************************(
2610  * Useful for debugging / schema alterations
2611 )******************************************************************************)
2612 let string_of_child_spec =
2613   let p = Printf.sprintf in
2614   let rec aux = function
2615     | Token -> "Token"
2616     | Just x -> p "Just \"%s\"" x
2617     | Aggregate x -> p "Aggregate %s" (string_of_aggregate_type x)
2618     | ZeroOrMore c -> p "ZeroOrMore (%s)" (aux c)
2619     | ZeroOrOne c -> p "ZeroOrOne (%s)" (aux c)
2620   in
2621   aux