hphp/hack/src/parser/syntax_by_ref/syntax_variant_generated.rs

   1 /**
   2  * Copyright (c) 2016, Facebook, Inc.
   3  * All rights reserved.
   4  *
   5  * This source code is licensed under the MIT license found in the
   6  * LICENSE file in the "hack" directory of this source tree. An additional
   7  * directory.
   8  *
   9  **
  10  *
  11  * THIS FILE IS @generated; DO NOT EDIT IT
  12  * To regenerate this file, run
  13  *
  14  *   buck run //hphp/hack/src:generate_full_fidelity
  15  *
  16  **
  17  *
  18  */
  19 use super::{
  20     syntax::Syntax,
  21     syntax_children_iterator::SyntaxChildrenIterator,
  22 };
  23
  24 #[derive(Debug, Clone)]
  25 pub enum SyntaxVariant<'a, T, V> {
  26     Token(T),
  27     Missing,
  28     SyntaxList(&'a [Syntax<'a, T, V>]),
  29     EndOfFile(&'a EndOfFileChildren<'a, T, V>),
  30     Script(&'a ScriptChildren<'a, T, V>),
  31     QualifiedName(&'a QualifiedNameChildren<'a, T, V>),
  32     SimpleTypeSpecifier(&'a SimpleTypeSpecifierChildren<'a, T, V>),
  33     LiteralExpression(&'a LiteralExpressionChildren<'a, T, V>),
  34     PrefixedStringExpression(&'a PrefixedStringExpressionChildren<'a, T, V>),
  35     PrefixedCodeExpression(&'a PrefixedCodeExpressionChildren<'a, T, V>),
  36     VariableExpression(&'a VariableExpressionChildren<'a, T, V>),
  37     PipeVariableExpression(&'a PipeVariableExpressionChildren<'a, T, V>),
  38     FileAttributeSpecification(&'a FileAttributeSpecificationChildren<'a, T, V>),
  39     EnumDeclaration(&'a EnumDeclarationChildren<'a, T, V>),
  40     EnumUse(&'a EnumUseChildren<'a, T, V>),
  41     Enumerator(&'a EnumeratorChildren<'a, T, V>),
  42     EnumClassDeclaration(&'a EnumClassDeclarationChildren<'a, T, V>),
  43     EnumClassEnumerator(&'a EnumClassEnumeratorChildren<'a, T, V>),
  44     RecordDeclaration(&'a RecordDeclarationChildren<'a, T, V>),
  45     RecordField(&'a RecordFieldChildren<'a, T, V>),
  46     AliasDeclaration(&'a AliasDeclarationChildren<'a, T, V>),
  47     ContextAliasDeclaration(&'a ContextAliasDeclarationChildren<'a, T, V>),
  48     PropertyDeclaration(&'a PropertyDeclarationChildren<'a, T, V>),
  49     PropertyDeclarator(&'a PropertyDeclaratorChildren<'a, T, V>),
  50     NamespaceDeclaration(&'a NamespaceDeclarationChildren<'a, T, V>),
  51     NamespaceDeclarationHeader(&'a NamespaceDeclarationHeaderChildren<'a, T, V>),
  52     NamespaceBody(&'a NamespaceBodyChildren<'a, T, V>),
  53     NamespaceEmptyBody(&'a NamespaceEmptyBodyChildren<'a, T, V>),
  54     NamespaceUseDeclaration(&'a NamespaceUseDeclarationChildren<'a, T, V>),
  55     NamespaceGroupUseDeclaration(&'a NamespaceGroupUseDeclarationChildren<'a, T, V>),
  56     NamespaceUseClause(&'a NamespaceUseClauseChildren<'a, T, V>),
  57     FunctionDeclaration(&'a FunctionDeclarationChildren<'a, T, V>),
  58     FunctionDeclarationHeader(&'a FunctionDeclarationHeaderChildren<'a, T, V>),
  59     Contexts(&'a ContextsChildren<'a, T, V>),
  60     WhereClause(&'a WhereClauseChildren<'a, T, V>),
  61     WhereConstraint(&'a WhereConstraintChildren<'a, T, V>),
  62     MethodishDeclaration(&'a MethodishDeclarationChildren<'a, T, V>),
  63     MethodishTraitResolution(&'a MethodishTraitResolutionChildren<'a, T, V>),
  64     ClassishDeclaration(&'a ClassishDeclarationChildren<'a, T, V>),
  65     ClassishBody(&'a ClassishBodyChildren<'a, T, V>),
  66     TraitUsePrecedenceItem(&'a TraitUsePrecedenceItemChildren<'a, T, V>),
  67     TraitUseAliasItem(&'a TraitUseAliasItemChildren<'a, T, V>),
  68     TraitUseConflictResolution(&'a TraitUseConflictResolutionChildren<'a, T, V>),
  69     TraitUse(&'a TraitUseChildren<'a, T, V>),
  70     RequireClause(&'a RequireClauseChildren<'a, T, V>),
  71     ConstDeclaration(&'a ConstDeclarationChildren<'a, T, V>),
  72     ConstantDeclarator(&'a ConstantDeclaratorChildren<'a, T, V>),
  73     TypeConstDeclaration(&'a TypeConstDeclarationChildren<'a, T, V>),
  74     ContextConstDeclaration(&'a ContextConstDeclarationChildren<'a, T, V>),
  75     DecoratedExpression(&'a DecoratedExpressionChildren<'a, T, V>),
  76     ParameterDeclaration(&'a ParameterDeclarationChildren<'a, T, V>),
  77     VariadicParameter(&'a VariadicParameterChildren<'a, T, V>),
  78     OldAttributeSpecification(&'a OldAttributeSpecificationChildren<'a, T, V>),
  79     AttributeSpecification(&'a AttributeSpecificationChildren<'a, T, V>),
  80     Attribute(&'a AttributeChildren<'a, T, V>),
  81     InclusionExpression(&'a InclusionExpressionChildren<'a, T, V>),
  82     InclusionDirective(&'a InclusionDirectiveChildren<'a, T, V>),
  83     CompoundStatement(&'a CompoundStatementChildren<'a, T, V>),
  84     ExpressionStatement(&'a ExpressionStatementChildren<'a, T, V>),
  85     MarkupSection(&'a MarkupSectionChildren<'a, T, V>),
  86     MarkupSuffix(&'a MarkupSuffixChildren<'a, T, V>),
  87     UnsetStatement(&'a UnsetStatementChildren<'a, T, V>),
  88     UsingStatementBlockScoped(&'a UsingStatementBlockScopedChildren<'a, T, V>),
  89     UsingStatementFunctionScoped(&'a UsingStatementFunctionScopedChildren<'a, T, V>),
  90     WhileStatement(&'a WhileStatementChildren<'a, T, V>),
  91     IfStatement(&'a IfStatementChildren<'a, T, V>),
  92     ElseifClause(&'a ElseifClauseChildren<'a, T, V>),
  93     ElseClause(&'a ElseClauseChildren<'a, T, V>),
  94     TryStatement(&'a TryStatementChildren<'a, T, V>),
  95     CatchClause(&'a CatchClauseChildren<'a, T, V>),
  96     FinallyClause(&'a FinallyClauseChildren<'a, T, V>),
  97     DoStatement(&'a DoStatementChildren<'a, T, V>),
  98     ForStatement(&'a ForStatementChildren<'a, T, V>),
  99     ForeachStatement(&'a ForeachStatementChildren<'a, T, V>),
 100     SwitchStatement(&'a SwitchStatementChildren<'a, T, V>),
 101     SwitchSection(&'a SwitchSectionChildren<'a, T, V>),
 102     SwitchFallthrough(&'a SwitchFallthroughChildren<'a, T, V>),
 103     CaseLabel(&'a CaseLabelChildren<'a, T, V>),
 104     DefaultLabel(&'a DefaultLabelChildren<'a, T, V>),
 105     ReturnStatement(&'a ReturnStatementChildren<'a, T, V>),
 106     YieldBreakStatement(&'a YieldBreakStatementChildren<'a, T, V>),
 107     ThrowStatement(&'a ThrowStatementChildren<'a, T, V>),
 108     BreakStatement(&'a BreakStatementChildren<'a, T, V>),
 109     ContinueStatement(&'a ContinueStatementChildren<'a, T, V>),
 110     EchoStatement(&'a EchoStatementChildren<'a, T, V>),
 111     ConcurrentStatement(&'a ConcurrentStatementChildren<'a, T, V>),
 112     SimpleInitializer(&'a SimpleInitializerChildren<'a, T, V>),
 113     AnonymousClass(&'a AnonymousClassChildren<'a, T, V>),
 114     AnonymousFunction(&'a AnonymousFunctionChildren<'a, T, V>),
 115     AnonymousFunctionUseClause(&'a AnonymousFunctionUseClauseChildren<'a, T, V>),
 116     LambdaExpression(&'a LambdaExpressionChildren<'a, T, V>),
 117     LambdaSignature(&'a LambdaSignatureChildren<'a, T, V>),
 118     CastExpression(&'a CastExpressionChildren<'a, T, V>),
 119     ScopeResolutionExpression(&'a ScopeResolutionExpressionChildren<'a, T, V>),
 120     MemberSelectionExpression(&'a MemberSelectionExpressionChildren<'a, T, V>),
 121     SafeMemberSelectionExpression(&'a SafeMemberSelectionExpressionChildren<'a, T, V>),
 122     EmbeddedMemberSelectionExpression(&'a EmbeddedMemberSelectionExpressionChildren<'a, T, V>),
 123     YieldExpression(&'a YieldExpressionChildren<'a, T, V>),
 124     PrefixUnaryExpression(&'a PrefixUnaryExpressionChildren<'a, T, V>),
 125     PostfixUnaryExpression(&'a PostfixUnaryExpressionChildren<'a, T, V>),
 126     BinaryExpression(&'a BinaryExpressionChildren<'a, T, V>),
 127     IsExpression(&'a IsExpressionChildren<'a, T, V>),
 128     AsExpression(&'a AsExpressionChildren<'a, T, V>),
 129     NullableAsExpression(&'a NullableAsExpressionChildren<'a, T, V>),
 130     UpcastExpression(&'a UpcastExpressionChildren<'a, T, V>),
 131     ConditionalExpression(&'a ConditionalExpressionChildren<'a, T, V>),
 132     EvalExpression(&'a EvalExpressionChildren<'a, T, V>),
 133     IssetExpression(&'a IssetExpressionChildren<'a, T, V>),
 134     FunctionCallExpression(&'a FunctionCallExpressionChildren<'a, T, V>),
 135     FunctionPointerExpression(&'a FunctionPointerExpressionChildren<'a, T, V>),
 136     ParenthesizedExpression(&'a ParenthesizedExpressionChildren<'a, T, V>),
 137     BracedExpression(&'a BracedExpressionChildren<'a, T, V>),
 138     ETSpliceExpression(&'a ETSpliceExpressionChildren<'a, T, V>),
 139     EmbeddedBracedExpression(&'a EmbeddedBracedExpressionChildren<'a, T, V>),
 140     ListExpression(&'a ListExpressionChildren<'a, T, V>),
 141     CollectionLiteralExpression(&'a CollectionLiteralExpressionChildren<'a, T, V>),
 142     ObjectCreationExpression(&'a ObjectCreationExpressionChildren<'a, T, V>),
 143     ConstructorCall(&'a ConstructorCallChildren<'a, T, V>),
 144     RecordCreationExpression(&'a RecordCreationExpressionChildren<'a, T, V>),
 145     DarrayIntrinsicExpression(&'a DarrayIntrinsicExpressionChildren<'a, T, V>),
 146     DictionaryIntrinsicExpression(&'a DictionaryIntrinsicExpressionChildren<'a, T, V>),
 147     KeysetIntrinsicExpression(&'a KeysetIntrinsicExpressionChildren<'a, T, V>),
 148     VarrayIntrinsicExpression(&'a VarrayIntrinsicExpressionChildren<'a, T, V>),
 149     VectorIntrinsicExpression(&'a VectorIntrinsicExpressionChildren<'a, T, V>),
 150     ElementInitializer(&'a ElementInitializerChildren<'a, T, V>),
 151     SubscriptExpression(&'a SubscriptExpressionChildren<'a, T, V>),
 152     EmbeddedSubscriptExpression(&'a EmbeddedSubscriptExpressionChildren<'a, T, V>),
 153     AwaitableCreationExpression(&'a AwaitableCreationExpressionChildren<'a, T, V>),
 154     XHPChildrenDeclaration(&'a XHPChildrenDeclarationChildren<'a, T, V>),
 155     XHPChildrenParenthesizedList(&'a XHPChildrenParenthesizedListChildren<'a, T, V>),
 156     XHPCategoryDeclaration(&'a XHPCategoryDeclarationChildren<'a, T, V>),
 157     XHPEnumType(&'a XHPEnumTypeChildren<'a, T, V>),
 158     XHPLateinit(&'a XHPLateinitChildren<'a, T, V>),
 159     XHPRequired(&'a XHPRequiredChildren<'a, T, V>),
 160     XHPClassAttributeDeclaration(&'a XHPClassAttributeDeclarationChildren<'a, T, V>),
 161     XHPClassAttribute(&'a XHPClassAttributeChildren<'a, T, V>),
 162     XHPSimpleClassAttribute(&'a XHPSimpleClassAttributeChildren<'a, T, V>),
 163     XHPSimpleAttribute(&'a XHPSimpleAttributeChildren<'a, T, V>),
 164     XHPSpreadAttribute(&'a XHPSpreadAttributeChildren<'a, T, V>),
 165     XHPOpen(&'a XHPOpenChildren<'a, T, V>),
 166     XHPExpression(&'a XHPExpressionChildren<'a, T, V>),
 167     XHPClose(&'a XHPCloseChildren<'a, T, V>),
 168     TypeConstant(&'a TypeConstantChildren<'a, T, V>),
 169     VectorTypeSpecifier(&'a VectorTypeSpecifierChildren<'a, T, V>),
 170     KeysetTypeSpecifier(&'a KeysetTypeSpecifierChildren<'a, T, V>),
 171     TupleTypeExplicitSpecifier(&'a TupleTypeExplicitSpecifierChildren<'a, T, V>),
 172     VarrayTypeSpecifier(&'a VarrayTypeSpecifierChildren<'a, T, V>),
 173     FunctionCtxTypeSpecifier(&'a FunctionCtxTypeSpecifierChildren<'a, T, V>),
 174     TypeParameter(&'a TypeParameterChildren<'a, T, V>),
 175     TypeConstraint(&'a TypeConstraintChildren<'a, T, V>),
 176     ContextConstraint(&'a ContextConstraintChildren<'a, T, V>),
 177     DarrayTypeSpecifier(&'a DarrayTypeSpecifierChildren<'a, T, V>),
 178     DictionaryTypeSpecifier(&'a DictionaryTypeSpecifierChildren<'a, T, V>),
 179     ClosureTypeSpecifier(&'a ClosureTypeSpecifierChildren<'a, T, V>),
 180     ClosureParameterTypeSpecifier(&'a ClosureParameterTypeSpecifierChildren<'a, T, V>),
 181     ClassnameTypeSpecifier(&'a ClassnameTypeSpecifierChildren<'a, T, V>),
 182     FieldSpecifier(&'a FieldSpecifierChildren<'a, T, V>),
 183     FieldInitializer(&'a FieldInitializerChildren<'a, T, V>),
 184     ShapeTypeSpecifier(&'a ShapeTypeSpecifierChildren<'a, T, V>),
 185     ShapeExpression(&'a ShapeExpressionChildren<'a, T, V>),
 186     TupleExpression(&'a TupleExpressionChildren<'a, T, V>),
 187     GenericTypeSpecifier(&'a GenericTypeSpecifierChildren<'a, T, V>),
 188     NullableTypeSpecifier(&'a NullableTypeSpecifierChildren<'a, T, V>),
 189     LikeTypeSpecifier(&'a LikeTypeSpecifierChildren<'a, T, V>),
 190     SoftTypeSpecifier(&'a SoftTypeSpecifierChildren<'a, T, V>),
 191     AttributizedSpecifier(&'a AttributizedSpecifierChildren<'a, T, V>),
 192     ReifiedTypeArgument(&'a ReifiedTypeArgumentChildren<'a, T, V>),
 193     TypeArguments(&'a TypeArgumentsChildren<'a, T, V>),
 194     TypeParameters(&'a TypeParametersChildren<'a, T, V>),
 195     TupleTypeSpecifier(&'a TupleTypeSpecifierChildren<'a, T, V>),
 196     UnionTypeSpecifier(&'a UnionTypeSpecifierChildren<'a, T, V>),
 197     IntersectionTypeSpecifier(&'a IntersectionTypeSpecifierChildren<'a, T, V>),
 198     ErrorSyntax(&'a ErrorSyntaxChildren<'a, T, V>),
 199     ListItem(&'a ListItemChildren<'a, T, V>),
 200     EnumClassLabelExpression(&'a EnumClassLabelExpressionChildren<'a, T, V>),
 201 }
 202
 203 #[derive(Debug, Clone)]
 204 pub struct EndOfFileChildren<'a, T, V> {
 205     pub token: Syntax<'a, T, V>,
 206 }
 207
 208 #[derive(Debug, Clone)]
 209 pub struct ScriptChildren<'a, T, V> {
 210     pub declarations: Syntax<'a, T, V>,
 211 }
 212
 213 #[derive(Debug, Clone)]
 214 pub struct QualifiedNameChildren<'a, T, V> {
 215     pub parts: Syntax<'a, T, V>,
 216 }
 217
 218 #[derive(Debug, Clone)]
 219 pub struct SimpleTypeSpecifierChildren<'a, T, V> {
 220     pub specifier: Syntax<'a, T, V>,
 221 }
 222
 223 #[derive(Debug, Clone)]
 224 pub struct LiteralExpressionChildren<'a, T, V> {
 225     pub expression: Syntax<'a, T, V>,
 226 }
 227
 228 #[derive(Debug, Clone)]
 229 pub struct PrefixedStringExpressionChildren<'a, T, V> {
 230     pub name: Syntax<'a, T, V>,
 231     pub str: Syntax<'a, T, V>,
 232 }
 233
 234 #[derive(Debug, Clone)]
 235 pub struct PrefixedCodeExpressionChildren<'a, T, V> {
 236     pub prefix: Syntax<'a, T, V>,
 237     pub left_backtick: Syntax<'a, T, V>,
 238     pub expression: Syntax<'a, T, V>,
 239     pub right_backtick: Syntax<'a, T, V>,
 240 }
 241
 242 #[derive(Debug, Clone)]
 243 pub struct VariableExpressionChildren<'a, T, V> {
 244     pub expression: Syntax<'a, T, V>,
 245 }
 246
 247 #[derive(Debug, Clone)]
 248 pub struct PipeVariableExpressionChildren<'a, T, V> {
 249     pub expression: Syntax<'a, T, V>,
 250 }
 251
 252 #[derive(Debug, Clone)]
 253 pub struct FileAttributeSpecificationChildren<'a, T, V> {
 254     pub left_double_angle: Syntax<'a, T, V>,
 255     pub keyword: Syntax<'a, T, V>,
 256     pub colon: Syntax<'a, T, V>,
 257     pub attributes: Syntax<'a, T, V>,
 258     pub right_double_angle: Syntax<'a, T, V>,
 259 }
 260
 261 #[derive(Debug, Clone)]
 262 pub struct EnumDeclarationChildren<'a, T, V> {
 263     pub attribute_spec: Syntax<'a, T, V>,
 264     pub keyword: Syntax<'a, T, V>,
 265     pub name: Syntax<'a, T, V>,
 266     pub colon: Syntax<'a, T, V>,
 267     pub base: Syntax<'a, T, V>,
 268     pub type_: Syntax<'a, T, V>,
 269     pub left_brace: Syntax<'a, T, V>,
 270     pub use_clauses: Syntax<'a, T, V>,
 271     pub enumerators: Syntax<'a, T, V>,
 272     pub right_brace: Syntax<'a, T, V>,
 273 }
 274
 275 #[derive(Debug, Clone)]
 276 pub struct EnumUseChildren<'a, T, V> {
 277     pub keyword: Syntax<'a, T, V>,
 278     pub names: Syntax<'a, T, V>,
 279     pub semicolon: Syntax<'a, T, V>,
 280 }
 281
 282 #[derive(Debug, Clone)]
 283 pub struct EnumeratorChildren<'a, T, V> {
 284     pub name: Syntax<'a, T, V>,
 285     pub equal: Syntax<'a, T, V>,
 286     pub value: Syntax<'a, T, V>,
 287     pub semicolon: Syntax<'a, T, V>,
 288 }
 289
 290 #[derive(Debug, Clone)]
 291 pub struct EnumClassDeclarationChildren<'a, T, V> {
 292     pub attribute_spec: Syntax<'a, T, V>,
 293     pub modifiers: Syntax<'a, T, V>,
 294     pub enum_keyword: Syntax<'a, T, V>,
 295     pub class_keyword: Syntax<'a, T, V>,
 296     pub name: Syntax<'a, T, V>,
 297     pub colon: Syntax<'a, T, V>,
 298     pub base: Syntax<'a, T, V>,
 299     pub extends: Syntax<'a, T, V>,
 300     pub extends_list: Syntax<'a, T, V>,
 301     pub left_brace: Syntax<'a, T, V>,
 302     pub elements: Syntax<'a, T, V>,
 303     pub right_brace: Syntax<'a, T, V>,
 304 }
 305
 306 #[derive(Debug, Clone)]
 307 pub struct EnumClassEnumeratorChildren<'a, T, V> {
 308     pub modifiers: Syntax<'a, T, V>,
 309     pub type_: Syntax<'a, T, V>,
 310     pub name: Syntax<'a, T, V>,
 311     pub initializer: Syntax<'a, T, V>,
 312     pub semicolon: Syntax<'a, T, V>,
 313 }
 314
 315 #[derive(Debug, Clone)]
 316 pub struct RecordDeclarationChildren<'a, T, V> {
 317     pub attribute_spec: Syntax<'a, T, V>,
 318     pub modifier: Syntax<'a, T, V>,
 319     pub keyword: Syntax<'a, T, V>,
 320     pub name: Syntax<'a, T, V>,
 321     pub extends_keyword: Syntax<'a, T, V>,
 322     pub extends_opt: Syntax<'a, T, V>,
 323     pub left_brace: Syntax<'a, T, V>,
 324     pub fields: Syntax<'a, T, V>,
 325     pub right_brace: Syntax<'a, T, V>,
 326 }
 327
 328 #[derive(Debug, Clone)]
 329 pub struct RecordFieldChildren<'a, T, V> {
 330     pub type_: Syntax<'a, T, V>,
 331     pub name: Syntax<'a, T, V>,
 332     pub init: Syntax<'a, T, V>,
 333     pub semi: Syntax<'a, T, V>,
 334 }
 335
 336 #[derive(Debug, Clone)]
 337 pub struct AliasDeclarationChildren<'a, T, V> {
 338     pub attribute_spec: Syntax<'a, T, V>,
 339     pub keyword: Syntax<'a, T, V>,
 340     pub name: Syntax<'a, T, V>,
 341     pub generic_parameter: Syntax<'a, T, V>,
 342     pub constraint: Syntax<'a, T, V>,
 343     pub equal: Syntax<'a, T, V>,
 344     pub type_: Syntax<'a, T, V>,
 345     pub semicolon: Syntax<'a, T, V>,
 346 }
 347
 348 #[derive(Debug, Clone)]
 349 pub struct ContextAliasDeclarationChildren<'a, T, V> {
 350     pub attribute_spec: Syntax<'a, T, V>,
 351     pub keyword: Syntax<'a, T, V>,
 352     pub name: Syntax<'a, T, V>,
 353     pub generic_parameter: Syntax<'a, T, V>,
 354     pub as_constraint: Syntax<'a, T, V>,
 355     pub equal: Syntax<'a, T, V>,
 356     pub context: Syntax<'a, T, V>,
 357     pub semicolon: Syntax<'a, T, V>,
 358 }
 359
 360 #[derive(Debug, Clone)]
 361 pub struct PropertyDeclarationChildren<'a, T, V> {
 362     pub attribute_spec: Syntax<'a, T, V>,
 363     pub modifiers: Syntax<'a, T, V>,
 364     pub type_: Syntax<'a, T, V>,
 365     pub declarators: Syntax<'a, T, V>,
 366     pub semicolon: Syntax<'a, T, V>,
 367 }
 368
 369 #[derive(Debug, Clone)]
 370 pub struct PropertyDeclaratorChildren<'a, T, V> {
 371     pub name: Syntax<'a, T, V>,
 372     pub initializer: Syntax<'a, T, V>,
 373 }
 374
 375 #[derive(Debug, Clone)]
 376 pub struct NamespaceDeclarationChildren<'a, T, V> {
 377     pub header: Syntax<'a, T, V>,
 378     pub body: Syntax<'a, T, V>,
 379 }
 380
 381 #[derive(Debug, Clone)]
 382 pub struct NamespaceDeclarationHeaderChildren<'a, T, V> {
 383     pub keyword: Syntax<'a, T, V>,
 384     pub name: Syntax<'a, T, V>,
 385 }
 386
 387 #[derive(Debug, Clone)]
 388 pub struct NamespaceBodyChildren<'a, T, V> {
 389     pub left_brace: Syntax<'a, T, V>,
 390     pub declarations: Syntax<'a, T, V>,
 391     pub right_brace: Syntax<'a, T, V>,
 392 }
 393
 394 #[derive(Debug, Clone)]
 395 pub struct NamespaceEmptyBodyChildren<'a, T, V> {
 396     pub semicolon: Syntax<'a, T, V>,
 397 }
 398
 399 #[derive(Debug, Clone)]
 400 pub struct NamespaceUseDeclarationChildren<'a, T, V> {
 401     pub keyword: Syntax<'a, T, V>,
 402     pub kind: Syntax<'a, T, V>,
 403     pub clauses: Syntax<'a, T, V>,
 404     pub semicolon: Syntax<'a, T, V>,
 405 }
 406
 407 #[derive(Debug, Clone)]
 408 pub struct NamespaceGroupUseDeclarationChildren<'a, T, V> {
 409     pub keyword: Syntax<'a, T, V>,
 410     pub kind: Syntax<'a, T, V>,
 411     pub prefix: Syntax<'a, T, V>,
 412     pub left_brace: Syntax<'a, T, V>,
 413     pub clauses: Syntax<'a, T, V>,
 414     pub right_brace: Syntax<'a, T, V>,
 415     pub semicolon: Syntax<'a, T, V>,
 416 }
 417
 418 #[derive(Debug, Clone)]
 419 pub struct NamespaceUseClauseChildren<'a, T, V> {
 420     pub clause_kind: Syntax<'a, T, V>,
 421     pub name: Syntax<'a, T, V>,
 422     pub as_: Syntax<'a, T, V>,
 423     pub alias: Syntax<'a, T, V>,
 424 }
 425
 426 #[derive(Debug, Clone)]
 427 pub struct FunctionDeclarationChildren<'a, T, V> {
 428     pub attribute_spec: Syntax<'a, T, V>,
 429     pub declaration_header: Syntax<'a, T, V>,
 430     pub body: Syntax<'a, T, V>,
 431 }
 432
 433 #[derive(Debug, Clone)]
 434 pub struct FunctionDeclarationHeaderChildren<'a, T, V> {
 435     pub modifiers: Syntax<'a, T, V>,
 436     pub keyword: Syntax<'a, T, V>,
 437     pub name: Syntax<'a, T, V>,
 438     pub type_parameter_list: Syntax<'a, T, V>,
 439     pub left_paren: Syntax<'a, T, V>,
 440     pub parameter_list: Syntax<'a, T, V>,
 441     pub right_paren: Syntax<'a, T, V>,
 442     pub contexts: Syntax<'a, T, V>,
 443     pub colon: Syntax<'a, T, V>,
 444     pub readonly_return: Syntax<'a, T, V>,
 445     pub type_: Syntax<'a, T, V>,
 446     pub where_clause: Syntax<'a, T, V>,
 447 }
 448
 449 #[derive(Debug, Clone)]
 450 pub struct ContextsChildren<'a, T, V> {
 451     pub left_bracket: Syntax<'a, T, V>,
 452     pub types: Syntax<'a, T, V>,
 453     pub right_bracket: Syntax<'a, T, V>,
 454 }
 455
 456 #[derive(Debug, Clone)]
 457 pub struct WhereClauseChildren<'a, T, V> {
 458     pub keyword: Syntax<'a, T, V>,
 459     pub constraints: Syntax<'a, T, V>,
 460 }
 461
 462 #[derive(Debug, Clone)]
 463 pub struct WhereConstraintChildren<'a, T, V> {
 464     pub left_type: Syntax<'a, T, V>,
 465     pub operator: Syntax<'a, T, V>,
 466     pub right_type: Syntax<'a, T, V>,
 467 }
 468
 469 #[derive(Debug, Clone)]
 470 pub struct MethodishDeclarationChildren<'a, T, V> {
 471     pub attribute: Syntax<'a, T, V>,
 472     pub function_decl_header: Syntax<'a, T, V>,
 473     pub function_body: Syntax<'a, T, V>,
 474     pub semicolon: Syntax<'a, T, V>,
 475 }
 476
 477 #[derive(Debug, Clone)]
 478 pub struct MethodishTraitResolutionChildren<'a, T, V> {
 479     pub attribute: Syntax<'a, T, V>,
 480     pub function_decl_header: Syntax<'a, T, V>,
 481     pub equal: Syntax<'a, T, V>,
 482     pub name: Syntax<'a, T, V>,
 483     pub semicolon: Syntax<'a, T, V>,
 484 }
 485
 486 #[derive(Debug, Clone)]
 487 pub struct ClassishDeclarationChildren<'a, T, V> {
 488     pub attribute: Syntax<'a, T, V>,
 489     pub modifiers: Syntax<'a, T, V>,
 490     pub xhp: Syntax<'a, T, V>,
 491     pub keyword: Syntax<'a, T, V>,
 492     pub name: Syntax<'a, T, V>,
 493     pub type_parameters: Syntax<'a, T, V>,
 494     pub extends_keyword: Syntax<'a, T, V>,
 495     pub extends_list: Syntax<'a, T, V>,
 496     pub implements_keyword: Syntax<'a, T, V>,
 497     pub implements_list: Syntax<'a, T, V>,
 498     pub where_clause: Syntax<'a, T, V>,
 499     pub body: Syntax<'a, T, V>,
 500 }
 501
 502 #[derive(Debug, Clone)]
 503 pub struct ClassishBodyChildren<'a, T, V> {
 504     pub left_brace: Syntax<'a, T, V>,
 505     pub elements: Syntax<'a, T, V>,
 506     pub right_brace: Syntax<'a, T, V>,
 507 }
 508
 509 #[derive(Debug, Clone)]
 510 pub struct TraitUsePrecedenceItemChildren<'a, T, V> {
 511     pub name: Syntax<'a, T, V>,
 512     pub keyword: Syntax<'a, T, V>,
 513     pub removed_names: Syntax<'a, T, V>,
 514 }
 515
 516 #[derive(Debug, Clone)]
 517 pub struct TraitUseAliasItemChildren<'a, T, V> {
 518     pub aliasing_name: Syntax<'a, T, V>,
 519     pub keyword: Syntax<'a, T, V>,
 520     pub modifiers: Syntax<'a, T, V>,
 521     pub aliased_name: Syntax<'a, T, V>,
 522 }
 523
 524 #[derive(Debug, Clone)]
 525 pub struct TraitUseConflictResolutionChildren<'a, T, V> {
 526     pub keyword: Syntax<'a, T, V>,
 527     pub names: Syntax<'a, T, V>,
 528     pub left_brace: Syntax<'a, T, V>,
 529     pub clauses: Syntax<'a, T, V>,
 530     pub right_brace: Syntax<'a, T, V>,
 531 }
 532
 533 #[derive(Debug, Clone)]
 534 pub struct TraitUseChildren<'a, T, V> {
 535     pub keyword: Syntax<'a, T, V>,
 536     pub names: Syntax<'a, T, V>,
 537     pub semicolon: Syntax<'a, T, V>,
 538 }
 539
 540 #[derive(Debug, Clone)]
 541 pub struct RequireClauseChildren<'a, T, V> {
 542     pub keyword: Syntax<'a, T, V>,
 543     pub kind: Syntax<'a, T, V>,
 544     pub name: Syntax<'a, T, V>,
 545     pub semicolon: Syntax<'a, T, V>,
 546 }
 547
 548 #[derive(Debug, Clone)]
 549 pub struct ConstDeclarationChildren<'a, T, V> {
 550     pub modifiers: Syntax<'a, T, V>,
 551     pub keyword: Syntax<'a, T, V>,
 552     pub type_specifier: Syntax<'a, T, V>,
 553     pub declarators: Syntax<'a, T, V>,
 554     pub semicolon: Syntax<'a, T, V>,
 555 }
 556
 557 #[derive(Debug, Clone)]
 558 pub struct ConstantDeclaratorChildren<'a, T, V> {
 559     pub name: Syntax<'a, T, V>,
 560     pub initializer: Syntax<'a, T, V>,
 561 }
 562
 563 #[derive(Debug, Clone)]
 564 pub struct TypeConstDeclarationChildren<'a, T, V> {
 565     pub attribute_spec: Syntax<'a, T, V>,
 566     pub modifiers: Syntax<'a, T, V>,
 567     pub keyword: Syntax<'a, T, V>,
 568     pub type_keyword: Syntax<'a, T, V>,
 569     pub name: Syntax<'a, T, V>,
 570     pub type_parameters: Syntax<'a, T, V>,
 571     pub type_constraint: Syntax<'a, T, V>,
 572     pub equal: Syntax<'a, T, V>,
 573     pub type_specifier: Syntax<'a, T, V>,
 574     pub semicolon: Syntax<'a, T, V>,
 575 }
 576
 577 #[derive(Debug, Clone)]
 578 pub struct ContextConstDeclarationChildren<'a, T, V> {
 579     pub modifiers: Syntax<'a, T, V>,
 580     pub const_keyword: Syntax<'a, T, V>,
 581     pub ctx_keyword: Syntax<'a, T, V>,
 582     pub name: Syntax<'a, T, V>,
 583     pub type_parameters: Syntax<'a, T, V>,
 584     pub constraint: Syntax<'a, T, V>,
 585     pub equal: Syntax<'a, T, V>,
 586     pub ctx_list: Syntax<'a, T, V>,
 587     pub semicolon: Syntax<'a, T, V>,
 588 }
 589
 590 #[derive(Debug, Clone)]
 591 pub struct DecoratedExpressionChildren<'a, T, V> {
 592     pub decorator: Syntax<'a, T, V>,
 593     pub expression: Syntax<'a, T, V>,
 594 }
 595
 596 #[derive(Debug, Clone)]
 597 pub struct ParameterDeclarationChildren<'a, T, V> {
 598     pub attribute: Syntax<'a, T, V>,
 599     pub visibility: Syntax<'a, T, V>,
 600     pub call_convention: Syntax<'a, T, V>,
 601     pub readonly: Syntax<'a, T, V>,
 602     pub type_: Syntax<'a, T, V>,
 603     pub name: Syntax<'a, T, V>,
 604     pub default_value: Syntax<'a, T, V>,
 605 }
 606
 607 #[derive(Debug, Clone)]
 608 pub struct VariadicParameterChildren<'a, T, V> {
 609     pub call_convention: Syntax<'a, T, V>,
 610     pub type_: Syntax<'a, T, V>,
 611     pub ellipsis: Syntax<'a, T, V>,
 612 }
 613
 614 #[derive(Debug, Clone)]
 615 pub struct OldAttributeSpecificationChildren<'a, T, V> {
 616     pub left_double_angle: Syntax<'a, T, V>,
 617     pub attributes: Syntax<'a, T, V>,
 618     pub right_double_angle: Syntax<'a, T, V>,
 619 }
 620
 621 #[derive(Debug, Clone)]
 622 pub struct AttributeSpecificationChildren<'a, T, V> {
 623     pub attributes: Syntax<'a, T, V>,
 624 }
 625
 626 #[derive(Debug, Clone)]
 627 pub struct AttributeChildren<'a, T, V> {
 628     pub at: Syntax<'a, T, V>,
 629     pub attribute_name: Syntax<'a, T, V>,
 630 }
 631
 632 #[derive(Debug, Clone)]
 633 pub struct InclusionExpressionChildren<'a, T, V> {
 634     pub require: Syntax<'a, T, V>,
 635     pub filename: Syntax<'a, T, V>,
 636 }
 637
 638 #[derive(Debug, Clone)]
 639 pub struct InclusionDirectiveChildren<'a, T, V> {
 640     pub expression: Syntax<'a, T, V>,
 641     pub semicolon: Syntax<'a, T, V>,
 642 }
 643
 644 #[derive(Debug, Clone)]
 645 pub struct CompoundStatementChildren<'a, T, V> {
 646     pub left_brace: Syntax<'a, T, V>,
 647     pub statements: Syntax<'a, T, V>,
 648     pub right_brace: Syntax<'a, T, V>,
 649 }
 650
 651 #[derive(Debug, Clone)]
 652 pub struct ExpressionStatementChildren<'a, T, V> {
 653     pub expression: Syntax<'a, T, V>,
 654     pub semicolon: Syntax<'a, T, V>,
 655 }
 656
 657 #[derive(Debug, Clone)]
 658 pub struct MarkupSectionChildren<'a, T, V> {
 659     pub hashbang: Syntax<'a, T, V>,
 660     pub suffix: Syntax<'a, T, V>,
 661 }
 662
 663 #[derive(Debug, Clone)]
 664 pub struct MarkupSuffixChildren<'a, T, V> {
 665     pub less_than_question: Syntax<'a, T, V>,
 666     pub name: Syntax<'a, T, V>,
 667 }
 668
 669 #[derive(Debug, Clone)]
 670 pub struct UnsetStatementChildren<'a, T, V> {
 671     pub keyword: Syntax<'a, T, V>,
 672     pub left_paren: Syntax<'a, T, V>,
 673     pub variables: Syntax<'a, T, V>,
 674     pub right_paren: Syntax<'a, T, V>,
 675     pub semicolon: Syntax<'a, T, V>,
 676 }
 677
 678 #[derive(Debug, Clone)]
 679 pub struct UsingStatementBlockScopedChildren<'a, T, V> {
 680     pub await_keyword: Syntax<'a, T, V>,
 681     pub using_keyword: Syntax<'a, T, V>,
 682     pub left_paren: Syntax<'a, T, V>,
 683     pub expressions: Syntax<'a, T, V>,
 684     pub right_paren: Syntax<'a, T, V>,
 685     pub body: Syntax<'a, T, V>,
 686 }
 687
 688 #[derive(Debug, Clone)]
 689 pub struct UsingStatementFunctionScopedChildren<'a, T, V> {
 690     pub await_keyword: Syntax<'a, T, V>,
 691     pub using_keyword: Syntax<'a, T, V>,
 692     pub expression: Syntax<'a, T, V>,
 693     pub semicolon: Syntax<'a, T, V>,
 694 }
 695
 696 #[derive(Debug, Clone)]
 697 pub struct WhileStatementChildren<'a, T, V> {
 698     pub keyword: Syntax<'a, T, V>,
 699     pub left_paren: Syntax<'a, T, V>,
 700     pub condition: Syntax<'a, T, V>,
 701     pub right_paren: Syntax<'a, T, V>,
 702     pub body: Syntax<'a, T, V>,
 703 }
 704
 705 #[derive(Debug, Clone)]
 706 pub struct IfStatementChildren<'a, T, V> {
 707     pub keyword: Syntax<'a, T, V>,
 708     pub left_paren: Syntax<'a, T, V>,
 709     pub condition: Syntax<'a, T, V>,
 710     pub right_paren: Syntax<'a, T, V>,
 711     pub statement: Syntax<'a, T, V>,
 712     pub elseif_clauses: Syntax<'a, T, V>,
 713     pub else_clause: Syntax<'a, T, V>,
 714 }
 715
 716 #[derive(Debug, Clone)]
 717 pub struct ElseifClauseChildren<'a, T, V> {
 718     pub keyword: Syntax<'a, T, V>,
 719     pub left_paren: Syntax<'a, T, V>,
 720     pub condition: Syntax<'a, T, V>,
 721     pub right_paren: Syntax<'a, T, V>,
 722     pub statement: Syntax<'a, T, V>,
 723 }
 724
 725 #[derive(Debug, Clone)]
 726 pub struct ElseClauseChildren<'a, T, V> {
 727     pub keyword: Syntax<'a, T, V>,
 728     pub statement: Syntax<'a, T, V>,
 729 }
 730
 731 #[derive(Debug, Clone)]
 732 pub struct TryStatementChildren<'a, T, V> {
 733     pub keyword: Syntax<'a, T, V>,
 734     pub compound_statement: Syntax<'a, T, V>,
 735     pub catch_clauses: Syntax<'a, T, V>,
 736     pub finally_clause: Syntax<'a, T, V>,
 737 }
 738
 739 #[derive(Debug, Clone)]
 740 pub struct CatchClauseChildren<'a, T, V> {
 741     pub keyword: Syntax<'a, T, V>,
 742     pub left_paren: Syntax<'a, T, V>,
 743     pub type_: Syntax<'a, T, V>,
 744     pub variable: Syntax<'a, T, V>,
 745     pub right_paren: Syntax<'a, T, V>,
 746     pub body: Syntax<'a, T, V>,
 747 }
 748
 749 #[derive(Debug, Clone)]
 750 pub struct FinallyClauseChildren<'a, T, V> {
 751     pub keyword: Syntax<'a, T, V>,
 752     pub body: Syntax<'a, T, V>,
 753 }
 754
 755 #[derive(Debug, Clone)]
 756 pub struct DoStatementChildren<'a, T, V> {
 757     pub keyword: Syntax<'a, T, V>,
 758     pub body: Syntax<'a, T, V>,
 759     pub while_keyword: Syntax<'a, T, V>,
 760     pub left_paren: Syntax<'a, T, V>,
 761     pub condition: Syntax<'a, T, V>,
 762     pub right_paren: Syntax<'a, T, V>,
 763     pub semicolon: Syntax<'a, T, V>,
 764 }
 765
 766 #[derive(Debug, Clone)]
 767 pub struct ForStatementChildren<'a, T, V> {
 768     pub keyword: Syntax<'a, T, V>,
 769     pub left_paren: Syntax<'a, T, V>,
 770     pub initializer: Syntax<'a, T, V>,
 771     pub first_semicolon: Syntax<'a, T, V>,
 772     pub control: Syntax<'a, T, V>,
 773     pub second_semicolon: Syntax<'a, T, V>,
 774     pub end_of_loop: Syntax<'a, T, V>,
 775     pub right_paren: Syntax<'a, T, V>,
 776     pub body: Syntax<'a, T, V>,
 777 }
 778
 779 #[derive(Debug, Clone)]
 780 pub struct ForeachStatementChildren<'a, T, V> {
 781     pub keyword: Syntax<'a, T, V>,
 782     pub left_paren: Syntax<'a, T, V>,
 783     pub collection: Syntax<'a, T, V>,
 784     pub await_keyword: Syntax<'a, T, V>,
 785     pub as_: Syntax<'a, T, V>,
 786     pub key: Syntax<'a, T, V>,
 787     pub arrow: Syntax<'a, T, V>,
 788     pub value: Syntax<'a, T, V>,
 789     pub right_paren: Syntax<'a, T, V>,
 790     pub body: Syntax<'a, T, V>,
 791 }
 792
 793 #[derive(Debug, Clone)]
 794 pub struct SwitchStatementChildren<'a, T, V> {
 795     pub keyword: Syntax<'a, T, V>,
 796     pub left_paren: Syntax<'a, T, V>,
 797     pub expression: Syntax<'a, T, V>,
 798     pub right_paren: Syntax<'a, T, V>,
 799     pub left_brace: Syntax<'a, T, V>,
 800     pub sections: Syntax<'a, T, V>,
 801     pub right_brace: Syntax<'a, T, V>,
 802 }
 803
 804 #[derive(Debug, Clone)]
 805 pub struct SwitchSectionChildren<'a, T, V> {
 806     pub labels: Syntax<'a, T, V>,
 807     pub statements: Syntax<'a, T, V>,
 808     pub fallthrough: Syntax<'a, T, V>,
 809 }
 810
 811 #[derive(Debug, Clone)]
 812 pub struct SwitchFallthroughChildren<'a, T, V> {
 813     pub keyword: Syntax<'a, T, V>,
 814     pub semicolon: Syntax<'a, T, V>,
 815 }
 816
 817 #[derive(Debug, Clone)]
 818 pub struct CaseLabelChildren<'a, T, V> {
 819     pub keyword: Syntax<'a, T, V>,
 820     pub expression: Syntax<'a, T, V>,
 821     pub colon: Syntax<'a, T, V>,
 822 }
 823
 824 #[derive(Debug, Clone)]
 825 pub struct DefaultLabelChildren<'a, T, V> {
 826     pub keyword: Syntax<'a, T, V>,
 827     pub colon: Syntax<'a, T, V>,
 828 }
 829
 830 #[derive(Debug, Clone)]
 831 pub struct ReturnStatementChildren<'a, T, V> {
 832     pub keyword: Syntax<'a, T, V>,
 833     pub expression: Syntax<'a, T, V>,
 834     pub semicolon: Syntax<'a, T, V>,
 835 }
 836
 837 #[derive(Debug, Clone)]
 838 pub struct YieldBreakStatementChildren<'a, T, V> {
 839     pub keyword: Syntax<'a, T, V>,
 840     pub break_: Syntax<'a, T, V>,
 841     pub semicolon: Syntax<'a, T, V>,
 842 }
 843
 844 #[derive(Debug, Clone)]
 845 pub struct ThrowStatementChildren<'a, T, V> {
 846     pub keyword: Syntax<'a, T, V>,
 847     pub expression: Syntax<'a, T, V>,
 848     pub semicolon: Syntax<'a, T, V>,
 849 }
 850
 851 #[derive(Debug, Clone)]
 852 pub struct BreakStatementChildren<'a, T, V> {
 853     pub keyword: Syntax<'a, T, V>,
 854     pub semicolon: Syntax<'a, T, V>,
 855 }
 856
 857 #[derive(Debug, Clone)]
 858 pub struct ContinueStatementChildren<'a, T, V> {
 859     pub keyword: Syntax<'a, T, V>,
 860     pub semicolon: Syntax<'a, T, V>,
 861 }
 862
 863 #[derive(Debug, Clone)]
 864 pub struct EchoStatementChildren<'a, T, V> {
 865     pub keyword: Syntax<'a, T, V>,
 866     pub expressions: Syntax<'a, T, V>,
 867     pub semicolon: Syntax<'a, T, V>,
 868 }
 869
 870 #[derive(Debug, Clone)]
 871 pub struct ConcurrentStatementChildren<'a, T, V> {
 872     pub keyword: Syntax<'a, T, V>,
 873     pub statement: Syntax<'a, T, V>,
 874 }
 875
 876 #[derive(Debug, Clone)]
 877 pub struct SimpleInitializerChildren<'a, T, V> {
 878     pub equal: Syntax<'a, T, V>,
 879     pub value: Syntax<'a, T, V>,
 880 }
 881
 882 #[derive(Debug, Clone)]
 883 pub struct AnonymousClassChildren<'a, T, V> {
 884     pub class_keyword: Syntax<'a, T, V>,
 885     pub left_paren: Syntax<'a, T, V>,
 886     pub argument_list: Syntax<'a, T, V>,
 887     pub right_paren: Syntax<'a, T, V>,
 888     pub extends_keyword: Syntax<'a, T, V>,
 889     pub extends_list: Syntax<'a, T, V>,
 890     pub implements_keyword: Syntax<'a, T, V>,
 891     pub implements_list: Syntax<'a, T, V>,
 892     pub body: Syntax<'a, T, V>,
 893 }
 894
 895 #[derive(Debug, Clone)]
 896 pub struct AnonymousFunctionChildren<'a, T, V> {
 897     pub attribute_spec: Syntax<'a, T, V>,
 898     pub async_keyword: Syntax<'a, T, V>,
 899     pub function_keyword: Syntax<'a, T, V>,
 900     pub left_paren: Syntax<'a, T, V>,
 901     pub parameters: Syntax<'a, T, V>,
 902     pub right_paren: Syntax<'a, T, V>,
 903     pub ctx_list: Syntax<'a, T, V>,
 904     pub colon: Syntax<'a, T, V>,
 905     pub readonly_return: Syntax<'a, T, V>,
 906     pub type_: Syntax<'a, T, V>,
 907     pub use_: Syntax<'a, T, V>,
 908     pub body: Syntax<'a, T, V>,
 909 }
 910
 911 #[derive(Debug, Clone)]
 912 pub struct AnonymousFunctionUseClauseChildren<'a, T, V> {
 913     pub keyword: Syntax<'a, T, V>,
 914     pub left_paren: Syntax<'a, T, V>,
 915     pub variables: Syntax<'a, T, V>,
 916     pub right_paren: Syntax<'a, T, V>,
 917 }
 918
 919 #[derive(Debug, Clone)]
 920 pub struct LambdaExpressionChildren<'a, T, V> {
 921     pub attribute_spec: Syntax<'a, T, V>,
 922     pub async_: Syntax<'a, T, V>,
 923     pub signature: Syntax<'a, T, V>,
 924     pub arrow: Syntax<'a, T, V>,
 925     pub body: Syntax<'a, T, V>,
 926 }
 927
 928 #[derive(Debug, Clone)]
 929 pub struct LambdaSignatureChildren<'a, T, V> {
 930     pub left_paren: Syntax<'a, T, V>,
 931     pub parameters: Syntax<'a, T, V>,
 932     pub right_paren: Syntax<'a, T, V>,
 933     pub contexts: Syntax<'a, T, V>,
 934     pub colon: Syntax<'a, T, V>,
 935     pub readonly_return: Syntax<'a, T, V>,
 936     pub type_: Syntax<'a, T, V>,
 937 }
 938
 939 #[derive(Debug, Clone)]
 940 pub struct CastExpressionChildren<'a, T, V> {
 941     pub left_paren: Syntax<'a, T, V>,
 942     pub type_: Syntax<'a, T, V>,
 943     pub right_paren: Syntax<'a, T, V>,
 944     pub operand: Syntax<'a, T, V>,
 945 }
 946
 947 #[derive(Debug, Clone)]
 948 pub struct ScopeResolutionExpressionChildren<'a, T, V> {
 949     pub qualifier: Syntax<'a, T, V>,
 950     pub operator: Syntax<'a, T, V>,
 951     pub name: Syntax<'a, T, V>,
 952 }
 953
 954 #[derive(Debug, Clone)]
 955 pub struct MemberSelectionExpressionChildren<'a, T, V> {
 956     pub object: Syntax<'a, T, V>,
 957     pub operator: Syntax<'a, T, V>,
 958     pub name: Syntax<'a, T, V>,
 959 }
 960
 961 #[derive(Debug, Clone)]
 962 pub struct SafeMemberSelectionExpressionChildren<'a, T, V> {
 963     pub object: Syntax<'a, T, V>,
 964     pub operator: Syntax<'a, T, V>,
 965     pub name: Syntax<'a, T, V>,
 966 }
 967
 968 #[derive(Debug, Clone)]
 969 pub struct EmbeddedMemberSelectionExpressionChildren<'a, T, V> {
 970     pub object: Syntax<'a, T, V>,
 971     pub operator: Syntax<'a, T, V>,
 972     pub name: Syntax<'a, T, V>,
 973 }
 974
 975 #[derive(Debug, Clone)]
 976 pub struct YieldExpressionChildren<'a, T, V> {
 977     pub keyword: Syntax<'a, T, V>,
 978     pub operand: Syntax<'a, T, V>,
 979 }
 980
 981 #[derive(Debug, Clone)]
 982 pub struct PrefixUnaryExpressionChildren<'a, T, V> {
 983     pub operator: Syntax<'a, T, V>,
 984     pub operand: Syntax<'a, T, V>,
 985 }
 986
 987 #[derive(Debug, Clone)]
 988 pub struct PostfixUnaryExpressionChildren<'a, T, V> {
 989     pub operand: Syntax<'a, T, V>,
 990     pub operator: Syntax<'a, T, V>,
 991 }
 992
 993 #[derive(Debug, Clone)]
 994 pub struct BinaryExpressionChildren<'a, T, V> {
 995     pub left_operand: Syntax<'a, T, V>,
 996     pub operator: Syntax<'a, T, V>,
 997     pub right_operand: Syntax<'a, T, V>,
 998 }
 999
1000 #[derive(Debug, Clone)]
1001 pub struct IsExpressionChildren<'a, T, V> {
1002     pub left_operand: Syntax<'a, T, V>,
1003     pub operator: Syntax<'a, T, V>,
1004     pub right_operand: Syntax<'a, T, V>,
1005 }
1006
1007 #[derive(Debug, Clone)]
1008 pub struct AsExpressionChildren<'a, T, V> {
1009     pub left_operand: Syntax<'a, T, V>,
1010     pub operator: Syntax<'a, T, V>,
1011     pub right_operand: Syntax<'a, T, V>,
1012 }
1013
1014 #[derive(Debug, Clone)]
1015 pub struct NullableAsExpressionChildren<'a, T, V> {
1016     pub left_operand: Syntax<'a, T, V>,
1017     pub operator: Syntax<'a, T, V>,
1018     pub right_operand: Syntax<'a, T, V>,
1019 }
1020
1021 #[derive(Debug, Clone)]
1022 pub struct UpcastExpressionChildren<'a, T, V> {
1023     pub left_operand: Syntax<'a, T, V>,
1024     pub operator: Syntax<'a, T, V>,
1025     pub right_operand: Syntax<'a, T, V>,
1026 }
1027
1028 #[derive(Debug, Clone)]
1029 pub struct ConditionalExpressionChildren<'a, T, V> {
1030     pub test: Syntax<'a, T, V>,
1031     pub question: Syntax<'a, T, V>,
1032     pub consequence: Syntax<'a, T, V>,
1033     pub colon: Syntax<'a, T, V>,
1034     pub alternative: Syntax<'a, T, V>,
1035 }
1036
1037 #[derive(Debug, Clone)]
1038 pub struct EvalExpressionChildren<'a, T, V> {
1039     pub keyword: Syntax<'a, T, V>,
1040     pub left_paren: Syntax<'a, T, V>,
1041     pub argument: Syntax<'a, T, V>,
1042     pub right_paren: Syntax<'a, T, V>,
1043 }
1044
1045 #[derive(Debug, Clone)]
1046 pub struct IssetExpressionChildren<'a, T, V> {
1047     pub keyword: Syntax<'a, T, V>,
1048     pub left_paren: Syntax<'a, T, V>,
1049     pub argument_list: Syntax<'a, T, V>,
1050     pub right_paren: Syntax<'a, T, V>,
1051 }
1052
1053 #[derive(Debug, Clone)]
1054 pub struct FunctionCallExpressionChildren<'a, T, V> {
1055     pub receiver: Syntax<'a, T, V>,
1056     pub type_args: Syntax<'a, T, V>,
1057     pub enum_class_label: Syntax<'a, T, V>,
1058     pub left_paren: Syntax<'a, T, V>,
1059     pub argument_list: Syntax<'a, T, V>,
1060     pub right_paren: Syntax<'a, T, V>,
1061 }
1062
1063 #[derive(Debug, Clone)]
1064 pub struct FunctionPointerExpressionChildren<'a, T, V> {
1065     pub receiver: Syntax<'a, T, V>,
1066     pub type_args: Syntax<'a, T, V>,
1067 }
1068
1069 #[derive(Debug, Clone)]
1070 pub struct ParenthesizedExpressionChildren<'a, T, V> {
1071     pub left_paren: Syntax<'a, T, V>,
1072     pub expression: Syntax<'a, T, V>,
1073     pub right_paren: Syntax<'a, T, V>,
1074 }
1075
1076 #[derive(Debug, Clone)]
1077 pub struct BracedExpressionChildren<'a, T, V> {
1078     pub left_brace: Syntax<'a, T, V>,
1079     pub expression: Syntax<'a, T, V>,
1080     pub right_brace: Syntax<'a, T, V>,
1081 }
1082
1083 #[derive(Debug, Clone)]
1084 pub struct ETSpliceExpressionChildren<'a, T, V> {
1085     pub dollar: Syntax<'a, T, V>,
1086     pub left_brace: Syntax<'a, T, V>,
1087     pub expression: Syntax<'a, T, V>,
1088     pub right_brace: Syntax<'a, T, V>,
1089 }
1090
1091 #[derive(Debug, Clone)]
1092 pub struct EmbeddedBracedExpressionChildren<'a, T, V> {
1093     pub left_brace: Syntax<'a, T, V>,
1094     pub expression: Syntax<'a, T, V>,
1095     pub right_brace: Syntax<'a, T, V>,
1096 }
1097
1098 #[derive(Debug, Clone)]
1099 pub struct ListExpressionChildren<'a, T, V> {
1100     pub keyword: Syntax<'a, T, V>,
1101     pub left_paren: Syntax<'a, T, V>,
1102     pub members: Syntax<'a, T, V>,
1103     pub right_paren: Syntax<'a, T, V>,
1104 }
1105
1106 #[derive(Debug, Clone)]
1107 pub struct CollectionLiteralExpressionChildren<'a, T, V> {
1108     pub name: Syntax<'a, T, V>,
1109     pub left_brace: Syntax<'a, T, V>,
1110     pub initializers: Syntax<'a, T, V>,
1111     pub right_brace: Syntax<'a, T, V>,
1112 }
1113
1114 #[derive(Debug, Clone)]
1115 pub struct ObjectCreationExpressionChildren<'a, T, V> {
1116     pub new_keyword: Syntax<'a, T, V>,
1117     pub object: Syntax<'a, T, V>,
1118 }
1119
1120 #[derive(Debug, Clone)]
1121 pub struct ConstructorCallChildren<'a, T, V> {
1122     pub type_: Syntax<'a, T, V>,
1123     pub left_paren: Syntax<'a, T, V>,
1124     pub argument_list: Syntax<'a, T, V>,
1125     pub right_paren: Syntax<'a, T, V>,
1126 }
1127
1128 #[derive(Debug, Clone)]
1129 pub struct RecordCreationExpressionChildren<'a, T, V> {
1130     pub type_: Syntax<'a, T, V>,
1131     pub left_bracket: Syntax<'a, T, V>,
1132     pub members: Syntax<'a, T, V>,
1133     pub right_bracket: Syntax<'a, T, V>,
1134 }
1135
1136 #[derive(Debug, Clone)]
1137 pub struct DarrayIntrinsicExpressionChildren<'a, T, V> {
1138     pub keyword: Syntax<'a, T, V>,
1139     pub explicit_type: Syntax<'a, T, V>,
1140     pub left_bracket: Syntax<'a, T, V>,
1141     pub members: Syntax<'a, T, V>,
1142     pub right_bracket: Syntax<'a, T, V>,
1143 }
1144
1145 #[derive(Debug, Clone)]
1146 pub struct DictionaryIntrinsicExpressionChildren<'a, T, V> {
1147     pub keyword: Syntax<'a, T, V>,
1148     pub explicit_type: Syntax<'a, T, V>,
1149     pub left_bracket: Syntax<'a, T, V>,
1150     pub members: Syntax<'a, T, V>,
1151     pub right_bracket: Syntax<'a, T, V>,
1152 }
1153
1154 #[derive(Debug, Clone)]
1155 pub struct KeysetIntrinsicExpressionChildren<'a, T, V> {
1156     pub keyword: Syntax<'a, T, V>,
1157     pub explicit_type: Syntax<'a, T, V>,
1158     pub left_bracket: Syntax<'a, T, V>,
1159     pub members: Syntax<'a, T, V>,
1160     pub right_bracket: Syntax<'a, T, V>,
1161 }
1162
1163 #[derive(Debug, Clone)]
1164 pub struct VarrayIntrinsicExpressionChildren<'a, T, V> {
1165     pub keyword: Syntax<'a, T, V>,
1166     pub explicit_type: Syntax<'a, T, V>,
1167     pub left_bracket: Syntax<'a, T, V>,
1168     pub members: Syntax<'a, T, V>,
1169     pub right_bracket: Syntax<'a, T, V>,
1170 }
1171
1172 #[derive(Debug, Clone)]
1173 pub struct VectorIntrinsicExpressionChildren<'a, T, V> {
1174     pub keyword: Syntax<'a, T, V>,
1175     pub explicit_type: Syntax<'a, T, V>,
1176     pub left_bracket: Syntax<'a, T, V>,
1177     pub members: Syntax<'a, T, V>,
1178     pub right_bracket: Syntax<'a, T, V>,
1179 }
1180
1181 #[derive(Debug, Clone)]
1182 pub struct ElementInitializerChildren<'a, T, V> {
1183     pub key: Syntax<'a, T, V>,
1184     pub arrow: Syntax<'a, T, V>,
1185     pub value: Syntax<'a, T, V>,
1186 }
1187
1188 #[derive(Debug, Clone)]
1189 pub struct SubscriptExpressionChildren<'a, T, V> {
1190     pub receiver: Syntax<'a, T, V>,
1191     pub left_bracket: Syntax<'a, T, V>,
1192     pub index: Syntax<'a, T, V>,
1193     pub right_bracket: Syntax<'a, T, V>,
1194 }
1195
1196 #[derive(Debug, Clone)]
1197 pub struct EmbeddedSubscriptExpressionChildren<'a, T, V> {
1198     pub receiver: Syntax<'a, T, V>,
1199     pub left_bracket: Syntax<'a, T, V>,
1200     pub index: Syntax<'a, T, V>,
1201     pub right_bracket: Syntax<'a, T, V>,
1202 }
1203
1204 #[derive(Debug, Clone)]
1205 pub struct AwaitableCreationExpressionChildren<'a, T, V> {
1206     pub attribute_spec: Syntax<'a, T, V>,
1207     pub async_: Syntax<'a, T, V>,
1208     pub compound_statement: Syntax<'a, T, V>,
1209 }
1210
1211 #[derive(Debug, Clone)]
1212 pub struct XHPChildrenDeclarationChildren<'a, T, V> {
1213     pub keyword: Syntax<'a, T, V>,
1214     pub expression: Syntax<'a, T, V>,
1215     pub semicolon: Syntax<'a, T, V>,
1216 }
1217
1218 #[derive(Debug, Clone)]
1219 pub struct XHPChildrenParenthesizedListChildren<'a, T, V> {
1220     pub left_paren: Syntax<'a, T, V>,
1221     pub xhp_children: Syntax<'a, T, V>,
1222     pub right_paren: Syntax<'a, T, V>,
1223 }
1224
1225 #[derive(Debug, Clone)]
1226 pub struct XHPCategoryDeclarationChildren<'a, T, V> {
1227     pub keyword: Syntax<'a, T, V>,
1228     pub categories: Syntax<'a, T, V>,
1229     pub semicolon: Syntax<'a, T, V>,
1230 }
1231
1232 #[derive(Debug, Clone)]
1233 pub struct XHPEnumTypeChildren<'a, T, V> {
1234     pub keyword: Syntax<'a, T, V>,
1235     pub left_brace: Syntax<'a, T, V>,
1236     pub values: Syntax<'a, T, V>,
1237     pub right_brace: Syntax<'a, T, V>,
1238 }
1239
1240 #[derive(Debug, Clone)]
1241 pub struct XHPLateinitChildren<'a, T, V> {
1242     pub at: Syntax<'a, T, V>,
1243     pub keyword: Syntax<'a, T, V>,
1244 }
1245
1246 #[derive(Debug, Clone)]
1247 pub struct XHPRequiredChildren<'a, T, V> {
1248     pub at: Syntax<'a, T, V>,
1249     pub keyword: Syntax<'a, T, V>,
1250 }
1251
1252 #[derive(Debug, Clone)]
1253 pub struct XHPClassAttributeDeclarationChildren<'a, T, V> {
1254     pub keyword: Syntax<'a, T, V>,
1255     pub attributes: Syntax<'a, T, V>,
1256     pub semicolon: Syntax<'a, T, V>,
1257 }
1258
1259 #[derive(Debug, Clone)]
1260 pub struct XHPClassAttributeChildren<'a, T, V> {
1261     pub type_: Syntax<'a, T, V>,
1262     pub name: Syntax<'a, T, V>,
1263     pub initializer: Syntax<'a, T, V>,
1264     pub required: Syntax<'a, T, V>,
1265 }
1266
1267 #[derive(Debug, Clone)]
1268 pub struct XHPSimpleClassAttributeChildren<'a, T, V> {
1269     pub type_: Syntax<'a, T, V>,
1270 }
1271
1272 #[derive(Debug, Clone)]
1273 pub struct XHPSimpleAttributeChildren<'a, T, V> {
1274     pub name: Syntax<'a, T, V>,
1275     pub equal: Syntax<'a, T, V>,
1276     pub expression: Syntax<'a, T, V>,
1277 }
1278
1279 #[derive(Debug, Clone)]
1280 pub struct XHPSpreadAttributeChildren<'a, T, V> {
1281     pub left_brace: Syntax<'a, T, V>,
1282     pub spread_operator: Syntax<'a, T, V>,
1283     pub expression: Syntax<'a, T, V>,
1284     pub right_brace: Syntax<'a, T, V>,
1285 }
1286
1287 #[derive(Debug, Clone)]
1288 pub struct XHPOpenChildren<'a, T, V> {
1289     pub left_angle: Syntax<'a, T, V>,
1290     pub name: Syntax<'a, T, V>,
1291     pub attributes: Syntax<'a, T, V>,
1292     pub right_angle: Syntax<'a, T, V>,
1293 }
1294
1295 #[derive(Debug, Clone)]
1296 pub struct XHPExpressionChildren<'a, T, V> {
1297     pub open: Syntax<'a, T, V>,
1298     pub body: Syntax<'a, T, V>,
1299     pub close: Syntax<'a, T, V>,
1300 }
1301
1302 #[derive(Debug, Clone)]
1303 pub struct XHPCloseChildren<'a, T, V> {
1304     pub left_angle: Syntax<'a, T, V>,
1305     pub name: Syntax<'a, T, V>,
1306     pub right_angle: Syntax<'a, T, V>,
1307 }
1308
1309 #[derive(Debug, Clone)]
1310 pub struct TypeConstantChildren<'a, T, V> {
1311     pub left_type: Syntax<'a, T, V>,
1312     pub separator: Syntax<'a, T, V>,
1313     pub right_type: Syntax<'a, T, V>,
1314 }
1315
1316 #[derive(Debug, Clone)]
1317 pub struct VectorTypeSpecifierChildren<'a, T, V> {
1318     pub keyword: Syntax<'a, T, V>,
1319     pub left_angle: Syntax<'a, T, V>,
1320     pub type_: Syntax<'a, T, V>,
1321     pub trailing_comma: Syntax<'a, T, V>,
1322     pub right_angle: Syntax<'a, T, V>,
1323 }
1324
1325 #[derive(Debug, Clone)]
1326 pub struct KeysetTypeSpecifierChildren<'a, T, V> {
1327     pub keyword: Syntax<'a, T, V>,
1328     pub left_angle: Syntax<'a, T, V>,
1329     pub type_: Syntax<'a, T, V>,
1330     pub trailing_comma: Syntax<'a, T, V>,
1331     pub right_angle: Syntax<'a, T, V>,
1332 }
1333
1334 #[derive(Debug, Clone)]
1335 pub struct TupleTypeExplicitSpecifierChildren<'a, T, V> {
1336     pub keyword: Syntax<'a, T, V>,
1337     pub left_angle: Syntax<'a, T, V>,
1338     pub types: Syntax<'a, T, V>,
1339     pub right_angle: Syntax<'a, T, V>,
1340 }
1341
1342 #[derive(Debug, Clone)]
1343 pub struct VarrayTypeSpecifierChildren<'a, T, V> {
1344     pub keyword: Syntax<'a, T, V>,
1345     pub left_angle: Syntax<'a, T, V>,
1346     pub type_: Syntax<'a, T, V>,
1347     pub trailing_comma: Syntax<'a, T, V>,
1348     pub right_angle: Syntax<'a, T, V>,
1349 }
1350
1351 #[derive(Debug, Clone)]
1352 pub struct FunctionCtxTypeSpecifierChildren<'a, T, V> {
1353     pub keyword: Syntax<'a, T, V>,
1354     pub variable: Syntax<'a, T, V>,
1355 }
1356
1357 #[derive(Debug, Clone)]
1358 pub struct TypeParameterChildren<'a, T, V> {
1359     pub attribute_spec: Syntax<'a, T, V>,
1360     pub reified: Syntax<'a, T, V>,
1361     pub variance: Syntax<'a, T, V>,
1362     pub name: Syntax<'a, T, V>,
1363     pub param_params: Syntax<'a, T, V>,
1364     pub constraints: Syntax<'a, T, V>,
1365 }
1366
1367 #[derive(Debug, Clone)]
1368 pub struct TypeConstraintChildren<'a, T, V> {
1369     pub keyword: Syntax<'a, T, V>,
1370     pub type_: Syntax<'a, T, V>,
1371 }
1372
1373 #[derive(Debug, Clone)]
1374 pub struct ContextConstraintChildren<'a, T, V> {
1375     pub keyword: Syntax<'a, T, V>,
1376     pub ctx_list: Syntax<'a, T, V>,
1377 }
1378
1379 #[derive(Debug, Clone)]
1380 pub struct DarrayTypeSpecifierChildren<'a, T, V> {
1381     pub keyword: Syntax<'a, T, V>,
1382     pub left_angle: Syntax<'a, T, V>,
1383     pub key: Syntax<'a, T, V>,
1384     pub comma: Syntax<'a, T, V>,
1385     pub value: Syntax<'a, T, V>,
1386     pub trailing_comma: Syntax<'a, T, V>,
1387     pub right_angle: Syntax<'a, T, V>,
1388 }
1389
1390 #[derive(Debug, Clone)]
1391 pub struct DictionaryTypeSpecifierChildren<'a, T, V> {
1392     pub keyword: Syntax<'a, T, V>,
1393     pub left_angle: Syntax<'a, T, V>,
1394     pub members: Syntax<'a, T, V>,
1395     pub right_angle: Syntax<'a, T, V>,
1396 }
1397
1398 #[derive(Debug, Clone)]
1399 pub struct ClosureTypeSpecifierChildren<'a, T, V> {
1400     pub outer_left_paren: Syntax<'a, T, V>,
1401     pub readonly_keyword: Syntax<'a, T, V>,
1402     pub function_keyword: Syntax<'a, T, V>,
1403     pub inner_left_paren: Syntax<'a, T, V>,
1404     pub parameter_list: Syntax<'a, T, V>,
1405     pub inner_right_paren: Syntax<'a, T, V>,
1406     pub contexts: Syntax<'a, T, V>,
1407     pub colon: Syntax<'a, T, V>,
1408     pub readonly_return: Syntax<'a, T, V>,
1409     pub return_type: Syntax<'a, T, V>,
1410     pub outer_right_paren: Syntax<'a, T, V>,
1411 }
1412
1413 #[derive(Debug, Clone)]
1414 pub struct ClosureParameterTypeSpecifierChildren<'a, T, V> {
1415     pub call_convention: Syntax<'a, T, V>,
1416     pub readonly: Syntax<'a, T, V>,
1417     pub type_: Syntax<'a, T, V>,
1418 }
1419
1420 #[derive(Debug, Clone)]
1421 pub struct ClassnameTypeSpecifierChildren<'a, T, V> {
1422     pub keyword: Syntax<'a, T, V>,
1423     pub left_angle: Syntax<'a, T, V>,
1424     pub type_: Syntax<'a, T, V>,
1425     pub trailing_comma: Syntax<'a, T, V>,
1426     pub right_angle: Syntax<'a, T, V>,
1427 }
1428
1429 #[derive(Debug, Clone)]
1430 pub struct FieldSpecifierChildren<'a, T, V> {
1431     pub question: Syntax<'a, T, V>,
1432     pub name: Syntax<'a, T, V>,
1433     pub arrow: Syntax<'a, T, V>,
1434     pub type_: Syntax<'a, T, V>,
1435 }
1436
1437 #[derive(Debug, Clone)]
1438 pub struct FieldInitializerChildren<'a, T, V> {
1439     pub name: Syntax<'a, T, V>,
1440     pub arrow: Syntax<'a, T, V>,
1441     pub value: Syntax<'a, T, V>,
1442 }
1443
1444 #[derive(Debug, Clone)]
1445 pub struct ShapeTypeSpecifierChildren<'a, T, V> {
1446     pub keyword: Syntax<'a, T, V>,
1447     pub left_paren: Syntax<'a, T, V>,
1448     pub fields: Syntax<'a, T, V>,
1449     pub ellipsis: Syntax<'a, T, V>,
1450     pub right_paren: Syntax<'a, T, V>,
1451 }
1452
1453 #[derive(Debug, Clone)]
1454 pub struct ShapeExpressionChildren<'a, T, V> {
1455     pub keyword: Syntax<'a, T, V>,
1456     pub left_paren: Syntax<'a, T, V>,
1457     pub fields: Syntax<'a, T, V>,
1458     pub right_paren: Syntax<'a, T, V>,
1459 }
1460
1461 #[derive(Debug, Clone)]
1462 pub struct TupleExpressionChildren<'a, T, V> {
1463     pub keyword: Syntax<'a, T, V>,
1464     pub left_paren: Syntax<'a, T, V>,
1465     pub items: Syntax<'a, T, V>,
1466     pub right_paren: Syntax<'a, T, V>,
1467 }
1468
1469 #[derive(Debug, Clone)]
1470 pub struct GenericTypeSpecifierChildren<'a, T, V> {
1471     pub class_type: Syntax<'a, T, V>,
1472     pub argument_list: Syntax<'a, T, V>,
1473 }
1474
1475 #[derive(Debug, Clone)]
1476 pub struct NullableTypeSpecifierChildren<'a, T, V> {
1477     pub question: Syntax<'a, T, V>,
1478     pub type_: Syntax<'a, T, V>,
1479 }
1480
1481 #[derive(Debug, Clone)]
1482 pub struct LikeTypeSpecifierChildren<'a, T, V> {
1483     pub tilde: Syntax<'a, T, V>,
1484     pub type_: Syntax<'a, T, V>,
1485 }
1486
1487 #[derive(Debug, Clone)]
1488 pub struct SoftTypeSpecifierChildren<'a, T, V> {
1489     pub at: Syntax<'a, T, V>,
1490     pub type_: Syntax<'a, T, V>,
1491 }
1492
1493 #[derive(Debug, Clone)]
1494 pub struct AttributizedSpecifierChildren<'a, T, V> {
1495     pub attribute_spec: Syntax<'a, T, V>,
1496     pub type_: Syntax<'a, T, V>,
1497 }
1498
1499 #[derive(Debug, Clone)]
1500 pub struct ReifiedTypeArgumentChildren<'a, T, V> {
1501     pub reified: Syntax<'a, T, V>,
1502     pub type_: Syntax<'a, T, V>,
1503 }
1504
1505 #[derive(Debug, Clone)]
1506 pub struct TypeArgumentsChildren<'a, T, V> {
1507     pub left_angle: Syntax<'a, T, V>,
1508     pub types: Syntax<'a, T, V>,
1509     pub right_angle: Syntax<'a, T, V>,
1510 }
1511
1512 #[derive(Debug, Clone)]
1513 pub struct TypeParametersChildren<'a, T, V> {
1514     pub left_angle: Syntax<'a, T, V>,
1515     pub parameters: Syntax<'a, T, V>,
1516     pub right_angle: Syntax<'a, T, V>,
1517 }
1518
1519 #[derive(Debug, Clone)]
1520 pub struct TupleTypeSpecifierChildren<'a, T, V> {
1521     pub left_paren: Syntax<'a, T, V>,
1522     pub types: Syntax<'a, T, V>,
1523     pub right_paren: Syntax<'a, T, V>,
1524 }
1525
1526 #[derive(Debug, Clone)]
1527 pub struct UnionTypeSpecifierChildren<'a, T, V> {
1528     pub left_paren: Syntax<'a, T, V>,
1529     pub types: Syntax<'a, T, V>,
1530     pub right_paren: Syntax<'a, T, V>,
1531 }
1532
1533 #[derive(Debug, Clone)]
1534 pub struct IntersectionTypeSpecifierChildren<'a, T, V> {
1535     pub left_paren: Syntax<'a, T, V>,
1536     pub types: Syntax<'a, T, V>,
1537     pub right_paren: Syntax<'a, T, V>,
1538 }
1539
1540 #[derive(Debug, Clone)]
1541 pub struct ErrorSyntaxChildren<'a, T, V> {
1542     pub error: Syntax<'a, T, V>,
1543 }
1544
1545 #[derive(Debug, Clone)]
1546 pub struct ListItemChildren<'a, T, V> {
1547     pub item: Syntax<'a, T, V>,
1548     pub separator: Syntax<'a, T, V>,
1549 }
1550
1551 #[derive(Debug, Clone)]
1552 pub struct EnumClassLabelExpressionChildren<'a, T, V> {
1553     pub qualifier: Syntax<'a, T, V>,
1554     pub hash: Syntax<'a, T, V>,
1555     pub expression: Syntax<'a, T, V>,
1556 }
1557
1558
1559
1560 impl<'a, T, V> SyntaxVariant<'a, T, V> {
1561     pub fn iter_children(&'a self) -> SyntaxChildrenIterator<'a, T, V> {
1562         SyntaxChildrenIterator {
1563             syntax: &self,
1564             index: 0,
1565             index_back: 0,
1566         }
1567     }
1568 }