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