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