| blob | 9df6d7ef66231e7e3d5cc915664a89ed9b30d038 |
1 /**
2 * Copyright (c) 2016, Facebook, Inc.
3 * All rights reserved.
4 *
5 * This source code is licensed under the MIT license found in the
6 * LICENSE file in the "hack" directory of this source tree. An additional
7 * directory.
8 *
9 **
10 *
11 * THIS FILE IS @generated; DO NOT EDIT IT
12 * To regenerate this file, run
13 *
14 * buck run //hphp/hack/src:generate_full_fidelity
15 *
16 **
17 *
18 */
19 use crate::lexable_token::LexableToken;
20 use crate::syntax::*;
21 use crate::syntax_kind::SyntaxKind;
23 impl<T, V> Syntax<T, V>
24 where
25 T: LexableToken,
26 V: SyntaxValueType<T>,
27 {
28 pub fn make_end_of_file(end_of_file_token: Self) -> Self {
29 let syntax = SyntaxVariant::EndOfFile(Box::new(EndOfFileChildren {
30 end_of_file_token,
31 }));
32 let value = V::from_syntax(&syntax);
33 Self::make(syntax, value)
34 }
36 pub fn make_script(script_declarations: Self) -> Self {
37 let syntax = SyntaxVariant::Script(Box::new(ScriptChildren {
38 script_declarations,
39 }));
40 let value = V::from_syntax(&syntax);
41 Self::make(syntax, value)
42 }
44 pub fn make_qualified_name(qualified_name_parts: Self) -> Self {
45 let syntax = SyntaxVariant::QualifiedName(Box::new(QualifiedNameChildren {
46 qualified_name_parts,
47 }));
48 let value = V::from_syntax(&syntax);
49 Self::make(syntax, value)
50 }
52 pub fn make_simple_type_specifier(simple_type_specifier: Self) -> Self {
53 let syntax = SyntaxVariant::SimpleTypeSpecifier(Box::new(SimpleTypeSpecifierChildren {
54 simple_type_specifier,
55 }));
56 let value = V::from_syntax(&syntax);
57 Self::make(syntax, value)
58 }
60 pub fn make_literal_expression(literal_expression: Self) -> Self {
61 let syntax = SyntaxVariant::LiteralExpression(Box::new(LiteralExpressionChildren {
62 literal_expression,
63 }));
64 let value = V::from_syntax(&syntax);
65 Self::make(syntax, value)
66 }
68 pub fn make_prefixed_string_expression(prefixed_string_name: Self, prefixed_string_str: Self) -> Self {
69 let syntax = SyntaxVariant::PrefixedStringExpression(Box::new(PrefixedStringExpressionChildren {
70 prefixed_string_name,
71 prefixed_string_str,
72 }));
73 let value = V::from_syntax(&syntax);
74 Self::make(syntax, value)
75 }
77 pub fn make_variable_expression(variable_expression: Self) -> Self {
78 let syntax = SyntaxVariant::VariableExpression(Box::new(VariableExpressionChildren {
79 variable_expression,
80 }));
81 let value = V::from_syntax(&syntax);
82 Self::make(syntax, value)
83 }
85 pub fn make_pipe_variable_expression(pipe_variable_expression: Self) -> Self {
86 let syntax = SyntaxVariant::PipeVariableExpression(Box::new(PipeVariableExpressionChildren {
87 pipe_variable_expression,
88 }));
89 let value = V::from_syntax(&syntax);
90 Self::make(syntax, value)
91 }
93 pub fn make_file_attribute_specification(file_attribute_specification_left_double_angle: Self, file_attribute_specification_keyword: Self, file_attribute_specification_colon: Self, file_attribute_specification_attributes: Self, file_attribute_specification_right_double_angle: Self) -> Self {
94 let syntax = SyntaxVariant::FileAttributeSpecification(Box::new(FileAttributeSpecificationChildren {
95 file_attribute_specification_left_double_angle,
96 file_attribute_specification_keyword,
97 file_attribute_specification_colon,
98 file_attribute_specification_attributes,
99 file_attribute_specification_right_double_angle,
100 }));
101 let value = V::from_syntax(&syntax);
102 Self::make(syntax, value)
103 }
105 pub fn make_enum_declaration(enum_attribute_spec: Self, enum_keyword: Self, enum_name: Self, enum_colon: Self, enum_base: Self, enum_type: Self, enum_left_brace: Self, enum_enumerators: Self, enum_right_brace: Self) -> Self {
106 let syntax = SyntaxVariant::EnumDeclaration(Box::new(EnumDeclarationChildren {
107 enum_attribute_spec,
108 enum_keyword,
109 enum_name,
110 enum_colon,
111 enum_base,
112 enum_type,
113 enum_left_brace,
114 enum_enumerators,
115 enum_right_brace,
116 }));
117 let value = V::from_syntax(&syntax);
118 Self::make(syntax, value)
119 }
121 pub fn make_enumerator(enumerator_name: Self, enumerator_equal: Self, enumerator_value: Self, enumerator_semicolon: Self) -> Self {
122 let syntax = SyntaxVariant::Enumerator(Box::new(EnumeratorChildren {
123 enumerator_name,
124 enumerator_equal,
125 enumerator_value,
126 enumerator_semicolon,
127 }));
128 let value = V::from_syntax(&syntax);
129 Self::make(syntax, value)
130 }
132 pub fn make_alias_declaration(alias_attribute_spec: Self, alias_keyword: Self, alias_name: Self, alias_generic_parameter: Self, alias_constraint: Self, alias_equal: Self, alias_type: Self, alias_semicolon: Self) -> Self {
133 let syntax = SyntaxVariant::AliasDeclaration(Box::new(AliasDeclarationChildren {
134 alias_attribute_spec,
135 alias_keyword,
136 alias_name,
137 alias_generic_parameter,
138 alias_constraint,
139 alias_equal,
140 alias_type,
141 alias_semicolon,
142 }));
143 let value = V::from_syntax(&syntax);
144 Self::make(syntax, value)
145 }
147 pub fn make_property_declaration(property_attribute_spec: Self, property_modifiers: Self, property_type: Self, property_declarators: Self, property_semicolon: Self) -> Self {
148 let syntax = SyntaxVariant::PropertyDeclaration(Box::new(PropertyDeclarationChildren {
149 property_attribute_spec,
150 property_modifiers,
151 property_type,
152 property_declarators,
153 property_semicolon,
154 }));
155 let value = V::from_syntax(&syntax);
156 Self::make(syntax, value)
157 }
159 pub fn make_property_declarator(property_name: Self, property_initializer: Self) -> Self {
160 let syntax = SyntaxVariant::PropertyDeclarator(Box::new(PropertyDeclaratorChildren {
161 property_name,
162 property_initializer,
163 }));
164 let value = V::from_syntax(&syntax);
165 Self::make(syntax, value)
166 }
168 pub fn make_namespace_declaration(namespace_keyword: Self, namespace_name: Self, namespace_body: Self) -> Self {
169 let syntax = SyntaxVariant::NamespaceDeclaration(Box::new(NamespaceDeclarationChildren {
170 namespace_keyword,
171 namespace_name,
172 namespace_body,
173 }));
174 let value = V::from_syntax(&syntax);
175 Self::make(syntax, value)
176 }
178 pub fn make_namespace_body(namespace_left_brace: Self, namespace_declarations: Self, namespace_right_brace: Self) -> Self {
179 let syntax = SyntaxVariant::NamespaceBody(Box::new(NamespaceBodyChildren {
180 namespace_left_brace,
181 namespace_declarations,
182 namespace_right_brace,
183 }));
184 let value = V::from_syntax(&syntax);
185 Self::make(syntax, value)
186 }
188 pub fn make_namespace_empty_body(namespace_semicolon: Self) -> Self {
189 let syntax = SyntaxVariant::NamespaceEmptyBody(Box::new(NamespaceEmptyBodyChildren {
190 namespace_semicolon,
191 }));
192 let value = V::from_syntax(&syntax);
193 Self::make(syntax, value)
194 }
196 pub fn make_namespace_use_declaration(namespace_use_keyword: Self, namespace_use_kind: Self, namespace_use_clauses: Self, namespace_use_semicolon: Self) -> Self {
197 let syntax = SyntaxVariant::NamespaceUseDeclaration(Box::new(NamespaceUseDeclarationChildren {
198 namespace_use_keyword,
199 namespace_use_kind,
200 namespace_use_clauses,
201 namespace_use_semicolon,
202 }));
203 let value = V::from_syntax(&syntax);
204 Self::make(syntax, value)
205 }
207 pub fn make_namespace_group_use_declaration(namespace_group_use_keyword: Self, namespace_group_use_kind: Self, namespace_group_use_prefix: Self, namespace_group_use_left_brace: Self, namespace_group_use_clauses: Self, namespace_group_use_right_brace: Self, namespace_group_use_semicolon: Self) -> Self {
208 let syntax = SyntaxVariant::NamespaceGroupUseDeclaration(Box::new(NamespaceGroupUseDeclarationChildren {
209 namespace_group_use_keyword,
210 namespace_group_use_kind,
211 namespace_group_use_prefix,
212 namespace_group_use_left_brace,
213 namespace_group_use_clauses,
214 namespace_group_use_right_brace,
215 namespace_group_use_semicolon,
216 }));
217 let value = V::from_syntax(&syntax);
218 Self::make(syntax, value)
219 }
221 pub fn make_namespace_use_clause(namespace_use_clause_kind: Self, namespace_use_name: Self, namespace_use_as: Self, namespace_use_alias: Self) -> Self {
222 let syntax = SyntaxVariant::NamespaceUseClause(Box::new(NamespaceUseClauseChildren {
223 namespace_use_clause_kind,
224 namespace_use_name,
225 namespace_use_as,
226 namespace_use_alias,
227 }));
228 let value = V::from_syntax(&syntax);
229 Self::make(syntax, value)
230 }
232 pub fn make_function_declaration(function_attribute_spec: Self, function_declaration_header: Self, function_body: Self) -> Self {
233 let syntax = SyntaxVariant::FunctionDeclaration(Box::new(FunctionDeclarationChildren {
234 function_attribute_spec,
235 function_declaration_header,
236 function_body,
237 }));
238 let value = V::from_syntax(&syntax);
239 Self::make(syntax, value)
240 }
242 pub fn make_function_declaration_header(function_modifiers: Self, function_keyword: Self, function_name: Self, function_type_parameter_list: Self, function_left_paren: Self, function_parameter_list: Self, function_right_paren: Self, function_colon: Self, function_type: Self, function_where_clause: Self) -> Self {
243 let syntax = SyntaxVariant::FunctionDeclarationHeader(Box::new(FunctionDeclarationHeaderChildren {
244 function_modifiers,
245 function_keyword,
246 function_name,
247 function_type_parameter_list,
248 function_left_paren,
249 function_parameter_list,
250 function_right_paren,
251 function_colon,
252 function_type,
253 function_where_clause,
254 }));
255 let value = V::from_syntax(&syntax);
256 Self::make(syntax, value)
257 }
259 pub fn make_where_clause(where_clause_keyword: Self, where_clause_constraints: Self) -> Self {
260 let syntax = SyntaxVariant::WhereClause(Box::new(WhereClauseChildren {
261 where_clause_keyword,
262 where_clause_constraints,
263 }));
264 let value = V::from_syntax(&syntax);
265 Self::make(syntax, value)
266 }
268 pub fn make_where_constraint(where_constraint_left_type: Self, where_constraint_operator: Self, where_constraint_right_type: Self) -> Self {
269 let syntax = SyntaxVariant::WhereConstraint(Box::new(WhereConstraintChildren {
270 where_constraint_left_type,
271 where_constraint_operator,
272 where_constraint_right_type,
273 }));
274 let value = V::from_syntax(&syntax);
275 Self::make(syntax, value)
276 }
278 pub fn make_methodish_declaration(methodish_attribute: Self, methodish_function_decl_header: Self, methodish_function_body: Self, methodish_semicolon: Self) -> Self {
279 let syntax = SyntaxVariant::MethodishDeclaration(Box::new(MethodishDeclarationChildren {
280 methodish_attribute,
281 methodish_function_decl_header,
282 methodish_function_body,
283 methodish_semicolon,
284 }));
285 let value = V::from_syntax(&syntax);
286 Self::make(syntax, value)
287 }
289 pub fn make_methodish_trait_resolution(methodish_trait_attribute: Self, methodish_trait_function_decl_header: Self, methodish_trait_equal: Self, methodish_trait_name: Self, methodish_trait_semicolon: Self) -> Self {
290 let syntax = SyntaxVariant::MethodishTraitResolution(Box::new(MethodishTraitResolutionChildren {
291 methodish_trait_attribute,
292 methodish_trait_function_decl_header,
293 methodish_trait_equal,
294 methodish_trait_name,
295 methodish_trait_semicolon,
296 }));
297 let value = V::from_syntax(&syntax);
298 Self::make(syntax, value)
299 }
301 pub fn make_classish_declaration(classish_attribute: Self, classish_modifiers: Self, classish_keyword: Self, classish_name: Self, classish_type_parameters: Self, classish_extends_keyword: Self, classish_extends_list: Self, classish_implements_keyword: Self, classish_implements_list: Self, classish_body: Self) -> Self {
302 let syntax = SyntaxVariant::ClassishDeclaration(Box::new(ClassishDeclarationChildren {
303 classish_attribute,
304 classish_modifiers,
305 classish_keyword,
306 classish_name,
307 classish_type_parameters,
308 classish_extends_keyword,
309 classish_extends_list,
310 classish_implements_keyword,
311 classish_implements_list,
312 classish_body,
313 }));
314 let value = V::from_syntax(&syntax);
315 Self::make(syntax, value)
316 }
318 pub fn make_classish_body(classish_body_left_brace: Self, classish_body_elements: Self, classish_body_right_brace: Self) -> Self {
319 let syntax = SyntaxVariant::ClassishBody(Box::new(ClassishBodyChildren {
320 classish_body_left_brace,
321 classish_body_elements,
322 classish_body_right_brace,
323 }));
324 let value = V::from_syntax(&syntax);
325 Self::make(syntax, value)
326 }
328 pub fn make_trait_use_precedence_item(trait_use_precedence_item_name: Self, trait_use_precedence_item_keyword: Self, trait_use_precedence_item_removed_names: Self) -> Self {
329 let syntax = SyntaxVariant::TraitUsePrecedenceItem(Box::new(TraitUsePrecedenceItemChildren {
330 trait_use_precedence_item_name,
331 trait_use_precedence_item_keyword,
332 trait_use_precedence_item_removed_names,
333 }));
334 let value = V::from_syntax(&syntax);
335 Self::make(syntax, value)
336 }
338 pub fn make_trait_use_alias_item(trait_use_alias_item_aliasing_name: Self, trait_use_alias_item_keyword: Self, trait_use_alias_item_modifiers: Self, trait_use_alias_item_aliased_name: Self) -> Self {
339 let syntax = SyntaxVariant::TraitUseAliasItem(Box::new(TraitUseAliasItemChildren {
340 trait_use_alias_item_aliasing_name,
341 trait_use_alias_item_keyword,
342 trait_use_alias_item_modifiers,
343 trait_use_alias_item_aliased_name,
344 }));
345 let value = V::from_syntax(&syntax);
346 Self::make(syntax, value)
347 }
349 pub fn make_trait_use_conflict_resolution(trait_use_conflict_resolution_keyword: Self, trait_use_conflict_resolution_names: Self, trait_use_conflict_resolution_left_brace: Self, trait_use_conflict_resolution_clauses: Self, trait_use_conflict_resolution_right_brace: Self) -> Self {
350 let syntax = SyntaxVariant::TraitUseConflictResolution(Box::new(TraitUseConflictResolutionChildren {
351 trait_use_conflict_resolution_keyword,
352 trait_use_conflict_resolution_names,
353 trait_use_conflict_resolution_left_brace,
354 trait_use_conflict_resolution_clauses,
355 trait_use_conflict_resolution_right_brace,
356 }));
357 let value = V::from_syntax(&syntax);
358 Self::make(syntax, value)
359 }
361 pub fn make_trait_use(trait_use_keyword: Self, trait_use_names: Self, trait_use_semicolon: Self) -> Self {
362 let syntax = SyntaxVariant::TraitUse(Box::new(TraitUseChildren {
363 trait_use_keyword,
364 trait_use_names,
365 trait_use_semicolon,
366 }));
367 let value = V::from_syntax(&syntax);
368 Self::make(syntax, value)
369 }
371 pub fn make_require_clause(require_keyword: Self, require_kind: Self, require_name: Self, require_semicolon: Self) -> Self {
372 let syntax = SyntaxVariant::RequireClause(Box::new(RequireClauseChildren {
373 require_keyword,
374 require_kind,
375 require_name,
376 require_semicolon,
377 }));
378 let value = V::from_syntax(&syntax);
379 Self::make(syntax, value)
380 }
382 pub fn make_const_declaration(const_visibility: Self, const_abstract: Self, const_keyword: Self, const_type_specifier: Self, const_declarators: Self, const_semicolon: Self) -> Self {
383 let syntax = SyntaxVariant::ConstDeclaration(Box::new(ConstDeclarationChildren {
384 const_visibility,
385 const_abstract,
386 const_keyword,
387 const_type_specifier,
388 const_declarators,
389 const_semicolon,
390 }));
391 let value = V::from_syntax(&syntax);
392 Self::make(syntax, value)
393 }
395 pub fn make_constant_declarator(constant_declarator_name: Self, constant_declarator_initializer: Self) -> Self {
396 let syntax = SyntaxVariant::ConstantDeclarator(Box::new(ConstantDeclaratorChildren {
397 constant_declarator_name,
398 constant_declarator_initializer,
399 }));
400 let value = V::from_syntax(&syntax);
401 Self::make(syntax, value)
402 }
404 pub fn make_type_const_declaration(type_const_attribute_spec: Self, type_const_abstract: Self, type_const_keyword: Self, type_const_type_keyword: Self, type_const_name: Self, type_const_type_parameters: Self, type_const_type_constraint: Self, type_const_equal: Self, type_const_type_specifier: Self, type_const_semicolon: Self) -> Self {
405 let syntax = SyntaxVariant::TypeConstDeclaration(Box::new(TypeConstDeclarationChildren {
406 type_const_attribute_spec,
407 type_const_abstract,
408 type_const_keyword,
409 type_const_type_keyword,
410 type_const_name,
411 type_const_type_parameters,
412 type_const_type_constraint,
413 type_const_equal,
414 type_const_type_specifier,
415 type_const_semicolon,
416 }));
417 let value = V::from_syntax(&syntax);
418 Self::make(syntax, value)
419 }
421 pub fn make_decorated_expression(decorated_expression_decorator: Self, decorated_expression_expression: Self) -> Self {
422 let syntax = SyntaxVariant::DecoratedExpression(Box::new(DecoratedExpressionChildren {
423 decorated_expression_decorator,
424 decorated_expression_expression,
425 }));
426 let value = V::from_syntax(&syntax);
427 Self::make(syntax, value)
428 }
430 pub fn make_parameter_declaration(parameter_attribute: Self, parameter_visibility: Self, parameter_call_convention: Self, parameter_type: Self, parameter_name: Self, parameter_default_value: Self) -> Self {
431 let syntax = SyntaxVariant::ParameterDeclaration(Box::new(ParameterDeclarationChildren {
432 parameter_attribute,
433 parameter_visibility,
434 parameter_call_convention,
435 parameter_type,
436 parameter_name,
437 parameter_default_value,
438 }));
439 let value = V::from_syntax(&syntax);
440 Self::make(syntax, value)
441 }
443 pub fn make_variadic_parameter(variadic_parameter_call_convention: Self, variadic_parameter_type: Self, variadic_parameter_ellipsis: Self) -> Self {
444 let syntax = SyntaxVariant::VariadicParameter(Box::new(VariadicParameterChildren {
445 variadic_parameter_call_convention,
446 variadic_parameter_type,
447 variadic_parameter_ellipsis,
448 }));
449 let value = V::from_syntax(&syntax);
450 Self::make(syntax, value)
451 }
453 pub fn make_attribute_specification(attribute_specification_left_double_angle: Self, attribute_specification_attributes: Self, attribute_specification_right_double_angle: Self) -> Self {
454 let syntax = SyntaxVariant::AttributeSpecification(Box::new(AttributeSpecificationChildren {
455 attribute_specification_left_double_angle,
456 attribute_specification_attributes,
457 attribute_specification_right_double_angle,
458 }));
459 let value = V::from_syntax(&syntax);
460 Self::make(syntax, value)
461 }
463 pub fn make_inclusion_expression(inclusion_require: Self, inclusion_filename: Self) -> Self {
464 let syntax = SyntaxVariant::InclusionExpression(Box::new(InclusionExpressionChildren {
465 inclusion_require,
466 inclusion_filename,
467 }));
468 let value = V::from_syntax(&syntax);
469 Self::make(syntax, value)
470 }
472 pub fn make_inclusion_directive(inclusion_expression: Self, inclusion_semicolon: Self) -> Self {
473 let syntax = SyntaxVariant::InclusionDirective(Box::new(InclusionDirectiveChildren {
474 inclusion_expression,
475 inclusion_semicolon,
476 }));
477 let value = V::from_syntax(&syntax);
478 Self::make(syntax, value)
479 }
481 pub fn make_compound_statement(compound_left_brace: Self, compound_statements: Self, compound_right_brace: Self) -> Self {
482 let syntax = SyntaxVariant::CompoundStatement(Box::new(CompoundStatementChildren {
483 compound_left_brace,
484 compound_statements,
485 compound_right_brace,
486 }));
487 let value = V::from_syntax(&syntax);
488 Self::make(syntax, value)
489 }
491 pub fn make_alternate_loop_statement(alternate_loop_opening_colon: Self, alternate_loop_statements: Self, alternate_loop_closing_keyword: Self, alternate_loop_closing_semicolon: Self) -> Self {
492 let syntax = SyntaxVariant::AlternateLoopStatement(Box::new(AlternateLoopStatementChildren {
493 alternate_loop_opening_colon,
494 alternate_loop_statements,
495 alternate_loop_closing_keyword,
496 alternate_loop_closing_semicolon,
497 }));
498 let value = V::from_syntax(&syntax);
499 Self::make(syntax, value)
500 }
502 pub fn make_expression_statement(expression_statement_expression: Self, expression_statement_semicolon: Self) -> Self {
503 let syntax = SyntaxVariant::ExpressionStatement(Box::new(ExpressionStatementChildren {
504 expression_statement_expression,
505 expression_statement_semicolon,
506 }));
507 let value = V::from_syntax(&syntax);
508 Self::make(syntax, value)
509 }
511 pub fn make_markup_section(markup_prefix: Self, markup_text: Self, markup_suffix: Self, markup_expression: Self) -> Self {
512 let syntax = SyntaxVariant::MarkupSection(Box::new(MarkupSectionChildren {
513 markup_prefix,
514 markup_text,
515 markup_suffix,
516 markup_expression,
517 }));
518 let value = V::from_syntax(&syntax);
519 Self::make(syntax, value)
520 }
522 pub fn make_markup_suffix(markup_suffix_less_than_question: Self, markup_suffix_name: Self) -> Self {
523 let syntax = SyntaxVariant::MarkupSuffix(Box::new(MarkupSuffixChildren {
524 markup_suffix_less_than_question,
525 markup_suffix_name,
526 }));
527 let value = V::from_syntax(&syntax);
528 Self::make(syntax, value)
529 }
531 pub fn make_unset_statement(unset_keyword: Self, unset_left_paren: Self, unset_variables: Self, unset_right_paren: Self, unset_semicolon: Self) -> Self {
532 let syntax = SyntaxVariant::UnsetStatement(Box::new(UnsetStatementChildren {
533 unset_keyword,
534 unset_left_paren,
535 unset_variables,
536 unset_right_paren,
537 unset_semicolon,
538 }));
539 let value = V::from_syntax(&syntax);
540 Self::make(syntax, value)
541 }
543 pub fn make_let_statement(let_statement_keyword: Self, let_statement_name: Self, let_statement_colon: Self, let_statement_type: Self, let_statement_initializer: Self, let_statement_semicolon: Self) -> Self {
544 let syntax = SyntaxVariant::LetStatement(Box::new(LetStatementChildren {
545 let_statement_keyword,
546 let_statement_name,
547 let_statement_colon,
548 let_statement_type,
549 let_statement_initializer,
550 let_statement_semicolon,
551 }));
552 let value = V::from_syntax(&syntax);
553 Self::make(syntax, value)
554 }
556 pub fn make_using_statement_block_scoped(using_block_await_keyword: Self, using_block_using_keyword: Self, using_block_left_paren: Self, using_block_expressions: Self, using_block_right_paren: Self, using_block_body: Self) -> Self {
557 let syntax = SyntaxVariant::UsingStatementBlockScoped(Box::new(UsingStatementBlockScopedChildren {
558 using_block_await_keyword,
559 using_block_using_keyword,
560 using_block_left_paren,
561 using_block_expressions,
562 using_block_right_paren,
563 using_block_body,
564 }));
565 let value = V::from_syntax(&syntax);
566 Self::make(syntax, value)
567 }
569 pub fn make_using_statement_function_scoped(using_function_await_keyword: Self, using_function_using_keyword: Self, using_function_expression: Self, using_function_semicolon: Self) -> Self {
570 let syntax = SyntaxVariant::UsingStatementFunctionScoped(Box::new(UsingStatementFunctionScopedChildren {
571 using_function_await_keyword,
572 using_function_using_keyword,
573 using_function_expression,
574 using_function_semicolon,
575 }));
576 let value = V::from_syntax(&syntax);
577 Self::make(syntax, value)
578 }
580 pub fn make_declare_directive_statement(declare_directive_keyword: Self, declare_directive_left_paren: Self, declare_directive_expression: Self, declare_directive_right_paren: Self, declare_directive_semicolon: Self) -> Self {
581 let syntax = SyntaxVariant::DeclareDirectiveStatement(Box::new(DeclareDirectiveStatementChildren {
582 declare_directive_keyword,
583 declare_directive_left_paren,
584 declare_directive_expression,
585 declare_directive_right_paren,
586 declare_directive_semicolon,
587 }));
588 let value = V::from_syntax(&syntax);
589 Self::make(syntax, value)
590 }
592 pub fn make_declare_block_statement(declare_block_keyword: Self, declare_block_left_paren: Self, declare_block_expression: Self, declare_block_right_paren: Self, declare_block_body: Self) -> Self {
593 let syntax = SyntaxVariant::DeclareBlockStatement(Box::new(DeclareBlockStatementChildren {
594 declare_block_keyword,
595 declare_block_left_paren,
596 declare_block_expression,
597 declare_block_right_paren,
598 declare_block_body,
599 }));
600 let value = V::from_syntax(&syntax);
601 Self::make(syntax, value)
602 }
604 pub fn make_while_statement(while_keyword: Self, while_left_paren: Self, while_condition: Self, while_right_paren: Self, while_body: Self) -> Self {
605 let syntax = SyntaxVariant::WhileStatement(Box::new(WhileStatementChildren {
606 while_keyword,
607 while_left_paren,
608 while_condition,
609 while_right_paren,
610 while_body,
611 }));
612 let value = V::from_syntax(&syntax);
613 Self::make(syntax, value)
614 }
616 pub fn make_if_statement(if_keyword: Self, if_left_paren: Self, if_condition: Self, if_right_paren: Self, if_statement: Self, if_elseif_clauses: Self, if_else_clause: Self) -> Self {
617 let syntax = SyntaxVariant::IfStatement(Box::new(IfStatementChildren {
618 if_keyword,
619 if_left_paren,
620 if_condition,
621 if_right_paren,
622 if_statement,
623 if_elseif_clauses,
624 if_else_clause,
625 }));
626 let value = V::from_syntax(&syntax);
627 Self::make(syntax, value)
628 }
630 pub fn make_elseif_clause(elseif_keyword: Self, elseif_left_paren: Self, elseif_condition: Self, elseif_right_paren: Self, elseif_statement: Self) -> Self {
631 let syntax = SyntaxVariant::ElseifClause(Box::new(ElseifClauseChildren {
632 elseif_keyword,
633 elseif_left_paren,
634 elseif_condition,
635 elseif_right_paren,
636 elseif_statement,
637 }));
638 let value = V::from_syntax(&syntax);
639 Self::make(syntax, value)
640 }
642 pub fn make_else_clause(else_keyword: Self, else_statement: Self) -> Self {
643 let syntax = SyntaxVariant::ElseClause(Box::new(ElseClauseChildren {
644 else_keyword,
645 else_statement,
646 }));
647 let value = V::from_syntax(&syntax);
648 Self::make(syntax, value)
649 }
651 pub fn make_alternate_if_statement(alternate_if_keyword: Self, alternate_if_left_paren: Self, alternate_if_condition: Self, alternate_if_right_paren: Self, alternate_if_colon: Self, alternate_if_statement: Self, alternate_if_elseif_clauses: Self, alternate_if_else_clause: Self, alternate_if_endif_keyword: Self, alternate_if_semicolon: Self) -> Self {
652 let syntax = SyntaxVariant::AlternateIfStatement(Box::new(AlternateIfStatementChildren {
653 alternate_if_keyword,
654 alternate_if_left_paren,
655 alternate_if_condition,
656 alternate_if_right_paren,
657 alternate_if_colon,
658 alternate_if_statement,
659 alternate_if_elseif_clauses,
660 alternate_if_else_clause,
661 alternate_if_endif_keyword,
662 alternate_if_semicolon,
663 }));
664 let value = V::from_syntax(&syntax);
665 Self::make(syntax, value)
666 }
668 pub fn make_alternate_elseif_clause(alternate_elseif_keyword: Self, alternate_elseif_left_paren: Self, alternate_elseif_condition: Self, alternate_elseif_right_paren: Self, alternate_elseif_colon: Self, alternate_elseif_statement: Self) -> Self {
669 let syntax = SyntaxVariant::AlternateElseifClause(Box::new(AlternateElseifClauseChildren {
670 alternate_elseif_keyword,
671 alternate_elseif_left_paren,
672 alternate_elseif_condition,
673 alternate_elseif_right_paren,
674 alternate_elseif_colon,
675 alternate_elseif_statement,
676 }));
677 let value = V::from_syntax(&syntax);
678 Self::make(syntax, value)
679 }
681 pub fn make_alternate_else_clause(alternate_else_keyword: Self, alternate_else_colon: Self, alternate_else_statement: Self) -> Self {
682 let syntax = SyntaxVariant::AlternateElseClause(Box::new(AlternateElseClauseChildren {
683 alternate_else_keyword,
684 alternate_else_colon,
685 alternate_else_statement,
686 }));
687 let value = V::from_syntax(&syntax);
688 Self::make(syntax, value)
689 }
691 pub fn make_try_statement(try_keyword: Self, try_compound_statement: Self, try_catch_clauses: Self, try_finally_clause: Self) -> Self {
692 let syntax = SyntaxVariant::TryStatement(Box::new(TryStatementChildren {
693 try_keyword,
694 try_compound_statement,
695 try_catch_clauses,
696 try_finally_clause,
697 }));
698 let value = V::from_syntax(&syntax);
699 Self::make(syntax, value)
700 }
702 pub fn make_catch_clause(catch_keyword: Self, catch_left_paren: Self, catch_type: Self, catch_variable: Self, catch_right_paren: Self, catch_body: Self) -> Self {
703 let syntax = SyntaxVariant::CatchClause(Box::new(CatchClauseChildren {
704 catch_keyword,
705 catch_left_paren,
706 catch_type,
707 catch_variable,
708 catch_right_paren,
709 catch_body,
710 }));
711 let value = V::from_syntax(&syntax);
712 Self::make(syntax, value)
713 }
715 pub fn make_finally_clause(finally_keyword: Self, finally_body: Self) -> Self {
716 let syntax = SyntaxVariant::FinallyClause(Box::new(FinallyClauseChildren {
717 finally_keyword,
718 finally_body,
719 }));
720 let value = V::from_syntax(&syntax);
721 Self::make(syntax, value)
722 }
724 pub fn make_do_statement(do_keyword: Self, do_body: Self, do_while_keyword: Self, do_left_paren: Self, do_condition: Self, do_right_paren: Self, do_semicolon: Self) -> Self {
725 let syntax = SyntaxVariant::DoStatement(Box::new(DoStatementChildren {
726 do_keyword,
727 do_body,
728 do_while_keyword,
729 do_left_paren,
730 do_condition,
731 do_right_paren,
732 do_semicolon,
733 }));
734 let value = V::from_syntax(&syntax);
735 Self::make(syntax, value)
736 }
738 pub fn make_for_statement(for_keyword: Self, for_left_paren: Self, for_initializer: Self, for_first_semicolon: Self, for_control: Self, for_second_semicolon: Self, for_end_of_loop: Self, for_right_paren: Self, for_body: Self) -> Self {
739 let syntax = SyntaxVariant::ForStatement(Box::new(ForStatementChildren {
740 for_keyword,
741 for_left_paren,
742 for_initializer,
743 for_first_semicolon,
744 for_control,
745 for_second_semicolon,
746 for_end_of_loop,
747 for_right_paren,
748 for_body,
749 }));
750 let value = V::from_syntax(&syntax);
751 Self::make(syntax, value)
752 }
754 pub fn make_foreach_statement(foreach_keyword: Self, foreach_left_paren: Self, foreach_collection: Self, foreach_await_keyword: Self, foreach_as: Self, foreach_key: Self, foreach_arrow: Self, foreach_value: Self, foreach_right_paren: Self, foreach_body: Self) -> Self {
755 let syntax = SyntaxVariant::ForeachStatement(Box::new(ForeachStatementChildren {
756 foreach_keyword,
757 foreach_left_paren,
758 foreach_collection,
759 foreach_await_keyword,
760 foreach_as,
761 foreach_key,
762 foreach_arrow,
763 foreach_value,
764 foreach_right_paren,
765 foreach_body,
766 }));
767 let value = V::from_syntax(&syntax);
768 Self::make(syntax, value)
769 }
771 pub fn make_switch_statement(switch_keyword: Self, switch_left_paren: Self, switch_expression: Self, switch_right_paren: Self, switch_left_brace: Self, switch_sections: Self, switch_right_brace: Self) -> Self {
772 let syntax = SyntaxVariant::SwitchStatement(Box::new(SwitchStatementChildren {
773 switch_keyword,
774 switch_left_paren,
775 switch_expression,
776 switch_right_paren,
777 switch_left_brace,
778 switch_sections,
779 switch_right_brace,
780 }));
781 let value = V::from_syntax(&syntax);
782 Self::make(syntax, value)
783 }
785 pub fn make_alternate_switch_statement(alternate_switch_keyword: Self, alternate_switch_left_paren: Self, alternate_switch_expression: Self, alternate_switch_right_paren: Self, alternate_switch_opening_colon: Self, alternate_switch_sections: Self, alternate_switch_closing_endswitch: Self, alternate_switch_closing_semicolon: Self) -> Self {
786 let syntax = SyntaxVariant::AlternateSwitchStatement(Box::new(AlternateSwitchStatementChildren {
787 alternate_switch_keyword,
788 alternate_switch_left_paren,
789 alternate_switch_expression,
790 alternate_switch_right_paren,
791 alternate_switch_opening_colon,
792 alternate_switch_sections,
793 alternate_switch_closing_endswitch,
794 alternate_switch_closing_semicolon,
795 }));
796 let value = V::from_syntax(&syntax);
797 Self::make(syntax, value)
798 }
800 pub fn make_switch_section(switch_section_labels: Self, switch_section_statements: Self, switch_section_fallthrough: Self) -> Self {
801 let syntax = SyntaxVariant::SwitchSection(Box::new(SwitchSectionChildren {
802 switch_section_labels,
803 switch_section_statements,
804 switch_section_fallthrough,
805 }));
806 let value = V::from_syntax(&syntax);
807 Self::make(syntax, value)
808 }
810 pub fn make_switch_fallthrough(fallthrough_keyword: Self, fallthrough_semicolon: Self) -> Self {
811 let syntax = SyntaxVariant::SwitchFallthrough(Box::new(SwitchFallthroughChildren {
812 fallthrough_keyword,
813 fallthrough_semicolon,
814 }));
815 let value = V::from_syntax(&syntax);
816 Self::make(syntax, value)
817 }
819 pub fn make_case_label(case_keyword: Self, case_expression: Self, case_colon: Self) -> Self {
820 let syntax = SyntaxVariant::CaseLabel(Box::new(CaseLabelChildren {
821 case_keyword,
822 case_expression,
823 case_colon,
824 }));
825 let value = V::from_syntax(&syntax);
826 Self::make(syntax, value)
827 }
829 pub fn make_default_label(default_keyword: Self, default_colon: Self) -> Self {
830 let syntax = SyntaxVariant::DefaultLabel(Box::new(DefaultLabelChildren {
831 default_keyword,
832 default_colon,
833 }));
834 let value = V::from_syntax(&syntax);
835 Self::make(syntax, value)
836 }
838 pub fn make_return_statement(return_keyword: Self, return_expression: Self, return_semicolon: Self) -> Self {
839 let syntax = SyntaxVariant::ReturnStatement(Box::new(ReturnStatementChildren {
840 return_keyword,
841 return_expression,
842 return_semicolon,
843 }));
844 let value = V::from_syntax(&syntax);
845 Self::make(syntax, value)
846 }
848 pub fn make_goto_label(goto_label_name: Self, goto_label_colon: Self) -> Self {
849 let syntax = SyntaxVariant::GotoLabel(Box::new(GotoLabelChildren {
850 goto_label_name,
851 goto_label_colon,
852 }));
853 let value = V::from_syntax(&syntax);
854 Self::make(syntax, value)
855 }
857 pub fn make_goto_statement(goto_statement_keyword: Self, goto_statement_label_name: Self, goto_statement_semicolon: Self) -> Self {
858 let syntax = SyntaxVariant::GotoStatement(Box::new(GotoStatementChildren {
859 goto_statement_keyword,
860 goto_statement_label_name,
861 goto_statement_semicolon,
862 }));
863 let value = V::from_syntax(&syntax);
864 Self::make(syntax, value)
865 }
867 pub fn make_throw_statement(throw_keyword: Self, throw_expression: Self, throw_semicolon: Self) -> Self {
868 let syntax = SyntaxVariant::ThrowStatement(Box::new(ThrowStatementChildren {
869 throw_keyword,
870 throw_expression,
871 throw_semicolon,
872 }));
873 let value = V::from_syntax(&syntax);
874 Self::make(syntax, value)
875 }
877 pub fn make_break_statement(break_keyword: Self, break_level: Self, break_semicolon: Self) -> Self {
878 let syntax = SyntaxVariant::BreakStatement(Box::new(BreakStatementChildren {
879 break_keyword,
880 break_level,
881 break_semicolon,
882 }));
883 let value = V::from_syntax(&syntax);
884 Self::make(syntax, value)
885 }
887 pub fn make_continue_statement(continue_keyword: Self, continue_level: Self, continue_semicolon: Self) -> Self {
888 let syntax = SyntaxVariant::ContinueStatement(Box::new(ContinueStatementChildren {
889 continue_keyword,
890 continue_level,
891 continue_semicolon,
892 }));
893 let value = V::from_syntax(&syntax);
894 Self::make(syntax, value)
895 }
897 pub fn make_echo_statement(echo_keyword: Self, echo_expressions: Self, echo_semicolon: Self) -> Self {
898 let syntax = SyntaxVariant::EchoStatement(Box::new(EchoStatementChildren {
899 echo_keyword,
900 echo_expressions,
901 echo_semicolon,
902 }));
903 let value = V::from_syntax(&syntax);
904 Self::make(syntax, value)
905 }
907 pub fn make_concurrent_statement(concurrent_keyword: Self, concurrent_statement: Self) -> Self {
908 let syntax = SyntaxVariant::ConcurrentStatement(Box::new(ConcurrentStatementChildren {
909 concurrent_keyword,
910 concurrent_statement,
911 }));
912 let value = V::from_syntax(&syntax);
913 Self::make(syntax, value)
914 }
916 pub fn make_simple_initializer(simple_initializer_equal: Self, simple_initializer_value: Self) -> Self {
917 let syntax = SyntaxVariant::SimpleInitializer(Box::new(SimpleInitializerChildren {
918 simple_initializer_equal,
919 simple_initializer_value,
920 }));
921 let value = V::from_syntax(&syntax);
922 Self::make(syntax, value)
923 }
925 pub fn make_anonymous_class(anonymous_class_class_keyword: Self, anonymous_class_left_paren: Self, anonymous_class_argument_list: Self, anonymous_class_right_paren: Self, anonymous_class_extends_keyword: Self, anonymous_class_extends_list: Self, anonymous_class_implements_keyword: Self, anonymous_class_implements_list: Self, anonymous_class_body: Self) -> Self {
926 let syntax = SyntaxVariant::AnonymousClass(Box::new(AnonymousClassChildren {
927 anonymous_class_class_keyword,
928 anonymous_class_left_paren,
929 anonymous_class_argument_list,
930 anonymous_class_right_paren,
931 anonymous_class_extends_keyword,
932 anonymous_class_extends_list,
933 anonymous_class_implements_keyword,
934 anonymous_class_implements_list,
935 anonymous_class_body,
936 }));
937 let value = V::from_syntax(&syntax);
938 Self::make(syntax, value)
939 }
941 pub fn make_anonymous_function(anonymous_attribute_spec: Self, anonymous_static_keyword: Self, anonymous_async_keyword: Self, anonymous_coroutine_keyword: Self, anonymous_function_keyword: Self, anonymous_left_paren: Self, anonymous_parameters: Self, anonymous_right_paren: Self, anonymous_colon: Self, anonymous_type: Self, anonymous_use: Self, anonymous_body: Self) -> Self {
942 let syntax = SyntaxVariant::AnonymousFunction(Box::new(AnonymousFunctionChildren {
943 anonymous_attribute_spec,
944 anonymous_static_keyword,
945 anonymous_async_keyword,
946 anonymous_coroutine_keyword,
947 anonymous_function_keyword,
948 anonymous_left_paren,
949 anonymous_parameters,
950 anonymous_right_paren,
951 anonymous_colon,
952 anonymous_type,
953 anonymous_use,
954 anonymous_body,
955 }));
956 let value = V::from_syntax(&syntax);
957 Self::make(syntax, value)
958 }
960 pub fn make_php7_anonymous_function(php7_anonymous_attribute_spec: Self, php7_anonymous_static_keyword: Self, php7_anonymous_async_keyword: Self, php7_anonymous_coroutine_keyword: Self, php7_anonymous_function_keyword: Self, php7_anonymous_left_paren: Self, php7_anonymous_parameters: Self, php7_anonymous_right_paren: Self, php7_anonymous_use: Self, php7_anonymous_colon: Self, php7_anonymous_type: Self, php7_anonymous_body: Self) -> Self {
961 let syntax = SyntaxVariant::Php7AnonymousFunction(Box::new(Php7AnonymousFunctionChildren {
962 php7_anonymous_attribute_spec,
963 php7_anonymous_static_keyword,
964 php7_anonymous_async_keyword,
965 php7_anonymous_coroutine_keyword,
966 php7_anonymous_function_keyword,
967 php7_anonymous_left_paren,
968 php7_anonymous_parameters,
969 php7_anonymous_right_paren,
970 php7_anonymous_use,
971 php7_anonymous_colon,
972 php7_anonymous_type,
973 php7_anonymous_body,
974 }));
975 let value = V::from_syntax(&syntax);
976 Self::make(syntax, value)
977 }
979 pub fn make_anonymous_function_use_clause(anonymous_use_keyword: Self, anonymous_use_left_paren: Self, anonymous_use_variables: Self, anonymous_use_right_paren: Self) -> Self {
980 let syntax = SyntaxVariant::AnonymousFunctionUseClause(Box::new(AnonymousFunctionUseClauseChildren {
981 anonymous_use_keyword,
982 anonymous_use_left_paren,
983 anonymous_use_variables,
984 anonymous_use_right_paren,
985 }));
986 let value = V::from_syntax(&syntax);
987 Self::make(syntax, value)
988 }
990 pub fn make_lambda_expression(lambda_attribute_spec: Self, lambda_async: Self, lambda_coroutine: Self, lambda_signature: Self, lambda_arrow: Self, lambda_body: Self) -> Self {
991 let syntax = SyntaxVariant::LambdaExpression(Box::new(LambdaExpressionChildren {
992 lambda_attribute_spec,
993 lambda_async,
994 lambda_coroutine,
995 lambda_signature,
996 lambda_arrow,
997 lambda_body,
998 }));
999 let value = V::from_syntax(&syntax);
1000 Self::make(syntax, value)
1001 }
1003 pub fn make_lambda_signature(lambda_left_paren: Self, lambda_parameters: Self, lambda_right_paren: Self, lambda_colon: Self, lambda_type: Self) -> Self {
1004 let syntax = SyntaxVariant::LambdaSignature(Box::new(LambdaSignatureChildren {
1005 lambda_left_paren,
1006 lambda_parameters,
1007 lambda_right_paren,
1008 lambda_colon,
1009 lambda_type,
1010 }));
1011 let value = V::from_syntax(&syntax);
1012 Self::make(syntax, value)
1013 }
1015 pub fn make_cast_expression(cast_left_paren: Self, cast_type: Self, cast_right_paren: Self, cast_operand: Self) -> Self {
1016 let syntax = SyntaxVariant::CastExpression(Box::new(CastExpressionChildren {
1017 cast_left_paren,
1018 cast_type,
1019 cast_right_paren,
1020 cast_operand,
1021 }));
1022 let value = V::from_syntax(&syntax);
1023 Self::make(syntax, value)
1024 }
1026 pub fn make_scope_resolution_expression(scope_resolution_qualifier: Self, scope_resolution_operator: Self, scope_resolution_name: Self) -> Self {
1027 let syntax = SyntaxVariant::ScopeResolutionExpression(Box::new(ScopeResolutionExpressionChildren {
1028 scope_resolution_qualifier,
1029 scope_resolution_operator,
1030 scope_resolution_name,
1031 }));
1032 let value = V::from_syntax(&syntax);
1033 Self::make(syntax, value)
1034 }
1036 pub fn make_member_selection_expression(member_object: Self, member_operator: Self, member_name: Self) -> Self {
1037 let syntax = SyntaxVariant::MemberSelectionExpression(Box::new(MemberSelectionExpressionChildren {
1038 member_object,
1039 member_operator,
1040 member_name,
1041 }));
1042 let value = V::from_syntax(&syntax);
1043 Self::make(syntax, value)
1044 }
1046 pub fn make_safe_member_selection_expression(safe_member_object: Self, safe_member_operator: Self, safe_member_name: Self) -> Self {
1047 let syntax = SyntaxVariant::SafeMemberSelectionExpression(Box::new(SafeMemberSelectionExpressionChildren {
1048 safe_member_object,
1049 safe_member_operator,
1050 safe_member_name,
1051 }));
1052 let value = V::from_syntax(&syntax);
1053 Self::make(syntax, value)
1054 }
1056 pub fn make_embedded_member_selection_expression(embedded_member_object: Self, embedded_member_operator: Self, embedded_member_name: Self) -> Self {
1057 let syntax = SyntaxVariant::EmbeddedMemberSelectionExpression(Box::new(EmbeddedMemberSelectionExpressionChildren {
1058 embedded_member_object,
1059 embedded_member_operator,
1060 embedded_member_name,
1061 }));
1062 let value = V::from_syntax(&syntax);
1063 Self::make(syntax, value)
1064 }
1066 pub fn make_yield_expression(yield_keyword: Self, yield_operand: Self) -> Self {
1067 let syntax = SyntaxVariant::YieldExpression(Box::new(YieldExpressionChildren {
1068 yield_keyword,
1069 yield_operand,
1070 }));
1071 let value = V::from_syntax(&syntax);
1072 Self::make(syntax, value)
1073 }
1075 pub fn make_yield_from_expression(yield_from_yield_keyword: Self, yield_from_from_keyword: Self, yield_from_operand: Self) -> Self {
1076 let syntax = SyntaxVariant::YieldFromExpression(Box::new(YieldFromExpressionChildren {
1077 yield_from_yield_keyword,
1078 yield_from_from_keyword,
1079 yield_from_operand,
1080 }));
1081 let value = V::from_syntax(&syntax);
1082 Self::make(syntax, value)
1083 }
1085 pub fn make_prefix_unary_expression(prefix_unary_operator: Self, prefix_unary_operand: Self) -> Self {
1086 let syntax = SyntaxVariant::PrefixUnaryExpression(Box::new(PrefixUnaryExpressionChildren {
1087 prefix_unary_operator,
1088 prefix_unary_operand,
1089 }));
1090 let value = V::from_syntax(&syntax);
1091 Self::make(syntax, value)
1092 }
1094 pub fn make_postfix_unary_expression(postfix_unary_operand: Self, postfix_unary_operator: Self) -> Self {
1095 let syntax = SyntaxVariant::PostfixUnaryExpression(Box::new(PostfixUnaryExpressionChildren {
1096 postfix_unary_operand,
1097 postfix_unary_operator,
1098 }));
1099 let value = V::from_syntax(&syntax);
1100 Self::make(syntax, value)
1101 }
1103 pub fn make_binary_expression(binary_left_operand: Self, binary_operator: Self, binary_right_operand: Self) -> Self {
1104 let syntax = SyntaxVariant::BinaryExpression(Box::new(BinaryExpressionChildren {
1105 binary_left_operand,
1106 binary_operator,
1107 binary_right_operand,
1108 }));
1109 let value = V::from_syntax(&syntax);
1110 Self::make(syntax, value)
1111 }
1113 pub fn make_instanceof_expression(instanceof_left_operand: Self, instanceof_operator: Self, instanceof_right_operand: Self) -> Self {
1114 let syntax = SyntaxVariant::InstanceofExpression(Box::new(InstanceofExpressionChildren {
1115 instanceof_left_operand,
1116 instanceof_operator,
1117 instanceof_right_operand,
1118 }));
1119 let value = V::from_syntax(&syntax);
1120 Self::make(syntax, value)
1121 }
1123 pub fn make_is_expression(is_left_operand: Self, is_operator: Self, is_right_operand: Self) -> Self {
1124 let syntax = SyntaxVariant::IsExpression(Box::new(IsExpressionChildren {
1125 is_left_operand,
1126 is_operator,
1127 is_right_operand,
1128 }));
1129 let value = V::from_syntax(&syntax);
1130 Self::make(syntax, value)
1131 }
1133 pub fn make_as_expression(as_left_operand: Self, as_operator: Self, as_right_operand: Self) -> Self {
1134 let syntax = SyntaxVariant::AsExpression(Box::new(AsExpressionChildren {
1135 as_left_operand,
1136 as_operator,
1137 as_right_operand,
1138 }));
1139 let value = V::from_syntax(&syntax);
1140 Self::make(syntax, value)
1141 }
1143 pub fn make_nullable_as_expression(nullable_as_left_operand: Self, nullable_as_operator: Self, nullable_as_right_operand: Self) -> Self {
1144 let syntax = SyntaxVariant::NullableAsExpression(Box::new(NullableAsExpressionChildren {
1145 nullable_as_left_operand,
1146 nullable_as_operator,
1147 nullable_as_right_operand,
1148 }));
1149 let value = V::from_syntax(&syntax);
1150 Self::make(syntax, value)
1151 }
1153 pub fn make_conditional_expression(conditional_test: Self, conditional_question: Self, conditional_consequence: Self, conditional_colon: Self, conditional_alternative: Self) -> Self {
1154 let syntax = SyntaxVariant::ConditionalExpression(Box::new(ConditionalExpressionChildren {
1155 conditional_test,
1156 conditional_question,
1157 conditional_consequence,
1158 conditional_colon,
1159 conditional_alternative,
1160 }));
1161 let value = V::from_syntax(&syntax);
1162 Self::make(syntax, value)
1163 }
1165 pub fn make_eval_expression(eval_keyword: Self, eval_left_paren: Self, eval_argument: Self, eval_right_paren: Self) -> Self {
1166 let syntax = SyntaxVariant::EvalExpression(Box::new(EvalExpressionChildren {
1167 eval_keyword,
1168 eval_left_paren,
1169 eval_argument,
1170 eval_right_paren,
1171 }));
1172 let value = V::from_syntax(&syntax);
1173 Self::make(syntax, value)
1174 }
1176 pub fn make_empty_expression(empty_keyword: Self, empty_left_paren: Self, empty_argument: Self, empty_right_paren: Self) -> Self {
1177 let syntax = SyntaxVariant::EmptyExpression(Box::new(EmptyExpressionChildren {
1178 empty_keyword,
1179 empty_left_paren,
1180 empty_argument,
1181 empty_right_paren,
1182 }));
1183 let value = V::from_syntax(&syntax);
1184 Self::make(syntax, value)
1185 }
1187 pub fn make_define_expression(define_keyword: Self, define_left_paren: Self, define_argument_list: Self, define_right_paren: Self) -> Self {
1188 let syntax = SyntaxVariant::DefineExpression(Box::new(DefineExpressionChildren {
1189 define_keyword,
1190 define_left_paren,
1191 define_argument_list,
1192 define_right_paren,
1193 }));
1194 let value = V::from_syntax(&syntax);
1195 Self::make(syntax, value)
1196 }
1198 pub fn make_halt_compiler_expression(halt_compiler_keyword: Self, halt_compiler_left_paren: Self, halt_compiler_argument_list: Self, halt_compiler_right_paren: Self) -> Self {
1199 let syntax = SyntaxVariant::HaltCompilerExpression(Box::new(HaltCompilerExpressionChildren {
1200 halt_compiler_keyword,
1201 halt_compiler_left_paren,
1202 halt_compiler_argument_list,
1203 halt_compiler_right_paren,
1204 }));
1205 let value = V::from_syntax(&syntax);
1206 Self::make(syntax, value)
1207 }
1209 pub fn make_isset_expression(isset_keyword: Self, isset_left_paren: Self, isset_argument_list: Self, isset_right_paren: Self) -> Self {
1210 let syntax = SyntaxVariant::IssetExpression(Box::new(IssetExpressionChildren {
1211 isset_keyword,
1212 isset_left_paren,
1213 isset_argument_list,
1214 isset_right_paren,
1215 }));
1216 let value = V::from_syntax(&syntax);
1217 Self::make(syntax, value)
1218 }
1220 pub fn make_function_call_expression(function_call_receiver: Self, function_call_type_args: Self, function_call_left_paren: Self, function_call_argument_list: Self, function_call_right_paren: Self) -> Self {
1221 let syntax = SyntaxVariant::FunctionCallExpression(Box::new(FunctionCallExpressionChildren {
1222 function_call_receiver,
1223 function_call_type_args,
1224 function_call_left_paren,
1225 function_call_argument_list,
1226 function_call_right_paren,
1227 }));
1228 let value = V::from_syntax(&syntax);
1229 Self::make(syntax, value)
1230 }
1232 pub fn make_parenthesized_expression(parenthesized_expression_left_paren: Self, parenthesized_expression_expression: Self, parenthesized_expression_right_paren: Self) -> Self {
1233 let syntax = SyntaxVariant::ParenthesizedExpression(Box::new(ParenthesizedExpressionChildren {
1234 parenthesized_expression_left_paren,
1235 parenthesized_expression_expression,
1236 parenthesized_expression_right_paren,
1237 }));
1238 let value = V::from_syntax(&syntax);
1239 Self::make(syntax, value)
1240 }
1242 pub fn make_braced_expression(braced_expression_left_brace: Self, braced_expression_expression: Self, braced_expression_right_brace: Self) -> Self {
1243 let syntax = SyntaxVariant::BracedExpression(Box::new(BracedExpressionChildren {
1244 braced_expression_left_brace,
1245 braced_expression_expression,
1246 braced_expression_right_brace,
1247 }));
1248 let value = V::from_syntax(&syntax);
1249 Self::make(syntax, value)
1250 }
1252 pub fn make_embedded_braced_expression(embedded_braced_expression_left_brace: Self, embedded_braced_expression_expression: Self, embedded_braced_expression_right_brace: Self) -> Self {
1253 let syntax = SyntaxVariant::EmbeddedBracedExpression(Box::new(EmbeddedBracedExpressionChildren {
1254 embedded_braced_expression_left_brace,
1255 embedded_braced_expression_expression,
1256 embedded_braced_expression_right_brace,
1257 }));
1258 let value = V::from_syntax(&syntax);
1259 Self::make(syntax, value)
1260 }
1262 pub fn make_list_expression(list_keyword: Self, list_left_paren: Self, list_members: Self, list_right_paren: Self) -> Self {
1263 let syntax = SyntaxVariant::ListExpression(Box::new(ListExpressionChildren {
1264 list_keyword,
1265 list_left_paren,
1266 list_members,
1267 list_right_paren,
1268 }));
1269 let value = V::from_syntax(&syntax);
1270 Self::make(syntax, value)
1271 }
1273 pub fn make_collection_literal_expression(collection_literal_name: Self, collection_literal_left_brace: Self, collection_literal_initializers: Self, collection_literal_right_brace: Self) -> Self {
1274 let syntax = SyntaxVariant::CollectionLiteralExpression(Box::new(CollectionLiteralExpressionChildren {
1275 collection_literal_name,
1276 collection_literal_left_brace,
1277 collection_literal_initializers,
1278 collection_literal_right_brace,
1279 }));
1280 let value = V::from_syntax(&syntax);
1281 Self::make(syntax, value)
1282 }
1284 pub fn make_object_creation_expression(object_creation_new_keyword: Self, object_creation_object: Self) -> Self {
1285 let syntax = SyntaxVariant::ObjectCreationExpression(Box::new(ObjectCreationExpressionChildren {
1286 object_creation_new_keyword,
1287 object_creation_object,
1288 }));
1289 let value = V::from_syntax(&syntax);
1290 Self::make(syntax, value)
1291 }
1293 pub fn make_constructor_call(constructor_call_type: Self, constructor_call_left_paren: Self, constructor_call_argument_list: Self, constructor_call_right_paren: Self) -> Self {
1294 let syntax = SyntaxVariant::ConstructorCall(Box::new(ConstructorCallChildren {
1295 constructor_call_type,
1296 constructor_call_left_paren,
1297 constructor_call_argument_list,
1298 constructor_call_right_paren,
1299 }));
1300 let value = V::from_syntax(&syntax);
1301 Self::make(syntax, value)
1302 }
1304 pub fn make_array_creation_expression(array_creation_left_bracket: Self, array_creation_members: Self, array_creation_right_bracket: Self) -> Self {
1305 let syntax = SyntaxVariant::ArrayCreationExpression(Box::new(ArrayCreationExpressionChildren {
1306 array_creation_left_bracket,
1307 array_creation_members,
1308 array_creation_right_bracket,
1309 }));
1310 let value = V::from_syntax(&syntax);
1311 Self::make(syntax, value)
1312 }
1314 pub fn make_array_intrinsic_expression(array_intrinsic_keyword: Self, array_intrinsic_left_paren: Self, array_intrinsic_members: Self, array_intrinsic_right_paren: Self) -> Self {
1315 let syntax = SyntaxVariant::ArrayIntrinsicExpression(Box::new(ArrayIntrinsicExpressionChildren {
1316 array_intrinsic_keyword,
1317 array_intrinsic_left_paren,
1318 array_intrinsic_members,
1319 array_intrinsic_right_paren,
1320 }));
1321 let value = V::from_syntax(&syntax);
1322 Self::make(syntax, value)
1323 }
1325 pub fn make_darray_intrinsic_expression(darray_intrinsic_keyword: Self, darray_intrinsic_explicit_type: Self, darray_intrinsic_left_bracket: Self, darray_intrinsic_members: Self, darray_intrinsic_right_bracket: Self) -> Self {
1326 let syntax = SyntaxVariant::DarrayIntrinsicExpression(Box::new(DarrayIntrinsicExpressionChildren {
1327 darray_intrinsic_keyword,
1328 darray_intrinsic_explicit_type,
1329 darray_intrinsic_left_bracket,
1330 darray_intrinsic_members,
1331 darray_intrinsic_right_bracket,
1332 }));
1333 let value = V::from_syntax(&syntax);
1334 Self::make(syntax, value)
1335 }
1337 pub fn make_dictionary_intrinsic_expression(dictionary_intrinsic_keyword: Self, dictionary_intrinsic_explicit_type: Self, dictionary_intrinsic_left_bracket: Self, dictionary_intrinsic_members: Self, dictionary_intrinsic_right_bracket: Self) -> Self {
1338 let syntax = SyntaxVariant::DictionaryIntrinsicExpression(Box::new(DictionaryIntrinsicExpressionChildren {
1339 dictionary_intrinsic_keyword,
1340 dictionary_intrinsic_explicit_type,
1341 dictionary_intrinsic_left_bracket,
1342 dictionary_intrinsic_members,
1343 dictionary_intrinsic_right_bracket,
1344 }));
1345 let value = V::from_syntax(&syntax);
1346 Self::make(syntax, value)
1347 }
1349 pub fn make_keyset_intrinsic_expression(keyset_intrinsic_keyword: Self, keyset_intrinsic_explicit_type: Self, keyset_intrinsic_left_bracket: Self, keyset_intrinsic_members: Self, keyset_intrinsic_right_bracket: Self) -> Self {
1350 let syntax = SyntaxVariant::KeysetIntrinsicExpression(Box::new(KeysetIntrinsicExpressionChildren {
1351 keyset_intrinsic_keyword,
1352 keyset_intrinsic_explicit_type,
1353 keyset_intrinsic_left_bracket,
1354 keyset_intrinsic_members,
1355 keyset_intrinsic_right_bracket,
1356 }));
1357 let value = V::from_syntax(&syntax);
1358 Self::make(syntax, value)
1359 }
1361 pub fn make_varray_intrinsic_expression(varray_intrinsic_keyword: Self, varray_intrinsic_explicit_type: Self, varray_intrinsic_left_bracket: Self, varray_intrinsic_members: Self, varray_intrinsic_right_bracket: Self) -> Self {
1362 let syntax = SyntaxVariant::VarrayIntrinsicExpression(Box::new(VarrayIntrinsicExpressionChildren {
1363 varray_intrinsic_keyword,
1364 varray_intrinsic_explicit_type,
1365 varray_intrinsic_left_bracket,
1366 varray_intrinsic_members,
1367 varray_intrinsic_right_bracket,
1368 }));
1369 let value = V::from_syntax(&syntax);
1370 Self::make(syntax, value)
1371 }
1373 pub fn make_vector_intrinsic_expression(vector_intrinsic_keyword: Self, vector_intrinsic_explicit_type: Self, vector_intrinsic_left_bracket: Self, vector_intrinsic_members: Self, vector_intrinsic_right_bracket: Self) -> Self {
1374 let syntax = SyntaxVariant::VectorIntrinsicExpression(Box::new(VectorIntrinsicExpressionChildren {
1375 vector_intrinsic_keyword,
1376 vector_intrinsic_explicit_type,
1377 vector_intrinsic_left_bracket,
1378 vector_intrinsic_members,
1379 vector_intrinsic_right_bracket,
1380 }));
1381 let value = V::from_syntax(&syntax);
1382 Self::make(syntax, value)
1383 }
1385 pub fn make_element_initializer(element_key: Self, element_arrow: Self, element_value: Self) -> Self {
1386 let syntax = SyntaxVariant::ElementInitializer(Box::new(ElementInitializerChildren {
1387 element_key,
1388 element_arrow,
1389 element_value,
1390 }));
1391 let value = V::from_syntax(&syntax);
1392 Self::make(syntax, value)
1393 }
1395 pub fn make_subscript_expression(subscript_receiver: Self, subscript_left_bracket: Self, subscript_index: Self, subscript_right_bracket: Self) -> Self {
1396 let syntax = SyntaxVariant::SubscriptExpression(Box::new(SubscriptExpressionChildren {
1397 subscript_receiver,
1398 subscript_left_bracket,
1399 subscript_index,
1400 subscript_right_bracket,
1401 }));
1402 let value = V::from_syntax(&syntax);
1403 Self::make(syntax, value)
1404 }
1406 pub fn make_embedded_subscript_expression(embedded_subscript_receiver: Self, embedded_subscript_left_bracket: Self, embedded_subscript_index: Self, embedded_subscript_right_bracket: Self) -> Self {
1407 let syntax = SyntaxVariant::EmbeddedSubscriptExpression(Box::new(EmbeddedSubscriptExpressionChildren {
1408 embedded_subscript_receiver,
1409 embedded_subscript_left_bracket,
1410 embedded_subscript_index,
1411 embedded_subscript_right_bracket,
1412 }));
1413 let value = V::from_syntax(&syntax);
1414 Self::make(syntax, value)
1415 }
1417 pub fn make_awaitable_creation_expression(awaitable_attribute_spec: Self, awaitable_async: Self, awaitable_coroutine: Self, awaitable_compound_statement: Self) -> Self {
1418 let syntax = SyntaxVariant::AwaitableCreationExpression(Box::new(AwaitableCreationExpressionChildren {
1419 awaitable_attribute_spec,
1420 awaitable_async,
1421 awaitable_coroutine,
1422 awaitable_compound_statement,
1423 }));
1424 let value = V::from_syntax(&syntax);
1425 Self::make(syntax, value)
1426 }
1428 pub fn make_xhp_children_declaration(xhp_children_keyword: Self, xhp_children_expression: Self, xhp_children_semicolon: Self) -> Self {
1429 let syntax = SyntaxVariant::XHPChildrenDeclaration(Box::new(XHPChildrenDeclarationChildren {
1430 xhp_children_keyword,
1431 xhp_children_expression,
1432 xhp_children_semicolon,
1433 }));
1434 let value = V::from_syntax(&syntax);
1435 Self::make(syntax, value)
1436 }
1438 pub fn make_xhp_children_parenthesized_list(xhp_children_list_left_paren: Self, xhp_children_list_xhp_children: Self, xhp_children_list_right_paren: Self) -> Self {
1439 let syntax = SyntaxVariant::XHPChildrenParenthesizedList(Box::new(XHPChildrenParenthesizedListChildren {
1440 xhp_children_list_left_paren,
1441 xhp_children_list_xhp_children,
1442 xhp_children_list_right_paren,
1443 }));
1444 let value = V::from_syntax(&syntax);
1445 Self::make(syntax, value)
1446 }
1448 pub fn make_xhp_category_declaration(xhp_category_keyword: Self, xhp_category_categories: Self, xhp_category_semicolon: Self) -> Self {
1449 let syntax = SyntaxVariant::XHPCategoryDeclaration(Box::new(XHPCategoryDeclarationChildren {
1450 xhp_category_keyword,
1451 xhp_category_categories,
1452 xhp_category_semicolon,
1453 }));
1454 let value = V::from_syntax(&syntax);
1455 Self::make(syntax, value)
1456 }
1458 pub fn make_xhp_enum_type(xhp_enum_optional: Self, xhp_enum_keyword: Self, xhp_enum_left_brace: Self, xhp_enum_values: Self, xhp_enum_right_brace: Self) -> Self {
1459 let syntax = SyntaxVariant::XHPEnumType(Box::new(XHPEnumTypeChildren {
1460 xhp_enum_optional,
1461 xhp_enum_keyword,
1462 xhp_enum_left_brace,
1463 xhp_enum_values,
1464 xhp_enum_right_brace,
1465 }));
1466 let value = V::from_syntax(&syntax);
1467 Self::make(syntax, value)
1468 }
1470 pub fn make_xhp_required(xhp_required_at: Self, xhp_required_keyword: Self) -> Self {
1471 let syntax = SyntaxVariant::XHPRequired(Box::new(XHPRequiredChildren {
1472 xhp_required_at,
1473 xhp_required_keyword,
1474 }));
1475 let value = V::from_syntax(&syntax);
1476 Self::make(syntax, value)
1477 }
1479 pub fn make_xhp_class_attribute_declaration(xhp_attribute_keyword: Self, xhp_attribute_attributes: Self, xhp_attribute_semicolon: Self) -> Self {
1480 let syntax = SyntaxVariant::XHPClassAttributeDeclaration(Box::new(XHPClassAttributeDeclarationChildren {
1481 xhp_attribute_keyword,
1482 xhp_attribute_attributes,
1483 xhp_attribute_semicolon,
1484 }));
1485 let value = V::from_syntax(&syntax);
1486 Self::make(syntax, value)
1487 }
1489 pub fn make_xhp_class_attribute(xhp_attribute_decl_type: Self, xhp_attribute_decl_name: Self, xhp_attribute_decl_initializer: Self, xhp_attribute_decl_required: Self) -> Self {
1490 let syntax = SyntaxVariant::XHPClassAttribute(Box::new(XHPClassAttributeChildren {
1491 xhp_attribute_decl_type,
1492 xhp_attribute_decl_name,
1493 xhp_attribute_decl_initializer,
1494 xhp_attribute_decl_required,
1495 }));
1496 let value = V::from_syntax(&syntax);
1497 Self::make(syntax, value)
1498 }
1500 pub fn make_xhp_simple_class_attribute(xhp_simple_class_attribute_type: Self) -> Self {
1501 let syntax = SyntaxVariant::XHPSimpleClassAttribute(Box::new(XHPSimpleClassAttributeChildren {
1502 xhp_simple_class_attribute_type,
1503 }));
1504 let value = V::from_syntax(&syntax);
1505 Self::make(syntax, value)
1506 }
1508 pub fn make_xhp_simple_attribute(xhp_simple_attribute_name: Self, xhp_simple_attribute_equal: Self, xhp_simple_attribute_expression: Self) -> Self {
1509 let syntax = SyntaxVariant::XHPSimpleAttribute(Box::new(XHPSimpleAttributeChildren {
1510 xhp_simple_attribute_name,
1511 xhp_simple_attribute_equal,
1512 xhp_simple_attribute_expression,
1513 }));
1514 let value = V::from_syntax(&syntax);
1515 Self::make(syntax, value)
1516 }
1518 pub fn make_xhp_spread_attribute(xhp_spread_attribute_left_brace: Self, xhp_spread_attribute_spread_operator: Self, xhp_spread_attribute_expression: Self, xhp_spread_attribute_right_brace: Self) -> Self {
1519 let syntax = SyntaxVariant::XHPSpreadAttribute(Box::new(XHPSpreadAttributeChildren {
1520 xhp_spread_attribute_left_brace,
1521 xhp_spread_attribute_spread_operator,
1522 xhp_spread_attribute_expression,
1523 xhp_spread_attribute_right_brace,
1524 }));
1525 let value = V::from_syntax(&syntax);
1526 Self::make(syntax, value)
1527 }
1529 pub fn make_xhp_open(xhp_open_left_angle: Self, xhp_open_name: Self, xhp_open_attributes: Self, xhp_open_right_angle: Self) -> Self {
1530 let syntax = SyntaxVariant::XHPOpen(Box::new(XHPOpenChildren {
1531 xhp_open_left_angle,
1532 xhp_open_name,
1533 xhp_open_attributes,
1534 xhp_open_right_angle,
1535 }));
1536 let value = V::from_syntax(&syntax);
1537 Self::make(syntax, value)
1538 }
1540 pub fn make_xhp_expression(xhp_open: Self, xhp_body: Self, xhp_close: Self) -> Self {
1541 let syntax = SyntaxVariant::XHPExpression(Box::new(XHPExpressionChildren {
1542 xhp_open,
1543 xhp_body,
1544 xhp_close,
1545 }));
1546 let value = V::from_syntax(&syntax);
1547 Self::make(syntax, value)
1548 }
1550 pub fn make_xhp_close(xhp_close_left_angle: Self, xhp_close_name: Self, xhp_close_right_angle: Self) -> Self {
1551 let syntax = SyntaxVariant::XHPClose(Box::new(XHPCloseChildren {
1552 xhp_close_left_angle,
1553 xhp_close_name,
1554 xhp_close_right_angle,
1555 }));
1556 let value = V::from_syntax(&syntax);
1557 Self::make(syntax, value)
1558 }
1560 pub fn make_type_constant(type_constant_left_type: Self, type_constant_separator: Self, type_constant_right_type: Self) -> Self {
1561 let syntax = SyntaxVariant::TypeConstant(Box::new(TypeConstantChildren {
1562 type_constant_left_type,
1563 type_constant_separator,
1564 type_constant_right_type,
1565 }));
1566 let value = V::from_syntax(&syntax);
1567 Self::make(syntax, value)
1568 }
1570 pub fn make_vector_type_specifier(vector_type_keyword: Self, vector_type_left_angle: Self, vector_type_type: Self, vector_type_trailing_comma: Self, vector_type_right_angle: Self) -> Self {
1571 let syntax = SyntaxVariant::VectorTypeSpecifier(Box::new(VectorTypeSpecifierChildren {
1572 vector_type_keyword,
1573 vector_type_left_angle,
1574 vector_type_type,
1575 vector_type_trailing_comma,
1576 vector_type_right_angle,
1577 }));
1578 let value = V::from_syntax(&syntax);
1579 Self::make(syntax, value)
1580 }
1582 pub fn make_keyset_type_specifier(keyset_type_keyword: Self, keyset_type_left_angle: Self, keyset_type_type: Self, keyset_type_trailing_comma: Self, keyset_type_right_angle: Self) -> Self {
1583 let syntax = SyntaxVariant::KeysetTypeSpecifier(Box::new(KeysetTypeSpecifierChildren {
1584 keyset_type_keyword,
1585 keyset_type_left_angle,
1586 keyset_type_type,
1587 keyset_type_trailing_comma,
1588 keyset_type_right_angle,
1589 }));
1590 let value = V::from_syntax(&syntax);
1591 Self::make(syntax, value)
1592 }
1594 pub fn make_tuple_type_explicit_specifier(tuple_type_keyword: Self, tuple_type_left_angle: Self, tuple_type_types: Self, tuple_type_right_angle: Self) -> Self {
1595 let syntax = SyntaxVariant::TupleTypeExplicitSpecifier(Box::new(TupleTypeExplicitSpecifierChildren {
1596 tuple_type_keyword,
1597 tuple_type_left_angle,
1598 tuple_type_types,
1599 tuple_type_right_angle,
1600 }));
1601 let value = V::from_syntax(&syntax);
1602 Self::make(syntax, value)
1603 }
1605 pub fn make_varray_type_specifier(varray_keyword: Self, varray_left_angle: Self, varray_type: Self, varray_trailing_comma: Self, varray_right_angle: Self) -> Self {
1606 let syntax = SyntaxVariant::VarrayTypeSpecifier(Box::new(VarrayTypeSpecifierChildren {
1607 varray_keyword,
1608 varray_left_angle,
1609 varray_type,
1610 varray_trailing_comma,
1611 varray_right_angle,
1612 }));
1613 let value = V::from_syntax(&syntax);
1614 Self::make(syntax, value)
1615 }
1617 pub fn make_vector_array_type_specifier(vector_array_keyword: Self, vector_array_left_angle: Self, vector_array_type: Self, vector_array_right_angle: Self) -> Self {
1618 let syntax = SyntaxVariant::VectorArrayTypeSpecifier(Box::new(VectorArrayTypeSpecifierChildren {
1619 vector_array_keyword,
1620 vector_array_left_angle,
1621 vector_array_type,
1622 vector_array_right_angle,
1623 }));
1624 let value = V::from_syntax(&syntax);
1625 Self::make(syntax, value)
1626 }
1628 pub fn make_type_parameter(type_attribute_spec: Self, type_reified: Self, type_variance: Self, type_name: Self, type_constraints: Self) -> Self {
1629 let syntax = SyntaxVariant::TypeParameter(Box::new(TypeParameterChildren {
1630 type_attribute_spec,
1631 type_reified,
1632 type_variance,
1633 type_name,
1634 type_constraints,
1635 }));
1636 let value = V::from_syntax(&syntax);
1637 Self::make(syntax, value)
1638 }
1640 pub fn make_type_constraint(constraint_keyword: Self, constraint_type: Self) -> Self {
1641 let syntax = SyntaxVariant::TypeConstraint(Box::new(TypeConstraintChildren {
1642 constraint_keyword,
1643 constraint_type,
1644 }));
1645 let value = V::from_syntax(&syntax);
1646 Self::make(syntax, value)
1647 }
1649 pub fn make_darray_type_specifier(darray_keyword: Self, darray_left_angle: Self, darray_key: Self, darray_comma: Self, darray_value: Self, darray_trailing_comma: Self, darray_right_angle: Self) -> Self {
1650 let syntax = SyntaxVariant::DarrayTypeSpecifier(Box::new(DarrayTypeSpecifierChildren {
1651 darray_keyword,
1652 darray_left_angle,
1653 darray_key,
1654 darray_comma,
1655 darray_value,
1656 darray_trailing_comma,
1657 darray_right_angle,
1658 }));
1659 let value = V::from_syntax(&syntax);
1660 Self::make(syntax, value)
1661 }
1663 pub fn make_map_array_type_specifier(map_array_keyword: Self, map_array_left_angle: Self, map_array_key: Self, map_array_comma: Self, map_array_value: Self, map_array_right_angle: Self) -> Self {
1664 let syntax = SyntaxVariant::MapArrayTypeSpecifier(Box::new(MapArrayTypeSpecifierChildren {
1665 map_array_keyword,
1666 map_array_left_angle,
1667 map_array_key,
1668 map_array_comma,
1669 map_array_value,
1670 map_array_right_angle,
1671 }));
1672 let value = V::from_syntax(&syntax);
1673 Self::make(syntax, value)
1674 }
1676 pub fn make_dictionary_type_specifier(dictionary_type_keyword: Self, dictionary_type_left_angle: Self, dictionary_type_members: Self, dictionary_type_right_angle: Self) -> Self {
1677 let syntax = SyntaxVariant::DictionaryTypeSpecifier(Box::new(DictionaryTypeSpecifierChildren {
1678 dictionary_type_keyword,
1679 dictionary_type_left_angle,
1680 dictionary_type_members,
1681 dictionary_type_right_angle,
1682 }));
1683 let value = V::from_syntax(&syntax);
1684 Self::make(syntax, value)
1685 }
1687 pub fn make_closure_type_specifier(closure_outer_left_paren: Self, closure_coroutine: Self, closure_function_keyword: Self, closure_inner_left_paren: Self, closure_parameter_list: Self, closure_inner_right_paren: Self, closure_colon: Self, closure_return_type: Self, closure_outer_right_paren: Self) -> Self {
1688 let syntax = SyntaxVariant::ClosureTypeSpecifier(Box::new(ClosureTypeSpecifierChildren {
1689 closure_outer_left_paren,
1690 closure_coroutine,
1691 closure_function_keyword,
1692 closure_inner_left_paren,
1693 closure_parameter_list,
1694 closure_inner_right_paren,
1695 closure_colon,
1696 closure_return_type,
1697 closure_outer_right_paren,
1698 }));
1699 let value = V::from_syntax(&syntax);
1700 Self::make(syntax, value)
1701 }
1703 pub fn make_closure_parameter_type_specifier(closure_parameter_call_convention: Self, closure_parameter_type: Self) -> Self {
1704 let syntax = SyntaxVariant::ClosureParameterTypeSpecifier(Box::new(ClosureParameterTypeSpecifierChildren {
1705 closure_parameter_call_convention,
1706 closure_parameter_type,
1707 }));
1708 let value = V::from_syntax(&syntax);
1709 Self::make(syntax, value)
1710 }
1712 pub fn make_classname_type_specifier(classname_keyword: Self, classname_left_angle: Self, classname_type: Self, classname_trailing_comma: Self, classname_right_angle: Self) -> Self {
1713 let syntax = SyntaxVariant::ClassnameTypeSpecifier(Box::new(ClassnameTypeSpecifierChildren {
1714 classname_keyword,
1715 classname_left_angle,
1716 classname_type,
1717 classname_trailing_comma,
1718 classname_right_angle,
1719 }));
1720 let value = V::from_syntax(&syntax);
1721 Self::make(syntax, value)
1722 }
1724 pub fn make_field_specifier(field_question: Self, field_name: Self, field_arrow: Self, field_type: Self) -> Self {
1725 let syntax = SyntaxVariant::FieldSpecifier(Box::new(FieldSpecifierChildren {
1726 field_question,
1727 field_name,
1728 field_arrow,
1729 field_type,
1730 }));
1731 let value = V::from_syntax(&syntax);
1732 Self::make(syntax, value)
1733 }
1735 pub fn make_field_initializer(field_initializer_name: Self, field_initializer_arrow: Self, field_initializer_value: Self) -> Self {
1736 let syntax = SyntaxVariant::FieldInitializer(Box::new(FieldInitializerChildren {
1737 field_initializer_name,
1738 field_initializer_arrow,
1739 field_initializer_value,
1740 }));
1741 let value = V::from_syntax(&syntax);
1742 Self::make(syntax, value)
1743 }
1745 pub fn make_shape_type_specifier(shape_type_keyword: Self, shape_type_left_paren: Self, shape_type_fields: Self, shape_type_ellipsis: Self, shape_type_right_paren: Self) -> Self {
1746 let syntax = SyntaxVariant::ShapeTypeSpecifier(Box::new(ShapeTypeSpecifierChildren {
1747 shape_type_keyword,
1748 shape_type_left_paren,
1749 shape_type_fields,
1750 shape_type_ellipsis,
1751 shape_type_right_paren,
1752 }));
1753 let value = V::from_syntax(&syntax);
1754 Self::make(syntax, value)
1755 }
1757 pub fn make_shape_expression(shape_expression_keyword: Self, shape_expression_left_paren: Self, shape_expression_fields: Self, shape_expression_right_paren: Self) -> Self {
1758 let syntax = SyntaxVariant::ShapeExpression(Box::new(ShapeExpressionChildren {
1759 shape_expression_keyword,
1760 shape_expression_left_paren,
1761 shape_expression_fields,
1762 shape_expression_right_paren,
1763 }));
1764 let value = V::from_syntax(&syntax);
1765 Self::make(syntax, value)
1766 }
1768 pub fn make_tuple_expression(tuple_expression_keyword: Self, tuple_expression_left_paren: Self, tuple_expression_items: Self, tuple_expression_right_paren: Self) -> Self {
1769 let syntax = SyntaxVariant::TupleExpression(Box::new(TupleExpressionChildren {
1770 tuple_expression_keyword,
1771 tuple_expression_left_paren,
1772 tuple_expression_items,
1773 tuple_expression_right_paren,
1774 }));
1775 let value = V::from_syntax(&syntax);
1776 Self::make(syntax, value)
1777 }
1779 pub fn make_generic_type_specifier(generic_class_type: Self, generic_argument_list: Self) -> Self {
1780 let syntax = SyntaxVariant::GenericTypeSpecifier(Box::new(GenericTypeSpecifierChildren {
1781 generic_class_type,
1782 generic_argument_list,
1783 }));
1784 let value = V::from_syntax(&syntax);
1785 Self::make(syntax, value)
1786 }
1788 pub fn make_nullable_type_specifier(nullable_question: Self, nullable_type: Self) -> Self {
1789 let syntax = SyntaxVariant::NullableTypeSpecifier(Box::new(NullableTypeSpecifierChildren {
1790 nullable_question,
1791 nullable_type,
1792 }));
1793 let value = V::from_syntax(&syntax);
1794 Self::make(syntax, value)
1795 }
1797 pub fn make_like_type_specifier(like_tilde: Self, like_type: Self) -> Self {
1798 let syntax = SyntaxVariant::LikeTypeSpecifier(Box::new(LikeTypeSpecifierChildren {
1799 like_tilde,
1800 like_type,
1801 }));
1802 let value = V::from_syntax(&syntax);
1803 Self::make(syntax, value)
1804 }
1806 pub fn make_soft_type_specifier(soft_at: Self, soft_type: Self) -> Self {
1807 let syntax = SyntaxVariant::SoftTypeSpecifier(Box::new(SoftTypeSpecifierChildren {
1808 soft_at,
1809 soft_type,
1810 }));
1811 let value = V::from_syntax(&syntax);
1812 Self::make(syntax, value)
1813 }
1815 pub fn make_reified_type_argument(reified_type_argument_reified: Self, reified_type_argument_type: Self) -> Self {
1816 let syntax = SyntaxVariant::ReifiedTypeArgument(Box::new(ReifiedTypeArgumentChildren {
1817 reified_type_argument_reified,
1818 reified_type_argument_type,
1819 }));
1820 let value = V::from_syntax(&syntax);
1821 Self::make(syntax, value)
1822 }
1824 pub fn make_type_arguments(type_arguments_left_angle: Self, type_arguments_types: Self, type_arguments_right_angle: Self) -> Self {
1825 let syntax = SyntaxVariant::TypeArguments(Box::new(TypeArgumentsChildren {
1826 type_arguments_left_angle,
1827 type_arguments_types,
1828 type_arguments_right_angle,
1829 }));
1830 let value = V::from_syntax(&syntax);
1831 Self::make(syntax, value)
1832 }
1834 pub fn make_type_parameters(type_parameters_left_angle: Self, type_parameters_parameters: Self, type_parameters_right_angle: Self) -> Self {
1835 let syntax = SyntaxVariant::TypeParameters(Box::new(TypeParametersChildren {
1836 type_parameters_left_angle,
1837 type_parameters_parameters,
1838 type_parameters_right_angle,
1839 }));
1840 let value = V::from_syntax(&syntax);
1841 Self::make(syntax, value)
1842 }
1844 pub fn make_tuple_type_specifier(tuple_left_paren: Self, tuple_types: Self, tuple_right_paren: Self) -> Self {
1845 let syntax = SyntaxVariant::TupleTypeSpecifier(Box::new(TupleTypeSpecifierChildren {
1846 tuple_left_paren,
1847 tuple_types,
1848 tuple_right_paren,
1849 }));
1850 let value = V::from_syntax(&syntax);
1851 Self::make(syntax, value)
1852 }
1854 pub fn make_error(error_error: Self) -> Self {
1855 let syntax = SyntaxVariant::ErrorSyntax(Box::new(ErrorSyntaxChildren {
1856 error_error,
1857 }));
1858 let value = V::from_syntax(&syntax);
1859 Self::make(syntax, value)
1860 }
1862 pub fn make_list_item(list_item: Self, list_separator: Self) -> Self {
1863 let syntax = SyntaxVariant::ListItem(Box::new(ListItemChildren {
1864 list_item,
1865 list_separator,
1866 }));
1867 let value = V::from_syntax(&syntax);
1868 Self::make(syntax, value)
1869 }
1871 pub fn make_pocket_atom_expression(pocket_atom_glyph: Self, pocket_atom_expression: Self) -> Self {
1872 let syntax = SyntaxVariant::PocketAtomExpression(Box::new(PocketAtomExpressionChildren {
1873 pocket_atom_glyph,
1874 pocket_atom_expression,
1875 }));
1876 let value = V::from_syntax(&syntax);
1877 Self::make(syntax, value)
1878 }
1880 pub fn make_pocket_identifier_expression(pocket_identifier_qualifier: Self, pocket_identifier_pu_operator: Self, pocket_identifier_field: Self, pocket_identifier_operator: Self, pocket_identifier_name: Self) -> Self {
1881 let syntax = SyntaxVariant::PocketIdentifierExpression(Box::new(PocketIdentifierExpressionChildren {
1882 pocket_identifier_qualifier,
1883 pocket_identifier_pu_operator,
1884 pocket_identifier_field,
1885 pocket_identifier_operator,
1886 pocket_identifier_name,
1887 }));
1888 let value = V::from_syntax(&syntax);
1889 Self::make(syntax, value)
1890 }
1892 pub fn make_pocket_atom_mapping_declaration(pocket_atom_mapping_glyph: Self, pocket_atom_mapping_name: Self, pocket_atom_mapping_left_paren: Self, pocket_atom_mapping_mappings: Self, pocket_atom_mapping_right_paren: Self, pocket_atom_mapping_semicolon: Self) -> Self {
1893 let syntax = SyntaxVariant::PocketAtomMappingDeclaration(Box::new(PocketAtomMappingDeclarationChildren {
1894 pocket_atom_mapping_glyph,
1895 pocket_atom_mapping_name,
1896 pocket_atom_mapping_left_paren,
1897 pocket_atom_mapping_mappings,
1898 pocket_atom_mapping_right_paren,
1899 pocket_atom_mapping_semicolon,
1900 }));
1901 let value = V::from_syntax(&syntax);
1902 Self::make(syntax, value)
1903 }
1905 pub fn make_pocket_enum_declaration(pocket_enum_modifiers: Self, pocket_enum_enum: Self, pocket_enum_name: Self, pocket_enum_left_brace: Self, pocket_enum_fields: Self, pocket_enum_right_brace: Self) -> Self {
1906 let syntax = SyntaxVariant::PocketEnumDeclaration(Box::new(PocketEnumDeclarationChildren {
1907 pocket_enum_modifiers,
1908 pocket_enum_enum,
1909 pocket_enum_name,
1910 pocket_enum_left_brace,
1911 pocket_enum_fields,
1912 pocket_enum_right_brace,
1913 }));
1914 let value = V::from_syntax(&syntax);
1915 Self::make(syntax, value)
1916 }
1918 pub fn make_pocket_field_type_expr_declaration(pocket_field_type_expr_case: Self, pocket_field_type_expr_type: Self, pocket_field_type_expr_name: Self, pocket_field_type_expr_semicolon: Self) -> Self {
1919 let syntax = SyntaxVariant::PocketFieldTypeExprDeclaration(Box::new(PocketFieldTypeExprDeclarationChildren {
1920 pocket_field_type_expr_case,
1921 pocket_field_type_expr_type,
1922 pocket_field_type_expr_name,
1923 pocket_field_type_expr_semicolon,
1924 }));
1925 let value = V::from_syntax(&syntax);
1926 Self::make(syntax, value)
1927 }
1929 pub fn make_pocket_field_type_declaration(pocket_field_type_case: Self, pocket_field_type_type: Self, pocket_field_type_name: Self, pocket_field_type_semicolon: Self) -> Self {
1930 let syntax = SyntaxVariant::PocketFieldTypeDeclaration(Box::new(PocketFieldTypeDeclarationChildren {
1931 pocket_field_type_case,
1932 pocket_field_type_type,
1933 pocket_field_type_name,
1934 pocket_field_type_semicolon,
1935 }));
1936 let value = V::from_syntax(&syntax);
1937 Self::make(syntax, value)
1938 }
1940 pub fn make_pocket_mapping_id_declaration(pocket_mapping_id_name: Self, pocket_mapping_id_initializer: Self) -> Self {
1941 let syntax = SyntaxVariant::PocketMappingIdDeclaration(Box::new(PocketMappingIdDeclarationChildren {
1942 pocket_mapping_id_name,
1943 pocket_mapping_id_initializer,
1944 }));
1945 let value = V::from_syntax(&syntax);
1946 Self::make(syntax, value)
1947 }
1949 pub fn make_pocket_mapping_type_declaration(pocket_mapping_type_keyword: Self, pocket_mapping_type_name: Self, pocket_mapping_type_equal: Self, pocket_mapping_type_type: Self) -> Self {
1950 let syntax = SyntaxVariant::PocketMappingTypeDeclaration(Box::new(PocketMappingTypeDeclarationChildren {
1951 pocket_mapping_type_keyword,
1952 pocket_mapping_type_name,
1953 pocket_mapping_type_equal,
1954 pocket_mapping_type_type,
1955 }));
1956 let value = V::from_syntax(&syntax);
1957 Self::make(syntax, value)
1958 }
1960 pub fn fold_over_children<'a, U>(
1961 f: &Fn(&'a Self, U) -> U,
1962 acc: U,
1963 syntax: &'a SyntaxVariant<T, V>,
1964 ) -> U {
1965 match syntax {
1966 SyntaxVariant::Missing => acc,
1967 SyntaxVariant::Token (_) => acc,
1968 SyntaxVariant::SyntaxList(elems) => {
1969 let mut acc = acc;
1970 for item in elems.iter() {
1971 acc = f(item, acc)
1972 }
1973 acc
1974 },
1975 SyntaxVariant::EndOfFile(x) => {
1976 let acc = f(&x.end_of_file_token, acc);
1977 acc
1978 },
1979 SyntaxVariant::Script(x) => {
1980 let acc = f(&x.script_declarations, acc);
1981 acc
1982 },
1983 SyntaxVariant::QualifiedName(x) => {
1984 let acc = f(&x.qualified_name_parts, acc);
1985 acc
1986 },
1987 SyntaxVariant::SimpleTypeSpecifier(x) => {
1988 let acc = f(&x.simple_type_specifier, acc);
1989 acc
1990 },
1991 SyntaxVariant::LiteralExpression(x) => {
1992 let acc = f(&x.literal_expression, acc);
1993 acc
1994 },
1995 SyntaxVariant::PrefixedStringExpression(x) => {
1996 let acc = f(&x.prefixed_string_name, acc);
1997 let acc = f(&x.prefixed_string_str, acc);
1998 acc
1999 },
2000 SyntaxVariant::VariableExpression(x) => {
2001 let acc = f(&x.variable_expression, acc);
2002 acc
2003 },
2004 SyntaxVariant::PipeVariableExpression(x) => {
2005 let acc = f(&x.pipe_variable_expression, acc);
2006 acc
2007 },
2008 SyntaxVariant::FileAttributeSpecification(x) => {
2009 let acc = f(&x.file_attribute_specification_left_double_angle, acc);
2010 let acc = f(&x.file_attribute_specification_keyword, acc);
2011 let acc = f(&x.file_attribute_specification_colon, acc);
2012 let acc = f(&x.file_attribute_specification_attributes, acc);
2013 let acc = f(&x.file_attribute_specification_right_double_angle, acc);
2014 acc
2015 },
2016 SyntaxVariant::EnumDeclaration(x) => {
2017 let acc = f(&x.enum_attribute_spec, acc);
2018 let acc = f(&x.enum_keyword, acc);
2019 let acc = f(&x.enum_name, acc);
2020 let acc = f(&x.enum_colon, acc);
2021 let acc = f(&x.enum_base, acc);
2022 let acc = f(&x.enum_type, acc);
2023 let acc = f(&x.enum_left_brace, acc);
2024 let acc = f(&x.enum_enumerators, acc);
2025 let acc = f(&x.enum_right_brace, acc);
2026 acc
2027 },
2028 SyntaxVariant::Enumerator(x) => {
2029 let acc = f(&x.enumerator_name, acc);
2030 let acc = f(&x.enumerator_equal, acc);
2031 let acc = f(&x.enumerator_value, acc);
2032 let acc = f(&x.enumerator_semicolon, acc);
2033 acc
2034 },
2035 SyntaxVariant::AliasDeclaration(x) => {
2036 let acc = f(&x.alias_attribute_spec, acc);
2037 let acc = f(&x.alias_keyword, acc);
2038 let acc = f(&x.alias_name, acc);
2039 let acc = f(&x.alias_generic_parameter, acc);
2040 let acc = f(&x.alias_constraint, acc);
2041 let acc = f(&x.alias_equal, acc);
2042 let acc = f(&x.alias_type, acc);
2043 let acc = f(&x.alias_semicolon, acc);
2044 acc
2045 },
2046 SyntaxVariant::PropertyDeclaration(x) => {
2047 let acc = f(&x.property_attribute_spec, acc);
2048 let acc = f(&x.property_modifiers, acc);
2049 let acc = f(&x.property_type, acc);
2050 let acc = f(&x.property_declarators, acc);
2051 let acc = f(&x.property_semicolon, acc);
2052 acc
2053 },
2054 SyntaxVariant::PropertyDeclarator(x) => {
2055 let acc = f(&x.property_name, acc);
2056 let acc = f(&x.property_initializer, acc);
2057 acc
2058 },
2059 SyntaxVariant::NamespaceDeclaration(x) => {
2060 let acc = f(&x.namespace_keyword, acc);
2061 let acc = f(&x.namespace_name, acc);
2062 let acc = f(&x.namespace_body, acc);
2063 acc
2064 },
2065 SyntaxVariant::NamespaceBody(x) => {
2066 let acc = f(&x.namespace_left_brace, acc);
2067 let acc = f(&x.namespace_declarations, acc);
2068 let acc = f(&x.namespace_right_brace, acc);
2069 acc
2070 },
2071 SyntaxVariant::NamespaceEmptyBody(x) => {
2072 let acc = f(&x.namespace_semicolon, acc);
2073 acc
2074 },
2075 SyntaxVariant::NamespaceUseDeclaration(x) => {
2076 let acc = f(&x.namespace_use_keyword, acc);
2077 let acc = f(&x.namespace_use_kind, acc);
2078 let acc = f(&x.namespace_use_clauses, acc);
2079 let acc = f(&x.namespace_use_semicolon, acc);
2080 acc
2081 },
2082 SyntaxVariant::NamespaceGroupUseDeclaration(x) => {
2083 let acc = f(&x.namespace_group_use_keyword, acc);
2084 let acc = f(&x.namespace_group_use_kind, acc);
2085 let acc = f(&x.namespace_group_use_prefix, acc);
2086 let acc = f(&x.namespace_group_use_left_brace, acc);
2087 let acc = f(&x.namespace_group_use_clauses, acc);
2088 let acc = f(&x.namespace_group_use_right_brace, acc);
2089 let acc = f(&x.namespace_group_use_semicolon, acc);
2090 acc
2091 },
2092 SyntaxVariant::NamespaceUseClause(x) => {
2093 let acc = f(&x.namespace_use_clause_kind, acc);
2094 let acc = f(&x.namespace_use_name, acc);
2095 let acc = f(&x.namespace_use_as, acc);
2096 let acc = f(&x.namespace_use_alias, acc);
2097 acc
2098 },
2099 SyntaxVariant::FunctionDeclaration(x) => {
2100 let acc = f(&x.function_attribute_spec, acc);
2101 let acc = f(&x.function_declaration_header, acc);
2102 let acc = f(&x.function_body, acc);
2103 acc
2104 },
2105 SyntaxVariant::FunctionDeclarationHeader(x) => {
2106 let acc = f(&x.function_modifiers, acc);
2107 let acc = f(&x.function_keyword, acc);
2108 let acc = f(&x.function_name, acc);
2109 let acc = f(&x.function_type_parameter_list, acc);
2110 let acc = f(&x.function_left_paren, acc);
2111 let acc = f(&x.function_parameter_list, acc);
2112 let acc = f(&x.function_right_paren, acc);
2113 let acc = f(&x.function_colon, acc);
2114 let acc = f(&x.function_type, acc);
2115 let acc = f(&x.function_where_clause, acc);
2116 acc
2117 },
2118 SyntaxVariant::WhereClause(x) => {
2119 let acc = f(&x.where_clause_keyword, acc);
2120 let acc = f(&x.where_clause_constraints, acc);
2121 acc
2122 },
2123 SyntaxVariant::WhereConstraint(x) => {
2124 let acc = f(&x.where_constraint_left_type, acc);
2125 let acc = f(&x.where_constraint_operator, acc);
2126 let acc = f(&x.where_constraint_right_type, acc);
2127 acc
2128 },
2129 SyntaxVariant::MethodishDeclaration(x) => {
2130 let acc = f(&x.methodish_attribute, acc);
2131 let acc = f(&x.methodish_function_decl_header, acc);
2132 let acc = f(&x.methodish_function_body, acc);
2133 let acc = f(&x.methodish_semicolon, acc);
2134 acc
2135 },
2136 SyntaxVariant::MethodishTraitResolution(x) => {
2137 let acc = f(&x.methodish_trait_attribute, acc);
2138 let acc = f(&x.methodish_trait_function_decl_header, acc);
2139 let acc = f(&x.methodish_trait_equal, acc);
2140 let acc = f(&x.methodish_trait_name, acc);
2141 let acc = f(&x.methodish_trait_semicolon, acc);
2142 acc
2143 },
2144 SyntaxVariant::ClassishDeclaration(x) => {
2145 let acc = f(&x.classish_attribute, acc);
2146 let acc = f(&x.classish_modifiers, acc);
2147 let acc = f(&x.classish_keyword, acc);
2148 let acc = f(&x.classish_name, acc);
2149 let acc = f(&x.classish_type_parameters, acc);
2150 let acc = f(&x.classish_extends_keyword, acc);
2151 let acc = f(&x.classish_extends_list, acc);
2152 let acc = f(&x.classish_implements_keyword, acc);
2153 let acc = f(&x.classish_implements_list, acc);
2154 let acc = f(&x.classish_body, acc);
2155 acc
2156 },
2157 SyntaxVariant::ClassishBody(x) => {
2158 let acc = f(&x.classish_body_left_brace, acc);
2159 let acc = f(&x.classish_body_elements, acc);
2160 let acc = f(&x.classish_body_right_brace, acc);
2161 acc
2162 },
2163 SyntaxVariant::TraitUsePrecedenceItem(x) => {
2164 let acc = f(&x.trait_use_precedence_item_name, acc);
2165 let acc = f(&x.trait_use_precedence_item_keyword, acc);
2166 let acc = f(&x.trait_use_precedence_item_removed_names, acc);
2167 acc
2168 },
2169 SyntaxVariant::TraitUseAliasItem(x) => {
2170 let acc = f(&x.trait_use_alias_item_aliasing_name, acc);
2171 let acc = f(&x.trait_use_alias_item_keyword, acc);
2172 let acc = f(&x.trait_use_alias_item_modifiers, acc);
2173 let acc = f(&x.trait_use_alias_item_aliased_name, acc);
2174 acc
2175 },
2176 SyntaxVariant::TraitUseConflictResolution(x) => {
2177 let acc = f(&x.trait_use_conflict_resolution_keyword, acc);
2178 let acc = f(&x.trait_use_conflict_resolution_names, acc);
2179 let acc = f(&x.trait_use_conflict_resolution_left_brace, acc);
2180 let acc = f(&x.trait_use_conflict_resolution_clauses, acc);
2181 let acc = f(&x.trait_use_conflict_resolution_right_brace, acc);
2182 acc
2183 },
2184 SyntaxVariant::TraitUse(x) => {
2185 let acc = f(&x.trait_use_keyword, acc);
2186 let acc = f(&x.trait_use_names, acc);
2187 let acc = f(&x.trait_use_semicolon, acc);
2188 acc
2189 },
2190 SyntaxVariant::RequireClause(x) => {
2191 let acc = f(&x.require_keyword, acc);
2192 let acc = f(&x.require_kind, acc);
2193 let acc = f(&x.require_name, acc);
2194 let acc = f(&x.require_semicolon, acc);
2195 acc
2196 },
2197 SyntaxVariant::ConstDeclaration(x) => {
2198 let acc = f(&x.const_visibility, acc);
2199 let acc = f(&x.const_abstract, acc);
2200 let acc = f(&x.const_keyword, acc);
2201 let acc = f(&x.const_type_specifier, acc);
2202 let acc = f(&x.const_declarators, acc);
2203 let acc = f(&x.const_semicolon, acc);
2204 acc
2205 },
2206 SyntaxVariant::ConstantDeclarator(x) => {
2207 let acc = f(&x.constant_declarator_name, acc);
2208 let acc = f(&x.constant_declarator_initializer, acc);
2209 acc
2210 },
2211 SyntaxVariant::TypeConstDeclaration(x) => {
2212 let acc = f(&x.type_const_attribute_spec, acc);
2213 let acc = f(&x.type_const_abstract, acc);
2214 let acc = f(&x.type_const_keyword, acc);
2215 let acc = f(&x.type_const_type_keyword, acc);
2216 let acc = f(&x.type_const_name, acc);
2217 let acc = f(&x.type_const_type_parameters, acc);
2218 let acc = f(&x.type_const_type_constraint, acc);
2219 let acc = f(&x.type_const_equal, acc);
2220 let acc = f(&x.type_const_type_specifier, acc);
2221 let acc = f(&x.type_const_semicolon, acc);
2222 acc
2223 },
2224 SyntaxVariant::DecoratedExpression(x) => {
2225 let acc = f(&x.decorated_expression_decorator, acc);
2226 let acc = f(&x.decorated_expression_expression, acc);
2227 acc
2228 },
2229 SyntaxVariant::ParameterDeclaration(x) => {
2230 let acc = f(&x.parameter_attribute, acc);
2231 let acc = f(&x.parameter_visibility, acc);
2232 let acc = f(&x.parameter_call_convention, acc);
2233 let acc = f(&x.parameter_type, acc);
2234 let acc = f(&x.parameter_name, acc);
2235 let acc = f(&x.parameter_default_value, acc);
2236 acc
2237 },
2238 SyntaxVariant::VariadicParameter(x) => {
2239 let acc = f(&x.variadic_parameter_call_convention, acc);
2240 let acc = f(&x.variadic_parameter_type, acc);
2241 let acc = f(&x.variadic_parameter_ellipsis, acc);
2242 acc
2243 },
2244 SyntaxVariant::AttributeSpecification(x) => {
2245 let acc = f(&x.attribute_specification_left_double_angle, acc);
2246 let acc = f(&x.attribute_specification_attributes, acc);
2247 let acc = f(&x.attribute_specification_right_double_angle, acc);
2248 acc
2249 },
2250 SyntaxVariant::InclusionExpression(x) => {
2251 let acc = f(&x.inclusion_require, acc);
2252 let acc = f(&x.inclusion_filename, acc);
2253 acc
2254 },
2255 SyntaxVariant::InclusionDirective(x) => {
2256 let acc = f(&x.inclusion_expression, acc);
2257 let acc = f(&x.inclusion_semicolon, acc);
2258 acc
2259 },
2260 SyntaxVariant::CompoundStatement(x) => {
2261 let acc = f(&x.compound_left_brace, acc);
2262 let acc = f(&x.compound_statements, acc);
2263 let acc = f(&x.compound_right_brace, acc);
2264 acc
2265 },
2266 SyntaxVariant::AlternateLoopStatement(x) => {
2267 let acc = f(&x.alternate_loop_opening_colon, acc);
2268 let acc = f(&x.alternate_loop_statements, acc);
2269 let acc = f(&x.alternate_loop_closing_keyword, acc);
2270 let acc = f(&x.alternate_loop_closing_semicolon, acc);
2271 acc
2272 },
2273 SyntaxVariant::ExpressionStatement(x) => {
2274 let acc = f(&x.expression_statement_expression, acc);
2275 let acc = f(&x.expression_statement_semicolon, acc);
2276 acc
2277 },
2278 SyntaxVariant::MarkupSection(x) => {
2279 let acc = f(&x.markup_prefix, acc);
2280 let acc = f(&x.markup_text, acc);
2281 let acc = f(&x.markup_suffix, acc);
2282 let acc = f(&x.markup_expression, acc);
2283 acc
2284 },
2285 SyntaxVariant::MarkupSuffix(x) => {
2286 let acc = f(&x.markup_suffix_less_than_question, acc);
2287 let acc = f(&x.markup_suffix_name, acc);
2288 acc
2289 },
2290 SyntaxVariant::UnsetStatement(x) => {
2291 let acc = f(&x.unset_keyword, acc);
2292 let acc = f(&x.unset_left_paren, acc);
2293 let acc = f(&x.unset_variables, acc);
2294 let acc = f(&x.unset_right_paren, acc);
2295 let acc = f(&x.unset_semicolon, acc);
2296 acc
2297 },
2298 SyntaxVariant::LetStatement(x) => {
2299 let acc = f(&x.let_statement_keyword, acc);
2300 let acc = f(&x.let_statement_name, acc);
2301 let acc = f(&x.let_statement_colon, acc);
2302 let acc = f(&x.let_statement_type, acc);
2303 let acc = f(&x.let_statement_initializer, acc);
2304 let acc = f(&x.let_statement_semicolon, acc);
2305 acc
2306 },
2307 SyntaxVariant::UsingStatementBlockScoped(x) => {
2308 let acc = f(&x.using_block_await_keyword, acc);
2309 let acc = f(&x.using_block_using_keyword, acc);
2310 let acc = f(&x.using_block_left_paren, acc);
2311 let acc = f(&x.using_block_expressions, acc);
2312 let acc = f(&x.using_block_right_paren, acc);
2313 let acc = f(&x.using_block_body, acc);
2314 acc
2315 },
2316 SyntaxVariant::UsingStatementFunctionScoped(x) => {
2317 let acc = f(&x.using_function_await_keyword, acc);
2318 let acc = f(&x.using_function_using_keyword, acc);
2319 let acc = f(&x.using_function_expression, acc);
2320 let acc = f(&x.using_function_semicolon, acc);
2321 acc
2322 },
2323 SyntaxVariant::DeclareDirectiveStatement(x) => {
2324 let acc = f(&x.declare_directive_keyword, acc);
2325 let acc = f(&x.declare_directive_left_paren, acc);
2326 let acc = f(&x.declare_directive_expression, acc);
2327 let acc = f(&x.declare_directive_right_paren, acc);
2328 let acc = f(&x.declare_directive_semicolon, acc);
2329 acc
2330 },
2331 SyntaxVariant::DeclareBlockStatement(x) => {
2332 let acc = f(&x.declare_block_keyword, acc);
2333 let acc = f(&x.declare_block_left_paren, acc);
2334 let acc = f(&x.declare_block_expression, acc);
2335 let acc = f(&x.declare_block_right_paren, acc);
2336 let acc = f(&x.declare_block_body, acc);
2337 acc
2338 },
2339 SyntaxVariant::WhileStatement(x) => {
2340 let acc = f(&x.while_keyword, acc);
2341 let acc = f(&x.while_left_paren, acc);
2342 let acc = f(&x.while_condition, acc);
2343 let acc = f(&x.while_right_paren, acc);
2344 let acc = f(&x.while_body, acc);
2345 acc
2346 },
2347 SyntaxVariant::IfStatement(x) => {
2348 let acc = f(&x.if_keyword, acc);
2349 let acc = f(&x.if_left_paren, acc);
2350 let acc = f(&x.if_condition, acc);
2351 let acc = f(&x.if_right_paren, acc);
2352 let acc = f(&x.if_statement, acc);
2353 let acc = f(&x.if_elseif_clauses, acc);
2354 let acc = f(&x.if_else_clause, acc);
2355 acc
2356 },
2357 SyntaxVariant::ElseifClause(x) => {
2358 let acc = f(&x.elseif_keyword, acc);
2359 let acc = f(&x.elseif_left_paren, acc);
2360 let acc = f(&x.elseif_condition, acc);
2361 let acc = f(&x.elseif_right_paren, acc);
2362 let acc = f(&x.elseif_statement, acc);
2363 acc
2364 },
2365 SyntaxVariant::ElseClause(x) => {
2366 let acc = f(&x.else_keyword, acc);
2367 let acc = f(&x.else_statement, acc);
2368 acc
2369 },
2370 SyntaxVariant::AlternateIfStatement(x) => {
2371 let acc = f(&x.alternate_if_keyword, acc);
2372 let acc = f(&x.alternate_if_left_paren, acc);
2373 let acc = f(&x.alternate_if_condition, acc);
2374 let acc = f(&x.alternate_if_right_paren, acc);
2375 let acc = f(&x.alternate_if_colon, acc);
2376 let acc = f(&x.alternate_if_statement, acc);
2377 let acc = f(&x.alternate_if_elseif_clauses, acc);
2378 let acc = f(&x.alternate_if_else_clause, acc);
2379 let acc = f(&x.alternate_if_endif_keyword, acc);
2380 let acc = f(&x.alternate_if_semicolon, acc);
2381 acc
2382 },
2383 SyntaxVariant::AlternateElseifClause(x) => {
2384 let acc = f(&x.alternate_elseif_keyword, acc);
2385 let acc = f(&x.alternate_elseif_left_paren, acc);
2386 let acc = f(&x.alternate_elseif_condition, acc);
2387 let acc = f(&x.alternate_elseif_right_paren, acc);
2388 let acc = f(&x.alternate_elseif_colon, acc);
2389 let acc = f(&x.alternate_elseif_statement, acc);
2390 acc
2391 },
2392 SyntaxVariant::AlternateElseClause(x) => {
2393 let acc = f(&x.alternate_else_keyword, acc);
2394 let acc = f(&x.alternate_else_colon, acc);
2395 let acc = f(&x.alternate_else_statement, acc);
2396 acc
2397 },
2398 SyntaxVariant::TryStatement(x) => {
2399 let acc = f(&x.try_keyword, acc);
2400 let acc = f(&x.try_compound_statement, acc);
2401 let acc = f(&x.try_catch_clauses, acc);
2402 let acc = f(&x.try_finally_clause, acc);
2403 acc
2404 },
2405 SyntaxVariant::CatchClause(x) => {
2406 let acc = f(&x.catch_keyword, acc);
2407 let acc = f(&x.catch_left_paren, acc);
2408 let acc = f(&x.catch_type, acc);
2409 let acc = f(&x.catch_variable, acc);
2410 let acc = f(&x.catch_right_paren, acc);
2411 let acc = f(&x.catch_body, acc);
2412 acc
2413 },
2414 SyntaxVariant::FinallyClause(x) => {
2415 let acc = f(&x.finally_keyword, acc);
2416 let acc = f(&x.finally_body, acc);
2417 acc
2418 },
2419 SyntaxVariant::DoStatement(x) => {
2420 let acc = f(&x.do_keyword, acc);
2421 let acc = f(&x.do_body, acc);
2422 let acc = f(&x.do_while_keyword, acc);
2423 let acc = f(&x.do_left_paren, acc);
2424 let acc = f(&x.do_condition, acc);
2425 let acc = f(&x.do_right_paren, acc);
2426 let acc = f(&x.do_semicolon, acc);
2427 acc
2428 },
2429 SyntaxVariant::ForStatement(x) => {
2430 let acc = f(&x.for_keyword, acc);
2431 let acc = f(&x.for_left_paren, acc);
2432 let acc = f(&x.for_initializer, acc);
2433 let acc = f(&x.for_first_semicolon, acc);
2434 let acc = f(&x.for_control, acc);
2435 let acc = f(&x.for_second_semicolon, acc);
2436 let acc = f(&x.for_end_of_loop, acc);
2437 let acc = f(&x.for_right_paren, acc);
2438 let acc = f(&x.for_body, acc);
2439 acc
2440 },
2441 SyntaxVariant::ForeachStatement(x) => {
2442 let acc = f(&x.foreach_keyword, acc);
2443 let acc = f(&x.foreach_left_paren, acc);
2444 let acc = f(&x.foreach_collection, acc);
2445 let acc = f(&x.foreach_await_keyword, acc);
2446 let acc = f(&x.foreach_as, acc);
2447 let acc = f(&x.foreach_key, acc);
2448 let acc = f(&x.foreach_arrow, acc);
2449 let acc = f(&x.foreach_value, acc);
2450 let acc = f(&x.foreach_right_paren, acc);
2451 let acc = f(&x.foreach_body, acc);
2452 acc
2453 },
2454 SyntaxVariant::SwitchStatement(x) => {
2455 let acc = f(&x.switch_keyword, acc);
2456 let acc = f(&x.switch_left_paren, acc);
2457 let acc = f(&x.switch_expression, acc);
2458 let acc = f(&x.switch_right_paren, acc);
2459 let acc = f(&x.switch_left_brace, acc);
2460 let acc = f(&x.switch_sections, acc);
2461 let acc = f(&x.switch_right_brace, acc);
2462 acc
2463 },
2464 SyntaxVariant::AlternateSwitchStatement(x) => {
2465 let acc = f(&x.alternate_switch_keyword, acc);
2466 let acc = f(&x.alternate_switch_left_paren, acc);
2467 let acc = f(&x.alternate_switch_expression, acc);
2468 let acc = f(&x.alternate_switch_right_paren, acc);
2469 let acc = f(&x.alternate_switch_opening_colon, acc);
2470 let acc = f(&x.alternate_switch_sections, acc);
2471 let acc = f(&x.alternate_switch_closing_endswitch, acc);
2472 let acc = f(&x.alternate_switch_closing_semicolon, acc);
2473 acc
2474 },
2475 SyntaxVariant::SwitchSection(x) => {
2476 let acc = f(&x.switch_section_labels, acc);
2477 let acc = f(&x.switch_section_statements, acc);
2478 let acc = f(&x.switch_section_fallthrough, acc);
2479 acc
2480 },
2481 SyntaxVariant::SwitchFallthrough(x) => {
2482 let acc = f(&x.fallthrough_keyword, acc);
2483 let acc = f(&x.fallthrough_semicolon, acc);
2484 acc
2485 },
2486 SyntaxVariant::CaseLabel(x) => {
2487 let acc = f(&x.case_keyword, acc);
2488 let acc = f(&x.case_expression, acc);
2489 let acc = f(&x.case_colon, acc);
2490 acc
2491 },
2492 SyntaxVariant::DefaultLabel(x) => {
2493 let acc = f(&x.default_keyword, acc);
2494 let acc = f(&x.default_colon, acc);
2495 acc
2496 },
2497 SyntaxVariant::ReturnStatement(x) => {
2498 let acc = f(&x.return_keyword, acc);
2499 let acc = f(&x.return_expression, acc);
2500 let acc = f(&x.return_semicolon, acc);
2501 acc
2502 },
2503 SyntaxVariant::GotoLabel(x) => {
2504 let acc = f(&x.goto_label_name, acc);
2505 let acc = f(&x.goto_label_colon, acc);
2506 acc
2507 },
2508 SyntaxVariant::GotoStatement(x) => {
2509 let acc = f(&x.goto_statement_keyword, acc);
2510 let acc = f(&x.goto_statement_label_name, acc);
2511 let acc = f(&x.goto_statement_semicolon, acc);
2512 acc
2513 },
2514 SyntaxVariant::ThrowStatement(x) => {
2515 let acc = f(&x.throw_keyword, acc);
2516 let acc = f(&x.throw_expression, acc);
2517 let acc = f(&x.throw_semicolon, acc);
2518 acc
2519 },
2520 SyntaxVariant::BreakStatement(x) => {
2521 let acc = f(&x.break_keyword, acc);
2522 let acc = f(&x.break_level, acc);
2523 let acc = f(&x.break_semicolon, acc);
2524 acc
2525 },
2526 SyntaxVariant::ContinueStatement(x) => {
2527 let acc = f(&x.continue_keyword, acc);
2528 let acc = f(&x.continue_level, acc);
2529 let acc = f(&x.continue_semicolon, acc);
2530 acc
2531 },
2532 SyntaxVariant::EchoStatement(x) => {
2533 let acc = f(&x.echo_keyword, acc);
2534 let acc = f(&x.echo_expressions, acc);
2535 let acc = f(&x.echo_semicolon, acc);
2536 acc
2537 },
2538 SyntaxVariant::ConcurrentStatement(x) => {
2539 let acc = f(&x.concurrent_keyword, acc);
2540 let acc = f(&x.concurrent_statement, acc);
2541 acc
2542 },
2543 SyntaxVariant::SimpleInitializer(x) => {
2544 let acc = f(&x.simple_initializer_equal, acc);
2545 let acc = f(&x.simple_initializer_value, acc);
2546 acc
2547 },
2548 SyntaxVariant::AnonymousClass(x) => {
2549 let acc = f(&x.anonymous_class_class_keyword, acc);
2550 let acc = f(&x.anonymous_class_left_paren, acc);
2551 let acc = f(&x.anonymous_class_argument_list, acc);
2552 let acc = f(&x.anonymous_class_right_paren, acc);
2553 let acc = f(&x.anonymous_class_extends_keyword, acc);
2554 let acc = f(&x.anonymous_class_extends_list, acc);
2555 let acc = f(&x.anonymous_class_implements_keyword, acc);
2556 let acc = f(&x.anonymous_class_implements_list, acc);
2557 let acc = f(&x.anonymous_class_body, acc);
2558 acc
2559 },
2560 SyntaxVariant::AnonymousFunction(x) => {
2561 let acc = f(&x.anonymous_attribute_spec, acc);
2562 let acc = f(&x.anonymous_static_keyword, acc);
2563 let acc = f(&x.anonymous_async_keyword, acc);
2564 let acc = f(&x.anonymous_coroutine_keyword, acc);
2565 let acc = f(&x.anonymous_function_keyword, acc);
2566 let acc = f(&x.anonymous_left_paren, acc);
2567 let acc = f(&x.anonymous_parameters, acc);
2568 let acc = f(&x.anonymous_right_paren, acc);
2569 let acc = f(&x.anonymous_colon, acc);
2570 let acc = f(&x.anonymous_type, acc);
2571 let acc = f(&x.anonymous_use, acc);
2572 let acc = f(&x.anonymous_body, acc);
2573 acc
2574 },
2575 SyntaxVariant::Php7AnonymousFunction(x) => {
2576 let acc = f(&x.php7_anonymous_attribute_spec, acc);
2577 let acc = f(&x.php7_anonymous_static_keyword, acc);
2578 let acc = f(&x.php7_anonymous_async_keyword, acc);
2579 let acc = f(&x.php7_anonymous_coroutine_keyword, acc);
2580 let acc = f(&x.php7_anonymous_function_keyword, acc);
2581 let acc = f(&x.php7_anonymous_left_paren, acc);
2582 let acc = f(&x.php7_anonymous_parameters, acc);
2583 let acc = f(&x.php7_anonymous_right_paren, acc);
2584 let acc = f(&x.php7_anonymous_use, acc);
2585 let acc = f(&x.php7_anonymous_colon, acc);
2586 let acc = f(&x.php7_anonymous_type, acc);
2587 let acc = f(&x.php7_anonymous_body, acc);
2588 acc
2589 },
2590 SyntaxVariant::AnonymousFunctionUseClause(x) => {
2591 let acc = f(&x.anonymous_use_keyword, acc);
2592 let acc = f(&x.anonymous_use_left_paren, acc);
2593 let acc = f(&x.anonymous_use_variables, acc);
2594 let acc = f(&x.anonymous_use_right_paren, acc);
2595 acc
2596 },
2597 SyntaxVariant::LambdaExpression(x) => {
2598 let acc = f(&x.lambda_attribute_spec, acc);
2599 let acc = f(&x.lambda_async, acc);
2600 let acc = f(&x.lambda_coroutine, acc);
2601 let acc = f(&x.lambda_signature, acc);
2602 let acc = f(&x.lambda_arrow, acc);
2603 let acc = f(&x.lambda_body, acc);
2604 acc
2605 },
2606 SyntaxVariant::LambdaSignature(x) => {
2607 let acc = f(&x.lambda_left_paren, acc);
2608 let acc = f(&x.lambda_parameters, acc);
2609 let acc = f(&x.lambda_right_paren, acc);
2610 let acc = f(&x.lambda_colon, acc);
2611 let acc = f(&x.lambda_type, acc);
2612 acc
2613 },
2614 SyntaxVariant::CastExpression(x) => {
2615 let acc = f(&x.cast_left_paren, acc);
2616 let acc = f(&x.cast_type, acc);
2617 let acc = f(&x.cast_right_paren, acc);
2618 let acc = f(&x.cast_operand, acc);
2619 acc
2620 },
2621 SyntaxVariant::ScopeResolutionExpression(x) => {
2622 let acc = f(&x.scope_resolution_qualifier, acc);
2623 let acc = f(&x.scope_resolution_operator, acc);
2624 let acc = f(&x.scope_resolution_name, acc);
2625 acc
2626 },
2627 SyntaxVariant::MemberSelectionExpression(x) => {
2628 let acc = f(&x.member_object, acc);
2629 let acc = f(&x.member_operator, acc);
2630 let acc = f(&x.member_name, acc);
2631 acc
2632 },
2633 SyntaxVariant::SafeMemberSelectionExpression(x) => {
2634 let acc = f(&x.safe_member_object, acc);
2635 let acc = f(&x.safe_member_operator, acc);
2636 let acc = f(&x.safe_member_name, acc);
2637 acc
2638 },
2639 SyntaxVariant::EmbeddedMemberSelectionExpression(x) => {
2640 let acc = f(&x.embedded_member_object, acc);
2641 let acc = f(&x.embedded_member_operator, acc);
2642 let acc = f(&x.embedded_member_name, acc);
2643 acc
2644 },
2645 SyntaxVariant::YieldExpression(x) => {
2646 let acc = f(&x.yield_keyword, acc);
2647 let acc = f(&x.yield_operand, acc);
2648 acc
2649 },
2650 SyntaxVariant::YieldFromExpression(x) => {
2651 let acc = f(&x.yield_from_yield_keyword, acc);
2652 let acc = f(&x.yield_from_from_keyword, acc);
2653 let acc = f(&x.yield_from_operand, acc);
2654 acc
2655 },
2656 SyntaxVariant::PrefixUnaryExpression(x) => {
2657 let acc = f(&x.prefix_unary_operator, acc);
2658 let acc = f(&x.prefix_unary_operand, acc);
2659 acc
2660 },
2661 SyntaxVariant::PostfixUnaryExpression(x) => {
2662 let acc = f(&x.postfix_unary_operand, acc);
2663 let acc = f(&x.postfix_unary_operator, acc);
2664 acc
2665 },
2666 SyntaxVariant::BinaryExpression(x) => {
2667 let acc = f(&x.binary_left_operand, acc);
2668 let acc = f(&x.binary_operator, acc);
2669 let acc = f(&x.binary_right_operand, acc);
2670 acc
2671 },
2672 SyntaxVariant::InstanceofExpression(x) => {
2673 let acc = f(&x.instanceof_left_operand, acc);
2674 let acc = f(&x.instanceof_operator, acc);
2675 let acc = f(&x.instanceof_right_operand, acc);
2676 acc
2677 },
2678 SyntaxVariant::IsExpression(x) => {
2679 let acc = f(&x.is_left_operand, acc);
2680 let acc = f(&x.is_operator, acc);
2681 let acc = f(&x.is_right_operand, acc);
2682 acc
2683 },
2684 SyntaxVariant::AsExpression(x) => {
2685 let acc = f(&x.as_left_operand, acc);
2686 let acc = f(&x.as_operator, acc);
2687 let acc = f(&x.as_right_operand, acc);
2688 acc
2689 },
2690 SyntaxVariant::NullableAsExpression(x) => {
2691 let acc = f(&x.nullable_as_left_operand, acc);
2692 let acc = f(&x.nullable_as_operator, acc);
2693 let acc = f(&x.nullable_as_right_operand, acc);
2694 acc
2695 },
2696 SyntaxVariant::ConditionalExpression(x) => {
2697 let acc = f(&x.conditional_test, acc);
2698 let acc = f(&x.conditional_question, acc);
2699 let acc = f(&x.conditional_consequence, acc);
2700 let acc = f(&x.conditional_colon, acc);
2701 let acc = f(&x.conditional_alternative, acc);
2702 acc
2703 },
2704 SyntaxVariant::EvalExpression(x) => {
2705 let acc = f(&x.eval_keyword, acc);
2706 let acc = f(&x.eval_left_paren, acc);
2707 let acc = f(&x.eval_argument, acc);
2708 let acc = f(&x.eval_right_paren, acc);
2709 acc
2710 },
2711 SyntaxVariant::EmptyExpression(x) => {
2712 let acc = f(&x.empty_keyword, acc);
2713 let acc = f(&x.empty_left_paren, acc);
2714 let acc = f(&x.empty_argument, acc);
2715 let acc = f(&x.empty_right_paren, acc);
2716 acc
2717 },
2718 SyntaxVariant::DefineExpression(x) => {
2719 let acc = f(&x.define_keyword, acc);
2720 let acc = f(&x.define_left_paren, acc);
2721 let acc = f(&x.define_argument_list, acc);
2722 let acc = f(&x.define_right_paren, acc);
2723 acc
2724 },
2725 SyntaxVariant::HaltCompilerExpression(x) => {
2726 let acc = f(&x.halt_compiler_keyword, acc);
2727 let acc = f(&x.halt_compiler_left_paren, acc);
2728 let acc = f(&x.halt_compiler_argument_list, acc);
2729 let acc = f(&x.halt_compiler_right_paren, acc);
2730 acc
2731 },
2732 SyntaxVariant::IssetExpression(x) => {
2733 let acc = f(&x.isset_keyword, acc);
2734 let acc = f(&x.isset_left_paren, acc);
2735 let acc = f(&x.isset_argument_list, acc);
2736 let acc = f(&x.isset_right_paren, acc);
2737 acc
2738 },
2739 SyntaxVariant::FunctionCallExpression(x) => {
2740 let acc = f(&x.function_call_receiver, acc);
2741 let acc = f(&x.function_call_type_args, acc);
2742 let acc = f(&x.function_call_left_paren, acc);
2743 let acc = f(&x.function_call_argument_list, acc);
2744 let acc = f(&x.function_call_right_paren, acc);
2745 acc
2746 },
2747 SyntaxVariant::ParenthesizedExpression(x) => {
2748 let acc = f(&x.parenthesized_expression_left_paren, acc);
2749 let acc = f(&x.parenthesized_expression_expression, acc);
2750 let acc = f(&x.parenthesized_expression_right_paren, acc);
2751 acc
2752 },
2753 SyntaxVariant::BracedExpression(x) => {
2754 let acc = f(&x.braced_expression_left_brace, acc);
2755 let acc = f(&x.braced_expression_expression, acc);
2756 let acc = f(&x.braced_expression_right_brace, acc);
2757 acc
2758 },
2759 SyntaxVariant::EmbeddedBracedExpression(x) => {
2760 let acc = f(&x.embedded_braced_expression_left_brace, acc);
2761 let acc = f(&x.embedded_braced_expression_expression, acc);
2762 let acc = f(&x.embedded_braced_expression_right_brace, acc);
2763 acc
2764 },
2765 SyntaxVariant::ListExpression(x) => {
2766 let acc = f(&x.list_keyword, acc);
2767 let acc = f(&x.list_left_paren, acc);
2768 let acc = f(&x.list_members, acc);
2769 let acc = f(&x.list_right_paren, acc);
2770 acc
2771 },
2772 SyntaxVariant::CollectionLiteralExpression(x) => {
2773 let acc = f(&x.collection_literal_name, acc);
2774 let acc = f(&x.collection_literal_left_brace, acc);
2775 let acc = f(&x.collection_literal_initializers, acc);
2776 let acc = f(&x.collection_literal_right_brace, acc);
2777 acc
2778 },
2779 SyntaxVariant::ObjectCreationExpression(x) => {
2780 let acc = f(&x.object_creation_new_keyword, acc);
2781 let acc = f(&x.object_creation_object, acc);
2782 acc
2783 },
2784 SyntaxVariant::ConstructorCall(x) => {
2785 let acc = f(&x.constructor_call_type, acc);
2786 let acc = f(&x.constructor_call_left_paren, acc);
2787 let acc = f(&x.constructor_call_argument_list, acc);
2788 let acc = f(&x.constructor_call_right_paren, acc);
2789 acc
2790 },
2791 SyntaxVariant::ArrayCreationExpression(x) => {
2792 let acc = f(&x.array_creation_left_bracket, acc);
2793 let acc = f(&x.array_creation_members, acc);
2794 let acc = f(&x.array_creation_right_bracket, acc);
2795 acc
2796 },
2797 SyntaxVariant::ArrayIntrinsicExpression(x) => {
2798 let acc = f(&x.array_intrinsic_keyword, acc);
2799 let acc = f(&x.array_intrinsic_left_paren, acc);
2800 let acc = f(&x.array_intrinsic_members, acc);
2801 let acc = f(&x.array_intrinsic_right_paren, acc);
2802 acc
2803 },
2804 SyntaxVariant::DarrayIntrinsicExpression(x) => {
2805 let acc = f(&x.darray_intrinsic_keyword, acc);
2806 let acc = f(&x.darray_intrinsic_explicit_type, acc);
2807 let acc = f(&x.darray_intrinsic_left_bracket, acc);
2808 let acc = f(&x.darray_intrinsic_members, acc);
2809 let acc = f(&x.darray_intrinsic_right_bracket, acc);
2810 acc
2811 },
2812 SyntaxVariant::DictionaryIntrinsicExpression(x) => {
2813 let acc = f(&x.dictionary_intrinsic_keyword, acc);
2814 let acc = f(&x.dictionary_intrinsic_explicit_type, acc);
2815 let acc = f(&x.dictionary_intrinsic_left_bracket, acc);
2816 let acc = f(&x.dictionary_intrinsic_members, acc);
2817 let acc = f(&x.dictionary_intrinsic_right_bracket, acc);
2818 acc
2819 },
2820 SyntaxVariant::KeysetIntrinsicExpression(x) => {
2821 let acc = f(&x.keyset_intrinsic_keyword, acc);
2822 let acc = f(&x.keyset_intrinsic_explicit_type, acc);
2823 let acc = f(&x.keyset_intrinsic_left_bracket, acc);
2824 let acc = f(&x.keyset_intrinsic_members, acc);
2825 let acc = f(&x.keyset_intrinsic_right_bracket, acc);
2826 acc
2827 },
2828 SyntaxVariant::VarrayIntrinsicExpression(x) => {
2829 let acc = f(&x.varray_intrinsic_keyword, acc);
2830 let acc = f(&x.varray_intrinsic_explicit_type, acc);
2831 let acc = f(&x.varray_intrinsic_left_bracket, acc);
2832 let acc = f(&x.varray_intrinsic_members, acc);
2833 let acc = f(&x.varray_intrinsic_right_bracket, acc);
2834 acc
2835 },
2836 SyntaxVariant::VectorIntrinsicExpression(x) => {
2837 let acc = f(&x.vector_intrinsic_keyword, acc);
2838 let acc = f(&x.vector_intrinsic_explicit_type, acc);
2839 let acc = f(&x.vector_intrinsic_left_bracket, acc);
2840 let acc = f(&x.vector_intrinsic_members, acc);
2841 let acc = f(&x.vector_intrinsic_right_bracket, acc);
2842 acc
2843 },
2844 SyntaxVariant::ElementInitializer(x) => {
2845 let acc = f(&x.element_key, acc);
2846 let acc = f(&x.element_arrow, acc);
2847 let acc = f(&x.element_value, acc);
2848 acc
2849 },
2850 SyntaxVariant::SubscriptExpression(x) => {
2851 let acc = f(&x.subscript_receiver, acc);
2852 let acc = f(&x.subscript_left_bracket, acc);
2853 let acc = f(&x.subscript_index, acc);
2854 let acc = f(&x.subscript_right_bracket, acc);
2855 acc
2856 },
2857 SyntaxVariant::EmbeddedSubscriptExpression(x) => {
2858 let acc = f(&x.embedded_subscript_receiver, acc);
2859 let acc = f(&x.embedded_subscript_left_bracket, acc);
2860 let acc = f(&x.embedded_subscript_index, acc);
2861 let acc = f(&x.embedded_subscript_right_bracket, acc);
2862 acc
2863 },
2864 SyntaxVariant::AwaitableCreationExpression(x) => {
2865 let acc = f(&x.awaitable_attribute_spec, acc);
2866 let acc = f(&x.awaitable_async, acc);
2867 let acc = f(&x.awaitable_coroutine, acc);
2868 let acc = f(&x.awaitable_compound_statement, acc);
2869 acc
2870 },
2871 SyntaxVariant::XHPChildrenDeclaration(x) => {
2872 let acc = f(&x.xhp_children_keyword, acc);
2873 let acc = f(&x.xhp_children_expression, acc);
2874 let acc = f(&x.xhp_children_semicolon, acc);
2875 acc
2876 },
2877 SyntaxVariant::XHPChildrenParenthesizedList(x) => {
2878 let acc = f(&x.xhp_children_list_left_paren, acc);
2879 let acc = f(&x.xhp_children_list_xhp_children, acc);
2880 let acc = f(&x.xhp_children_list_right_paren, acc);
2881 acc
2882 },
2883 SyntaxVariant::XHPCategoryDeclaration(x) => {
2884 let acc = f(&x.xhp_category_keyword, acc);
2885 let acc = f(&x.xhp_category_categories, acc);
2886 let acc = f(&x.xhp_category_semicolon, acc);
2887 acc
2888 },
2889 SyntaxVariant::XHPEnumType(x) => {
2890 let acc = f(&x.xhp_enum_optional, acc);
2891 let acc = f(&x.xhp_enum_keyword, acc);
2892 let acc = f(&x.xhp_enum_left_brace, acc);
2893 let acc = f(&x.xhp_enum_values, acc);
2894 let acc = f(&x.xhp_enum_right_brace, acc);
2895 acc
2896 },
2897 SyntaxVariant::XHPRequired(x) => {
2898 let acc = f(&x.xhp_required_at, acc);
2899 let acc = f(&x.xhp_required_keyword, acc);
2900 acc
2901 },
2902 SyntaxVariant::XHPClassAttributeDeclaration(x) => {
2903 let acc = f(&x.xhp_attribute_keyword, acc);
2904 let acc = f(&x.xhp_attribute_attributes, acc);
2905 let acc = f(&x.xhp_attribute_semicolon, acc);
2906 acc
2907 },
2908 SyntaxVariant::XHPClassAttribute(x) => {
2909 let acc = f(&x.xhp_attribute_decl_type, acc);
2910 let acc = f(&x.xhp_attribute_decl_name, acc);
2911 let acc = f(&x.xhp_attribute_decl_initializer, acc);
2912 let acc = f(&x.xhp_attribute_decl_required, acc);
2913 acc
2914 },
2915 SyntaxVariant::XHPSimpleClassAttribute(x) => {
2916 let acc = f(&x.xhp_simple_class_attribute_type, acc);
2917 acc
2918 },
2919 SyntaxVariant::XHPSimpleAttribute(x) => {
2920 let acc = f(&x.xhp_simple_attribute_name, acc);
2921 let acc = f(&x.xhp_simple_attribute_equal, acc);
2922 let acc = f(&x.xhp_simple_attribute_expression, acc);
2923 acc
2924 },
2925 SyntaxVariant::XHPSpreadAttribute(x) => {
2926 let acc = f(&x.xhp_spread_attribute_left_brace, acc);
2927 let acc = f(&x.xhp_spread_attribute_spread_operator, acc);
2928 let acc = f(&x.xhp_spread_attribute_expression, acc);
2929 let acc = f(&x.xhp_spread_attribute_right_brace, acc);
2930 acc
2931 },
2932 SyntaxVariant::XHPOpen(x) => {
2933 let acc = f(&x.xhp_open_left_angle, acc);
2934 let acc = f(&x.xhp_open_name, acc);
2935 let acc = f(&x.xhp_open_attributes, acc);
2936 let acc = f(&x.xhp_open_right_angle, acc);
2937 acc
2938 },
2939 SyntaxVariant::XHPExpression(x) => {
2940 let acc = f(&x.xhp_open, acc);
2941 let acc = f(&x.xhp_body, acc);
2942 let acc = f(&x.xhp_close, acc);
2943 acc
2944 },
2945 SyntaxVariant::XHPClose(x) => {
2946 let acc = f(&x.xhp_close_left_angle, acc);
2947 let acc = f(&x.xhp_close_name, acc);
2948 let acc = f(&x.xhp_close_right_angle, acc);
2949 acc
2950 },
2951 SyntaxVariant::TypeConstant(x) => {
2952 let acc = f(&x.type_constant_left_type, acc);
2953 let acc = f(&x.type_constant_separator, acc);
2954 let acc = f(&x.type_constant_right_type, acc);
2955 acc
2956 },
2957 SyntaxVariant::VectorTypeSpecifier(x) => {
2958 let acc = f(&x.vector_type_keyword, acc);
2959 let acc = f(&x.vector_type_left_angle, acc);
2960 let acc = f(&x.vector_type_type, acc);
2961 let acc = f(&x.vector_type_trailing_comma, acc);
2962 let acc = f(&x.vector_type_right_angle, acc);
2963 acc
2964 },
2965 SyntaxVariant::KeysetTypeSpecifier(x) => {
2966 let acc = f(&x.keyset_type_keyword, acc);
2967 let acc = f(&x.keyset_type_left_angle, acc);
2968 let acc = f(&x.keyset_type_type, acc);
2969 let acc = f(&x.keyset_type_trailing_comma, acc);
2970 let acc = f(&x.keyset_type_right_angle, acc);
2971 acc
2972 },
2973 SyntaxVariant::TupleTypeExplicitSpecifier(x) => {
2974 let acc = f(&x.tuple_type_keyword, acc);
2975 let acc = f(&x.tuple_type_left_angle, acc);
2976 let acc = f(&x.tuple_type_types, acc);
2977 let acc = f(&x.tuple_type_right_angle, acc);
2978 acc
2979 },
2980 SyntaxVariant::VarrayTypeSpecifier(x) => {
2981 let acc = f(&x.varray_keyword, acc);
2982 let acc = f(&x.varray_left_angle, acc);
2983 let acc = f(&x.varray_type, acc);
2984 let acc = f(&x.varray_trailing_comma, acc);
2985 let acc = f(&x.varray_right_angle, acc);
2986 acc
2987 },
2988 SyntaxVariant::VectorArrayTypeSpecifier(x) => {
2989 let acc = f(&x.vector_array_keyword, acc);
2990 let acc = f(&x.vector_array_left_angle, acc);
2991 let acc = f(&x.vector_array_type, acc);
2992 let acc = f(&x.vector_array_right_angle, acc);
2993 acc
2994 },
2995 SyntaxVariant::TypeParameter(x) => {
2996 let acc = f(&x.type_attribute_spec, acc);
2997 let acc = f(&x.type_reified, acc);
2998 let acc = f(&x.type_variance, acc);
2999 let acc = f(&x.type_name, acc);
3000 let acc = f(&x.type_constraints, acc);
3001 acc
3002 },
3003 SyntaxVariant::TypeConstraint(x) => {
3004 let acc = f(&x.constraint_keyword, acc);
3005 let acc = f(&x.constraint_type, acc);
3006 acc
3007 },
3008 SyntaxVariant::DarrayTypeSpecifier(x) => {
3009 let acc = f(&x.darray_keyword, acc);
3010 let acc = f(&x.darray_left_angle, acc);
3011 let acc = f(&x.darray_key, acc);
3012 let acc = f(&x.darray_comma, acc);
3013 let acc = f(&x.darray_value, acc);
3014 let acc = f(&x.darray_trailing_comma, acc);
3015 let acc = f(&x.darray_right_angle, acc);
3016 acc
3017 },
3018 SyntaxVariant::MapArrayTypeSpecifier(x) => {
3019 let acc = f(&x.map_array_keyword, acc);
3020 let acc = f(&x.map_array_left_angle, acc);
3021 let acc = f(&x.map_array_key, acc);
3022 let acc = f(&x.map_array_comma, acc);
3023 let acc = f(&x.map_array_value, acc);
3024 let acc = f(&x.map_array_right_angle, acc);
3025 acc
3026 },
3027 SyntaxVariant::DictionaryTypeSpecifier(x) => {
3028 let acc = f(&x.dictionary_type_keyword, acc);
3029 let acc = f(&x.dictionary_type_left_angle, acc);
3030 let acc = f(&x.dictionary_type_members, acc);
3031 let acc = f(&x.dictionary_type_right_angle, acc);
3032 acc
3033 },
3034 SyntaxVariant::ClosureTypeSpecifier(x) => {
3035 let acc = f(&x.closure_outer_left_paren, acc);
3036 let acc = f(&x.closure_coroutine, acc);
3037 let acc = f(&x.closure_function_keyword, acc);
3038 let acc = f(&x.closure_inner_left_paren, acc);
3039 let acc = f(&x.closure_parameter_list, acc);
3040 let acc = f(&x.closure_inner_right_paren, acc);
3041 let acc = f(&x.closure_colon, acc);
3042 let acc = f(&x.closure_return_type, acc);
3043 let acc = f(&x.closure_outer_right_paren, acc);
3044 acc
3045 },
3046 SyntaxVariant::ClosureParameterTypeSpecifier(x) => {
3047 let acc = f(&x.closure_parameter_call_convention, acc);
3048 let acc = f(&x.closure_parameter_type, acc);
3049 acc
3050 },
3051 SyntaxVariant::ClassnameTypeSpecifier(x) => {
3052 let acc = f(&x.classname_keyword, acc);
3053 let acc = f(&x.classname_left_angle, acc);
3054 let acc = f(&x.classname_type, acc);
3055 let acc = f(&x.classname_trailing_comma, acc);
3056 let acc = f(&x.classname_right_angle, acc);
3057 acc
3058 },
3059 SyntaxVariant::FieldSpecifier(x) => {
3060 let acc = f(&x.field_question, acc);
3061 let acc = f(&x.field_name, acc);
3062 let acc = f(&x.field_arrow, acc);
3063 let acc = f(&x.field_type, acc);
3064 acc
3065 },
3066 SyntaxVariant::FieldInitializer(x) => {
3067 let acc = f(&x.field_initializer_name, acc);
3068 let acc = f(&x.field_initializer_arrow, acc);
3069 let acc = f(&x.field_initializer_value, acc);
3070 acc
3071 },
3072 SyntaxVariant::ShapeTypeSpecifier(x) => {
3073 let acc = f(&x.shape_type_keyword, acc);
3074 let acc = f(&x.shape_type_left_paren, acc);
3075 let acc = f(&x.shape_type_fields, acc);
3076 let acc = f(&x.shape_type_ellipsis, acc);
3077 let acc = f(&x.shape_type_right_paren, acc);
3078 acc
3079 },
3080 SyntaxVariant::ShapeExpression(x) => {
3081 let acc = f(&x.shape_expression_keyword, acc);
3082 let acc = f(&x.shape_expression_left_paren, acc);
3083 let acc = f(&x.shape_expression_fields, acc);
3084 let acc = f(&x.shape_expression_right_paren, acc);
3085 acc
3086 },
3087 SyntaxVariant::TupleExpression(x) => {
3088 let acc = f(&x.tuple_expression_keyword, acc);
3089 let acc = f(&x.tuple_expression_left_paren, acc);
3090 let acc = f(&x.tuple_expression_items, acc);
3091 let acc = f(&x.tuple_expression_right_paren, acc);
3092 acc
3093 },
3094 SyntaxVariant::GenericTypeSpecifier(x) => {
3095 let acc = f(&x.generic_class_type, acc);
3096 let acc = f(&x.generic_argument_list, acc);
3097 acc
3098 },
3099 SyntaxVariant::NullableTypeSpecifier(x) => {
3100 let acc = f(&x.nullable_question, acc);
3101 let acc = f(&x.nullable_type, acc);
3102 acc
3103 },
3104 SyntaxVariant::LikeTypeSpecifier(x) => {
3105 let acc = f(&x.like_tilde, acc);
3106 let acc = f(&x.like_type, acc);
3107 acc
3108 },
3109 SyntaxVariant::SoftTypeSpecifier(x) => {
3110 let acc = f(&x.soft_at, acc);
3111 let acc = f(&x.soft_type, acc);
3112 acc
3113 },
3114 SyntaxVariant::ReifiedTypeArgument(x) => {
3115 let acc = f(&x.reified_type_argument_reified, acc);
3116 let acc = f(&x.reified_type_argument_type, acc);
3117 acc
3118 },
3119 SyntaxVariant::TypeArguments(x) => {
3120 let acc = f(&x.type_arguments_left_angle, acc);
3121 let acc = f(&x.type_arguments_types, acc);
3122 let acc = f(&x.type_arguments_right_angle, acc);
3123 acc
3124 },
3125 SyntaxVariant::TypeParameters(x) => {
3126 let acc = f(&x.type_parameters_left_angle, acc);
3127 let acc = f(&x.type_parameters_parameters, acc);
3128 let acc = f(&x.type_parameters_right_angle, acc);
3129 acc
3130 },
3131 SyntaxVariant::TupleTypeSpecifier(x) => {
3132 let acc = f(&x.tuple_left_paren, acc);
3133 let acc = f(&x.tuple_types, acc);
3134 let acc = f(&x.tuple_right_paren, acc);
3135 acc
3136 },
3137 SyntaxVariant::ErrorSyntax(x) => {
3138 let acc = f(&x.error_error, acc);
3139 acc
3140 },
3141 SyntaxVariant::ListItem(x) => {
3142 let acc = f(&x.list_item, acc);
3143 let acc = f(&x.list_separator, acc);
3144 acc
3145 },
3146 SyntaxVariant::PocketAtomExpression(x) => {
3147 let acc = f(&x.pocket_atom_glyph, acc);
3148 let acc = f(&x.pocket_atom_expression, acc);
3149 acc
3150 },
3151 SyntaxVariant::PocketIdentifierExpression(x) => {
3152 let acc = f(&x.pocket_identifier_qualifier, acc);
3153 let acc = f(&x.pocket_identifier_pu_operator, acc);
3154 let acc = f(&x.pocket_identifier_field, acc);
3155 let acc = f(&x.pocket_identifier_operator, acc);
3156 let acc = f(&x.pocket_identifier_name, acc);
3157 acc
3158 },
3159 SyntaxVariant::PocketAtomMappingDeclaration(x) => {
3160 let acc = f(&x.pocket_atom_mapping_glyph, acc);
3161 let acc = f(&x.pocket_atom_mapping_name, acc);
3162 let acc = f(&x.pocket_atom_mapping_left_paren, acc);
3163 let acc = f(&x.pocket_atom_mapping_mappings, acc);
3164 let acc = f(&x.pocket_atom_mapping_right_paren, acc);
3165 let acc = f(&x.pocket_atom_mapping_semicolon, acc);
3166 acc
3167 },
3168 SyntaxVariant::PocketEnumDeclaration(x) => {
3169 let acc = f(&x.pocket_enum_modifiers, acc);
3170 let acc = f(&x.pocket_enum_enum, acc);
3171 let acc = f(&x.pocket_enum_name, acc);
3172 let acc = f(&x.pocket_enum_left_brace, acc);
3173 let acc = f(&x.pocket_enum_fields, acc);
3174 let acc = f(&x.pocket_enum_right_brace, acc);
3175 acc
3176 },
3177 SyntaxVariant::PocketFieldTypeExprDeclaration(x) => {
3178 let acc = f(&x.pocket_field_type_expr_case, acc);
3179 let acc = f(&x.pocket_field_type_expr_type, acc);
3180 let acc = f(&x.pocket_field_type_expr_name, acc);
3181 let acc = f(&x.pocket_field_type_expr_semicolon, acc);
3182 acc
3183 },
3184 SyntaxVariant::PocketFieldTypeDeclaration(x) => {
3185 let acc = f(&x.pocket_field_type_case, acc);
3186 let acc = f(&x.pocket_field_type_type, acc);
3187 let acc = f(&x.pocket_field_type_name, acc);
3188 let acc = f(&x.pocket_field_type_semicolon, acc);
3189 acc
3190 },
3191 SyntaxVariant::PocketMappingIdDeclaration(x) => {
3192 let acc = f(&x.pocket_mapping_id_name, acc);
3193 let acc = f(&x.pocket_mapping_id_initializer, acc);
3194 acc
3195 },
3196 SyntaxVariant::PocketMappingTypeDeclaration(x) => {
3197 let acc = f(&x.pocket_mapping_type_keyword, acc);
3198 let acc = f(&x.pocket_mapping_type_name, acc);
3199 let acc = f(&x.pocket_mapping_type_equal, acc);
3200 let acc = f(&x.pocket_mapping_type_type, acc);
3201 acc
3202 },
3204 }
3205 }
3207 pub fn kind(&self) -> SyntaxKind {
3208 match self.syntax {
3209 SyntaxVariant::Missing => SyntaxKind::Missing,
3210 SyntaxVariant::Token (_) => SyntaxKind::Token,
3211 SyntaxVariant::SyntaxList (_) => SyntaxKind::SyntaxList,
3212 SyntaxVariant::EndOfFile {..} => SyntaxKind::EndOfFile,
3213 SyntaxVariant::Script {..} => SyntaxKind::Script,
3214 SyntaxVariant::QualifiedName {..} => SyntaxKind::QualifiedName,
3215 SyntaxVariant::SimpleTypeSpecifier {..} => SyntaxKind::SimpleTypeSpecifier,
3216 SyntaxVariant::LiteralExpression {..} => SyntaxKind::LiteralExpression,
3217 SyntaxVariant::PrefixedStringExpression {..} => SyntaxKind::PrefixedStringExpression,
3218 SyntaxVariant::VariableExpression {..} => SyntaxKind::VariableExpression,
3219 SyntaxVariant::PipeVariableExpression {..} => SyntaxKind::PipeVariableExpression,
3220 SyntaxVariant::FileAttributeSpecification {..} => SyntaxKind::FileAttributeSpecification,
3221 SyntaxVariant::EnumDeclaration {..} => SyntaxKind::EnumDeclaration,
3222 SyntaxVariant::Enumerator {..} => SyntaxKind::Enumerator,
3223 SyntaxVariant::AliasDeclaration {..} => SyntaxKind::AliasDeclaration,
3224 SyntaxVariant::PropertyDeclaration {..} => SyntaxKind::PropertyDeclaration,
3225 SyntaxVariant::PropertyDeclarator {..} => SyntaxKind::PropertyDeclarator,
3226 SyntaxVariant::NamespaceDeclaration {..} => SyntaxKind::NamespaceDeclaration,
3227 SyntaxVariant::NamespaceBody {..} => SyntaxKind::NamespaceBody,
3228 SyntaxVariant::NamespaceEmptyBody {..} => SyntaxKind::NamespaceEmptyBody,
3229 SyntaxVariant::NamespaceUseDeclaration {..} => SyntaxKind::NamespaceUseDeclaration,
3230 SyntaxVariant::NamespaceGroupUseDeclaration {..} => SyntaxKind::NamespaceGroupUseDeclaration,
3231 SyntaxVariant::NamespaceUseClause {..} => SyntaxKind::NamespaceUseClause,
3232 SyntaxVariant::FunctionDeclaration {..} => SyntaxKind::FunctionDeclaration,
3233 SyntaxVariant::FunctionDeclarationHeader {..} => SyntaxKind::FunctionDeclarationHeader,
3234 SyntaxVariant::WhereClause {..} => SyntaxKind::WhereClause,
3235 SyntaxVariant::WhereConstraint {..} => SyntaxKind::WhereConstraint,
3236 SyntaxVariant::MethodishDeclaration {..} => SyntaxKind::MethodishDeclaration,
3237 SyntaxVariant::MethodishTraitResolution {..} => SyntaxKind::MethodishTraitResolution,
3238 SyntaxVariant::ClassishDeclaration {..} => SyntaxKind::ClassishDeclaration,
3239 SyntaxVariant::ClassishBody {..} => SyntaxKind::ClassishBody,
3240 SyntaxVariant::TraitUsePrecedenceItem {..} => SyntaxKind::TraitUsePrecedenceItem,
3241 SyntaxVariant::TraitUseAliasItem {..} => SyntaxKind::TraitUseAliasItem,
3242 SyntaxVariant::TraitUseConflictResolution {..} => SyntaxKind::TraitUseConflictResolution,
3243 SyntaxVariant::TraitUse {..} => SyntaxKind::TraitUse,
3244 SyntaxVariant::RequireClause {..} => SyntaxKind::RequireClause,
3245 SyntaxVariant::ConstDeclaration {..} => SyntaxKind::ConstDeclaration,
3246 SyntaxVariant::ConstantDeclarator {..} => SyntaxKind::ConstantDeclarator,
3247 SyntaxVariant::TypeConstDeclaration {..} => SyntaxKind::TypeConstDeclaration,
3248 SyntaxVariant::DecoratedExpression {..} => SyntaxKind::DecoratedExpression,
3249 SyntaxVariant::ParameterDeclaration {..} => SyntaxKind::ParameterDeclaration,
3250 SyntaxVariant::VariadicParameter {..} => SyntaxKind::VariadicParameter,
3251 SyntaxVariant::AttributeSpecification {..} => SyntaxKind::AttributeSpecification,
3252 SyntaxVariant::InclusionExpression {..} => SyntaxKind::InclusionExpression,
3253 SyntaxVariant::InclusionDirective {..} => SyntaxKind::InclusionDirective,
3254 SyntaxVariant::CompoundStatement {..} => SyntaxKind::CompoundStatement,
3255 SyntaxVariant::AlternateLoopStatement {..} => SyntaxKind::AlternateLoopStatement,
3256 SyntaxVariant::ExpressionStatement {..} => SyntaxKind::ExpressionStatement,
3257 SyntaxVariant::MarkupSection {..} => SyntaxKind::MarkupSection,
3258 SyntaxVariant::MarkupSuffix {..} => SyntaxKind::MarkupSuffix,
3259 SyntaxVariant::UnsetStatement {..} => SyntaxKind::UnsetStatement,
3260 SyntaxVariant::LetStatement {..} => SyntaxKind::LetStatement,
3261 SyntaxVariant::UsingStatementBlockScoped {..} => SyntaxKind::UsingStatementBlockScoped,
3262 SyntaxVariant::UsingStatementFunctionScoped {..} => SyntaxKind::UsingStatementFunctionScoped,
3263 SyntaxVariant::DeclareDirectiveStatement {..} => SyntaxKind::DeclareDirectiveStatement,
3264 SyntaxVariant::DeclareBlockStatement {..} => SyntaxKind::DeclareBlockStatement,
3265 SyntaxVariant::WhileStatement {..} => SyntaxKind::WhileStatement,
3266 SyntaxVariant::IfStatement {..} => SyntaxKind::IfStatement,
3267 SyntaxVariant::ElseifClause {..} => SyntaxKind::ElseifClause,
3268 SyntaxVariant::ElseClause {..} => SyntaxKind::ElseClause,
3269 SyntaxVariant::AlternateIfStatement {..} => SyntaxKind::AlternateIfStatement,
3270 SyntaxVariant::AlternateElseifClause {..} => SyntaxKind::AlternateElseifClause,
3271 SyntaxVariant::AlternateElseClause {..} => SyntaxKind::AlternateElseClause,
3272 SyntaxVariant::TryStatement {..} => SyntaxKind::TryStatement,
3273 SyntaxVariant::CatchClause {..} => SyntaxKind::CatchClause,
3274 SyntaxVariant::FinallyClause {..} => SyntaxKind::FinallyClause,
3275 SyntaxVariant::DoStatement {..} => SyntaxKind::DoStatement,
3276 SyntaxVariant::ForStatement {..} => SyntaxKind::ForStatement,
3277 SyntaxVariant::ForeachStatement {..} => SyntaxKind::ForeachStatement,
3278 SyntaxVariant::SwitchStatement {..} => SyntaxKind::SwitchStatement,
3279 SyntaxVariant::AlternateSwitchStatement {..} => SyntaxKind::AlternateSwitchStatement,
3280 SyntaxVariant::SwitchSection {..} => SyntaxKind::SwitchSection,
3281 SyntaxVariant::SwitchFallthrough {..} => SyntaxKind::SwitchFallthrough,
3282 SyntaxVariant::CaseLabel {..} => SyntaxKind::CaseLabel,
3283 SyntaxVariant::DefaultLabel {..} => SyntaxKind::DefaultLabel,
3284 SyntaxVariant::ReturnStatement {..} => SyntaxKind::ReturnStatement,
3285 SyntaxVariant::GotoLabel {..} => SyntaxKind::GotoLabel,
3286 SyntaxVariant::GotoStatement {..} => SyntaxKind::GotoStatement,
3287 SyntaxVariant::ThrowStatement {..} => SyntaxKind::ThrowStatement,
3288 SyntaxVariant::BreakStatement {..} => SyntaxKind::BreakStatement,
3289 SyntaxVariant::ContinueStatement {..} => SyntaxKind::ContinueStatement,
3290 SyntaxVariant::EchoStatement {..} => SyntaxKind::EchoStatement,
3291 SyntaxVariant::ConcurrentStatement {..} => SyntaxKind::ConcurrentStatement,
3292 SyntaxVariant::SimpleInitializer {..} => SyntaxKind::SimpleInitializer,
3293 SyntaxVariant::AnonymousClass {..} => SyntaxKind::AnonymousClass,
3294 SyntaxVariant::AnonymousFunction {..} => SyntaxKind::AnonymousFunction,
3295 SyntaxVariant::Php7AnonymousFunction {..} => SyntaxKind::Php7AnonymousFunction,
3296 SyntaxVariant::AnonymousFunctionUseClause {..} => SyntaxKind::AnonymousFunctionUseClause,
3297 SyntaxVariant::LambdaExpression {..} => SyntaxKind::LambdaExpression,
3298 SyntaxVariant::LambdaSignature {..} => SyntaxKind::LambdaSignature,
3299 SyntaxVariant::CastExpression {..} => SyntaxKind::CastExpression,
3300 SyntaxVariant::ScopeResolutionExpression {..} => SyntaxKind::ScopeResolutionExpression,
3301 SyntaxVariant::MemberSelectionExpression {..} => SyntaxKind::MemberSelectionExpression,
3302 SyntaxVariant::SafeMemberSelectionExpression {..} => SyntaxKind::SafeMemberSelectionExpression,
3303 SyntaxVariant::EmbeddedMemberSelectionExpression {..} => SyntaxKind::EmbeddedMemberSelectionExpression,
3304 SyntaxVariant::YieldExpression {..} => SyntaxKind::YieldExpression,
3305 SyntaxVariant::YieldFromExpression {..} => SyntaxKind::YieldFromExpression,
3306 SyntaxVariant::PrefixUnaryExpression {..} => SyntaxKind::PrefixUnaryExpression,
3307 SyntaxVariant::PostfixUnaryExpression {..} => SyntaxKind::PostfixUnaryExpression,
3308 SyntaxVariant::BinaryExpression {..} => SyntaxKind::BinaryExpression,
3309 SyntaxVariant::InstanceofExpression {..} => SyntaxKind::InstanceofExpression,
3310 SyntaxVariant::IsExpression {..} => SyntaxKind::IsExpression,
3311 SyntaxVariant::AsExpression {..} => SyntaxKind::AsExpression,
3312 SyntaxVariant::NullableAsExpression {..} => SyntaxKind::NullableAsExpression,
3313 SyntaxVariant::ConditionalExpression {..} => SyntaxKind::ConditionalExpression,
3314 SyntaxVariant::EvalExpression {..} => SyntaxKind::EvalExpression,
3315 SyntaxVariant::EmptyExpression {..} => SyntaxKind::EmptyExpression,
3316 SyntaxVariant::DefineExpression {..} => SyntaxKind::DefineExpression,
3317 SyntaxVariant::HaltCompilerExpression {..} => SyntaxKind::HaltCompilerExpression,
3318 SyntaxVariant::IssetExpression {..} => SyntaxKind::IssetExpression,
3319 SyntaxVariant::FunctionCallExpression {..} => SyntaxKind::FunctionCallExpression,
3320 SyntaxVariant::ParenthesizedExpression {..} => SyntaxKind::ParenthesizedExpression,
3321 SyntaxVariant::BracedExpression {..} => SyntaxKind::BracedExpression,
3322 SyntaxVariant::EmbeddedBracedExpression {..} => SyntaxKind::EmbeddedBracedExpression,
3323 SyntaxVariant::ListExpression {..} => SyntaxKind::ListExpression,
3324 SyntaxVariant::CollectionLiteralExpression {..} => SyntaxKind::CollectionLiteralExpression,
3325 SyntaxVariant::ObjectCreationExpression {..} => SyntaxKind::ObjectCreationExpression,
3326 SyntaxVariant::ConstructorCall {..} => SyntaxKind::ConstructorCall,
3327 SyntaxVariant::ArrayCreationExpression {..} => SyntaxKind::ArrayCreationExpression,
3328 SyntaxVariant::ArrayIntrinsicExpression {..} => SyntaxKind::ArrayIntrinsicExpression,
3329 SyntaxVariant::DarrayIntrinsicExpression {..} => SyntaxKind::DarrayIntrinsicExpression,
3330 SyntaxVariant::DictionaryIntrinsicExpression {..} => SyntaxKind::DictionaryIntrinsicExpression,
3331 SyntaxVariant::KeysetIntrinsicExpression {..} => SyntaxKind::KeysetIntrinsicExpression,
3332 SyntaxVariant::VarrayIntrinsicExpression {..} => SyntaxKind::VarrayIntrinsicExpression,
3333 SyntaxVariant::VectorIntrinsicExpression {..} => SyntaxKind::VectorIntrinsicExpression,
3334 SyntaxVariant::ElementInitializer {..} => SyntaxKind::ElementInitializer,
3335 SyntaxVariant::SubscriptExpression {..} => SyntaxKind::SubscriptExpression,
3336 SyntaxVariant::EmbeddedSubscriptExpression {..} => SyntaxKind::EmbeddedSubscriptExpression,
3337 SyntaxVariant::AwaitableCreationExpression {..} => SyntaxKind::AwaitableCreationExpression,
3338 SyntaxVariant::XHPChildrenDeclaration {..} => SyntaxKind::XHPChildrenDeclaration,
3339 SyntaxVariant::XHPChildrenParenthesizedList {..} => SyntaxKind::XHPChildrenParenthesizedList,
3340 SyntaxVariant::XHPCategoryDeclaration {..} => SyntaxKind::XHPCategoryDeclaration,
3341 SyntaxVariant::XHPEnumType {..} => SyntaxKind::XHPEnumType,
3342 SyntaxVariant::XHPRequired {..} => SyntaxKind::XHPRequired,
3343 SyntaxVariant::XHPClassAttributeDeclaration {..} => SyntaxKind::XHPClassAttributeDeclaration,
3344 SyntaxVariant::XHPClassAttribute {..} => SyntaxKind::XHPClassAttribute,
3345 SyntaxVariant::XHPSimpleClassAttribute {..} => SyntaxKind::XHPSimpleClassAttribute,
3346 SyntaxVariant::XHPSimpleAttribute {..} => SyntaxKind::XHPSimpleAttribute,
3347 SyntaxVariant::XHPSpreadAttribute {..} => SyntaxKind::XHPSpreadAttribute,
3348 SyntaxVariant::XHPOpen {..} => SyntaxKind::XHPOpen,
3349 SyntaxVariant::XHPExpression {..} => SyntaxKind::XHPExpression,
3350 SyntaxVariant::XHPClose {..} => SyntaxKind::XHPClose,
3351 SyntaxVariant::TypeConstant {..} => SyntaxKind::TypeConstant,
3352 SyntaxVariant::VectorTypeSpecifier {..} => SyntaxKind::VectorTypeSpecifier,
3353 SyntaxVariant::KeysetTypeSpecifier {..} => SyntaxKind::KeysetTypeSpecifier,
3354 SyntaxVariant::TupleTypeExplicitSpecifier {..} => SyntaxKind::TupleTypeExplicitSpecifier,
3355 SyntaxVariant::VarrayTypeSpecifier {..} => SyntaxKind::VarrayTypeSpecifier,
3356 SyntaxVariant::VectorArrayTypeSpecifier {..} => SyntaxKind::VectorArrayTypeSpecifier,
3357 SyntaxVariant::TypeParameter {..} => SyntaxKind::TypeParameter,
3358 SyntaxVariant::TypeConstraint {..} => SyntaxKind::TypeConstraint,
3359 SyntaxVariant::DarrayTypeSpecifier {..} => SyntaxKind::DarrayTypeSpecifier,
3360 SyntaxVariant::MapArrayTypeSpecifier {..} => SyntaxKind::MapArrayTypeSpecifier,
3361 SyntaxVariant::DictionaryTypeSpecifier {..} => SyntaxKind::DictionaryTypeSpecifier,
3362 SyntaxVariant::ClosureTypeSpecifier {..} => SyntaxKind::ClosureTypeSpecifier,
3363 SyntaxVariant::ClosureParameterTypeSpecifier {..} => SyntaxKind::ClosureParameterTypeSpecifier,
3364 SyntaxVariant::ClassnameTypeSpecifier {..} => SyntaxKind::ClassnameTypeSpecifier,
3365 SyntaxVariant::FieldSpecifier {..} => SyntaxKind::FieldSpecifier,
3366 SyntaxVariant::FieldInitializer {..} => SyntaxKind::FieldInitializer,
3367 SyntaxVariant::ShapeTypeSpecifier {..} => SyntaxKind::ShapeTypeSpecifier,
3368 SyntaxVariant::ShapeExpression {..} => SyntaxKind::ShapeExpression,
3369 SyntaxVariant::TupleExpression {..} => SyntaxKind::TupleExpression,
3370 SyntaxVariant::GenericTypeSpecifier {..} => SyntaxKind::GenericTypeSpecifier,
3371 SyntaxVariant::NullableTypeSpecifier {..} => SyntaxKind::NullableTypeSpecifier,
3372 SyntaxVariant::LikeTypeSpecifier {..} => SyntaxKind::LikeTypeSpecifier,
3373 SyntaxVariant::SoftTypeSpecifier {..} => SyntaxKind::SoftTypeSpecifier,
3374 SyntaxVariant::ReifiedTypeArgument {..} => SyntaxKind::ReifiedTypeArgument,
3375 SyntaxVariant::TypeArguments {..} => SyntaxKind::TypeArguments,
3376 SyntaxVariant::TypeParameters {..} => SyntaxKind::TypeParameters,
3377 SyntaxVariant::TupleTypeSpecifier {..} => SyntaxKind::TupleTypeSpecifier,
3378 SyntaxVariant::ErrorSyntax {..} => SyntaxKind::ErrorSyntax,
3379 SyntaxVariant::ListItem {..} => SyntaxKind::ListItem,
3380 SyntaxVariant::PocketAtomExpression {..} => SyntaxKind::PocketAtomExpression,
3381 SyntaxVariant::PocketIdentifierExpression {..} => SyntaxKind::PocketIdentifierExpression,
3382 SyntaxVariant::PocketAtomMappingDeclaration {..} => SyntaxKind::PocketAtomMappingDeclaration,
3383 SyntaxVariant::PocketEnumDeclaration {..} => SyntaxKind::PocketEnumDeclaration,
3384 SyntaxVariant::PocketFieldTypeExprDeclaration {..} => SyntaxKind::PocketFieldTypeExprDeclaration,
3385 SyntaxVariant::PocketFieldTypeDeclaration {..} => SyntaxKind::PocketFieldTypeDeclaration,
3386 SyntaxVariant::PocketMappingIdDeclaration {..} => SyntaxKind::PocketMappingIdDeclaration,
3387 SyntaxVariant::PocketMappingTypeDeclaration {..} => SyntaxKind::PocketMappingTypeDeclaration,
3388 }
3389 }
3390 }
3392 #[derive(Debug, Clone)]
3393 pub struct EndOfFileChildren<T, V> {
3394 pub end_of_file_token: Syntax<T, V>,
3395 }
3397 #[derive(Debug, Clone)]
3398 pub struct ScriptChildren<T, V> {
3399 pub script_declarations: Syntax<T, V>,
3400 }
3402 #[derive(Debug, Clone)]
3403 pub struct QualifiedNameChildren<T, V> {
3404 pub qualified_name_parts: Syntax<T, V>,
3405 }
3407 #[derive(Debug, Clone)]
3408 pub struct SimpleTypeSpecifierChildren<T, V> {
3409 pub simple_type_specifier: Syntax<T, V>,
3410 }
3412 #[derive(Debug, Clone)]
3413 pub struct LiteralExpressionChildren<T, V> {
3414 pub literal_expression: Syntax<T, V>,
3415 }
3417 #[derive(Debug, Clone)]
3418 pub struct PrefixedStringExpressionChildren<T, V> {
3419 pub prefixed_string_name: Syntax<T, V>,
3420 pub prefixed_string_str: Syntax<T, V>,
3421 }
3423 #[derive(Debug, Clone)]
3424 pub struct VariableExpressionChildren<T, V> {
3425 pub variable_expression: Syntax<T, V>,
3426 }
3428 #[derive(Debug, Clone)]
3429 pub struct PipeVariableExpressionChildren<T, V> {
3430 pub pipe_variable_expression: Syntax<T, V>,
3431 }
3433 #[derive(Debug, Clone)]
3434 pub struct FileAttributeSpecificationChildren<T, V> {
3435 pub file_attribute_specification_left_double_angle: Syntax<T, V>,
3436 pub file_attribute_specification_keyword: Syntax<T, V>,
3437 pub file_attribute_specification_colon: Syntax<T, V>,
3438 pub file_attribute_specification_attributes: Syntax<T, V>,
3439 pub file_attribute_specification_right_double_angle: Syntax<T, V>,
3440 }
3442 #[derive(Debug, Clone)]
3443 pub struct EnumDeclarationChildren<T, V> {
3444 pub enum_attribute_spec: Syntax<T, V>,
3445 pub enum_keyword: Syntax<T, V>,
3446 pub enum_name: Syntax<T, V>,
3447 pub enum_colon: Syntax<T, V>,
3448 pub enum_base: Syntax<T, V>,
3449 pub enum_type: Syntax<T, V>,
3450 pub enum_left_brace: Syntax<T, V>,
3451 pub enum_enumerators: Syntax<T, V>,
3452 pub enum_right_brace: Syntax<T, V>,
3453 }
3455 #[derive(Debug, Clone)]
3456 pub struct EnumeratorChildren<T, V> {
3457 pub enumerator_name: Syntax<T, V>,
3458 pub enumerator_equal: Syntax<T, V>,
3459 pub enumerator_value: Syntax<T, V>,
3460 pub enumerator_semicolon: Syntax<T, V>,
3461 }
3463 #[derive(Debug, Clone)]
3464 pub struct AliasDeclarationChildren<T, V> {
3465 pub alias_attribute_spec: Syntax<T, V>,
3466 pub alias_keyword: Syntax<T, V>,
3467 pub alias_name: Syntax<T, V>,
3468 pub alias_generic_parameter: Syntax<T, V>,
3469 pub alias_constraint: Syntax<T, V>,
3470 pub alias_equal: Syntax<T, V>,
3471 pub alias_type: Syntax<T, V>,
3472 pub alias_semicolon: Syntax<T, V>,
3473 }
3475 #[derive(Debug, Clone)]
3476 pub struct PropertyDeclarationChildren<T, V> {
3477 pub property_attribute_spec: Syntax<T, V>,
3478 pub property_modifiers: Syntax<T, V>,
3479 pub property_type: Syntax<T, V>,
3480 pub property_declarators: Syntax<T, V>,
3481 pub property_semicolon: Syntax<T, V>,
3482 }
3484 #[derive(Debug, Clone)]
3485 pub struct PropertyDeclaratorChildren<T, V> {
3486 pub property_name: Syntax<T, V>,
3487 pub property_initializer: Syntax<T, V>,
3488 }
3490 #[derive(Debug, Clone)]
3491 pub struct NamespaceDeclarationChildren<T, V> {
3492 pub namespace_keyword: Syntax<T, V>,
3493 pub namespace_name: Syntax<T, V>,
3494 pub namespace_body: Syntax<T, V>,
3495 }
3497 #[derive(Debug, Clone)]
3498 pub struct NamespaceBodyChildren<T, V> {
3499 pub namespace_left_brace: Syntax<T, V>,
3500 pub namespace_declarations: Syntax<T, V>,
3501 pub namespace_right_brace: Syntax<T, V>,
3502 }
3504 #[derive(Debug, Clone)]
3505 pub struct NamespaceEmptyBodyChildren<T, V> {
3506 pub namespace_semicolon: Syntax<T, V>,
3507 }
3509 #[derive(Debug, Clone)]
3510 pub struct NamespaceUseDeclarationChildren<T, V> {
3511 pub namespace_use_keyword: Syntax<T, V>,
3512 pub namespace_use_kind: Syntax<T, V>,
3513 pub namespace_use_clauses: Syntax<T, V>,
3514 pub namespace_use_semicolon: Syntax<T, V>,
3515 }
3517 #[derive(Debug, Clone)]
3518 pub struct NamespaceGroupUseDeclarationChildren<T, V> {
3519 pub namespace_group_use_keyword: Syntax<T, V>,
3520 pub namespace_group_use_kind: Syntax<T, V>,
3521 pub namespace_group_use_prefix: Syntax<T, V>,
3522 pub namespace_group_use_left_brace: Syntax<T, V>,
3523 pub namespace_group_use_clauses: Syntax<T, V>,
3524 pub namespace_group_use_right_brace: Syntax<T, V>,
3525 pub namespace_group_use_semicolon: Syntax<T, V>,
3526 }
3528 #[derive(Debug, Clone)]
3529 pub struct NamespaceUseClauseChildren<T, V> {
3530 pub namespace_use_clause_kind: Syntax<T, V>,
3531 pub namespace_use_name: Syntax<T, V>,
3532 pub namespace_use_as: Syntax<T, V>,
3533 pub namespace_use_alias: Syntax<T, V>,
3534 }
3536 #[derive(Debug, Clone)]
3537 pub struct FunctionDeclarationChildren<T, V> {
3538 pub function_attribute_spec: Syntax<T, V>,
3539 pub function_declaration_header: Syntax<T, V>,
3540 pub function_body: Syntax<T, V>,
3541 }
3543 #[derive(Debug, Clone)]
3544 pub struct FunctionDeclarationHeaderChildren<T, V> {
3545 pub function_modifiers: Syntax<T, V>,
3546 pub function_keyword: Syntax<T, V>,
3547 pub function_name: Syntax<T, V>,
3548 pub function_type_parameter_list: Syntax<T, V>,
3549 pub function_left_paren: Syntax<T, V>,
3550 pub function_parameter_list: Syntax<T, V>,
3551 pub function_right_paren: Syntax<T, V>,
3552 pub function_colon: Syntax<T, V>,
3553 pub function_type: Syntax<T, V>,
3554 pub function_where_clause: Syntax<T, V>,
3555 }
3557 #[derive(Debug, Clone)]
3558 pub struct WhereClauseChildren<T, V> {
3559 pub where_clause_keyword: Syntax<T, V>,
3560 pub where_clause_constraints: Syntax<T, V>,
3561 }
3563 #[derive(Debug, Clone)]
3564 pub struct WhereConstraintChildren<T, V> {
3565 pub where_constraint_left_type: Syntax<T, V>,
3566 pub where_constraint_operator: Syntax<T, V>,
3567 pub where_constraint_right_type: Syntax<T, V>,
3568 }
3570 #[derive(Debug, Clone)]
3571 pub struct MethodishDeclarationChildren<T, V> {
3572 pub methodish_attribute: Syntax<T, V>,
3573 pub methodish_function_decl_header: Syntax<T, V>,
3574 pub methodish_function_body: Syntax<T, V>,
3575 pub methodish_semicolon: Syntax<T, V>,
3576 }
3578 #[derive(Debug, Clone)]
3579 pub struct MethodishTraitResolutionChildren<T, V> {
3580 pub methodish_trait_attribute: Syntax<T, V>,
3581 pub methodish_trait_function_decl_header: Syntax<T, V>,
3582 pub methodish_trait_equal: Syntax<T, V>,
3583 pub methodish_trait_name: Syntax<T, V>,
3584 pub methodish_trait_semicolon: Syntax<T, V>,
3585 }
3587 #[derive(Debug, Clone)]
3588 pub struct ClassishDeclarationChildren<T, V> {
3589 pub classish_attribute: Syntax<T, V>,
3590 pub classish_modifiers: Syntax<T, V>,
3591 pub classish_keyword: Syntax<T, V>,
3592 pub classish_name: Syntax<T, V>,
3593 pub classish_type_parameters: Syntax<T, V>,
3594 pub classish_extends_keyword: Syntax<T, V>,
3595 pub classish_extends_list: Syntax<T, V>,
3596 pub classish_implements_keyword: Syntax<T, V>,
3597 pub classish_implements_list: Syntax<T, V>,
3598 pub classish_body: Syntax<T, V>,
3599 }
3601 #[derive(Debug, Clone)]
3602 pub struct ClassishBodyChildren<T, V> {
3603 pub classish_body_left_brace: Syntax<T, V>,
3604 pub classish_body_elements: Syntax<T, V>,
3605 pub classish_body_right_brace: Syntax<T, V>,
3606 }
3608 #[derive(Debug, Clone)]
3609 pub struct TraitUsePrecedenceItemChildren<T, V> {
3610 pub trait_use_precedence_item_name: Syntax<T, V>,
3611 pub trait_use_precedence_item_keyword: Syntax<T, V>,
3612 pub trait_use_precedence_item_removed_names: Syntax<T, V>,
3613 }
3615 #[derive(Debug, Clone)]
3616 pub struct TraitUseAliasItemChildren<T, V> {
3617 pub trait_use_alias_item_aliasing_name: Syntax<T, V>,
3618 pub trait_use_alias_item_keyword: Syntax<T, V>,
3619 pub trait_use_alias_item_modifiers: Syntax<T, V>,
3620 pub trait_use_alias_item_aliased_name: Syntax<T, V>,
3621 }
3623 #[derive(Debug, Clone)]
3624 pub struct TraitUseConflictResolutionChildren<T, V> {
3625 pub trait_use_conflict_resolution_keyword: Syntax<T, V>,
3626 pub trait_use_conflict_resolution_names: Syntax<T, V>,
3627 pub trait_use_conflict_resolution_left_brace: Syntax<T, V>,
3628 pub trait_use_conflict_resolution_clauses: Syntax<T, V>,
3629 pub trait_use_conflict_resolution_right_brace: Syntax<T, V>,
3630 }
3632 #[derive(Debug, Clone)]
3633 pub struct TraitUseChildren<T, V> {
3634 pub trait_use_keyword: Syntax<T, V>,
3635 pub trait_use_names: Syntax<T, V>,
3636 pub trait_use_semicolon: Syntax<T, V>,
3637 }
3639 #[derive(Debug, Clone)]
3640 pub struct RequireClauseChildren<T, V> {
3641 pub require_keyword: Syntax<T, V>,
3642 pub require_kind: Syntax<T, V>,
3643 pub require_name: Syntax<T, V>,
3644 pub require_semicolon: Syntax<T, V>,
3645 }
3647 #[derive(Debug, Clone)]
3648 pub struct ConstDeclarationChildren<T, V> {
3649 pub const_visibility: Syntax<T, V>,
3650 pub const_abstract: Syntax<T, V>,
3651 pub const_keyword: Syntax<T, V>,
3652 pub const_type_specifier: Syntax<T, V>,
3653 pub const_declarators: Syntax<T, V>,
3654 pub const_semicolon: Syntax<T, V>,
3655 }
3657 #[derive(Debug, Clone)]
3658 pub struct ConstantDeclaratorChildren<T, V> {
3659 pub constant_declarator_name: Syntax<T, V>,
3660 pub constant_declarator_initializer: Syntax<T, V>,
3661 }
3663 #[derive(Debug, Clone)]
3664 pub struct TypeConstDeclarationChildren<T, V> {
3665 pub type_const_attribute_spec: Syntax<T, V>,
3666 pub type_const_abstract: Syntax<T, V>,
3667 pub type_const_keyword: Syntax<T, V>,
3668 pub type_const_type_keyword: Syntax<T, V>,
3669 pub type_const_name: Syntax<T, V>,
3670 pub type_const_type_parameters: Syntax<T, V>,
3671 pub type_const_type_constraint: Syntax<T, V>,
3672 pub type_const_equal: Syntax<T, V>,
3673 pub type_const_type_specifier: Syntax<T, V>,
3674 pub type_const_semicolon: Syntax<T, V>,
3675 }
3677 #[derive(Debug, Clone)]
3678 pub struct DecoratedExpressionChildren<T, V> {
3679 pub decorated_expression_decorator: Syntax<T, V>,
3680 pub decorated_expression_expression: Syntax<T, V>,
3681 }
3683 #[derive(Debug, Clone)]
3684 pub struct ParameterDeclarationChildren<T, V> {
3685 pub parameter_attribute: Syntax<T, V>,
3686 pub parameter_visibility: Syntax<T, V>,
3687 pub parameter_call_convention: Syntax<T, V>,
3688 pub parameter_type: Syntax<T, V>,
3689 pub parameter_name: Syntax<T, V>,
3690 pub parameter_default_value: Syntax<T, V>,
3691 }
3693 #[derive(Debug, Clone)]
3694 pub struct VariadicParameterChildren<T, V> {
3695 pub variadic_parameter_call_convention: Syntax<T, V>,
3696 pub variadic_parameter_type: Syntax<T, V>,
3697 pub variadic_parameter_ellipsis: Syntax<T, V>,
3698 }
3700 #[derive(Debug, Clone)]
3701 pub struct AttributeSpecificationChildren<T, V> {
3702 pub attribute_specification_left_double_angle: Syntax<T, V>,
3703 pub attribute_specification_attributes: Syntax<T, V>,
3704 pub attribute_specification_right_double_angle: Syntax<T, V>,
3705 }
3707 #[derive(Debug, Clone)]
3708 pub struct InclusionExpressionChildren<T, V> {
3709 pub inclusion_require: Syntax<T, V>,
3710 pub inclusion_filename: Syntax<T, V>,
3711 }
3713 #[derive(Debug, Clone)]
3714 pub struct InclusionDirectiveChildren<T, V> {
3715 pub inclusion_expression: Syntax<T, V>,
3716 pub inclusion_semicolon: Syntax<T, V>,
3717 }
3719 #[derive(Debug, Clone)]
3720 pub struct CompoundStatementChildren<T, V> {
3721 pub compound_left_brace: Syntax<T, V>,
3722 pub compound_statements: Syntax<T, V>,
3723 pub compound_right_brace: Syntax<T, V>,
3724 }
3726 #[derive(Debug, Clone)]
3727 pub struct AlternateLoopStatementChildren<T, V> {
3728 pub alternate_loop_opening_colon: Syntax<T, V>,
3729 pub alternate_loop_statements: Syntax<T, V>,
3730 pub alternate_loop_closing_keyword: Syntax<T, V>,
3731 pub alternate_loop_closing_semicolon: Syntax<T, V>,
3732 }
3734 #[derive(Debug, Clone)]
3735 pub struct ExpressionStatementChildren<T, V> {
3736 pub expression_statement_expression: Syntax<T, V>,
3737 pub expression_statement_semicolon: Syntax<T, V>,
3738 }
3740 #[derive(Debug, Clone)]
3741 pub struct MarkupSectionChildren<T, V> {
3742 pub markup_prefix: Syntax<T, V>,
3743 pub markup_text: Syntax<T, V>,
3744 pub markup_suffix: Syntax<T, V>,
3745 pub markup_expression: Syntax<T, V>,
3746 }
3748 #[derive(Debug, Clone)]
3749 pub struct MarkupSuffixChildren<T, V> {
3750 pub markup_suffix_less_than_question: Syntax<T, V>,
3751 pub markup_suffix_name: Syntax<T, V>,
3752 }
3754 #[derive(Debug, Clone)]
3755 pub struct UnsetStatementChildren<T, V> {
3756 pub unset_keyword: Syntax<T, V>,
3757 pub unset_left_paren: Syntax<T, V>,
3758 pub unset_variables: Syntax<T, V>,
3759 pub unset_right_paren: Syntax<T, V>,
3760 pub unset_semicolon: Syntax<T, V>,
3761 }
3763 #[derive(Debug, Clone)]
3764 pub struct LetStatementChildren<T, V> {
3765 pub let_statement_keyword: Syntax<T, V>,
3766 pub let_statement_name: Syntax<T, V>,
3767 pub let_statement_colon: Syntax<T, V>,
3768 pub let_statement_type: Syntax<T, V>,
3769 pub let_statement_initializer: Syntax<T, V>,
3770 pub let_statement_semicolon: Syntax<T, V>,
3771 }
3773 #[derive(Debug, Clone)]
3774 pub struct UsingStatementBlockScopedChildren<T, V> {
3775 pub using_block_await_keyword: Syntax<T, V>,
3776 pub using_block_using_keyword: Syntax<T, V>,
3777 pub using_block_left_paren: Syntax<T, V>,
3778 pub using_block_expressions: Syntax<T, V>,
3779 pub using_block_right_paren: Syntax<T, V>,
3780 pub using_block_body: Syntax<T, V>,
3781 }
3783 #[derive(Debug, Clone)]
3784 pub struct UsingStatementFunctionScopedChildren<T, V> {
3785 pub using_function_await_keyword: Syntax<T, V>,
3786 pub using_function_using_keyword: Syntax<T, V>,
3787 pub using_function_expression: Syntax<T, V>,
3788 pub using_function_semicolon: Syntax<T, V>,
3789 }
3791 #[derive(Debug, Clone)]
3792 pub struct DeclareDirectiveStatementChildren<T, V> {
3793 pub declare_directive_keyword: Syntax<T, V>,
3794 pub declare_directive_left_paren: Syntax<T, V>,
3795 pub declare_directive_expression: Syntax<T, V>,
3796 pub declare_directive_right_paren: Syntax<T, V>,
3797 pub declare_directive_semicolon: Syntax<T, V>,
3798 }
3800 #[derive(Debug, Clone)]
3801 pub struct DeclareBlockStatementChildren<T, V> {
3802 pub declare_block_keyword: Syntax<T, V>,
3803 pub declare_block_left_paren: Syntax<T, V>,
3804 pub declare_block_expression: Syntax<T, V>,
3805 pub declare_block_right_paren: Syntax<T, V>,
3806 pub declare_block_body: Syntax<T, V>,
3807 }
3809 #[derive(Debug, Clone)]
3810 pub struct WhileStatementChildren<T, V> {
3811 pub while_keyword: Syntax<T, V>,
3812 pub while_left_paren: Syntax<T, V>,
3813 pub while_condition: Syntax<T, V>,
3814 pub while_right_paren: Syntax<T, V>,
3815 pub while_body: Syntax<T, V>,
3816 }
3818 #[derive(Debug, Clone)]
3819 pub struct IfStatementChildren<T, V> {
3820 pub if_keyword: Syntax<T, V>,
3821 pub if_left_paren: Syntax<T, V>,
3822 pub if_condition: Syntax<T, V>,
3823 pub if_right_paren: Syntax<T, V>,
3824 pub if_statement: Syntax<T, V>,
3825 pub if_elseif_clauses: Syntax<T, V>,
3826 pub if_else_clause: Syntax<T, V>,
3827 }
3829 #[derive(Debug, Clone)]
3830 pub struct ElseifClauseChildren<T, V> {
3831 pub elseif_keyword: Syntax<T, V>,
3832 pub elseif_left_paren: Syntax<T, V>,
3833 pub elseif_condition: Syntax<T, V>,
3834 pub elseif_right_paren: Syntax<T, V>,
3835 pub elseif_statement: Syntax<T, V>,
3836 }
3838 #[derive(Debug, Clone)]
3839 pub struct ElseClauseChildren<T, V> {
3840 pub else_keyword: Syntax<T, V>,
3841 pub else_statement: Syntax<T, V>,
3842 }
3844 #[derive(Debug, Clone)]
3845 pub struct AlternateIfStatementChildren<T, V> {
3846 pub alternate_if_keyword: Syntax<T, V>,
3847 pub alternate_if_left_paren: Syntax<T, V>,
3848 pub alternate_if_condition: Syntax<T, V>,
3849 pub alternate_if_right_paren: Syntax<T, V>,
3850 pub alternate_if_colon: Syntax<T, V>,
3851 pub alternate_if_statement: Syntax<T, V>,
3852 pub alternate_if_elseif_clauses: Syntax<T, V>,
3853 pub alternate_if_else_clause: Syntax<T, V>,
3854 pub alternate_if_endif_keyword: Syntax<T, V>,
3855 pub alternate_if_semicolon: Syntax<T, V>,
3856 }
3858 #[derive(Debug, Clone)]
3859 pub struct AlternateElseifClauseChildren<T, V> {
3860 pub alternate_elseif_keyword: Syntax<T, V>,
3861 pub alternate_elseif_left_paren: Syntax<T, V>,
3862 pub alternate_elseif_condition: Syntax<T, V>,
3863 pub alternate_elseif_right_paren: Syntax<T, V>,
3864 pub alternate_elseif_colon: Syntax<T, V>,
3865 pub alternate_elseif_statement: Syntax<T, V>,
3866 }
3868 #[derive(Debug, Clone)]
3869 pub struct AlternateElseClauseChildren<T, V> {
3870 pub alternate_else_keyword: Syntax<T, V>,
3871 pub alternate_else_colon: Syntax<T, V>,
3872 pub alternate_else_statement: Syntax<T, V>,
3873 }
3875 #[derive(Debug, Clone)]
3876 pub struct TryStatementChildren<T, V> {
3877 pub try_keyword: Syntax<T, V>,
3878 pub try_compound_statement: Syntax<T, V>,
3879 pub try_catch_clauses: Syntax<T, V>,
3880 pub try_finally_clause: Syntax<T, V>,
3881 }
3883 #[derive(Debug, Clone)]
3884 pub struct CatchClauseChildren<T, V> {
3885 pub catch_keyword: Syntax<T, V>,
3886 pub catch_left_paren: Syntax<T, V>,
3887 pub catch_type: Syntax<T, V>,
3888 pub catch_variable: Syntax<T, V>,
3889 pub catch_right_paren: Syntax<T, V>,
3890 pub catch_body: Syntax<T, V>,
3891 }
3893 #[derive(Debug, Clone)]
3894 pub struct FinallyClauseChildren<T, V> {
3895 pub finally_keyword: Syntax<T, V>,
3896 pub finally_body: Syntax<T, V>,
3897 }
3899 #[derive(Debug, Clone)]
3900 pub struct DoStatementChildren<T, V> {
3901 pub do_keyword: Syntax<T, V>,
3902 pub do_body: Syntax<T, V>,
3903 pub do_while_keyword: Syntax<T, V>,
3904 pub do_left_paren: Syntax<T, V>,
3905 pub do_condition: Syntax<T, V>,
3906 pub do_right_paren: Syntax<T, V>,
3907 pub do_semicolon: Syntax<T, V>,
3908 }
3910 #[derive(Debug, Clone)]
3911 pub struct ForStatementChildren<T, V> {
3912 pub for_keyword: Syntax<T, V>,
3913 pub for_left_paren: Syntax<T, V>,
3914 pub for_initializer: Syntax<T, V>,
3915 pub for_first_semicolon: Syntax<T, V>,
3916 pub for_control: Syntax<T, V>,
3917 pub for_second_semicolon: Syntax<T, V>,
3918 pub for_end_of_loop: Syntax<T, V>,
3919 pub for_right_paren: Syntax<T, V>,
3920 pub for_body: Syntax<T, V>,
3921 }
3923 #[derive(Debug, Clone)]
3924 pub struct ForeachStatementChildren<T, V> {
3925 pub foreach_keyword: Syntax<T, V>,
3926 pub foreach_left_paren: Syntax<T, V>,
3927 pub foreach_collection: Syntax<T, V>,
3928 pub foreach_await_keyword: Syntax<T, V>,
3929 pub foreach_as: Syntax<T, V>,
3930 pub foreach_key: Syntax<T, V>,
3931 pub foreach_arrow: Syntax<T, V>,
3932 pub foreach_value: Syntax<T, V>,
3933 pub foreach_right_paren: Syntax<T, V>,
3934 pub foreach_body: Syntax<T, V>,
3935 }
3937 #[derive(Debug, Clone)]
3938 pub struct SwitchStatementChildren<T, V> {
3939 pub switch_keyword: Syntax<T, V>,
3940 pub switch_left_paren: Syntax<T, V>,
3941 pub switch_expression: Syntax<T, V>,
3942 pub switch_right_paren: Syntax<T, V>,
3943 pub switch_left_brace: Syntax<T, V>,
3944 pub switch_sections: Syntax<T, V>,
3945 pub switch_right_brace: Syntax<T, V>,
3946 }
3948 #[derive(Debug, Clone)]
3949 pub struct AlternateSwitchStatementChildren<T, V> {
3950 pub alternate_switch_keyword: Syntax<T, V>,
3951 pub alternate_switch_left_paren: Syntax<T, V>,
3952 pub alternate_switch_expression: Syntax<T, V>,
3953 pub alternate_switch_right_paren: Syntax<T, V>,
3954 pub alternate_switch_opening_colon: Syntax<T, V>,
3955 pub alternate_switch_sections: Syntax<T, V>,
3956 pub alternate_switch_closing_endswitch: Syntax<T, V>,
3957 pub alternate_switch_closing_semicolon: Syntax<T, V>,
3958 }
3960 #[derive(Debug, Clone)]
3961 pub struct SwitchSectionChildren<T, V> {
3962 pub switch_section_labels: Syntax<T, V>,
3963 pub switch_section_statements: Syntax<T, V>,
3964 pub switch_section_fallthrough: Syntax<T, V>,
3965 }
3967 #[derive(Debug, Clone)]
3968 pub struct SwitchFallthroughChildren<T, V> {
3969 pub fallthrough_keyword: Syntax<T, V>,
3970 pub fallthrough_semicolon: Syntax<T, V>,
3971 }
3973 #[derive(Debug, Clone)]
3974 pub struct CaseLabelChildren<T, V> {
3975 pub case_keyword: Syntax<T, V>,
3976 pub case_expression: Syntax<T, V>,
3977 pub case_colon: Syntax<T, V>,
3978 }
3980 #[derive(Debug, Clone)]
3981 pub struct DefaultLabelChildren<T, V> {
3982 pub default_keyword: Syntax<T, V>,
3983 pub default_colon: Syntax<T, V>,
3984 }
3986 #[derive(Debug, Clone)]
3987 pub struct ReturnStatementChildren<T, V> {
3988 pub return_keyword: Syntax<T, V>,
3989 pub return_expression: Syntax<T, V>,
3990 pub return_semicolon: Syntax<T, V>,
3991 }
3993 #[derive(Debug, Clone)]
3994 pub struct GotoLabelChildren<T, V> {
3995 pub goto_label_name: Syntax<T, V>,
3996 pub goto_label_colon: Syntax<T, V>,
3997 }
3999 #[derive(Debug, Clone)]
4000 pub struct GotoStatementChildren<T, V> {
4001 pub goto_statement_keyword: Syntax<T, V>,
4002 pub goto_statement_label_name: Syntax<T, V>,
4003 pub goto_statement_semicolon: Syntax<T, V>,
4004 }
4006 #[derive(Debug, Clone)]
4007 pub struct ThrowStatementChildren<T, V> {
4008 pub throw_keyword: Syntax<T, V>,
4009 pub throw_expression: Syntax<T, V>,
4010 pub throw_semicolon: Syntax<T, V>,
4011 }
4013 #[derive(Debug, Clone)]
4014 pub struct BreakStatementChildren<T, V> {
4015 pub break_keyword: Syntax<T, V>,
4016 pub break_level: Syntax<T, V>,
4017 pub break_semicolon: Syntax<T, V>,
4018 }
4020 #[derive(Debug, Clone)]
4021 pub struct ContinueStatementChildren<T, V> {
4022 pub continue_keyword: Syntax<T, V>,
4023 pub continue_level: Syntax<T, V>,
4024 pub continue_semicolon: Syntax<T, V>,
4025 }
4027 #[derive(Debug, Clone)]
4028 pub struct EchoStatementChildren<T, V> {
4029 pub echo_keyword: Syntax<T, V>,
4030 pub echo_expressions: Syntax<T, V>,
4031 pub echo_semicolon: Syntax<T, V>,
4032 }
4034 #[derive(Debug, Clone)]
4035 pub struct ConcurrentStatementChildren<T, V> {
4036 pub concurrent_keyword: Syntax<T, V>,
4037 pub concurrent_statement: Syntax<T, V>,
4038 }
4040 #[derive(Debug, Clone)]
4041 pub struct SimpleInitializerChildren<T, V> {
4042 pub simple_initializer_equal: Syntax<T, V>,
4043 pub simple_initializer_value: Syntax<T, V>,
4044 }
4046 #[derive(Debug, Clone)]
4047 pub struct AnonymousClassChildren<T, V> {
4048 pub anonymous_class_class_keyword: Syntax<T, V>,
4049 pub anonymous_class_left_paren: Syntax<T, V>,
4050 pub anonymous_class_argument_list: Syntax<T, V>,
4051 pub anonymous_class_right_paren: Syntax<T, V>,
4052 pub anonymous_class_extends_keyword: Syntax<T, V>,
4053 pub anonymous_class_extends_list: Syntax<T, V>,
4054 pub anonymous_class_implements_keyword: Syntax<T, V>,
4055 pub anonymous_class_implements_list: Syntax<T, V>,
4056 pub anonymous_class_body: Syntax<T, V>,
4057 }
4059 #[derive(Debug, Clone)]
4060 pub struct AnonymousFunctionChildren<T, V> {
4061 pub anonymous_attribute_spec: Syntax<T, V>,
4062 pub anonymous_static_keyword: Syntax<T, V>,
4063 pub anonymous_async_keyword: Syntax<T, V>,
4064 pub anonymous_coroutine_keyword: Syntax<T, V>,
4065 pub anonymous_function_keyword: Syntax<T, V>,
4066 pub anonymous_left_paren: Syntax<T, V>,
4067 pub anonymous_parameters: Syntax<T, V>,
4068 pub anonymous_right_paren: Syntax<T, V>,
4069 pub anonymous_colon: Syntax<T, V>,
4070 pub anonymous_type: Syntax<T, V>,
4071 pub anonymous_use: Syntax<T, V>,
4072 pub anonymous_body: Syntax<T, V>,
4073 }
4075 #[derive(Debug, Clone)]
4076 pub struct Php7AnonymousFunctionChildren<T, V> {
4077 pub php7_anonymous_attribute_spec: Syntax<T, V>,
4078 pub php7_anonymous_static_keyword: Syntax<T, V>,
4079 pub php7_anonymous_async_keyword: Syntax<T, V>,
4080 pub php7_anonymous_coroutine_keyword: Syntax<T, V>,
4081 pub php7_anonymous_function_keyword: Syntax<T, V>,
4082 pub php7_anonymous_left_paren: Syntax<T, V>,
4083 pub php7_anonymous_parameters: Syntax<T, V>,
4084 pub php7_anonymous_right_paren: Syntax<T, V>,
4085 pub php7_anonymous_use: Syntax<T, V>,
4086 pub php7_anonymous_colon: Syntax<T, V>,
4087 pub php7_anonymous_type: Syntax<T, V>,
4088 pub php7_anonymous_body: Syntax<T, V>,
4089 }
4091 #[derive(Debug, Clone)]
4092 pub struct AnonymousFunctionUseClauseChildren<T, V> {
4093 pub anonymous_use_keyword: Syntax<T, V>,
4094 pub anonymous_use_left_paren: Syntax<T, V>,
4095 pub anonymous_use_variables: Syntax<T, V>,
4096 pub anonymous_use_right_paren: Syntax<T, V>,
4097 }
4099 #[derive(Debug, Clone)]
4100 pub struct LambdaExpressionChildren<T, V> {
4101 pub lambda_attribute_spec: Syntax<T, V>,
4102 pub lambda_async: Syntax<T, V>,
4103 pub lambda_coroutine: Syntax<T, V>,
4104 pub lambda_signature: Syntax<T, V>,
4105 pub lambda_arrow: Syntax<T, V>,
4106 pub lambda_body: Syntax<T, V>,
4107 }
4109 #[derive(Debug, Clone)]
4110 pub struct LambdaSignatureChildren<T, V> {
4111 pub lambda_left_paren: Syntax<T, V>,
4112 pub lambda_parameters: Syntax<T, V>,
4113 pub lambda_right_paren: Syntax<T, V>,
4114 pub lambda_colon: Syntax<T, V>,
4115 pub lambda_type: Syntax<T, V>,
4116 }
4118 #[derive(Debug, Clone)]
4119 pub struct CastExpressionChildren<T, V> {
4120 pub cast_left_paren: Syntax<T, V>,
4121 pub cast_type: Syntax<T, V>,
4122 pub cast_right_paren: Syntax<T, V>,
4123 pub cast_operand: Syntax<T, V>,
4124 }
4126 #[derive(Debug, Clone)]
4127 pub struct ScopeResolutionExpressionChildren<T, V> {
4128 pub scope_resolution_qualifier: Syntax<T, V>,
4129 pub scope_resolution_operator: Syntax<T, V>,
4130 pub scope_resolution_name: Syntax<T, V>,
4131 }
4133 #[derive(Debug, Clone)]
4134 pub struct MemberSelectionExpressionChildren<T, V> {
4135 pub member_object: Syntax<T, V>,
4136 pub member_operator: Syntax<T, V>,
4137 pub member_name: Syntax<T, V>,
4138 }
4140 #[derive(Debug, Clone)]
4141 pub struct SafeMemberSelectionExpressionChildren<T, V> {
4142 pub safe_member_object: Syntax<T, V>,
4143 pub safe_member_operator: Syntax<T, V>,
4144 pub safe_member_name: Syntax<T, V>,
4145 }
4147 #[derive(Debug, Clone)]
4148 pub struct EmbeddedMemberSelectionExpressionChildren<T, V> {
4149 pub embedded_member_object: Syntax<T, V>,
4150 pub embedded_member_operator: Syntax<T, V>,
4151 pub embedded_member_name: Syntax<T, V>,
4152 }
4154 #[derive(Debug, Clone)]
4155 pub struct YieldExpressionChildren<T, V> {
4156 pub yield_keyword: Syntax<T, V>,
4157 pub yield_operand: Syntax<T, V>,
4158 }
4160 #[derive(Debug, Clone)]
4161 pub struct YieldFromExpressionChildren<T, V> {
4162 pub yield_from_yield_keyword: Syntax<T, V>,
4163 pub yield_from_from_keyword: Syntax<T, V>,
4164 pub yield_from_operand: Syntax<T, V>,
4165 }
4167 #[derive(Debug, Clone)]
4168 pub struct PrefixUnaryExpressionChildren<T, V> {
4169 pub prefix_unary_operator: Syntax<T, V>,
4170 pub prefix_unary_operand: Syntax<T, V>,
4171 }
4173 #[derive(Debug, Clone)]
4174 pub struct PostfixUnaryExpressionChildren<T, V> {
4175 pub postfix_unary_operand: Syntax<T, V>,
4176 pub postfix_unary_operator: Syntax<T, V>,
4177 }
4179 #[derive(Debug, Clone)]
4180 pub struct BinaryExpressionChildren<T, V> {
4181 pub binary_left_operand: Syntax<T, V>,
4182 pub binary_operator: Syntax<T, V>,
4183 pub binary_right_operand: Syntax<T, V>,
4184 }
4186 #[derive(Debug, Clone)]
4187 pub struct InstanceofExpressionChildren<T, V> {
4188 pub instanceof_left_operand: Syntax<T, V>,
4189 pub instanceof_operator: Syntax<T, V>,
4190 pub instanceof_right_operand: Syntax<T, V>,
4191 }
4193 #[derive(Debug, Clone)]
4194 pub struct IsExpressionChildren<T, V> {
4195 pub is_left_operand: Syntax<T, V>,
4196 pub is_operator: Syntax<T, V>,
4197 pub is_right_operand: Syntax<T, V>,
4198 }
4200 #[derive(Debug, Clone)]
4201 pub struct AsExpressionChildren<T, V> {
4202 pub as_left_operand: Syntax<T, V>,
4203 pub as_operator: Syntax<T, V>,
4204 pub as_right_operand: Syntax<T, V>,
4205 }
4207 #[derive(Debug, Clone)]
4208 pub struct NullableAsExpressionChildren<T, V> {
4209 pub nullable_as_left_operand: Syntax<T, V>,
4210 pub nullable_as_operator: Syntax<T, V>,
4211 pub nullable_as_right_operand: Syntax<T, V>,
4212 }
4214 #[derive(Debug, Clone)]
4215 pub struct ConditionalExpressionChildren<T, V> {
4216 pub conditional_test: Syntax<T, V>,
4217 pub conditional_question: Syntax<T, V>,
4218 pub conditional_consequence: Syntax<T, V>,
4219 pub conditional_colon: Syntax<T, V>,
4220 pub conditional_alternative: Syntax<T, V>,
4221 }
4223 #[derive(Debug, Clone)]
4224 pub struct EvalExpressionChildren<T, V> {
4225 pub eval_keyword: Syntax<T, V>,
4226 pub eval_left_paren: Syntax<T, V>,
4227 pub eval_argument: Syntax<T, V>,
4228 pub eval_right_paren: Syntax<T, V>,
4229 }
4231 #[derive(Debug, Clone)]
4232 pub struct EmptyExpressionChildren<T, V> {
4233 pub empty_keyword: Syntax<T, V>,
4234 pub empty_left_paren: Syntax<T, V>,
4235 pub empty_argument: Syntax<T, V>,
4236 pub empty_right_paren: Syntax<T, V>,
4237 }
4239 #[derive(Debug, Clone)]
4240 pub struct DefineExpressionChildren<T, V> {
4241 pub define_keyword: Syntax<T, V>,
4242 pub define_left_paren: Syntax<T, V>,
4243 pub define_argument_list: Syntax<T, V>,
4244 pub define_right_paren: Syntax<T, V>,
4245 }
4247 #[derive(Debug, Clone)]
4248 pub struct HaltCompilerExpressionChildren<T, V> {
4249 pub halt_compiler_keyword: Syntax<T, V>,
4250 pub halt_compiler_left_paren: Syntax<T, V>,
4251 pub halt_compiler_argument_list: Syntax<T, V>,
4252 pub halt_compiler_right_paren: Syntax<T, V>,
4253 }
4255 #[derive(Debug, Clone)]
4256 pub struct IssetExpressionChildren<T, V> {
4257 pub isset_keyword: Syntax<T, V>,
4258 pub isset_left_paren: Syntax<T, V>,
4259 pub isset_argument_list: Syntax<T, V>,
4260 pub isset_right_paren: Syntax<T, V>,
4261 }
4263 #[derive(Debug, Clone)]
4264 pub struct FunctionCallExpressionChildren<T, V> {
4265 pub function_call_receiver: Syntax<T, V>,
4266 pub function_call_type_args: Syntax<T, V>,
4267 pub function_call_left_paren: Syntax<T, V>,
4268 pub function_call_argument_list: Syntax<T, V>,
4269 pub function_call_right_paren: Syntax<T, V>,
4270 }
4272 #[derive(Debug, Clone)]
4273 pub struct ParenthesizedExpressionChildren<T, V> {
4274 pub parenthesized_expression_left_paren: Syntax<T, V>,
4275 pub parenthesized_expression_expression: Syntax<T, V>,
4276 pub parenthesized_expression_right_paren: Syntax<T, V>,
4277 }
4279 #[derive(Debug, Clone)]
4280 pub struct BracedExpressionChildren<T, V> {
4281 pub braced_expression_left_brace: Syntax<T, V>,
4282 pub braced_expression_expression: Syntax<T, V>,
4283 pub braced_expression_right_brace: Syntax<T, V>,
4284 }
4286 #[derive(Debug, Clone)]
4287 pub struct EmbeddedBracedExpressionChildren<T, V> {
4288 pub embedded_braced_expression_left_brace: Syntax<T, V>,
4289 pub embedded_braced_expression_expression: Syntax<T, V>,
4290 pub embedded_braced_expression_right_brace: Syntax<T, V>,
4291 }
4293 #[derive(Debug, Clone)]
4294 pub struct ListExpressionChildren<T, V> {
4295 pub list_keyword: Syntax<T, V>,
4296 pub list_left_paren: Syntax<T, V>,
4297 pub list_members: Syntax<T, V>,
4298 pub list_right_paren: Syntax<T, V>,
4299 }
4301 #[derive(Debug, Clone)]
4302 pub struct CollectionLiteralExpressionChildren<T, V> {
4303 pub collection_literal_name: Syntax<T, V>,
4304 pub collection_literal_left_brace: Syntax<T, V>,
4305 pub collection_literal_initializers: Syntax<T, V>,
4306 pub collection_literal_right_brace: Syntax<T, V>,
4307 }
4309 #[derive(Debug, Clone)]
4310 pub struct ObjectCreationExpressionChildren<T, V> {
4311 pub object_creation_new_keyword: Syntax<T, V>,
4312 pub object_creation_object: Syntax<T, V>,
4313 }
4315 #[derive(Debug, Clone)]
4316 pub struct ConstructorCallChildren<T, V> {
4317 pub constructor_call_type: Syntax<T, V>,
4318 pub constructor_call_left_paren: Syntax<T, V>,
4319 pub constructor_call_argument_list: Syntax<T, V>,
4320 pub constructor_call_right_paren: Syntax<T, V>,
4321 }
4323 #[derive(Debug, Clone)]
4324 pub struct ArrayCreationExpressionChildren<T, V> {
4325 pub array_creation_left_bracket: Syntax<T, V>,
4326 pub array_creation_members: Syntax<T, V>,
4327 pub array_creation_right_bracket: Syntax<T, V>,
4328 }
4330 #[derive(Debug, Clone)]
4331 pub struct ArrayIntrinsicExpressionChildren<T, V> {
4332 pub array_intrinsic_keyword: Syntax<T, V>,
4333 pub array_intrinsic_left_paren: Syntax<T, V>,
4334 pub array_intrinsic_members: Syntax<T, V>,
4335 pub array_intrinsic_right_paren: Syntax<T, V>,
4336 }
4338 #[derive(Debug, Clone)]
4339 pub struct DarrayIntrinsicExpressionChildren<T, V> {
4340 pub darray_intrinsic_keyword: Syntax<T, V>,
4341 pub darray_intrinsic_explicit_type: Syntax<T, V>,
4342 pub darray_intrinsic_left_bracket: Syntax<T, V>,
4343 pub darray_intrinsic_members: Syntax<T, V>,
4344 pub darray_intrinsic_right_bracket: Syntax<T, V>,
4345 }
4347 #[derive(Debug, Clone)]
4348 pub struct DictionaryIntrinsicExpressionChildren<T, V> {
4349 pub dictionary_intrinsic_keyword: Syntax<T, V>,
4350 pub dictionary_intrinsic_explicit_type: Syntax<T, V>,
4351 pub dictionary_intrinsic_left_bracket: Syntax<T, V>,
4352 pub dictionary_intrinsic_members: Syntax<T, V>,
4353 pub dictionary_intrinsic_right_bracket: Syntax<T, V>,
4354 }
4356 #[derive(Debug, Clone)]
4357 pub struct KeysetIntrinsicExpressionChildren<T, V> {
4358 pub keyset_intrinsic_keyword: Syntax<T, V>,
4359 pub keyset_intrinsic_explicit_type: Syntax<T, V>,
4360 pub keyset_intrinsic_left_bracket: Syntax<T, V>,
4361 pub keyset_intrinsic_members: Syntax<T, V>,
4362 pub keyset_intrinsic_right_bracket: Syntax<T, V>,
4363 }
4365 #[derive(Debug, Clone)]
4366 pub struct VarrayIntrinsicExpressionChildren<T, V> {
4367 pub varray_intrinsic_keyword: Syntax<T, V>,
4368 pub varray_intrinsic_explicit_type: Syntax<T, V>,
4369 pub varray_intrinsic_left_bracket: Syntax<T, V>,
4370 pub varray_intrinsic_members: Syntax<T, V>,
4371 pub varray_intrinsic_right_bracket: Syntax<T, V>,
4372 }
4374 #[derive(Debug, Clone)]
4375 pub struct VectorIntrinsicExpressionChildren<T, V> {
4376 pub vector_intrinsic_keyword: Syntax<T, V>,
4377 pub vector_intrinsic_explicit_type: Syntax<T, V>,
4378 pub vector_intrinsic_left_bracket: Syntax<T, V>,
4379 pub vector_intrinsic_members: Syntax<T, V>,
4380 pub vector_intrinsic_right_bracket: Syntax<T, V>,
4381 }
4383 #[derive(Debug, Clone)]
4384 pub struct ElementInitializerChildren<T, V> {
4385 pub element_key: Syntax<T, V>,
4386 pub element_arrow: Syntax<T, V>,
4387 pub element_value: Syntax<T, V>,
4388 }
4390 #[derive(Debug, Clone)]
4391 pub struct SubscriptExpressionChildren<T, V> {
4392 pub subscript_receiver: Syntax<T, V>,
4393 pub subscript_left_bracket: Syntax<T, V>,
4394 pub subscript_index: Syntax<T, V>,
4395 pub subscript_right_bracket: Syntax<T, V>,
4396 }
4398 #[derive(Debug, Clone)]
4399 pub struct EmbeddedSubscriptExpressionChildren<T, V> {
4400 pub embedded_subscript_receiver: Syntax<T, V>,
4401 pub embedded_subscript_left_bracket: Syntax<T, V>,
4402 pub embedded_subscript_index: Syntax<T, V>,
4403 pub embedded_subscript_right_bracket: Syntax<T, V>,
4404 }
4406 #[derive(Debug, Clone)]
4407 pub struct AwaitableCreationExpressionChildren<T, V> {
4408 pub awaitable_attribute_spec: Syntax<T, V>,
4409 pub awaitable_async: Syntax<T, V>,
4410 pub awaitable_coroutine: Syntax<T, V>,
4411 pub awaitable_compound_statement: Syntax<T, V>,
4412 }
4414 #[derive(Debug, Clone)]
4415 pub struct XHPChildrenDeclarationChildren<T, V> {
4416 pub xhp_children_keyword: Syntax<T, V>,
4417 pub xhp_children_expression: Syntax<T, V>,
4418 pub xhp_children_semicolon: Syntax<T, V>,
4419 }
4421 #[derive(Debug, Clone)]
4422 pub struct XHPChildrenParenthesizedListChildren<T, V> {
4423 pub xhp_children_list_left_paren: Syntax<T, V>,
4424 pub xhp_children_list_xhp_children: Syntax<T, V>,
4425 pub xhp_children_list_right_paren: Syntax<T, V>,
4426 }
4428 #[derive(Debug, Clone)]
4429 pub struct XHPCategoryDeclarationChildren<T, V> {
4430 pub xhp_category_keyword: Syntax<T, V>,
4431 pub xhp_category_categories: Syntax<T, V>,
4432 pub xhp_category_semicolon: Syntax<T, V>,
4433 }
4435 #[derive(Debug, Clone)]
4436 pub struct XHPEnumTypeChildren<T, V> {
4437 pub xhp_enum_optional: Syntax<T, V>,
4438 pub xhp_enum_keyword: Syntax<T, V>,
4439 pub xhp_enum_left_brace: Syntax<T, V>,
4440 pub xhp_enum_values: Syntax<T, V>,
4441 pub xhp_enum_right_brace: Syntax<T, V>,
4442 }
4444 #[derive(Debug, Clone)]
4445 pub struct XHPRequiredChildren<T, V> {
4446 pub xhp_required_at: Syntax<T, V>,
4447 pub xhp_required_keyword: Syntax<T, V>,
4448 }
4450 #[derive(Debug, Clone)]
4451 pub struct XHPClassAttributeDeclarationChildren<T, V> {
4452 pub xhp_attribute_keyword: Syntax<T, V>,
4453 pub xhp_attribute_attributes: Syntax<T, V>,
4454 pub xhp_attribute_semicolon: Syntax<T, V>,
4455 }
4457 #[derive(Debug, Clone)]
4458 pub struct XHPClassAttributeChildren<T, V> {
4459 pub xhp_attribute_decl_type: Syntax<T, V>,
4460 pub xhp_attribute_decl_name: Syntax<T, V>,
4461 pub xhp_attribute_decl_initializer: Syntax<T, V>,
4462 pub xhp_attribute_decl_required: Syntax<T, V>,
4463 }
4465 #[derive(Debug, Clone)]
4466 pub struct XHPSimpleClassAttributeChildren<T, V> {
4467 pub xhp_simple_class_attribute_type: Syntax<T, V>,
4468 }
4470 #[derive(Debug, Clone)]
4471 pub struct XHPSimpleAttributeChildren<T, V> {
4472 pub xhp_simple_attribute_name: Syntax<T, V>,
4473 pub xhp_simple_attribute_equal: Syntax<T, V>,
4474 pub xhp_simple_attribute_expression: Syntax<T, V>,
4475 }
4477 #[derive(Debug, Clone)]
4478 pub struct XHPSpreadAttributeChildren<T, V> {
4479 pub xhp_spread_attribute_left_brace: Syntax<T, V>,
4480 pub xhp_spread_attribute_spread_operator: Syntax<T, V>,
4481 pub xhp_spread_attribute_expression: Syntax<T, V>,
4482 pub xhp_spread_attribute_right_brace: Syntax<T, V>,
4483 }
4485 #[derive(Debug, Clone)]
4486 pub struct XHPOpenChildren<T, V> {
4487 pub xhp_open_left_angle: Syntax<T, V>,
4488 pub xhp_open_name: Syntax<T, V>,
4489 pub xhp_open_attributes: Syntax<T, V>,
4490 pub xhp_open_right_angle: Syntax<T, V>,
4491 }
4493 #[derive(Debug, Clone)]
4494 pub struct XHPExpressionChildren<T, V> {
4495 pub xhp_open: Syntax<T, V>,
4496 pub xhp_body: Syntax<T, V>,
4497 pub xhp_close: Syntax<T, V>,
4498 }
4500 #[derive(Debug, Clone)]
4501 pub struct XHPCloseChildren<T, V> {
4502 pub xhp_close_left_angle: Syntax<T, V>,
4503 pub xhp_close_name: Syntax<T, V>,
4504 pub xhp_close_right_angle: Syntax<T, V>,
4505 }
4507 #[derive(Debug, Clone)]
4508 pub struct TypeConstantChildren<T, V> {
4509 pub type_constant_left_type: Syntax<T, V>,
4510 pub type_constant_separator: Syntax<T, V>,
4511 pub type_constant_right_type: Syntax<T, V>,
4512 }
4514 #[derive(Debug, Clone)]
4515 pub struct VectorTypeSpecifierChildren<T, V> {
4516 pub vector_type_keyword: Syntax<T, V>,
4517 pub vector_type_left_angle: Syntax<T, V>,
4518 pub vector_type_type: Syntax<T, V>,
4519 pub vector_type_trailing_comma: Syntax<T, V>,
4520 pub vector_type_right_angle: Syntax<T, V>,
4521 }
4523 #[derive(Debug, Clone)]
4524 pub struct KeysetTypeSpecifierChildren<T, V> {
4525 pub keyset_type_keyword: Syntax<T, V>,
4526 pub keyset_type_left_angle: Syntax<T, V>,
4527 pub keyset_type_type: Syntax<T, V>,
4528 pub keyset_type_trailing_comma: Syntax<T, V>,
4529 pub keyset_type_right_angle: Syntax<T, V>,
4530 }
4532 #[derive(Debug, Clone)]
4533 pub struct TupleTypeExplicitSpecifierChildren<T, V> {
4534 pub tuple_type_keyword: Syntax<T, V>,
4535 pub tuple_type_left_angle: Syntax<T, V>,
4536 pub tuple_type_types: Syntax<T, V>,
4537 pub tuple_type_right_angle: Syntax<T, V>,
4538 }
4540 #[derive(Debug, Clone)]
4541 pub struct VarrayTypeSpecifierChildren<T, V> {
4542 pub varray_keyword: Syntax<T, V>,
4543 pub varray_left_angle: Syntax<T, V>,
4544 pub varray_type: Syntax<T, V>,
4545 pub varray_trailing_comma: Syntax<T, V>,
4546 pub varray_right_angle: Syntax<T, V>,
4547 }
4549 #[derive(Debug, Clone)]
4550 pub struct VectorArrayTypeSpecifierChildren<T, V> {
4551 pub vector_array_keyword: Syntax<T, V>,
4552 pub vector_array_left_angle: Syntax<T, V>,
4553 pub vector_array_type: Syntax<T, V>,
4554 pub vector_array_right_angle: Syntax<T, V>,
4555 }
4557 #[derive(Debug, Clone)]
4558 pub struct TypeParameterChildren<T, V> {
4559 pub type_attribute_spec: Syntax<T, V>,
4560 pub type_reified: Syntax<T, V>,
4561 pub type_variance: Syntax<T, V>,
4562 pub type_name: Syntax<T, V>,
4563 pub type_constraints: Syntax<T, V>,
4564 }
4566 #[derive(Debug, Clone)]
4567 pub struct TypeConstraintChildren<T, V> {
4568 pub constraint_keyword: Syntax<T, V>,
4569 pub constraint_type: Syntax<T, V>,
4570 }
4572 #[derive(Debug, Clone)]
4573 pub struct DarrayTypeSpecifierChildren<T, V> {
4574 pub darray_keyword: Syntax<T, V>,
4575 pub darray_left_angle: Syntax<T, V>,
4576 pub darray_key: Syntax<T, V>,
4577 pub darray_comma: Syntax<T, V>,
4578 pub darray_value: Syntax<T, V>,
4579 pub darray_trailing_comma: Syntax<T, V>,
4580 pub darray_right_angle: Syntax<T, V>,
4581 }
4583 #[derive(Debug, Clone)]
4584 pub struct MapArrayTypeSpecifierChildren<T, V> {
4585 pub map_array_keyword: Syntax<T, V>,
4586 pub map_array_left_angle: Syntax<T, V>,
4587 pub map_array_key: Syntax<T, V>,
4588 pub map_array_comma: Syntax<T, V>,
4589 pub map_array_value: Syntax<T, V>,
4590 pub map_array_right_angle: Syntax<T, V>,
4591 }
4593 #[derive(Debug, Clone)]
4594 pub struct DictionaryTypeSpecifierChildren<T, V> {
4595 pub dictionary_type_keyword: Syntax<T, V>,
4596 pub dictionary_type_left_angle: Syntax<T, V>,
4597 pub dictionary_type_members: Syntax<T, V>,
4598 pub dictionary_type_right_angle: Syntax<T, V>,
4599 }
4601 #[derive(Debug, Clone)]
4602 pub struct ClosureTypeSpecifierChildren<T, V> {
4603 pub closure_outer_left_paren: Syntax<T, V>,
4604 pub closure_coroutine: Syntax<T, V>,
4605 pub closure_function_keyword: Syntax<T, V>,
4606 pub closure_inner_left_paren: Syntax<T, V>,
4607 pub closure_parameter_list: Syntax<T, V>,
4608 pub closure_inner_right_paren: Syntax<T, V>,
4609 pub closure_colon: Syntax<T, V>,
4610 pub closure_return_type: Syntax<T, V>,
4611 pub closure_outer_right_paren: Syntax<T, V>,
4612 }
4614 #[derive(Debug, Clone)]
4615 pub struct ClosureParameterTypeSpecifierChildren<T, V> {
4616 pub closure_parameter_call_convention: Syntax<T, V>,
4617 pub closure_parameter_type: Syntax<T, V>,
4618 }
4620 #[derive(Debug, Clone)]
4621 pub struct ClassnameTypeSpecifierChildren<T, V> {
4622 pub classname_keyword: Syntax<T, V>,
4623 pub classname_left_angle: Syntax<T, V>,
4624 pub classname_type: Syntax<T, V>,
4625 pub classname_trailing_comma: Syntax<T, V>,
4626 pub classname_right_angle: Syntax<T, V>,
4627 }
4629 #[derive(Debug, Clone)]
4630 pub struct FieldSpecifierChildren<T, V> {
4631 pub field_question: Syntax<T, V>,
4632 pub field_name: Syntax<T, V>,
4633 pub field_arrow: Syntax<T, V>,
4634 pub field_type: Syntax<T, V>,
4635 }
4637 #[derive(Debug, Clone)]
4638 pub struct FieldInitializerChildren<T, V> {
4639 pub field_initializer_name: Syntax<T, V>,
4640 pub field_initializer_arrow: Syntax<T, V>,
4641 pub field_initializer_value: Syntax<T, V>,
4642 }
4644 #[derive(Debug, Clone)]
4645 pub struct ShapeTypeSpecifierChildren<T, V> {
4646 pub shape_type_keyword: Syntax<T, V>,
4647 pub shape_type_left_paren: Syntax<T, V>,
4648 pub shape_type_fields: Syntax<T, V>,
4649 pub shape_type_ellipsis: Syntax<T, V>,
4650 pub shape_type_right_paren: Syntax<T, V>,
4651 }
4653 #[derive(Debug, Clone)]
4654 pub struct ShapeExpressionChildren<T, V> {
4655 pub shape_expression_keyword: Syntax<T, V>,
4656 pub shape_expression_left_paren: Syntax<T, V>,
4657 pub shape_expression_fields: Syntax<T, V>,
4658 pub shape_expression_right_paren: Syntax<T, V>,
4659 }
4661 #[derive(Debug, Clone)]
4662 pub struct TupleExpressionChildren<T, V> {
4663 pub tuple_expression_keyword: Syntax<T, V>,
4664 pub tuple_expression_left_paren: Syntax<T, V>,
4665 pub tuple_expression_items: Syntax<T, V>,
4666 pub tuple_expression_right_paren: Syntax<T, V>,
4667 }
4669 #[derive(Debug, Clone)]
4670 pub struct GenericTypeSpecifierChildren<T, V> {
4671 pub generic_class_type: Syntax<T, V>,
4672 pub generic_argument_list: Syntax<T, V>,
4673 }
4675 #[derive(Debug, Clone)]
4676 pub struct NullableTypeSpecifierChildren<T, V> {
4677 pub nullable_question: Syntax<T, V>,
4678 pub nullable_type: Syntax<T, V>,
4679 }
4681 #[derive(Debug, Clone)]
4682 pub struct LikeTypeSpecifierChildren<T, V> {
4683 pub like_tilde: Syntax<T, V>,
4684 pub like_type: Syntax<T, V>,
4685 }
4687 #[derive(Debug, Clone)]
4688 pub struct SoftTypeSpecifierChildren<T, V> {
4689 pub soft_at: Syntax<T, V>,
4690 pub soft_type: Syntax<T, V>,
4691 }
4693 #[derive(Debug, Clone)]
4694 pub struct ReifiedTypeArgumentChildren<T, V> {
4695 pub reified_type_argument_reified: Syntax<T, V>,
4696 pub reified_type_argument_type: Syntax<T, V>,
4697 }
4699 #[derive(Debug, Clone)]
4700 pub struct TypeArgumentsChildren<T, V> {
4701 pub type_arguments_left_angle: Syntax<T, V>,
4702 pub type_arguments_types: Syntax<T, V>,
4703 pub type_arguments_right_angle: Syntax<T, V>,
4704 }
4706 #[derive(Debug, Clone)]
4707 pub struct TypeParametersChildren<T, V> {
4708 pub type_parameters_left_angle: Syntax<T, V>,
4709 pub type_parameters_parameters: Syntax<T, V>,
4710 pub type_parameters_right_angle: Syntax<T, V>,
4711 }
4713 #[derive(Debug, Clone)]
4714 pub struct TupleTypeSpecifierChildren<T, V> {
4715 pub tuple_left_paren: Syntax<T, V>,
4716 pub tuple_types: Syntax<T, V>,
4717 pub tuple_right_paren: Syntax<T, V>,
4718 }
4720 #[derive(Debug, Clone)]
4721 pub struct ErrorSyntaxChildren<T, V> {
4722 pub error_error: Syntax<T, V>,
4723 }
4725 #[derive(Debug, Clone)]
4726 pub struct ListItemChildren<T, V> {
4727 pub list_item: Syntax<T, V>,
4728 pub list_separator: Syntax<T, V>,
4729 }
4731 #[derive(Debug, Clone)]
4732 pub struct PocketAtomExpressionChildren<T, V> {
4733 pub pocket_atom_glyph: Syntax<T, V>,
4734 pub pocket_atom_expression: Syntax<T, V>,
4735 }
4737 #[derive(Debug, Clone)]
4738 pub struct PocketIdentifierExpressionChildren<T, V> {
4739 pub pocket_identifier_qualifier: Syntax<T, V>,
4740 pub pocket_identifier_pu_operator: Syntax<T, V>,
4741 pub pocket_identifier_field: Syntax<T, V>,
4742 pub pocket_identifier_operator: Syntax<T, V>,
4743 pub pocket_identifier_name: Syntax<T, V>,
4744 }
4746 #[derive(Debug, Clone)]
4747 pub struct PocketAtomMappingDeclarationChildren<T, V> {
4748 pub pocket_atom_mapping_glyph: Syntax<T, V>,
4749 pub pocket_atom_mapping_name: Syntax<T, V>,
4750 pub pocket_atom_mapping_left_paren: Syntax<T, V>,
4751 pub pocket_atom_mapping_mappings: Syntax<T, V>,
4752 pub pocket_atom_mapping_right_paren: Syntax<T, V>,
4753 pub pocket_atom_mapping_semicolon: Syntax<T, V>,
4754 }
4756 #[derive(Debug, Clone)]
4757 pub struct PocketEnumDeclarationChildren<T, V> {
4758 pub pocket_enum_modifiers: Syntax<T, V>,
4759 pub pocket_enum_enum: Syntax<T, V>,
4760 pub pocket_enum_name: Syntax<T, V>,
4761 pub pocket_enum_left_brace: Syntax<T, V>,
4762 pub pocket_enum_fields: Syntax<T, V>,
4763 pub pocket_enum_right_brace: Syntax<T, V>,
4764 }
4766 #[derive(Debug, Clone)]
4767 pub struct PocketFieldTypeExprDeclarationChildren<T, V> {
4768 pub pocket_field_type_expr_case: Syntax<T, V>,
4769 pub pocket_field_type_expr_type: Syntax<T, V>,
4770 pub pocket_field_type_expr_name: Syntax<T, V>,
4771 pub pocket_field_type_expr_semicolon: Syntax<T, V>,
4772 }
4774 #[derive(Debug, Clone)]
4775 pub struct PocketFieldTypeDeclarationChildren<T, V> {
4776 pub pocket_field_type_case: Syntax<T, V>,
4777 pub pocket_field_type_type: Syntax<T, V>,
4778 pub pocket_field_type_name: Syntax<T, V>,
4779 pub pocket_field_type_semicolon: Syntax<T, V>,
4780 }
4782 #[derive(Debug, Clone)]
4783 pub struct PocketMappingIdDeclarationChildren<T, V> {
4784 pub pocket_mapping_id_name: Syntax<T, V>,
4785 pub pocket_mapping_id_initializer: Syntax<T, V>,
4786 }
4788 #[derive(Debug, Clone)]
4789 pub struct PocketMappingTypeDeclarationChildren<T, V> {
4790 pub pocket_mapping_type_keyword: Syntax<T, V>,
4791 pub pocket_mapping_type_name: Syntax<T, V>,
4792 pub pocket_mapping_type_equal: Syntax<T, V>,
4793 pub pocket_mapping_type_type: Syntax<T, V>,
4794 }
4797 #[derive(Debug, Clone)]
4798 pub enum SyntaxVariant<T, V> {
4799 Token(Box<T>),
4800 Missing,
4801 SyntaxList(Box<Vec<Syntax<T, V>>>),
4802 EndOfFile(Box<EndOfFileChildren<T, V>>),
4803 Script(Box<ScriptChildren<T, V>>),
4804 QualifiedName(Box<QualifiedNameChildren<T, V>>),
4805 SimpleTypeSpecifier(Box<SimpleTypeSpecifierChildren<T, V>>),
4806 LiteralExpression(Box<LiteralExpressionChildren<T, V>>),
4807 PrefixedStringExpression(Box<PrefixedStringExpressionChildren<T, V>>),
4808 VariableExpression(Box<VariableExpressionChildren<T, V>>),
4809 PipeVariableExpression(Box<PipeVariableExpressionChildren<T, V>>),
4810 FileAttributeSpecification(Box<FileAttributeSpecificationChildren<T, V>>),
4811 EnumDeclaration(Box<EnumDeclarationChildren<T, V>>),
4812 Enumerator(Box<EnumeratorChildren<T, V>>),
4813 AliasDeclaration(Box<AliasDeclarationChildren<T, V>>),
4814 PropertyDeclaration(Box<PropertyDeclarationChildren<T, V>>),
4815 PropertyDeclarator(Box<PropertyDeclaratorChildren<T, V>>),
4816 NamespaceDeclaration(Box<NamespaceDeclarationChildren<T, V>>),
4817 NamespaceBody(Box<NamespaceBodyChildren<T, V>>),
4818 NamespaceEmptyBody(Box<NamespaceEmptyBodyChildren<T, V>>),
4819 NamespaceUseDeclaration(Box<NamespaceUseDeclarationChildren<T, V>>),
4820 NamespaceGroupUseDeclaration(Box<NamespaceGroupUseDeclarationChildren<T, V>>),
4821 NamespaceUseClause(Box<NamespaceUseClauseChildren<T, V>>),
4822 FunctionDeclaration(Box<FunctionDeclarationChildren<T, V>>),
4823 FunctionDeclarationHeader(Box<FunctionDeclarationHeaderChildren<T, V>>),
4824 WhereClause(Box<WhereClauseChildren<T, V>>),
4825 WhereConstraint(Box<WhereConstraintChildren<T, V>>),
4826 MethodishDeclaration(Box<MethodishDeclarationChildren<T, V>>),
4827 MethodishTraitResolution(Box<MethodishTraitResolutionChildren<T, V>>),
4828 ClassishDeclaration(Box<ClassishDeclarationChildren<T, V>>),
4829 ClassishBody(Box<ClassishBodyChildren<T, V>>),
4830 TraitUsePrecedenceItem(Box<TraitUsePrecedenceItemChildren<T, V>>),
4831 TraitUseAliasItem(Box<TraitUseAliasItemChildren<T, V>>),
4832 TraitUseConflictResolution(Box<TraitUseConflictResolutionChildren<T, V>>),
4833 TraitUse(Box<TraitUseChildren<T, V>>),
4834 RequireClause(Box<RequireClauseChildren<T, V>>),
4835 ConstDeclaration(Box<ConstDeclarationChildren<T, V>>),
4836 ConstantDeclarator(Box<ConstantDeclaratorChildren<T, V>>),
4837 TypeConstDeclaration(Box<TypeConstDeclarationChildren<T, V>>),
4838 DecoratedExpression(Box<DecoratedExpressionChildren<T, V>>),
4839 ParameterDeclaration(Box<ParameterDeclarationChildren<T, V>>),
4840 VariadicParameter(Box<VariadicParameterChildren<T, V>>),
4841 AttributeSpecification(Box<AttributeSpecificationChildren<T, V>>),
4842 InclusionExpression(Box<InclusionExpressionChildren<T, V>>),
4843 InclusionDirective(Box<InclusionDirectiveChildren<T, V>>),
4844 CompoundStatement(Box<CompoundStatementChildren<T, V>>),
4845 AlternateLoopStatement(Box<AlternateLoopStatementChildren<T, V>>),
4846 ExpressionStatement(Box<ExpressionStatementChildren<T, V>>),
4847 MarkupSection(Box<MarkupSectionChildren<T, V>>),
4848 MarkupSuffix(Box<MarkupSuffixChildren<T, V>>),
4849 UnsetStatement(Box<UnsetStatementChildren<T, V>>),
4850 LetStatement(Box<LetStatementChildren<T, V>>),
4851 UsingStatementBlockScoped(Box<UsingStatementBlockScopedChildren<T, V>>),
4852 UsingStatementFunctionScoped(Box<UsingStatementFunctionScopedChildren<T, V>>),
4853 DeclareDirectiveStatement(Box<DeclareDirectiveStatementChildren<T, V>>),
4854 DeclareBlockStatement(Box<DeclareBlockStatementChildren<T, V>>),
4855 WhileStatement(Box<WhileStatementChildren<T, V>>),
4856 IfStatement(Box<IfStatementChildren<T, V>>),
4857 ElseifClause(Box<ElseifClauseChildren<T, V>>),
4858 ElseClause(Box<ElseClauseChildren<T, V>>),
4859 AlternateIfStatement(Box<AlternateIfStatementChildren<T, V>>),
4860 AlternateElseifClause(Box<AlternateElseifClauseChildren<T, V>>),
4861 AlternateElseClause(Box<AlternateElseClauseChildren<T, V>>),
4862 TryStatement(Box<TryStatementChildren<T, V>>),
4863 CatchClause(Box<CatchClauseChildren<T, V>>),
4864 FinallyClause(Box<FinallyClauseChildren<T, V>>),
4865 DoStatement(Box<DoStatementChildren<T, V>>),
4866 ForStatement(Box<ForStatementChildren<T, V>>),
4867 ForeachStatement(Box<ForeachStatementChildren<T, V>>),
4868 SwitchStatement(Box<SwitchStatementChildren<T, V>>),
4869 AlternateSwitchStatement(Box<AlternateSwitchStatementChildren<T, V>>),
4870 SwitchSection(Box<SwitchSectionChildren<T, V>>),
4871 SwitchFallthrough(Box<SwitchFallthroughChildren<T, V>>),
4872 CaseLabel(Box<CaseLabelChildren<T, V>>),
4873 DefaultLabel(Box<DefaultLabelChildren<T, V>>),
4874 ReturnStatement(Box<ReturnStatementChildren<T, V>>),
4875 GotoLabel(Box<GotoLabelChildren<T, V>>),
4876 GotoStatement(Box<GotoStatementChildren<T, V>>),
4877 ThrowStatement(Box<ThrowStatementChildren<T, V>>),
4878 BreakStatement(Box<BreakStatementChildren<T, V>>),
4879 ContinueStatement(Box<ContinueStatementChildren<T, V>>),
4880 EchoStatement(Box<EchoStatementChildren<T, V>>),
4881 ConcurrentStatement(Box<ConcurrentStatementChildren<T, V>>),
4882 SimpleInitializer(Box<SimpleInitializerChildren<T, V>>),
4883 AnonymousClass(Box<AnonymousClassChildren<T, V>>),
4884 AnonymousFunction(Box<AnonymousFunctionChildren<T, V>>),
4885 Php7AnonymousFunction(Box<Php7AnonymousFunctionChildren<T, V>>),
4886 AnonymousFunctionUseClause(Box<AnonymousFunctionUseClauseChildren<T, V>>),
4887 LambdaExpression(Box<LambdaExpressionChildren<T, V>>),
4888 LambdaSignature(Box<LambdaSignatureChildren<T, V>>),
4889 CastExpression(Box<CastExpressionChildren<T, V>>),
4890 ScopeResolutionExpression(Box<ScopeResolutionExpressionChildren<T, V>>),
4891 MemberSelectionExpression(Box<MemberSelectionExpressionChildren<T, V>>),
4892 SafeMemberSelectionExpression(Box<SafeMemberSelectionExpressionChildren<T, V>>),
4893 EmbeddedMemberSelectionExpression(Box<EmbeddedMemberSelectionExpressionChildren<T, V>>),
4894 YieldExpression(Box<YieldExpressionChildren<T, V>>),
4895 YieldFromExpression(Box<YieldFromExpressionChildren<T, V>>),
4896 PrefixUnaryExpression(Box<PrefixUnaryExpressionChildren<T, V>>),
4897 PostfixUnaryExpression(Box<PostfixUnaryExpressionChildren<T, V>>),
4898 BinaryExpression(Box<BinaryExpressionChildren<T, V>>),
4899 InstanceofExpression(Box<InstanceofExpressionChildren<T, V>>),
4900 IsExpression(Box<IsExpressionChildren<T, V>>),
4901 AsExpression(Box<AsExpressionChildren<T, V>>),
4902 NullableAsExpression(Box<NullableAsExpressionChildren<T, V>>),
4903 ConditionalExpression(Box<ConditionalExpressionChildren<T, V>>),
4904 EvalExpression(Box<EvalExpressionChildren<T, V>>),
4905 EmptyExpression(Box<EmptyExpressionChildren<T, V>>),
4906 DefineExpression(Box<DefineExpressionChildren<T, V>>),
4907 HaltCompilerExpression(Box<HaltCompilerExpressionChildren<T, V>>),
4908 IssetExpression(Box<IssetExpressionChildren<T, V>>),
4909 FunctionCallExpression(Box<FunctionCallExpressionChildren<T, V>>),
4910 ParenthesizedExpression(Box<ParenthesizedExpressionChildren<T, V>>),
4911 BracedExpression(Box<BracedExpressionChildren<T, V>>),
4912 EmbeddedBracedExpression(Box<EmbeddedBracedExpressionChildren<T, V>>),
4913 ListExpression(Box<ListExpressionChildren<T, V>>),
4914 CollectionLiteralExpression(Box<CollectionLiteralExpressionChildren<T, V>>),
4915 ObjectCreationExpression(Box<ObjectCreationExpressionChildren<T, V>>),
4916 ConstructorCall(Box<ConstructorCallChildren<T, V>>),
4917 ArrayCreationExpression(Box<ArrayCreationExpressionChildren<T, V>>),
4918 ArrayIntrinsicExpression(Box<ArrayIntrinsicExpressionChildren<T, V>>),
4919 DarrayIntrinsicExpression(Box<DarrayIntrinsicExpressionChildren<T, V>>),
4920 DictionaryIntrinsicExpression(Box<DictionaryIntrinsicExpressionChildren<T, V>>),
4921 KeysetIntrinsicExpression(Box<KeysetIntrinsicExpressionChildren<T, V>>),
4922 VarrayIntrinsicExpression(Box<VarrayIntrinsicExpressionChildren<T, V>>),
4923 VectorIntrinsicExpression(Box<VectorIntrinsicExpressionChildren<T, V>>),
4924 ElementInitializer(Box<ElementInitializerChildren<T, V>>),
4925 SubscriptExpression(Box<SubscriptExpressionChildren<T, V>>),
4926 EmbeddedSubscriptExpression(Box<EmbeddedSubscriptExpressionChildren<T, V>>),
4927 AwaitableCreationExpression(Box<AwaitableCreationExpressionChildren<T, V>>),
4928 XHPChildrenDeclaration(Box<XHPChildrenDeclarationChildren<T, V>>),
4929 XHPChildrenParenthesizedList(Box<XHPChildrenParenthesizedListChildren<T, V>>),
4930 XHPCategoryDeclaration(Box<XHPCategoryDeclarationChildren<T, V>>),
4931 XHPEnumType(Box<XHPEnumTypeChildren<T, V>>),
4932 XHPRequired(Box<XHPRequiredChildren<T, V>>),
4933 XHPClassAttributeDeclaration(Box<XHPClassAttributeDeclarationChildren<T, V>>),
4934 XHPClassAttribute(Box<XHPClassAttributeChildren<T, V>>),
4935 XHPSimpleClassAttribute(Box<XHPSimpleClassAttributeChildren<T, V>>),
4936 XHPSimpleAttribute(Box<XHPSimpleAttributeChildren<T, V>>),
4937 XHPSpreadAttribute(Box<XHPSpreadAttributeChildren<T, V>>),
4938 XHPOpen(Box<XHPOpenChildren<T, V>>),
4939 XHPExpression(Box<XHPExpressionChildren<T, V>>),
4940 XHPClose(Box<XHPCloseChildren<T, V>>),
4941 TypeConstant(Box<TypeConstantChildren<T, V>>),
4942 VectorTypeSpecifier(Box<VectorTypeSpecifierChildren<T, V>>),
4943 KeysetTypeSpecifier(Box<KeysetTypeSpecifierChildren<T, V>>),
4944 TupleTypeExplicitSpecifier(Box<TupleTypeExplicitSpecifierChildren<T, V>>),
4945 VarrayTypeSpecifier(Box<VarrayTypeSpecifierChildren<T, V>>),
4946 VectorArrayTypeSpecifier(Box<VectorArrayTypeSpecifierChildren<T, V>>),
4947 TypeParameter(Box<TypeParameterChildren<T, V>>),
4948 TypeConstraint(Box<TypeConstraintChildren<T, V>>),
4949 DarrayTypeSpecifier(Box<DarrayTypeSpecifierChildren<T, V>>),
4950 MapArrayTypeSpecifier(Box<MapArrayTypeSpecifierChildren<T, V>>),
4951 DictionaryTypeSpecifier(Box<DictionaryTypeSpecifierChildren<T, V>>),
4952 ClosureTypeSpecifier(Box<ClosureTypeSpecifierChildren<T, V>>),
4953 ClosureParameterTypeSpecifier(Box<ClosureParameterTypeSpecifierChildren<T, V>>),
4954 ClassnameTypeSpecifier(Box<ClassnameTypeSpecifierChildren<T, V>>),
4955 FieldSpecifier(Box<FieldSpecifierChildren<T, V>>),
4956 FieldInitializer(Box<FieldInitializerChildren<T, V>>),
4957 ShapeTypeSpecifier(Box<ShapeTypeSpecifierChildren<T, V>>),
4958 ShapeExpression(Box<ShapeExpressionChildren<T, V>>),
4959 TupleExpression(Box<TupleExpressionChildren<T, V>>),
4960 GenericTypeSpecifier(Box<GenericTypeSpecifierChildren<T, V>>),
4961 NullableTypeSpecifier(Box<NullableTypeSpecifierChildren<T, V>>),
4962 LikeTypeSpecifier(Box<LikeTypeSpecifierChildren<T, V>>),
4963 SoftTypeSpecifier(Box<SoftTypeSpecifierChildren<T, V>>),
4964 ReifiedTypeArgument(Box<ReifiedTypeArgumentChildren<T, V>>),
4965 TypeArguments(Box<TypeArgumentsChildren<T, V>>),
4966 TypeParameters(Box<TypeParametersChildren<T, V>>),
4967 TupleTypeSpecifier(Box<TupleTypeSpecifierChildren<T, V>>),
4968 ErrorSyntax(Box<ErrorSyntaxChildren<T, V>>),
4969 ListItem(Box<ListItemChildren<T, V>>),
4970 PocketAtomExpression(Box<PocketAtomExpressionChildren<T, V>>),
4971 PocketIdentifierExpression(Box<PocketIdentifierExpressionChildren<T, V>>),
4972 PocketAtomMappingDeclaration(Box<PocketAtomMappingDeclarationChildren<T, V>>),
4973 PocketEnumDeclaration(Box<PocketEnumDeclarationChildren<T, V>>),
4974 PocketFieldTypeExprDeclaration(Box<PocketFieldTypeExprDeclarationChildren<T, V>>),
4975 PocketFieldTypeDeclaration(Box<PocketFieldTypeDeclarationChildren<T, V>>),
4976 PocketMappingIdDeclaration(Box<PocketMappingIdDeclarationChildren<T, V>>),
4977 PocketMappingTypeDeclaration(Box<PocketMappingTypeDeclarationChildren<T, V>>),
4978 }