| blob | 5b11cd8aafd5915e9e6b26ab92bd218df2973eb1 |
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, C> SyntaxType<C> for Syntax<T, V>
24 where
25 T: LexableToken,
26 V: SyntaxValueType<T>,
27 {
28 fn make_end_of_file(_: &C, 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_values(syntax.iter_children().map(|child| &child.value));
33 Self::make(syntax, value)
34 }
36 fn make_script(_: &C, script_declarations: Self) -> Self {
37 let syntax = SyntaxVariant::Script(Box::new(ScriptChildren {
38 script_declarations,
39 }));
40 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
41 Self::make(syntax, value)
42 }
44 fn make_qualified_name(_: &C, qualified_name_parts: Self) -> Self {
45 let syntax = SyntaxVariant::QualifiedName(Box::new(QualifiedNameChildren {
46 qualified_name_parts,
47 }));
48 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
49 Self::make(syntax, value)
50 }
52 fn make_simple_type_specifier(_: &C, simple_type_specifier: Self) -> Self {
53 let syntax = SyntaxVariant::SimpleTypeSpecifier(Box::new(SimpleTypeSpecifierChildren {
54 simple_type_specifier,
55 }));
56 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
57 Self::make(syntax, value)
58 }
60 fn make_literal_expression(_: &C, literal_expression: Self) -> Self {
61 let syntax = SyntaxVariant::LiteralExpression(Box::new(LiteralExpressionChildren {
62 literal_expression,
63 }));
64 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
65 Self::make(syntax, value)
66 }
68 fn make_prefixed_string_expression(_: &C, 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_values(syntax.iter_children().map(|child| &child.value));
74 Self::make(syntax, value)
75 }
77 fn make_prefixed_code_expression(_: &C, prefixed_code_prefix: Self, prefixed_code_left_backtick: Self, prefixed_code_expression: Self, prefixed_code_right_backtick: Self) -> Self {
78 let syntax = SyntaxVariant::PrefixedCodeExpression(Box::new(PrefixedCodeExpressionChildren {
79 prefixed_code_prefix,
80 prefixed_code_left_backtick,
81 prefixed_code_expression,
82 prefixed_code_right_backtick,
83 }));
84 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
85 Self::make(syntax, value)
86 }
88 fn make_variable_expression(_: &C, variable_expression: Self) -> Self {
89 let syntax = SyntaxVariant::VariableExpression(Box::new(VariableExpressionChildren {
90 variable_expression,
91 }));
92 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
93 Self::make(syntax, value)
94 }
96 fn make_pipe_variable_expression(_: &C, pipe_variable_expression: Self) -> Self {
97 let syntax = SyntaxVariant::PipeVariableExpression(Box::new(PipeVariableExpressionChildren {
98 pipe_variable_expression,
99 }));
100 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
101 Self::make(syntax, value)
102 }
104 fn make_file_attribute_specification(_: &C, 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 {
105 let syntax = SyntaxVariant::FileAttributeSpecification(Box::new(FileAttributeSpecificationChildren {
106 file_attribute_specification_left_double_angle,
107 file_attribute_specification_keyword,
108 file_attribute_specification_colon,
109 file_attribute_specification_attributes,
110 file_attribute_specification_right_double_angle,
111 }));
112 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
113 Self::make(syntax, value)
114 }
116 fn make_enum_declaration(_: &C, enum_attribute_spec: Self, enum_keyword: Self, enum_name: Self, enum_colon: Self, enum_base: Self, enum_type: Self, enum_left_brace: Self, enum_use_clauses: Self, enum_enumerators: Self, enum_right_brace: Self) -> Self {
117 let syntax = SyntaxVariant::EnumDeclaration(Box::new(EnumDeclarationChildren {
118 enum_attribute_spec,
119 enum_keyword,
120 enum_name,
121 enum_colon,
122 enum_base,
123 enum_type,
124 enum_left_brace,
125 enum_use_clauses,
126 enum_enumerators,
127 enum_right_brace,
128 }));
129 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
130 Self::make(syntax, value)
131 }
133 fn make_enum_use(_: &C, enum_use_keyword: Self, enum_use_names: Self, enum_use_semicolon: Self) -> Self {
134 let syntax = SyntaxVariant::EnumUse(Box::new(EnumUseChildren {
135 enum_use_keyword,
136 enum_use_names,
137 enum_use_semicolon,
138 }));
139 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
140 Self::make(syntax, value)
141 }
143 fn make_enumerator(_: &C, enumerator_name: Self, enumerator_equal: Self, enumerator_value: Self, enumerator_semicolon: Self) -> Self {
144 let syntax = SyntaxVariant::Enumerator(Box::new(EnumeratorChildren {
145 enumerator_name,
146 enumerator_equal,
147 enumerator_value,
148 enumerator_semicolon,
149 }));
150 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
151 Self::make(syntax, value)
152 }
154 fn make_enum_class_declaration(_: &C, enum_class_attribute_spec: Self, enum_class_enum_keyword: Self, enum_class_class_keyword: Self, enum_class_name: Self, enum_class_colon: Self, enum_class_base: Self, enum_class_extends: Self, enum_class_extends_list: Self, enum_class_left_brace: Self, enum_class_elements: Self, enum_class_right_brace: Self) -> Self {
155 let syntax = SyntaxVariant::EnumClassDeclaration(Box::new(EnumClassDeclarationChildren {
156 enum_class_attribute_spec,
157 enum_class_enum_keyword,
158 enum_class_class_keyword,
159 enum_class_name,
160 enum_class_colon,
161 enum_class_base,
162 enum_class_extends,
163 enum_class_extends_list,
164 enum_class_left_brace,
165 enum_class_elements,
166 enum_class_right_brace,
167 }));
168 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
169 Self::make(syntax, value)
170 }
172 fn make_enum_class_enumerator(_: &C, enum_class_enumerator_type: Self, enum_class_enumerator_name: Self, enum_class_enumerator_equal: Self, enum_class_enumerator_initial_value: Self, enum_class_enumerator_semicolon: Self) -> Self {
173 let syntax = SyntaxVariant::EnumClassEnumerator(Box::new(EnumClassEnumeratorChildren {
174 enum_class_enumerator_type,
175 enum_class_enumerator_name,
176 enum_class_enumerator_equal,
177 enum_class_enumerator_initial_value,
178 enum_class_enumerator_semicolon,
179 }));
180 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
181 Self::make(syntax, value)
182 }
184 fn make_record_declaration(_: &C, record_attribute_spec: Self, record_modifier: Self, record_keyword: Self, record_name: Self, record_extends_keyword: Self, record_extends_opt: Self, record_left_brace: Self, record_fields: Self, record_right_brace: Self) -> Self {
185 let syntax = SyntaxVariant::RecordDeclaration(Box::new(RecordDeclarationChildren {
186 record_attribute_spec,
187 record_modifier,
188 record_keyword,
189 record_name,
190 record_extends_keyword,
191 record_extends_opt,
192 record_left_brace,
193 record_fields,
194 record_right_brace,
195 }));
196 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
197 Self::make(syntax, value)
198 }
200 fn make_record_field(_: &C, record_field_type: Self, record_field_name: Self, record_field_init: Self, record_field_semi: Self) -> Self {
201 let syntax = SyntaxVariant::RecordField(Box::new(RecordFieldChildren {
202 record_field_type,
203 record_field_name,
204 record_field_init,
205 record_field_semi,
206 }));
207 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
208 Self::make(syntax, value)
209 }
211 fn make_alias_declaration(_: &C, 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 {
212 let syntax = SyntaxVariant::AliasDeclaration(Box::new(AliasDeclarationChildren {
213 alias_attribute_spec,
214 alias_keyword,
215 alias_name,
216 alias_generic_parameter,
217 alias_constraint,
218 alias_equal,
219 alias_type,
220 alias_semicolon,
221 }));
222 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
223 Self::make(syntax, value)
224 }
226 fn make_property_declaration(_: &C, property_attribute_spec: Self, property_modifiers: Self, property_type: Self, property_declarators: Self, property_semicolon: Self) -> Self {
227 let syntax = SyntaxVariant::PropertyDeclaration(Box::new(PropertyDeclarationChildren {
228 property_attribute_spec,
229 property_modifiers,
230 property_type,
231 property_declarators,
232 property_semicolon,
233 }));
234 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
235 Self::make(syntax, value)
236 }
238 fn make_property_declarator(_: &C, property_name: Self, property_initializer: Self) -> Self {
239 let syntax = SyntaxVariant::PropertyDeclarator(Box::new(PropertyDeclaratorChildren {
240 property_name,
241 property_initializer,
242 }));
243 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
244 Self::make(syntax, value)
245 }
247 fn make_namespace_declaration(_: &C, namespace_header: Self, namespace_body: Self) -> Self {
248 let syntax = SyntaxVariant::NamespaceDeclaration(Box::new(NamespaceDeclarationChildren {
249 namespace_header,
250 namespace_body,
251 }));
252 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
253 Self::make(syntax, value)
254 }
256 fn make_namespace_declaration_header(_: &C, namespace_keyword: Self, namespace_name: Self) -> Self {
257 let syntax = SyntaxVariant::NamespaceDeclarationHeader(Box::new(NamespaceDeclarationHeaderChildren {
258 namespace_keyword,
259 namespace_name,
260 }));
261 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
262 Self::make(syntax, value)
263 }
265 fn make_namespace_body(_: &C, namespace_left_brace: Self, namespace_declarations: Self, namespace_right_brace: Self) -> Self {
266 let syntax = SyntaxVariant::NamespaceBody(Box::new(NamespaceBodyChildren {
267 namespace_left_brace,
268 namespace_declarations,
269 namespace_right_brace,
270 }));
271 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
272 Self::make(syntax, value)
273 }
275 fn make_namespace_empty_body(_: &C, namespace_semicolon: Self) -> Self {
276 let syntax = SyntaxVariant::NamespaceEmptyBody(Box::new(NamespaceEmptyBodyChildren {
277 namespace_semicolon,
278 }));
279 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
280 Self::make(syntax, value)
281 }
283 fn make_namespace_use_declaration(_: &C, namespace_use_keyword: Self, namespace_use_kind: Self, namespace_use_clauses: Self, namespace_use_semicolon: Self) -> Self {
284 let syntax = SyntaxVariant::NamespaceUseDeclaration(Box::new(NamespaceUseDeclarationChildren {
285 namespace_use_keyword,
286 namespace_use_kind,
287 namespace_use_clauses,
288 namespace_use_semicolon,
289 }));
290 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
291 Self::make(syntax, value)
292 }
294 fn make_namespace_group_use_declaration(_: &C, 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 {
295 let syntax = SyntaxVariant::NamespaceGroupUseDeclaration(Box::new(NamespaceGroupUseDeclarationChildren {
296 namespace_group_use_keyword,
297 namespace_group_use_kind,
298 namespace_group_use_prefix,
299 namespace_group_use_left_brace,
300 namespace_group_use_clauses,
301 namespace_group_use_right_brace,
302 namespace_group_use_semicolon,
303 }));
304 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
305 Self::make(syntax, value)
306 }
308 fn make_namespace_use_clause(_: &C, namespace_use_clause_kind: Self, namespace_use_name: Self, namespace_use_as: Self, namespace_use_alias: Self) -> Self {
309 let syntax = SyntaxVariant::NamespaceUseClause(Box::new(NamespaceUseClauseChildren {
310 namespace_use_clause_kind,
311 namespace_use_name,
312 namespace_use_as,
313 namespace_use_alias,
314 }));
315 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
316 Self::make(syntax, value)
317 }
319 fn make_function_declaration(_: &C, function_attribute_spec: Self, function_declaration_header: Self, function_body: Self) -> Self {
320 let syntax = SyntaxVariant::FunctionDeclaration(Box::new(FunctionDeclarationChildren {
321 function_attribute_spec,
322 function_declaration_header,
323 function_body,
324 }));
325 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
326 Self::make(syntax, value)
327 }
329 fn make_function_declaration_header(_: &C, 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_contexts: Self, function_colon: Self, function_type: Self, function_where_clause: Self) -> Self {
330 let syntax = SyntaxVariant::FunctionDeclarationHeader(Box::new(FunctionDeclarationHeaderChildren {
331 function_modifiers,
332 function_keyword,
333 function_name,
334 function_type_parameter_list,
335 function_left_paren,
336 function_parameter_list,
337 function_right_paren,
338 function_contexts,
339 function_colon,
340 function_type,
341 function_where_clause,
342 }));
343 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
344 Self::make(syntax, value)
345 }
347 fn make_contexts(_: &C, contexts_left_bracket: Self, contexts_types: Self, contexts_right_bracket: Self) -> Self {
348 let syntax = SyntaxVariant::Contexts(Box::new(ContextsChildren {
349 contexts_left_bracket,
350 contexts_types,
351 contexts_right_bracket,
352 }));
353 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
354 Self::make(syntax, value)
355 }
357 fn make_where_clause(_: &C, where_clause_keyword: Self, where_clause_constraints: Self) -> Self {
358 let syntax = SyntaxVariant::WhereClause(Box::new(WhereClauseChildren {
359 where_clause_keyword,
360 where_clause_constraints,
361 }));
362 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
363 Self::make(syntax, value)
364 }
366 fn make_where_constraint(_: &C, where_constraint_left_type: Self, where_constraint_operator: Self, where_constraint_right_type: Self) -> Self {
367 let syntax = SyntaxVariant::WhereConstraint(Box::new(WhereConstraintChildren {
368 where_constraint_left_type,
369 where_constraint_operator,
370 where_constraint_right_type,
371 }));
372 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
373 Self::make(syntax, value)
374 }
376 fn make_methodish_declaration(_: &C, methodish_attribute: Self, methodish_function_decl_header: Self, methodish_function_body: Self, methodish_semicolon: Self) -> Self {
377 let syntax = SyntaxVariant::MethodishDeclaration(Box::new(MethodishDeclarationChildren {
378 methodish_attribute,
379 methodish_function_decl_header,
380 methodish_function_body,
381 methodish_semicolon,
382 }));
383 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
384 Self::make(syntax, value)
385 }
387 fn make_methodish_trait_resolution(_: &C, methodish_trait_attribute: Self, methodish_trait_function_decl_header: Self, methodish_trait_equal: Self, methodish_trait_name: Self, methodish_trait_semicolon: Self) -> Self {
388 let syntax = SyntaxVariant::MethodishTraitResolution(Box::new(MethodishTraitResolutionChildren {
389 methodish_trait_attribute,
390 methodish_trait_function_decl_header,
391 methodish_trait_equal,
392 methodish_trait_name,
393 methodish_trait_semicolon,
394 }));
395 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
396 Self::make(syntax, value)
397 }
399 fn make_classish_declaration(_: &C, classish_attribute: Self, classish_modifiers: Self, classish_xhp: 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_where_clause: Self, classish_body: Self) -> Self {
400 let syntax = SyntaxVariant::ClassishDeclaration(Box::new(ClassishDeclarationChildren {
401 classish_attribute,
402 classish_modifiers,
403 classish_xhp,
404 classish_keyword,
405 classish_name,
406 classish_type_parameters,
407 classish_extends_keyword,
408 classish_extends_list,
409 classish_implements_keyword,
410 classish_implements_list,
411 classish_where_clause,
412 classish_body,
413 }));
414 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
415 Self::make(syntax, value)
416 }
418 fn make_classish_body(_: &C, classish_body_left_brace: Self, classish_body_elements: Self, classish_body_right_brace: Self) -> Self {
419 let syntax = SyntaxVariant::ClassishBody(Box::new(ClassishBodyChildren {
420 classish_body_left_brace,
421 classish_body_elements,
422 classish_body_right_brace,
423 }));
424 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
425 Self::make(syntax, value)
426 }
428 fn make_trait_use_precedence_item(_: &C, trait_use_precedence_item_name: Self, trait_use_precedence_item_keyword: Self, trait_use_precedence_item_removed_names: Self) -> Self {
429 let syntax = SyntaxVariant::TraitUsePrecedenceItem(Box::new(TraitUsePrecedenceItemChildren {
430 trait_use_precedence_item_name,
431 trait_use_precedence_item_keyword,
432 trait_use_precedence_item_removed_names,
433 }));
434 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
435 Self::make(syntax, value)
436 }
438 fn make_trait_use_alias_item(_: &C, 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 {
439 let syntax = SyntaxVariant::TraitUseAliasItem(Box::new(TraitUseAliasItemChildren {
440 trait_use_alias_item_aliasing_name,
441 trait_use_alias_item_keyword,
442 trait_use_alias_item_modifiers,
443 trait_use_alias_item_aliased_name,
444 }));
445 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
446 Self::make(syntax, value)
447 }
449 fn make_trait_use_conflict_resolution(_: &C, 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 {
450 let syntax = SyntaxVariant::TraitUseConflictResolution(Box::new(TraitUseConflictResolutionChildren {
451 trait_use_conflict_resolution_keyword,
452 trait_use_conflict_resolution_names,
453 trait_use_conflict_resolution_left_brace,
454 trait_use_conflict_resolution_clauses,
455 trait_use_conflict_resolution_right_brace,
456 }));
457 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
458 Self::make(syntax, value)
459 }
461 fn make_trait_use(_: &C, trait_use_keyword: Self, trait_use_names: Self, trait_use_semicolon: Self) -> Self {
462 let syntax = SyntaxVariant::TraitUse(Box::new(TraitUseChildren {
463 trait_use_keyword,
464 trait_use_names,
465 trait_use_semicolon,
466 }));
467 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
468 Self::make(syntax, value)
469 }
471 fn make_require_clause(_: &C, require_keyword: Self, require_kind: Self, require_name: Self, require_semicolon: Self) -> Self {
472 let syntax = SyntaxVariant::RequireClause(Box::new(RequireClauseChildren {
473 require_keyword,
474 require_kind,
475 require_name,
476 require_semicolon,
477 }));
478 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
479 Self::make(syntax, value)
480 }
482 fn make_const_declaration(_: &C, const_modifiers: Self, const_keyword: Self, const_type_specifier: Self, const_declarators: Self, const_semicolon: Self) -> Self {
483 let syntax = SyntaxVariant::ConstDeclaration(Box::new(ConstDeclarationChildren {
484 const_modifiers,
485 const_keyword,
486 const_type_specifier,
487 const_declarators,
488 const_semicolon,
489 }));
490 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
491 Self::make(syntax, value)
492 }
494 fn make_constant_declarator(_: &C, constant_declarator_name: Self, constant_declarator_initializer: Self) -> Self {
495 let syntax = SyntaxVariant::ConstantDeclarator(Box::new(ConstantDeclaratorChildren {
496 constant_declarator_name,
497 constant_declarator_initializer,
498 }));
499 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
500 Self::make(syntax, value)
501 }
503 fn make_type_const_declaration(_: &C, type_const_attribute_spec: Self, type_const_modifiers: 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 {
504 let syntax = SyntaxVariant::TypeConstDeclaration(Box::new(TypeConstDeclarationChildren {
505 type_const_attribute_spec,
506 type_const_modifiers,
507 type_const_keyword,
508 type_const_type_keyword,
509 type_const_name,
510 type_const_type_parameters,
511 type_const_type_constraint,
512 type_const_equal,
513 type_const_type_specifier,
514 type_const_semicolon,
515 }));
516 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
517 Self::make(syntax, value)
518 }
520 fn make_context_const_declaration(_: &C, context_const_modifiers: Self, context_const_const_keyword: Self, context_const_ctx_keyword: Self, context_const_name: Self, context_const_type_parameters: Self, context_const_constraint: Self, context_const_equal: Self, context_const_ctx_list: Self, context_const_semicolon: Self) -> Self {
521 let syntax = SyntaxVariant::ContextConstDeclaration(Box::new(ContextConstDeclarationChildren {
522 context_const_modifiers,
523 context_const_const_keyword,
524 context_const_ctx_keyword,
525 context_const_name,
526 context_const_type_parameters,
527 context_const_constraint,
528 context_const_equal,
529 context_const_ctx_list,
530 context_const_semicolon,
531 }));
532 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
533 Self::make(syntax, value)
534 }
536 fn make_decorated_expression(_: &C, decorated_expression_decorator: Self, decorated_expression_expression: Self) -> Self {
537 let syntax = SyntaxVariant::DecoratedExpression(Box::new(DecoratedExpressionChildren {
538 decorated_expression_decorator,
539 decorated_expression_expression,
540 }));
541 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
542 Self::make(syntax, value)
543 }
545 fn make_parameter_declaration(_: &C, parameter_attribute: Self, parameter_visibility: Self, parameter_call_convention: Self, parameter_type: Self, parameter_name: Self, parameter_default_value: Self) -> Self {
546 let syntax = SyntaxVariant::ParameterDeclaration(Box::new(ParameterDeclarationChildren {
547 parameter_attribute,
548 parameter_visibility,
549 parameter_call_convention,
550 parameter_type,
551 parameter_name,
552 parameter_default_value,
553 }));
554 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
555 Self::make(syntax, value)
556 }
558 fn make_variadic_parameter(_: &C, variadic_parameter_call_convention: Self, variadic_parameter_type: Self, variadic_parameter_ellipsis: Self) -> Self {
559 let syntax = SyntaxVariant::VariadicParameter(Box::new(VariadicParameterChildren {
560 variadic_parameter_call_convention,
561 variadic_parameter_type,
562 variadic_parameter_ellipsis,
563 }));
564 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
565 Self::make(syntax, value)
566 }
568 fn make_old_attribute_specification(_: &C, old_attribute_specification_left_double_angle: Self, old_attribute_specification_attributes: Self, old_attribute_specification_right_double_angle: Self) -> Self {
569 let syntax = SyntaxVariant::OldAttributeSpecification(Box::new(OldAttributeSpecificationChildren {
570 old_attribute_specification_left_double_angle,
571 old_attribute_specification_attributes,
572 old_attribute_specification_right_double_angle,
573 }));
574 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
575 Self::make(syntax, value)
576 }
578 fn make_attribute_specification(_: &C, attribute_specification_attributes: Self) -> Self {
579 let syntax = SyntaxVariant::AttributeSpecification(Box::new(AttributeSpecificationChildren {
580 attribute_specification_attributes,
581 }));
582 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
583 Self::make(syntax, value)
584 }
586 fn make_attribute(_: &C, attribute_at: Self, attribute_attribute_name: Self) -> Self {
587 let syntax = SyntaxVariant::Attribute(Box::new(AttributeChildren {
588 attribute_at,
589 attribute_attribute_name,
590 }));
591 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
592 Self::make(syntax, value)
593 }
595 fn make_inclusion_expression(_: &C, inclusion_require: Self, inclusion_filename: Self) -> Self {
596 let syntax = SyntaxVariant::InclusionExpression(Box::new(InclusionExpressionChildren {
597 inclusion_require,
598 inclusion_filename,
599 }));
600 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
601 Self::make(syntax, value)
602 }
604 fn make_inclusion_directive(_: &C, inclusion_expression: Self, inclusion_semicolon: Self) -> Self {
605 let syntax = SyntaxVariant::InclusionDirective(Box::new(InclusionDirectiveChildren {
606 inclusion_expression,
607 inclusion_semicolon,
608 }));
609 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
610 Self::make(syntax, value)
611 }
613 fn make_compound_statement(_: &C, compound_left_brace: Self, compound_statements: Self, compound_right_brace: Self) -> Self {
614 let syntax = SyntaxVariant::CompoundStatement(Box::new(CompoundStatementChildren {
615 compound_left_brace,
616 compound_statements,
617 compound_right_brace,
618 }));
619 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
620 Self::make(syntax, value)
621 }
623 fn make_expression_statement(_: &C, expression_statement_expression: Self, expression_statement_semicolon: Self) -> Self {
624 let syntax = SyntaxVariant::ExpressionStatement(Box::new(ExpressionStatementChildren {
625 expression_statement_expression,
626 expression_statement_semicolon,
627 }));
628 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
629 Self::make(syntax, value)
630 }
632 fn make_markup_section(_: &C, markup_hashbang: Self, markup_suffix: Self) -> Self {
633 let syntax = SyntaxVariant::MarkupSection(Box::new(MarkupSectionChildren {
634 markup_hashbang,
635 markup_suffix,
636 }));
637 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
638 Self::make(syntax, value)
639 }
641 fn make_markup_suffix(_: &C, markup_suffix_less_than_question: Self, markup_suffix_name: Self) -> Self {
642 let syntax = SyntaxVariant::MarkupSuffix(Box::new(MarkupSuffixChildren {
643 markup_suffix_less_than_question,
644 markup_suffix_name,
645 }));
646 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
647 Self::make(syntax, value)
648 }
650 fn make_unset_statement(_: &C, unset_keyword: Self, unset_left_paren: Self, unset_variables: Self, unset_right_paren: Self, unset_semicolon: Self) -> Self {
651 let syntax = SyntaxVariant::UnsetStatement(Box::new(UnsetStatementChildren {
652 unset_keyword,
653 unset_left_paren,
654 unset_variables,
655 unset_right_paren,
656 unset_semicolon,
657 }));
658 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
659 Self::make(syntax, value)
660 }
662 fn make_using_statement_block_scoped(_: &C, 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 {
663 let syntax = SyntaxVariant::UsingStatementBlockScoped(Box::new(UsingStatementBlockScopedChildren {
664 using_block_await_keyword,
665 using_block_using_keyword,
666 using_block_left_paren,
667 using_block_expressions,
668 using_block_right_paren,
669 using_block_body,
670 }));
671 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
672 Self::make(syntax, value)
673 }
675 fn make_using_statement_function_scoped(_: &C, using_function_await_keyword: Self, using_function_using_keyword: Self, using_function_expression: Self, using_function_semicolon: Self) -> Self {
676 let syntax = SyntaxVariant::UsingStatementFunctionScoped(Box::new(UsingStatementFunctionScopedChildren {
677 using_function_await_keyword,
678 using_function_using_keyword,
679 using_function_expression,
680 using_function_semicolon,
681 }));
682 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
683 Self::make(syntax, value)
684 }
686 fn make_while_statement(_: &C, while_keyword: Self, while_left_paren: Self, while_condition: Self, while_right_paren: Self, while_body: Self) -> Self {
687 let syntax = SyntaxVariant::WhileStatement(Box::new(WhileStatementChildren {
688 while_keyword,
689 while_left_paren,
690 while_condition,
691 while_right_paren,
692 while_body,
693 }));
694 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
695 Self::make(syntax, value)
696 }
698 fn make_if_statement(_: &C, 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 {
699 let syntax = SyntaxVariant::IfStatement(Box::new(IfStatementChildren {
700 if_keyword,
701 if_left_paren,
702 if_condition,
703 if_right_paren,
704 if_statement,
705 if_elseif_clauses,
706 if_else_clause,
707 }));
708 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
709 Self::make(syntax, value)
710 }
712 fn make_elseif_clause(_: &C, elseif_keyword: Self, elseif_left_paren: Self, elseif_condition: Self, elseif_right_paren: Self, elseif_statement: Self) -> Self {
713 let syntax = SyntaxVariant::ElseifClause(Box::new(ElseifClauseChildren {
714 elseif_keyword,
715 elseif_left_paren,
716 elseif_condition,
717 elseif_right_paren,
718 elseif_statement,
719 }));
720 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
721 Self::make(syntax, value)
722 }
724 fn make_else_clause(_: &C, else_keyword: Self, else_statement: Self) -> Self {
725 let syntax = SyntaxVariant::ElseClause(Box::new(ElseClauseChildren {
726 else_keyword,
727 else_statement,
728 }));
729 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
730 Self::make(syntax, value)
731 }
733 fn make_try_statement(_: &C, try_keyword: Self, try_compound_statement: Self, try_catch_clauses: Self, try_finally_clause: Self) -> Self {
734 let syntax = SyntaxVariant::TryStatement(Box::new(TryStatementChildren {
735 try_keyword,
736 try_compound_statement,
737 try_catch_clauses,
738 try_finally_clause,
739 }));
740 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
741 Self::make(syntax, value)
742 }
744 fn make_catch_clause(_: &C, catch_keyword: Self, catch_left_paren: Self, catch_type: Self, catch_variable: Self, catch_right_paren: Self, catch_body: Self) -> Self {
745 let syntax = SyntaxVariant::CatchClause(Box::new(CatchClauseChildren {
746 catch_keyword,
747 catch_left_paren,
748 catch_type,
749 catch_variable,
750 catch_right_paren,
751 catch_body,
752 }));
753 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
754 Self::make(syntax, value)
755 }
757 fn make_finally_clause(_: &C, finally_keyword: Self, finally_body: Self) -> Self {
758 let syntax = SyntaxVariant::FinallyClause(Box::new(FinallyClauseChildren {
759 finally_keyword,
760 finally_body,
761 }));
762 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
763 Self::make(syntax, value)
764 }
766 fn make_do_statement(_: &C, 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 {
767 let syntax = SyntaxVariant::DoStatement(Box::new(DoStatementChildren {
768 do_keyword,
769 do_body,
770 do_while_keyword,
771 do_left_paren,
772 do_condition,
773 do_right_paren,
774 do_semicolon,
775 }));
776 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
777 Self::make(syntax, value)
778 }
780 fn make_for_statement(_: &C, 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 {
781 let syntax = SyntaxVariant::ForStatement(Box::new(ForStatementChildren {
782 for_keyword,
783 for_left_paren,
784 for_initializer,
785 for_first_semicolon,
786 for_control,
787 for_second_semicolon,
788 for_end_of_loop,
789 for_right_paren,
790 for_body,
791 }));
792 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
793 Self::make(syntax, value)
794 }
796 fn make_foreach_statement(_: &C, 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 {
797 let syntax = SyntaxVariant::ForeachStatement(Box::new(ForeachStatementChildren {
798 foreach_keyword,
799 foreach_left_paren,
800 foreach_collection,
801 foreach_await_keyword,
802 foreach_as,
803 foreach_key,
804 foreach_arrow,
805 foreach_value,
806 foreach_right_paren,
807 foreach_body,
808 }));
809 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
810 Self::make(syntax, value)
811 }
813 fn make_switch_statement(_: &C, 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 {
814 let syntax = SyntaxVariant::SwitchStatement(Box::new(SwitchStatementChildren {
815 switch_keyword,
816 switch_left_paren,
817 switch_expression,
818 switch_right_paren,
819 switch_left_brace,
820 switch_sections,
821 switch_right_brace,
822 }));
823 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
824 Self::make(syntax, value)
825 }
827 fn make_switch_section(_: &C, switch_section_labels: Self, switch_section_statements: Self, switch_section_fallthrough: Self) -> Self {
828 let syntax = SyntaxVariant::SwitchSection(Box::new(SwitchSectionChildren {
829 switch_section_labels,
830 switch_section_statements,
831 switch_section_fallthrough,
832 }));
833 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
834 Self::make(syntax, value)
835 }
837 fn make_switch_fallthrough(_: &C, fallthrough_keyword: Self, fallthrough_semicolon: Self) -> Self {
838 let syntax = SyntaxVariant::SwitchFallthrough(Box::new(SwitchFallthroughChildren {
839 fallthrough_keyword,
840 fallthrough_semicolon,
841 }));
842 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
843 Self::make(syntax, value)
844 }
846 fn make_case_label(_: &C, case_keyword: Self, case_expression: Self, case_colon: Self) -> Self {
847 let syntax = SyntaxVariant::CaseLabel(Box::new(CaseLabelChildren {
848 case_keyword,
849 case_expression,
850 case_colon,
851 }));
852 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
853 Self::make(syntax, value)
854 }
856 fn make_default_label(_: &C, default_keyword: Self, default_colon: Self) -> Self {
857 let syntax = SyntaxVariant::DefaultLabel(Box::new(DefaultLabelChildren {
858 default_keyword,
859 default_colon,
860 }));
861 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
862 Self::make(syntax, value)
863 }
865 fn make_return_statement(_: &C, return_keyword: Self, return_expression: Self, return_semicolon: Self) -> Self {
866 let syntax = SyntaxVariant::ReturnStatement(Box::new(ReturnStatementChildren {
867 return_keyword,
868 return_expression,
869 return_semicolon,
870 }));
871 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
872 Self::make(syntax, value)
873 }
875 fn make_yield_break_statement(_: &C, yield_break_keyword: Self, yield_break_break: Self, yield_break_semicolon: Self) -> Self {
876 let syntax = SyntaxVariant::YieldBreakStatement(Box::new(YieldBreakStatementChildren {
877 yield_break_keyword,
878 yield_break_break,
879 yield_break_semicolon,
880 }));
881 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
882 Self::make(syntax, value)
883 }
885 fn make_throw_statement(_: &C, throw_keyword: Self, throw_expression: Self, throw_semicolon: Self) -> Self {
886 let syntax = SyntaxVariant::ThrowStatement(Box::new(ThrowStatementChildren {
887 throw_keyword,
888 throw_expression,
889 throw_semicolon,
890 }));
891 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
892 Self::make(syntax, value)
893 }
895 fn make_break_statement(_: &C, break_keyword: Self, break_semicolon: Self) -> Self {
896 let syntax = SyntaxVariant::BreakStatement(Box::new(BreakStatementChildren {
897 break_keyword,
898 break_semicolon,
899 }));
900 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
901 Self::make(syntax, value)
902 }
904 fn make_continue_statement(_: &C, continue_keyword: Self, continue_semicolon: Self) -> Self {
905 let syntax = SyntaxVariant::ContinueStatement(Box::new(ContinueStatementChildren {
906 continue_keyword,
907 continue_semicolon,
908 }));
909 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
910 Self::make(syntax, value)
911 }
913 fn make_echo_statement(_: &C, echo_keyword: Self, echo_expressions: Self, echo_semicolon: Self) -> Self {
914 let syntax = SyntaxVariant::EchoStatement(Box::new(EchoStatementChildren {
915 echo_keyword,
916 echo_expressions,
917 echo_semicolon,
918 }));
919 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
920 Self::make(syntax, value)
921 }
923 fn make_concurrent_statement(_: &C, concurrent_keyword: Self, concurrent_statement: Self) -> Self {
924 let syntax = SyntaxVariant::ConcurrentStatement(Box::new(ConcurrentStatementChildren {
925 concurrent_keyword,
926 concurrent_statement,
927 }));
928 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
929 Self::make(syntax, value)
930 }
932 fn make_simple_initializer(_: &C, simple_initializer_equal: Self, simple_initializer_value: Self) -> Self {
933 let syntax = SyntaxVariant::SimpleInitializer(Box::new(SimpleInitializerChildren {
934 simple_initializer_equal,
935 simple_initializer_value,
936 }));
937 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
938 Self::make(syntax, value)
939 }
941 fn make_anonymous_class(_: &C, 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 {
942 let syntax = SyntaxVariant::AnonymousClass(Box::new(AnonymousClassChildren {
943 anonymous_class_class_keyword,
944 anonymous_class_left_paren,
945 anonymous_class_argument_list,
946 anonymous_class_right_paren,
947 anonymous_class_extends_keyword,
948 anonymous_class_extends_list,
949 anonymous_class_implements_keyword,
950 anonymous_class_implements_list,
951 anonymous_class_body,
952 }));
953 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
954 Self::make(syntax, value)
955 }
957 fn make_anonymous_function(_: &C, anonymous_attribute_spec: Self, anonymous_static_keyword: Self, anonymous_async_keyword: Self, anonymous_function_keyword: Self, anonymous_left_paren: Self, anonymous_parameters: Self, anonymous_right_paren: Self, anonymous_ctx_list: Self, anonymous_colon: Self, anonymous_type: Self, anonymous_use: Self, anonymous_body: Self) -> Self {
958 let syntax = SyntaxVariant::AnonymousFunction(Box::new(AnonymousFunctionChildren {
959 anonymous_attribute_spec,
960 anonymous_static_keyword,
961 anonymous_async_keyword,
962 anonymous_function_keyword,
963 anonymous_left_paren,
964 anonymous_parameters,
965 anonymous_right_paren,
966 anonymous_ctx_list,
967 anonymous_colon,
968 anonymous_type,
969 anonymous_use,
970 anonymous_body,
971 }));
972 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
973 Self::make(syntax, value)
974 }
976 fn make_anonymous_function_use_clause(_: &C, anonymous_use_keyword: Self, anonymous_use_left_paren: Self, anonymous_use_variables: Self, anonymous_use_right_paren: Self) -> Self {
977 let syntax = SyntaxVariant::AnonymousFunctionUseClause(Box::new(AnonymousFunctionUseClauseChildren {
978 anonymous_use_keyword,
979 anonymous_use_left_paren,
980 anonymous_use_variables,
981 anonymous_use_right_paren,
982 }));
983 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
984 Self::make(syntax, value)
985 }
987 fn make_lambda_expression(_: &C, lambda_attribute_spec: Self, lambda_async: Self, lambda_signature: Self, lambda_arrow: Self, lambda_body: Self) -> Self {
988 let syntax = SyntaxVariant::LambdaExpression(Box::new(LambdaExpressionChildren {
989 lambda_attribute_spec,
990 lambda_async,
991 lambda_signature,
992 lambda_arrow,
993 lambda_body,
994 }));
995 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
996 Self::make(syntax, value)
997 }
999 fn make_lambda_signature(_: &C, lambda_left_paren: Self, lambda_parameters: Self, lambda_right_paren: Self, lambda_contexts: Self, lambda_colon: Self, lambda_type: Self) -> Self {
1000 let syntax = SyntaxVariant::LambdaSignature(Box::new(LambdaSignatureChildren {
1001 lambda_left_paren,
1002 lambda_parameters,
1003 lambda_right_paren,
1004 lambda_contexts,
1005 lambda_colon,
1006 lambda_type,
1007 }));
1008 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1009 Self::make(syntax, value)
1010 }
1012 fn make_cast_expression(_: &C, cast_left_paren: Self, cast_type: Self, cast_right_paren: Self, cast_operand: Self) -> Self {
1013 let syntax = SyntaxVariant::CastExpression(Box::new(CastExpressionChildren {
1014 cast_left_paren,
1015 cast_type,
1016 cast_right_paren,
1017 cast_operand,
1018 }));
1019 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1020 Self::make(syntax, value)
1021 }
1023 fn make_scope_resolution_expression(_: &C, scope_resolution_qualifier: Self, scope_resolution_operator: Self, scope_resolution_name: Self) -> Self {
1024 let syntax = SyntaxVariant::ScopeResolutionExpression(Box::new(ScopeResolutionExpressionChildren {
1025 scope_resolution_qualifier,
1026 scope_resolution_operator,
1027 scope_resolution_name,
1028 }));
1029 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1030 Self::make(syntax, value)
1031 }
1033 fn make_member_selection_expression(_: &C, member_object: Self, member_operator: Self, member_name: Self) -> Self {
1034 let syntax = SyntaxVariant::MemberSelectionExpression(Box::new(MemberSelectionExpressionChildren {
1035 member_object,
1036 member_operator,
1037 member_name,
1038 }));
1039 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1040 Self::make(syntax, value)
1041 }
1043 fn make_safe_member_selection_expression(_: &C, safe_member_object: Self, safe_member_operator: Self, safe_member_name: Self) -> Self {
1044 let syntax = SyntaxVariant::SafeMemberSelectionExpression(Box::new(SafeMemberSelectionExpressionChildren {
1045 safe_member_object,
1046 safe_member_operator,
1047 safe_member_name,
1048 }));
1049 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1050 Self::make(syntax, value)
1051 }
1053 fn make_embedded_member_selection_expression(_: &C, embedded_member_object: Self, embedded_member_operator: Self, embedded_member_name: Self) -> Self {
1054 let syntax = SyntaxVariant::EmbeddedMemberSelectionExpression(Box::new(EmbeddedMemberSelectionExpressionChildren {
1055 embedded_member_object,
1056 embedded_member_operator,
1057 embedded_member_name,
1058 }));
1059 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1060 Self::make(syntax, value)
1061 }
1063 fn make_yield_expression(_: &C, yield_keyword: Self, yield_operand: Self) -> Self {
1064 let syntax = SyntaxVariant::YieldExpression(Box::new(YieldExpressionChildren {
1065 yield_keyword,
1066 yield_operand,
1067 }));
1068 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1069 Self::make(syntax, value)
1070 }
1072 fn make_prefix_unary_expression(_: &C, prefix_unary_operator: Self, prefix_unary_operand: Self) -> Self {
1073 let syntax = SyntaxVariant::PrefixUnaryExpression(Box::new(PrefixUnaryExpressionChildren {
1074 prefix_unary_operator,
1075 prefix_unary_operand,
1076 }));
1077 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1078 Self::make(syntax, value)
1079 }
1081 fn make_postfix_unary_expression(_: &C, postfix_unary_operand: Self, postfix_unary_operator: Self) -> Self {
1082 let syntax = SyntaxVariant::PostfixUnaryExpression(Box::new(PostfixUnaryExpressionChildren {
1083 postfix_unary_operand,
1084 postfix_unary_operator,
1085 }));
1086 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1087 Self::make(syntax, value)
1088 }
1090 fn make_binary_expression(_: &C, binary_left_operand: Self, binary_operator: Self, binary_right_operand: Self) -> Self {
1091 let syntax = SyntaxVariant::BinaryExpression(Box::new(BinaryExpressionChildren {
1092 binary_left_operand,
1093 binary_operator,
1094 binary_right_operand,
1095 }));
1096 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1097 Self::make(syntax, value)
1098 }
1100 fn make_is_expression(_: &C, is_left_operand: Self, is_operator: Self, is_right_operand: Self) -> Self {
1101 let syntax = SyntaxVariant::IsExpression(Box::new(IsExpressionChildren {
1102 is_left_operand,
1103 is_operator,
1104 is_right_operand,
1105 }));
1106 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1107 Self::make(syntax, value)
1108 }
1110 fn make_as_expression(_: &C, as_left_operand: Self, as_operator: Self, as_right_operand: Self) -> Self {
1111 let syntax = SyntaxVariant::AsExpression(Box::new(AsExpressionChildren {
1112 as_left_operand,
1113 as_operator,
1114 as_right_operand,
1115 }));
1116 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1117 Self::make(syntax, value)
1118 }
1120 fn make_nullable_as_expression(_: &C, nullable_as_left_operand: Self, nullable_as_operator: Self, nullable_as_right_operand: Self) -> Self {
1121 let syntax = SyntaxVariant::NullableAsExpression(Box::new(NullableAsExpressionChildren {
1122 nullable_as_left_operand,
1123 nullable_as_operator,
1124 nullable_as_right_operand,
1125 }));
1126 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1127 Self::make(syntax, value)
1128 }
1130 fn make_conditional_expression(_: &C, conditional_test: Self, conditional_question: Self, conditional_consequence: Self, conditional_colon: Self, conditional_alternative: Self) -> Self {
1131 let syntax = SyntaxVariant::ConditionalExpression(Box::new(ConditionalExpressionChildren {
1132 conditional_test,
1133 conditional_question,
1134 conditional_consequence,
1135 conditional_colon,
1136 conditional_alternative,
1137 }));
1138 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1139 Self::make(syntax, value)
1140 }
1142 fn make_eval_expression(_: &C, eval_keyword: Self, eval_left_paren: Self, eval_argument: Self, eval_right_paren: Self) -> Self {
1143 let syntax = SyntaxVariant::EvalExpression(Box::new(EvalExpressionChildren {
1144 eval_keyword,
1145 eval_left_paren,
1146 eval_argument,
1147 eval_right_paren,
1148 }));
1149 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1150 Self::make(syntax, value)
1151 }
1153 fn make_define_expression(_: &C, define_keyword: Self, define_left_paren: Self, define_argument_list: Self, define_right_paren: Self) -> Self {
1154 let syntax = SyntaxVariant::DefineExpression(Box::new(DefineExpressionChildren {
1155 define_keyword,
1156 define_left_paren,
1157 define_argument_list,
1158 define_right_paren,
1159 }));
1160 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1161 Self::make(syntax, value)
1162 }
1164 fn make_isset_expression(_: &C, isset_keyword: Self, isset_left_paren: Self, isset_argument_list: Self, isset_right_paren: Self) -> Self {
1165 let syntax = SyntaxVariant::IssetExpression(Box::new(IssetExpressionChildren {
1166 isset_keyword,
1167 isset_left_paren,
1168 isset_argument_list,
1169 isset_right_paren,
1170 }));
1171 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1172 Self::make(syntax, value)
1173 }
1175 fn make_function_call_expression(_: &C, 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 {
1176 let syntax = SyntaxVariant::FunctionCallExpression(Box::new(FunctionCallExpressionChildren {
1177 function_call_receiver,
1178 function_call_type_args,
1179 function_call_left_paren,
1180 function_call_argument_list,
1181 function_call_right_paren,
1182 }));
1183 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1184 Self::make(syntax, value)
1185 }
1187 fn make_function_pointer_expression(_: &C, function_pointer_receiver: Self, function_pointer_type_args: Self) -> Self {
1188 let syntax = SyntaxVariant::FunctionPointerExpression(Box::new(FunctionPointerExpressionChildren {
1189 function_pointer_receiver,
1190 function_pointer_type_args,
1191 }));
1192 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1193 Self::make(syntax, value)
1194 }
1196 fn make_parenthesized_expression(_: &C, parenthesized_expression_left_paren: Self, parenthesized_expression_expression: Self, parenthesized_expression_right_paren: Self) -> Self {
1197 let syntax = SyntaxVariant::ParenthesizedExpression(Box::new(ParenthesizedExpressionChildren {
1198 parenthesized_expression_left_paren,
1199 parenthesized_expression_expression,
1200 parenthesized_expression_right_paren,
1201 }));
1202 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1203 Self::make(syntax, value)
1204 }
1206 fn make_braced_expression(_: &C, braced_expression_left_brace: Self, braced_expression_expression: Self, braced_expression_right_brace: Self) -> Self {
1207 let syntax = SyntaxVariant::BracedExpression(Box::new(BracedExpressionChildren {
1208 braced_expression_left_brace,
1209 braced_expression_expression,
1210 braced_expression_right_brace,
1211 }));
1212 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1213 Self::make(syntax, value)
1214 }
1216 fn make_et_splice_expression(_: &C, et_splice_expression_dollar: Self, et_splice_expression_left_brace: Self, et_splice_expression_expression: Self, et_splice_expression_right_brace: Self) -> Self {
1217 let syntax = SyntaxVariant::ETSpliceExpression(Box::new(ETSpliceExpressionChildren {
1218 et_splice_expression_dollar,
1219 et_splice_expression_left_brace,
1220 et_splice_expression_expression,
1221 et_splice_expression_right_brace,
1222 }));
1223 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1224 Self::make(syntax, value)
1225 }
1227 fn make_embedded_braced_expression(_: &C, embedded_braced_expression_left_brace: Self, embedded_braced_expression_expression: Self, embedded_braced_expression_right_brace: Self) -> Self {
1228 let syntax = SyntaxVariant::EmbeddedBracedExpression(Box::new(EmbeddedBracedExpressionChildren {
1229 embedded_braced_expression_left_brace,
1230 embedded_braced_expression_expression,
1231 embedded_braced_expression_right_brace,
1232 }));
1233 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1234 Self::make(syntax, value)
1235 }
1237 fn make_list_expression(_: &C, list_keyword: Self, list_left_paren: Self, list_members: Self, list_right_paren: Self) -> Self {
1238 let syntax = SyntaxVariant::ListExpression(Box::new(ListExpressionChildren {
1239 list_keyword,
1240 list_left_paren,
1241 list_members,
1242 list_right_paren,
1243 }));
1244 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1245 Self::make(syntax, value)
1246 }
1248 fn make_collection_literal_expression(_: &C, collection_literal_name: Self, collection_literal_left_brace: Self, collection_literal_initializers: Self, collection_literal_right_brace: Self) -> Self {
1249 let syntax = SyntaxVariant::CollectionLiteralExpression(Box::new(CollectionLiteralExpressionChildren {
1250 collection_literal_name,
1251 collection_literal_left_brace,
1252 collection_literal_initializers,
1253 collection_literal_right_brace,
1254 }));
1255 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1256 Self::make(syntax, value)
1257 }
1259 fn make_object_creation_expression(_: &C, object_creation_new_keyword: Self, object_creation_object: Self) -> Self {
1260 let syntax = SyntaxVariant::ObjectCreationExpression(Box::new(ObjectCreationExpressionChildren {
1261 object_creation_new_keyword,
1262 object_creation_object,
1263 }));
1264 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1265 Self::make(syntax, value)
1266 }
1268 fn make_constructor_call(_: &C, constructor_call_type: Self, constructor_call_left_paren: Self, constructor_call_argument_list: Self, constructor_call_right_paren: Self) -> Self {
1269 let syntax = SyntaxVariant::ConstructorCall(Box::new(ConstructorCallChildren {
1270 constructor_call_type,
1271 constructor_call_left_paren,
1272 constructor_call_argument_list,
1273 constructor_call_right_paren,
1274 }));
1275 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1276 Self::make(syntax, value)
1277 }
1279 fn make_record_creation_expression(_: &C, record_creation_type: Self, record_creation_left_bracket: Self, record_creation_members: Self, record_creation_right_bracket: Self) -> Self {
1280 let syntax = SyntaxVariant::RecordCreationExpression(Box::new(RecordCreationExpressionChildren {
1281 record_creation_type,
1282 record_creation_left_bracket,
1283 record_creation_members,
1284 record_creation_right_bracket,
1285 }));
1286 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1287 Self::make(syntax, value)
1288 }
1290 fn make_darray_intrinsic_expression(_: &C, darray_intrinsic_keyword: Self, darray_intrinsic_explicit_type: Self, darray_intrinsic_left_bracket: Self, darray_intrinsic_members: Self, darray_intrinsic_right_bracket: Self) -> Self {
1291 let syntax = SyntaxVariant::DarrayIntrinsicExpression(Box::new(DarrayIntrinsicExpressionChildren {
1292 darray_intrinsic_keyword,
1293 darray_intrinsic_explicit_type,
1294 darray_intrinsic_left_bracket,
1295 darray_intrinsic_members,
1296 darray_intrinsic_right_bracket,
1297 }));
1298 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1299 Self::make(syntax, value)
1300 }
1302 fn make_dictionary_intrinsic_expression(_: &C, dictionary_intrinsic_keyword: Self, dictionary_intrinsic_explicit_type: Self, dictionary_intrinsic_left_bracket: Self, dictionary_intrinsic_members: Self, dictionary_intrinsic_right_bracket: Self) -> Self {
1303 let syntax = SyntaxVariant::DictionaryIntrinsicExpression(Box::new(DictionaryIntrinsicExpressionChildren {
1304 dictionary_intrinsic_keyword,
1305 dictionary_intrinsic_explicit_type,
1306 dictionary_intrinsic_left_bracket,
1307 dictionary_intrinsic_members,
1308 dictionary_intrinsic_right_bracket,
1309 }));
1310 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1311 Self::make(syntax, value)
1312 }
1314 fn make_keyset_intrinsic_expression(_: &C, keyset_intrinsic_keyword: Self, keyset_intrinsic_explicit_type: Self, keyset_intrinsic_left_bracket: Self, keyset_intrinsic_members: Self, keyset_intrinsic_right_bracket: Self) -> Self {
1315 let syntax = SyntaxVariant::KeysetIntrinsicExpression(Box::new(KeysetIntrinsicExpressionChildren {
1316 keyset_intrinsic_keyword,
1317 keyset_intrinsic_explicit_type,
1318 keyset_intrinsic_left_bracket,
1319 keyset_intrinsic_members,
1320 keyset_intrinsic_right_bracket,
1321 }));
1322 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1323 Self::make(syntax, value)
1324 }
1326 fn make_varray_intrinsic_expression(_: &C, varray_intrinsic_keyword: Self, varray_intrinsic_explicit_type: Self, varray_intrinsic_left_bracket: Self, varray_intrinsic_members: Self, varray_intrinsic_right_bracket: Self) -> Self {
1327 let syntax = SyntaxVariant::VarrayIntrinsicExpression(Box::new(VarrayIntrinsicExpressionChildren {
1328 varray_intrinsic_keyword,
1329 varray_intrinsic_explicit_type,
1330 varray_intrinsic_left_bracket,
1331 varray_intrinsic_members,
1332 varray_intrinsic_right_bracket,
1333 }));
1334 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1335 Self::make(syntax, value)
1336 }
1338 fn make_vector_intrinsic_expression(_: &C, vector_intrinsic_keyword: Self, vector_intrinsic_explicit_type: Self, vector_intrinsic_left_bracket: Self, vector_intrinsic_members: Self, vector_intrinsic_right_bracket: Self) -> Self {
1339 let syntax = SyntaxVariant::VectorIntrinsicExpression(Box::new(VectorIntrinsicExpressionChildren {
1340 vector_intrinsic_keyword,
1341 vector_intrinsic_explicit_type,
1342 vector_intrinsic_left_bracket,
1343 vector_intrinsic_members,
1344 vector_intrinsic_right_bracket,
1345 }));
1346 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1347 Self::make(syntax, value)
1348 }
1350 fn make_element_initializer(_: &C, element_key: Self, element_arrow: Self, element_value: Self) -> Self {
1351 let syntax = SyntaxVariant::ElementInitializer(Box::new(ElementInitializerChildren {
1352 element_key,
1353 element_arrow,
1354 element_value,
1355 }));
1356 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1357 Self::make(syntax, value)
1358 }
1360 fn make_subscript_expression(_: &C, subscript_receiver: Self, subscript_left_bracket: Self, subscript_index: Self, subscript_right_bracket: Self) -> Self {
1361 let syntax = SyntaxVariant::SubscriptExpression(Box::new(SubscriptExpressionChildren {
1362 subscript_receiver,
1363 subscript_left_bracket,
1364 subscript_index,
1365 subscript_right_bracket,
1366 }));
1367 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1368 Self::make(syntax, value)
1369 }
1371 fn make_embedded_subscript_expression(_: &C, embedded_subscript_receiver: Self, embedded_subscript_left_bracket: Self, embedded_subscript_index: Self, embedded_subscript_right_bracket: Self) -> Self {
1372 let syntax = SyntaxVariant::EmbeddedSubscriptExpression(Box::new(EmbeddedSubscriptExpressionChildren {
1373 embedded_subscript_receiver,
1374 embedded_subscript_left_bracket,
1375 embedded_subscript_index,
1376 embedded_subscript_right_bracket,
1377 }));
1378 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1379 Self::make(syntax, value)
1380 }
1382 fn make_awaitable_creation_expression(_: &C, awaitable_attribute_spec: Self, awaitable_async: Self, awaitable_compound_statement: Self) -> Self {
1383 let syntax = SyntaxVariant::AwaitableCreationExpression(Box::new(AwaitableCreationExpressionChildren {
1384 awaitable_attribute_spec,
1385 awaitable_async,
1386 awaitable_compound_statement,
1387 }));
1388 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1389 Self::make(syntax, value)
1390 }
1392 fn make_xhp_children_declaration(_: &C, xhp_children_keyword: Self, xhp_children_expression: Self, xhp_children_semicolon: Self) -> Self {
1393 let syntax = SyntaxVariant::XHPChildrenDeclaration(Box::new(XHPChildrenDeclarationChildren {
1394 xhp_children_keyword,
1395 xhp_children_expression,
1396 xhp_children_semicolon,
1397 }));
1398 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1399 Self::make(syntax, value)
1400 }
1402 fn make_xhp_children_parenthesized_list(_: &C, xhp_children_list_left_paren: Self, xhp_children_list_xhp_children: Self, xhp_children_list_right_paren: Self) -> Self {
1403 let syntax = SyntaxVariant::XHPChildrenParenthesizedList(Box::new(XHPChildrenParenthesizedListChildren {
1404 xhp_children_list_left_paren,
1405 xhp_children_list_xhp_children,
1406 xhp_children_list_right_paren,
1407 }));
1408 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1409 Self::make(syntax, value)
1410 }
1412 fn make_xhp_category_declaration(_: &C, xhp_category_keyword: Self, xhp_category_categories: Self, xhp_category_semicolon: Self) -> Self {
1413 let syntax = SyntaxVariant::XHPCategoryDeclaration(Box::new(XHPCategoryDeclarationChildren {
1414 xhp_category_keyword,
1415 xhp_category_categories,
1416 xhp_category_semicolon,
1417 }));
1418 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1419 Self::make(syntax, value)
1420 }
1422 fn make_xhp_enum_type(_: &C, xhp_enum_keyword: Self, xhp_enum_left_brace: Self, xhp_enum_values: Self, xhp_enum_right_brace: Self) -> Self {
1423 let syntax = SyntaxVariant::XHPEnumType(Box::new(XHPEnumTypeChildren {
1424 xhp_enum_keyword,
1425 xhp_enum_left_brace,
1426 xhp_enum_values,
1427 xhp_enum_right_brace,
1428 }));
1429 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1430 Self::make(syntax, value)
1431 }
1433 fn make_xhp_lateinit(_: &C, xhp_lateinit_at: Self, xhp_lateinit_keyword: Self) -> Self {
1434 let syntax = SyntaxVariant::XHPLateinit(Box::new(XHPLateinitChildren {
1435 xhp_lateinit_at,
1436 xhp_lateinit_keyword,
1437 }));
1438 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1439 Self::make(syntax, value)
1440 }
1442 fn make_xhp_required(_: &C, xhp_required_at: Self, xhp_required_keyword: Self) -> Self {
1443 let syntax = SyntaxVariant::XHPRequired(Box::new(XHPRequiredChildren {
1444 xhp_required_at,
1445 xhp_required_keyword,
1446 }));
1447 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1448 Self::make(syntax, value)
1449 }
1451 fn make_xhp_class_attribute_declaration(_: &C, xhp_attribute_keyword: Self, xhp_attribute_attributes: Self, xhp_attribute_semicolon: Self) -> Self {
1452 let syntax = SyntaxVariant::XHPClassAttributeDeclaration(Box::new(XHPClassAttributeDeclarationChildren {
1453 xhp_attribute_keyword,
1454 xhp_attribute_attributes,
1455 xhp_attribute_semicolon,
1456 }));
1457 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1458 Self::make(syntax, value)
1459 }
1461 fn make_xhp_class_attribute(_: &C, xhp_attribute_decl_type: Self, xhp_attribute_decl_name: Self, xhp_attribute_decl_initializer: Self, xhp_attribute_decl_required: Self) -> Self {
1462 let syntax = SyntaxVariant::XHPClassAttribute(Box::new(XHPClassAttributeChildren {
1463 xhp_attribute_decl_type,
1464 xhp_attribute_decl_name,
1465 xhp_attribute_decl_initializer,
1466 xhp_attribute_decl_required,
1467 }));
1468 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1469 Self::make(syntax, value)
1470 }
1472 fn make_xhp_simple_class_attribute(_: &C, xhp_simple_class_attribute_type: Self) -> Self {
1473 let syntax = SyntaxVariant::XHPSimpleClassAttribute(Box::new(XHPSimpleClassAttributeChildren {
1474 xhp_simple_class_attribute_type,
1475 }));
1476 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1477 Self::make(syntax, value)
1478 }
1480 fn make_xhp_simple_attribute(_: &C, xhp_simple_attribute_name: Self, xhp_simple_attribute_equal: Self, xhp_simple_attribute_expression: Self) -> Self {
1481 let syntax = SyntaxVariant::XHPSimpleAttribute(Box::new(XHPSimpleAttributeChildren {
1482 xhp_simple_attribute_name,
1483 xhp_simple_attribute_equal,
1484 xhp_simple_attribute_expression,
1485 }));
1486 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1487 Self::make(syntax, value)
1488 }
1490 fn make_xhp_spread_attribute(_: &C, xhp_spread_attribute_left_brace: Self, xhp_spread_attribute_spread_operator: Self, xhp_spread_attribute_expression: Self, xhp_spread_attribute_right_brace: Self) -> Self {
1491 let syntax = SyntaxVariant::XHPSpreadAttribute(Box::new(XHPSpreadAttributeChildren {
1492 xhp_spread_attribute_left_brace,
1493 xhp_spread_attribute_spread_operator,
1494 xhp_spread_attribute_expression,
1495 xhp_spread_attribute_right_brace,
1496 }));
1497 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1498 Self::make(syntax, value)
1499 }
1501 fn make_xhp_open(_: &C, xhp_open_left_angle: Self, xhp_open_name: Self, xhp_open_attributes: Self, xhp_open_right_angle: Self) -> Self {
1502 let syntax = SyntaxVariant::XHPOpen(Box::new(XHPOpenChildren {
1503 xhp_open_left_angle,
1504 xhp_open_name,
1505 xhp_open_attributes,
1506 xhp_open_right_angle,
1507 }));
1508 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1509 Self::make(syntax, value)
1510 }
1512 fn make_xhp_expression(_: &C, xhp_open: Self, xhp_body: Self, xhp_close: Self) -> Self {
1513 let syntax = SyntaxVariant::XHPExpression(Box::new(XHPExpressionChildren {
1514 xhp_open,
1515 xhp_body,
1516 xhp_close,
1517 }));
1518 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1519 Self::make(syntax, value)
1520 }
1522 fn make_xhp_close(_: &C, xhp_close_left_angle: Self, xhp_close_name: Self, xhp_close_right_angle: Self) -> Self {
1523 let syntax = SyntaxVariant::XHPClose(Box::new(XHPCloseChildren {
1524 xhp_close_left_angle,
1525 xhp_close_name,
1526 xhp_close_right_angle,
1527 }));
1528 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1529 Self::make(syntax, value)
1530 }
1532 fn make_type_constant(_: &C, type_constant_left_type: Self, type_constant_separator: Self, type_constant_right_type: Self) -> Self {
1533 let syntax = SyntaxVariant::TypeConstant(Box::new(TypeConstantChildren {
1534 type_constant_left_type,
1535 type_constant_separator,
1536 type_constant_right_type,
1537 }));
1538 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1539 Self::make(syntax, value)
1540 }
1542 fn make_vector_type_specifier(_: &C, vector_type_keyword: Self, vector_type_left_angle: Self, vector_type_type: Self, vector_type_trailing_comma: Self, vector_type_right_angle: Self) -> Self {
1543 let syntax = SyntaxVariant::VectorTypeSpecifier(Box::new(VectorTypeSpecifierChildren {
1544 vector_type_keyword,
1545 vector_type_left_angle,
1546 vector_type_type,
1547 vector_type_trailing_comma,
1548 vector_type_right_angle,
1549 }));
1550 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1551 Self::make(syntax, value)
1552 }
1554 fn make_keyset_type_specifier(_: &C, keyset_type_keyword: Self, keyset_type_left_angle: Self, keyset_type_type: Self, keyset_type_trailing_comma: Self, keyset_type_right_angle: Self) -> Self {
1555 let syntax = SyntaxVariant::KeysetTypeSpecifier(Box::new(KeysetTypeSpecifierChildren {
1556 keyset_type_keyword,
1557 keyset_type_left_angle,
1558 keyset_type_type,
1559 keyset_type_trailing_comma,
1560 keyset_type_right_angle,
1561 }));
1562 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1563 Self::make(syntax, value)
1564 }
1566 fn make_tuple_type_explicit_specifier(_: &C, tuple_type_keyword: Self, tuple_type_left_angle: Self, tuple_type_types: Self, tuple_type_right_angle: Self) -> Self {
1567 let syntax = SyntaxVariant::TupleTypeExplicitSpecifier(Box::new(TupleTypeExplicitSpecifierChildren {
1568 tuple_type_keyword,
1569 tuple_type_left_angle,
1570 tuple_type_types,
1571 tuple_type_right_angle,
1572 }));
1573 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1574 Self::make(syntax, value)
1575 }
1577 fn make_varray_type_specifier(_: &C, varray_keyword: Self, varray_left_angle: Self, varray_type: Self, varray_trailing_comma: Self, varray_right_angle: Self) -> Self {
1578 let syntax = SyntaxVariant::VarrayTypeSpecifier(Box::new(VarrayTypeSpecifierChildren {
1579 varray_keyword,
1580 varray_left_angle,
1581 varray_type,
1582 varray_trailing_comma,
1583 varray_right_angle,
1584 }));
1585 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1586 Self::make(syntax, value)
1587 }
1589 fn make_function_ctx_type_specifier(_: &C, function_ctx_type_keyword: Self, function_ctx_type_variable: Self) -> Self {
1590 let syntax = SyntaxVariant::FunctionCtxTypeSpecifier(Box::new(FunctionCtxTypeSpecifierChildren {
1591 function_ctx_type_keyword,
1592 function_ctx_type_variable,
1593 }));
1594 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1595 Self::make(syntax, value)
1596 }
1598 fn make_type_parameter(_: &C, type_attribute_spec: Self, type_reified: Self, type_variance: Self, type_name: Self, type_param_params: Self, type_constraints: Self) -> Self {
1599 let syntax = SyntaxVariant::TypeParameter(Box::new(TypeParameterChildren {
1600 type_attribute_spec,
1601 type_reified,
1602 type_variance,
1603 type_name,
1604 type_param_params,
1605 type_constraints,
1606 }));
1607 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1608 Self::make(syntax, value)
1609 }
1611 fn make_type_constraint(_: &C, constraint_keyword: Self, constraint_type: Self) -> Self {
1612 let syntax = SyntaxVariant::TypeConstraint(Box::new(TypeConstraintChildren {
1613 constraint_keyword,
1614 constraint_type,
1615 }));
1616 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1617 Self::make(syntax, value)
1618 }
1620 fn make_context_constraint(_: &C, ctx_constraint_keyword: Self, ctx_constraint_ctx_list: Self) -> Self {
1621 let syntax = SyntaxVariant::ContextConstraint(Box::new(ContextConstraintChildren {
1622 ctx_constraint_keyword,
1623 ctx_constraint_ctx_list,
1624 }));
1625 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1626 Self::make(syntax, value)
1627 }
1629 fn make_darray_type_specifier(_: &C, 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 {
1630 let syntax = SyntaxVariant::DarrayTypeSpecifier(Box::new(DarrayTypeSpecifierChildren {
1631 darray_keyword,
1632 darray_left_angle,
1633 darray_key,
1634 darray_comma,
1635 darray_value,
1636 darray_trailing_comma,
1637 darray_right_angle,
1638 }));
1639 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1640 Self::make(syntax, value)
1641 }
1643 fn make_dictionary_type_specifier(_: &C, dictionary_type_keyword: Self, dictionary_type_left_angle: Self, dictionary_type_members: Self, dictionary_type_right_angle: Self) -> Self {
1644 let syntax = SyntaxVariant::DictionaryTypeSpecifier(Box::new(DictionaryTypeSpecifierChildren {
1645 dictionary_type_keyword,
1646 dictionary_type_left_angle,
1647 dictionary_type_members,
1648 dictionary_type_right_angle,
1649 }));
1650 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1651 Self::make(syntax, value)
1652 }
1654 fn make_closure_type_specifier(_: &C, closure_outer_left_paren: Self, closure_function_keyword: Self, closure_inner_left_paren: Self, closure_parameter_list: Self, closure_inner_right_paren: Self, closure_contexts: Self, closure_colon: Self, closure_return_type: Self, closure_outer_right_paren: Self) -> Self {
1655 let syntax = SyntaxVariant::ClosureTypeSpecifier(Box::new(ClosureTypeSpecifierChildren {
1656 closure_outer_left_paren,
1657 closure_function_keyword,
1658 closure_inner_left_paren,
1659 closure_parameter_list,
1660 closure_inner_right_paren,
1661 closure_contexts,
1662 closure_colon,
1663 closure_return_type,
1664 closure_outer_right_paren,
1665 }));
1666 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1667 Self::make(syntax, value)
1668 }
1670 fn make_closure_parameter_type_specifier(_: &C, closure_parameter_call_convention: Self, closure_parameter_type: Self) -> Self {
1671 let syntax = SyntaxVariant::ClosureParameterTypeSpecifier(Box::new(ClosureParameterTypeSpecifierChildren {
1672 closure_parameter_call_convention,
1673 closure_parameter_type,
1674 }));
1675 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1676 Self::make(syntax, value)
1677 }
1679 fn make_classname_type_specifier(_: &C, classname_keyword: Self, classname_left_angle: Self, classname_type: Self, classname_trailing_comma: Self, classname_right_angle: Self) -> Self {
1680 let syntax = SyntaxVariant::ClassnameTypeSpecifier(Box::new(ClassnameTypeSpecifierChildren {
1681 classname_keyword,
1682 classname_left_angle,
1683 classname_type,
1684 classname_trailing_comma,
1685 classname_right_angle,
1686 }));
1687 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1688 Self::make(syntax, value)
1689 }
1691 fn make_field_specifier(_: &C, field_question: Self, field_name: Self, field_arrow: Self, field_type: Self) -> Self {
1692 let syntax = SyntaxVariant::FieldSpecifier(Box::new(FieldSpecifierChildren {
1693 field_question,
1694 field_name,
1695 field_arrow,
1696 field_type,
1697 }));
1698 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1699 Self::make(syntax, value)
1700 }
1702 fn make_field_initializer(_: &C, field_initializer_name: Self, field_initializer_arrow: Self, field_initializer_value: Self) -> Self {
1703 let syntax = SyntaxVariant::FieldInitializer(Box::new(FieldInitializerChildren {
1704 field_initializer_name,
1705 field_initializer_arrow,
1706 field_initializer_value,
1707 }));
1708 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1709 Self::make(syntax, value)
1710 }
1712 fn make_shape_type_specifier(_: &C, shape_type_keyword: Self, shape_type_left_paren: Self, shape_type_fields: Self, shape_type_ellipsis: Self, shape_type_right_paren: Self) -> Self {
1713 let syntax = SyntaxVariant::ShapeTypeSpecifier(Box::new(ShapeTypeSpecifierChildren {
1714 shape_type_keyword,
1715 shape_type_left_paren,
1716 shape_type_fields,
1717 shape_type_ellipsis,
1718 shape_type_right_paren,
1719 }));
1720 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1721 Self::make(syntax, value)
1722 }
1724 fn make_shape_expression(_: &C, shape_expression_keyword: Self, shape_expression_left_paren: Self, shape_expression_fields: Self, shape_expression_right_paren: Self) -> Self {
1725 let syntax = SyntaxVariant::ShapeExpression(Box::new(ShapeExpressionChildren {
1726 shape_expression_keyword,
1727 shape_expression_left_paren,
1728 shape_expression_fields,
1729 shape_expression_right_paren,
1730 }));
1731 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1732 Self::make(syntax, value)
1733 }
1735 fn make_tuple_expression(_: &C, tuple_expression_keyword: Self, tuple_expression_left_paren: Self, tuple_expression_items: Self, tuple_expression_right_paren: Self) -> Self {
1736 let syntax = SyntaxVariant::TupleExpression(Box::new(TupleExpressionChildren {
1737 tuple_expression_keyword,
1738 tuple_expression_left_paren,
1739 tuple_expression_items,
1740 tuple_expression_right_paren,
1741 }));
1742 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1743 Self::make(syntax, value)
1744 }
1746 fn make_generic_type_specifier(_: &C, generic_class_type: Self, generic_argument_list: Self) -> Self {
1747 let syntax = SyntaxVariant::GenericTypeSpecifier(Box::new(GenericTypeSpecifierChildren {
1748 generic_class_type,
1749 generic_argument_list,
1750 }));
1751 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1752 Self::make(syntax, value)
1753 }
1755 fn make_nullable_type_specifier(_: &C, nullable_question: Self, nullable_type: Self) -> Self {
1756 let syntax = SyntaxVariant::NullableTypeSpecifier(Box::new(NullableTypeSpecifierChildren {
1757 nullable_question,
1758 nullable_type,
1759 }));
1760 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1761 Self::make(syntax, value)
1762 }
1764 fn make_like_type_specifier(_: &C, like_tilde: Self, like_type: Self) -> Self {
1765 let syntax = SyntaxVariant::LikeTypeSpecifier(Box::new(LikeTypeSpecifierChildren {
1766 like_tilde,
1767 like_type,
1768 }));
1769 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1770 Self::make(syntax, value)
1771 }
1773 fn make_soft_type_specifier(_: &C, soft_at: Self, soft_type: Self) -> Self {
1774 let syntax = SyntaxVariant::SoftTypeSpecifier(Box::new(SoftTypeSpecifierChildren {
1775 soft_at,
1776 soft_type,
1777 }));
1778 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1779 Self::make(syntax, value)
1780 }
1782 fn make_attributized_specifier(_: &C, attributized_specifier_attribute_spec: Self, attributized_specifier_type: Self) -> Self {
1783 let syntax = SyntaxVariant::AttributizedSpecifier(Box::new(AttributizedSpecifierChildren {
1784 attributized_specifier_attribute_spec,
1785 attributized_specifier_type,
1786 }));
1787 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1788 Self::make(syntax, value)
1789 }
1791 fn make_reified_type_argument(_: &C, reified_type_argument_reified: Self, reified_type_argument_type: Self) -> Self {
1792 let syntax = SyntaxVariant::ReifiedTypeArgument(Box::new(ReifiedTypeArgumentChildren {
1793 reified_type_argument_reified,
1794 reified_type_argument_type,
1795 }));
1796 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1797 Self::make(syntax, value)
1798 }
1800 fn make_type_arguments(_: &C, type_arguments_left_angle: Self, type_arguments_types: Self, type_arguments_right_angle: Self) -> Self {
1801 let syntax = SyntaxVariant::TypeArguments(Box::new(TypeArgumentsChildren {
1802 type_arguments_left_angle,
1803 type_arguments_types,
1804 type_arguments_right_angle,
1805 }));
1806 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1807 Self::make(syntax, value)
1808 }
1810 fn make_type_parameters(_: &C, type_parameters_left_angle: Self, type_parameters_parameters: Self, type_parameters_right_angle: Self) -> Self {
1811 let syntax = SyntaxVariant::TypeParameters(Box::new(TypeParametersChildren {
1812 type_parameters_left_angle,
1813 type_parameters_parameters,
1814 type_parameters_right_angle,
1815 }));
1816 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1817 Self::make(syntax, value)
1818 }
1820 fn make_tuple_type_specifier(_: &C, tuple_left_paren: Self, tuple_types: Self, tuple_right_paren: Self) -> Self {
1821 let syntax = SyntaxVariant::TupleTypeSpecifier(Box::new(TupleTypeSpecifierChildren {
1822 tuple_left_paren,
1823 tuple_types,
1824 tuple_right_paren,
1825 }));
1826 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1827 Self::make(syntax, value)
1828 }
1830 fn make_union_type_specifier(_: &C, union_left_paren: Self, union_types: Self, union_right_paren: Self) -> Self {
1831 let syntax = SyntaxVariant::UnionTypeSpecifier(Box::new(UnionTypeSpecifierChildren {
1832 union_left_paren,
1833 union_types,
1834 union_right_paren,
1835 }));
1836 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1837 Self::make(syntax, value)
1838 }
1840 fn make_intersection_type_specifier(_: &C, intersection_left_paren: Self, intersection_types: Self, intersection_right_paren: Self) -> Self {
1841 let syntax = SyntaxVariant::IntersectionTypeSpecifier(Box::new(IntersectionTypeSpecifierChildren {
1842 intersection_left_paren,
1843 intersection_types,
1844 intersection_right_paren,
1845 }));
1846 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1847 Self::make(syntax, value)
1848 }
1850 fn make_error(_: &C, error_error: Self) -> Self {
1851 let syntax = SyntaxVariant::ErrorSyntax(Box::new(ErrorSyntaxChildren {
1852 error_error,
1853 }));
1854 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1855 Self::make(syntax, value)
1856 }
1858 fn make_list_item(_: &C, list_item: Self, list_separator: Self) -> Self {
1859 let syntax = SyntaxVariant::ListItem(Box::new(ListItemChildren {
1860 list_item,
1861 list_separator,
1862 }));
1863 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1864 Self::make(syntax, value)
1865 }
1867 fn make_enum_atom_expression(_: &C, enum_atom_hash: Self, enum_atom_expression: Self) -> Self {
1868 let syntax = SyntaxVariant::EnumAtomExpression(Box::new(EnumAtomExpressionChildren {
1869 enum_atom_hash,
1870 enum_atom_expression,
1871 }));
1872 let value = V::from_values(syntax.iter_children().map(|child| &child.value));
1873 Self::make(syntax, value)
1874 }
1876 }
1878 impl<T, V> Syntax<T, V>
1879 where
1880 T: LexableToken,
1881 {
1882 pub fn fold_over_children_owned<U>(
1883 f: &dyn Fn(Self, U) -> U,
1884 acc: U,
1885 syntax: SyntaxVariant<T, V>,
1886 ) -> U {
1887 match syntax {
1888 SyntaxVariant::Missing => acc,
1889 SyntaxVariant::Token (_) => acc,
1890 SyntaxVariant::SyntaxList(elems) => {
1891 let mut acc = acc;
1892 for item in elems {
1893 acc = f(item, acc);
1894 }
1895 acc
1896 },
1897 SyntaxVariant::EndOfFile(x) => {
1898 let EndOfFileChildren { end_of_file_token } = *x;
1899 let acc = f(end_of_file_token, acc);
1900 acc
1901 },
1902 SyntaxVariant::Script(x) => {
1903 let ScriptChildren { script_declarations } = *x;
1904 let acc = f(script_declarations, acc);
1905 acc
1906 },
1907 SyntaxVariant::QualifiedName(x) => {
1908 let QualifiedNameChildren { qualified_name_parts } = *x;
1909 let acc = f(qualified_name_parts, acc);
1910 acc
1911 },
1912 SyntaxVariant::SimpleTypeSpecifier(x) => {
1913 let SimpleTypeSpecifierChildren { simple_type_specifier } = *x;
1914 let acc = f(simple_type_specifier, acc);
1915 acc
1916 },
1917 SyntaxVariant::LiteralExpression(x) => {
1918 let LiteralExpressionChildren { literal_expression } = *x;
1919 let acc = f(literal_expression, acc);
1920 acc
1921 },
1922 SyntaxVariant::PrefixedStringExpression(x) => {
1923 let PrefixedStringExpressionChildren { prefixed_string_name, prefixed_string_str } = *x;
1924 let acc = f(prefixed_string_name, acc);
1925 let acc = f(prefixed_string_str, acc);
1926 acc
1927 },
1928 SyntaxVariant::PrefixedCodeExpression(x) => {
1929 let PrefixedCodeExpressionChildren { prefixed_code_prefix, prefixed_code_left_backtick, prefixed_code_expression, prefixed_code_right_backtick } = *x;
1930 let acc = f(prefixed_code_prefix, acc);
1931 let acc = f(prefixed_code_left_backtick, acc);
1932 let acc = f(prefixed_code_expression, acc);
1933 let acc = f(prefixed_code_right_backtick, acc);
1934 acc
1935 },
1936 SyntaxVariant::VariableExpression(x) => {
1937 let VariableExpressionChildren { variable_expression } = *x;
1938 let acc = f(variable_expression, acc);
1939 acc
1940 },
1941 SyntaxVariant::PipeVariableExpression(x) => {
1942 let PipeVariableExpressionChildren { pipe_variable_expression } = *x;
1943 let acc = f(pipe_variable_expression, acc);
1944 acc
1945 },
1946 SyntaxVariant::FileAttributeSpecification(x) => {
1947 let FileAttributeSpecificationChildren { file_attribute_specification_left_double_angle, file_attribute_specification_keyword, file_attribute_specification_colon, file_attribute_specification_attributes, file_attribute_specification_right_double_angle } = *x;
1948 let acc = f(file_attribute_specification_left_double_angle, acc);
1949 let acc = f(file_attribute_specification_keyword, acc);
1950 let acc = f(file_attribute_specification_colon, acc);
1951 let acc = f(file_attribute_specification_attributes, acc);
1952 let acc = f(file_attribute_specification_right_double_angle, acc);
1953 acc
1954 },
1955 SyntaxVariant::EnumDeclaration(x) => {
1956 let EnumDeclarationChildren { enum_attribute_spec, enum_keyword, enum_name, enum_colon, enum_base, enum_type, enum_left_brace, enum_use_clauses, enum_enumerators, enum_right_brace } = *x;
1957 let acc = f(enum_attribute_spec, acc);
1958 let acc = f(enum_keyword, acc);
1959 let acc = f(enum_name, acc);
1960 let acc = f(enum_colon, acc);
1961 let acc = f(enum_base, acc);
1962 let acc = f(enum_type, acc);
1963 let acc = f(enum_left_brace, acc);
1964 let acc = f(enum_use_clauses, acc);
1965 let acc = f(enum_enumerators, acc);
1966 let acc = f(enum_right_brace, acc);
1967 acc
1968 },
1969 SyntaxVariant::EnumUse(x) => {
1970 let EnumUseChildren { enum_use_keyword, enum_use_names, enum_use_semicolon } = *x;
1971 let acc = f(enum_use_keyword, acc);
1972 let acc = f(enum_use_names, acc);
1973 let acc = f(enum_use_semicolon, acc);
1974 acc
1975 },
1976 SyntaxVariant::Enumerator(x) => {
1977 let EnumeratorChildren { enumerator_name, enumerator_equal, enumerator_value, enumerator_semicolon } = *x;
1978 let acc = f(enumerator_name, acc);
1979 let acc = f(enumerator_equal, acc);
1980 let acc = f(enumerator_value, acc);
1981 let acc = f(enumerator_semicolon, acc);
1982 acc
1983 },
1984 SyntaxVariant::EnumClassDeclaration(x) => {
1985 let EnumClassDeclarationChildren { enum_class_attribute_spec, enum_class_enum_keyword, enum_class_class_keyword, enum_class_name, enum_class_colon, enum_class_base, enum_class_extends, enum_class_extends_list, enum_class_left_brace, enum_class_elements, enum_class_right_brace } = *x;
1986 let acc = f(enum_class_attribute_spec, acc);
1987 let acc = f(enum_class_enum_keyword, acc);
1988 let acc = f(enum_class_class_keyword, acc);
1989 let acc = f(enum_class_name, acc);
1990 let acc = f(enum_class_colon, acc);
1991 let acc = f(enum_class_base, acc);
1992 let acc = f(enum_class_extends, acc);
1993 let acc = f(enum_class_extends_list, acc);
1994 let acc = f(enum_class_left_brace, acc);
1995 let acc = f(enum_class_elements, acc);
1996 let acc = f(enum_class_right_brace, acc);
1997 acc
1998 },
1999 SyntaxVariant::EnumClassEnumerator(x) => {
2000 let EnumClassEnumeratorChildren { enum_class_enumerator_type, enum_class_enumerator_name, enum_class_enumerator_equal, enum_class_enumerator_initial_value, enum_class_enumerator_semicolon } = *x;
2001 let acc = f(enum_class_enumerator_type, acc);
2002 let acc = f(enum_class_enumerator_name, acc);
2003 let acc = f(enum_class_enumerator_equal, acc);
2004 let acc = f(enum_class_enumerator_initial_value, acc);
2005 let acc = f(enum_class_enumerator_semicolon, acc);
2006 acc
2007 },
2008 SyntaxVariant::RecordDeclaration(x) => {
2009 let RecordDeclarationChildren { record_attribute_spec, record_modifier, record_keyword, record_name, record_extends_keyword, record_extends_opt, record_left_brace, record_fields, record_right_brace } = *x;
2010 let acc = f(record_attribute_spec, acc);
2011 let acc = f(record_modifier, acc);
2012 let acc = f(record_keyword, acc);
2013 let acc = f(record_name, acc);
2014 let acc = f(record_extends_keyword, acc);
2015 let acc = f(record_extends_opt, acc);
2016 let acc = f(record_left_brace, acc);
2017 let acc = f(record_fields, acc);
2018 let acc = f(record_right_brace, acc);
2019 acc
2020 },
2021 SyntaxVariant::RecordField(x) => {
2022 let RecordFieldChildren { record_field_type, record_field_name, record_field_init, record_field_semi } = *x;
2023 let acc = f(record_field_type, acc);
2024 let acc = f(record_field_name, acc);
2025 let acc = f(record_field_init, acc);
2026 let acc = f(record_field_semi, acc);
2027 acc
2028 },
2029 SyntaxVariant::AliasDeclaration(x) => {
2030 let AliasDeclarationChildren { alias_attribute_spec, alias_keyword, alias_name, alias_generic_parameter, alias_constraint, alias_equal, alias_type, alias_semicolon } = *x;
2031 let acc = f(alias_attribute_spec, acc);
2032 let acc = f(alias_keyword, acc);
2033 let acc = f(alias_name, acc);
2034 let acc = f(alias_generic_parameter, acc);
2035 let acc = f(alias_constraint, acc);
2036 let acc = f(alias_equal, acc);
2037 let acc = f(alias_type, acc);
2038 let acc = f(alias_semicolon, acc);
2039 acc
2040 },
2041 SyntaxVariant::PropertyDeclaration(x) => {
2042 let PropertyDeclarationChildren { property_attribute_spec, property_modifiers, property_type, property_declarators, property_semicolon } = *x;
2043 let acc = f(property_attribute_spec, acc);
2044 let acc = f(property_modifiers, acc);
2045 let acc = f(property_type, acc);
2046 let acc = f(property_declarators, acc);
2047 let acc = f(property_semicolon, acc);
2048 acc
2049 },
2050 SyntaxVariant::PropertyDeclarator(x) => {
2051 let PropertyDeclaratorChildren { property_name, property_initializer } = *x;
2052 let acc = f(property_name, acc);
2053 let acc = f(property_initializer, acc);
2054 acc
2055 },
2056 SyntaxVariant::NamespaceDeclaration(x) => {
2057 let NamespaceDeclarationChildren { namespace_header, namespace_body } = *x;
2058 let acc = f(namespace_header, acc);
2059 let acc = f(namespace_body, acc);
2060 acc
2061 },
2062 SyntaxVariant::NamespaceDeclarationHeader(x) => {
2063 let NamespaceDeclarationHeaderChildren { namespace_keyword, namespace_name } = *x;
2064 let acc = f(namespace_keyword, acc);
2065 let acc = f(namespace_name, acc);
2066 acc
2067 },
2068 SyntaxVariant::NamespaceBody(x) => {
2069 let NamespaceBodyChildren { namespace_left_brace, namespace_declarations, namespace_right_brace } = *x;
2070 let acc = f(namespace_left_brace, acc);
2071 let acc = f(namespace_declarations, acc);
2072 let acc = f(namespace_right_brace, acc);
2073 acc
2074 },
2075 SyntaxVariant::NamespaceEmptyBody(x) => {
2076 let NamespaceEmptyBodyChildren { namespace_semicolon } = *x;
2077 let acc = f(namespace_semicolon, acc);
2078 acc
2079 },
2080 SyntaxVariant::NamespaceUseDeclaration(x) => {
2081 let NamespaceUseDeclarationChildren { namespace_use_keyword, namespace_use_kind, namespace_use_clauses, namespace_use_semicolon } = *x;
2082 let acc = f(namespace_use_keyword, acc);
2083 let acc = f(namespace_use_kind, acc);
2084 let acc = f(namespace_use_clauses, acc);
2085 let acc = f(namespace_use_semicolon, acc);
2086 acc
2087 },
2088 SyntaxVariant::NamespaceGroupUseDeclaration(x) => {
2089 let NamespaceGroupUseDeclarationChildren { namespace_group_use_keyword, namespace_group_use_kind, namespace_group_use_prefix, namespace_group_use_left_brace, namespace_group_use_clauses, namespace_group_use_right_brace, namespace_group_use_semicolon } = *x;
2090 let acc = f(namespace_group_use_keyword, acc);
2091 let acc = f(namespace_group_use_kind, acc);
2092 let acc = f(namespace_group_use_prefix, acc);
2093 let acc = f(namespace_group_use_left_brace, acc);
2094 let acc = f(namespace_group_use_clauses, acc);
2095 let acc = f(namespace_group_use_right_brace, acc);
2096 let acc = f(namespace_group_use_semicolon, acc);
2097 acc
2098 },
2099 SyntaxVariant::NamespaceUseClause(x) => {
2100 let NamespaceUseClauseChildren { namespace_use_clause_kind, namespace_use_name, namespace_use_as, namespace_use_alias } = *x;
2101 let acc = f(namespace_use_clause_kind, acc);
2102 let acc = f(namespace_use_name, acc);
2103 let acc = f(namespace_use_as, acc);
2104 let acc = f(namespace_use_alias, acc);
2105 acc
2106 },
2107 SyntaxVariant::FunctionDeclaration(x) => {
2108 let FunctionDeclarationChildren { function_attribute_spec, function_declaration_header, function_body } = *x;
2109 let acc = f(function_attribute_spec, acc);
2110 let acc = f(function_declaration_header, acc);
2111 let acc = f(function_body, acc);
2112 acc
2113 },
2114 SyntaxVariant::FunctionDeclarationHeader(x) => {
2115 let FunctionDeclarationHeaderChildren { function_modifiers, function_keyword, function_name, function_type_parameter_list, function_left_paren, function_parameter_list, function_right_paren, function_contexts, function_colon, function_type, function_where_clause } = *x;
2116 let acc = f(function_modifiers, acc);
2117 let acc = f(function_keyword, acc);
2118 let acc = f(function_name, acc);
2119 let acc = f(function_type_parameter_list, acc);
2120 let acc = f(function_left_paren, acc);
2121 let acc = f(function_parameter_list, acc);
2122 let acc = f(function_right_paren, acc);
2123 let acc = f(function_contexts, acc);
2124 let acc = f(function_colon, acc);
2125 let acc = f(function_type, acc);
2126 let acc = f(function_where_clause, acc);
2127 acc
2128 },
2129 SyntaxVariant::Contexts(x) => {
2130 let ContextsChildren { contexts_left_bracket, contexts_types, contexts_right_bracket } = *x;
2131 let acc = f(contexts_left_bracket, acc);
2132 let acc = f(contexts_types, acc);
2133 let acc = f(contexts_right_bracket, acc);
2134 acc
2135 },
2136 SyntaxVariant::WhereClause(x) => {
2137 let WhereClauseChildren { where_clause_keyword, where_clause_constraints } = *x;
2138 let acc = f(where_clause_keyword, acc);
2139 let acc = f(where_clause_constraints, acc);
2140 acc
2141 },
2142 SyntaxVariant::WhereConstraint(x) => {
2143 let WhereConstraintChildren { where_constraint_left_type, where_constraint_operator, where_constraint_right_type } = *x;
2144 let acc = f(where_constraint_left_type, acc);
2145 let acc = f(where_constraint_operator, acc);
2146 let acc = f(where_constraint_right_type, acc);
2147 acc
2148 },
2149 SyntaxVariant::MethodishDeclaration(x) => {
2150 let MethodishDeclarationChildren { methodish_attribute, methodish_function_decl_header, methodish_function_body, methodish_semicolon } = *x;
2151 let acc = f(methodish_attribute, acc);
2152 let acc = f(methodish_function_decl_header, acc);
2153 let acc = f(methodish_function_body, acc);
2154 let acc = f(methodish_semicolon, acc);
2155 acc
2156 },
2157 SyntaxVariant::MethodishTraitResolution(x) => {
2158 let MethodishTraitResolutionChildren { methodish_trait_attribute, methodish_trait_function_decl_header, methodish_trait_equal, methodish_trait_name, methodish_trait_semicolon } = *x;
2159 let acc = f(methodish_trait_attribute, acc);
2160 let acc = f(methodish_trait_function_decl_header, acc);
2161 let acc = f(methodish_trait_equal, acc);
2162 let acc = f(methodish_trait_name, acc);
2163 let acc = f(methodish_trait_semicolon, acc);
2164 acc
2165 },
2166 SyntaxVariant::ClassishDeclaration(x) => {
2167 let ClassishDeclarationChildren { classish_attribute, classish_modifiers, classish_xhp, classish_keyword, classish_name, classish_type_parameters, classish_extends_keyword, classish_extends_list, classish_implements_keyword, classish_implements_list, classish_where_clause, classish_body } = *x;
2168 let acc = f(classish_attribute, acc);
2169 let acc = f(classish_modifiers, acc);
2170 let acc = f(classish_xhp, acc);
2171 let acc = f(classish_keyword, acc);
2172 let acc = f(classish_name, acc);
2173 let acc = f(classish_type_parameters, acc);
2174 let acc = f(classish_extends_keyword, acc);
2175 let acc = f(classish_extends_list, acc);
2176 let acc = f(classish_implements_keyword, acc);
2177 let acc = f(classish_implements_list, acc);
2178 let acc = f(classish_where_clause, acc);
2179 let acc = f(classish_body, acc);
2180 acc
2181 },
2182 SyntaxVariant::ClassishBody(x) => {
2183 let ClassishBodyChildren { classish_body_left_brace, classish_body_elements, classish_body_right_brace } = *x;
2184 let acc = f(classish_body_left_brace, acc);
2185 let acc = f(classish_body_elements, acc);
2186 let acc = f(classish_body_right_brace, acc);
2187 acc
2188 },
2189 SyntaxVariant::TraitUsePrecedenceItem(x) => {
2190 let TraitUsePrecedenceItemChildren { trait_use_precedence_item_name, trait_use_precedence_item_keyword, trait_use_precedence_item_removed_names } = *x;
2191 let acc = f(trait_use_precedence_item_name, acc);
2192 let acc = f(trait_use_precedence_item_keyword, acc);
2193 let acc = f(trait_use_precedence_item_removed_names, acc);
2194 acc
2195 },
2196 SyntaxVariant::TraitUseAliasItem(x) => {
2197 let TraitUseAliasItemChildren { trait_use_alias_item_aliasing_name, trait_use_alias_item_keyword, trait_use_alias_item_modifiers, trait_use_alias_item_aliased_name } = *x;
2198 let acc = f(trait_use_alias_item_aliasing_name, acc);
2199 let acc = f(trait_use_alias_item_keyword, acc);
2200 let acc = f(trait_use_alias_item_modifiers, acc);
2201 let acc = f(trait_use_alias_item_aliased_name, acc);
2202 acc
2203 },
2204 SyntaxVariant::TraitUseConflictResolution(x) => {
2205 let TraitUseConflictResolutionChildren { trait_use_conflict_resolution_keyword, trait_use_conflict_resolution_names, trait_use_conflict_resolution_left_brace, trait_use_conflict_resolution_clauses, trait_use_conflict_resolution_right_brace } = *x;
2206 let acc = f(trait_use_conflict_resolution_keyword, acc);
2207 let acc = f(trait_use_conflict_resolution_names, acc);
2208 let acc = f(trait_use_conflict_resolution_left_brace, acc);
2209 let acc = f(trait_use_conflict_resolution_clauses, acc);
2210 let acc = f(trait_use_conflict_resolution_right_brace, acc);
2211 acc
2212 },
2213 SyntaxVariant::TraitUse(x) => {
2214 let TraitUseChildren { trait_use_keyword, trait_use_names, trait_use_semicolon } = *x;
2215 let acc = f(trait_use_keyword, acc);
2216 let acc = f(trait_use_names, acc);
2217 let acc = f(trait_use_semicolon, acc);
2218 acc
2219 },
2220 SyntaxVariant::RequireClause(x) => {
2221 let RequireClauseChildren { require_keyword, require_kind, require_name, require_semicolon } = *x;
2222 let acc = f(require_keyword, acc);
2223 let acc = f(require_kind, acc);
2224 let acc = f(require_name, acc);
2225 let acc = f(require_semicolon, acc);
2226 acc
2227 },
2228 SyntaxVariant::ConstDeclaration(x) => {
2229 let ConstDeclarationChildren { const_modifiers, const_keyword, const_type_specifier, const_declarators, const_semicolon } = *x;
2230 let acc = f(const_modifiers, acc);
2231 let acc = f(const_keyword, acc);
2232 let acc = f(const_type_specifier, acc);
2233 let acc = f(const_declarators, acc);
2234 let acc = f(const_semicolon, acc);
2235 acc
2236 },
2237 SyntaxVariant::ConstantDeclarator(x) => {
2238 let ConstantDeclaratorChildren { constant_declarator_name, constant_declarator_initializer } = *x;
2239 let acc = f(constant_declarator_name, acc);
2240 let acc = f(constant_declarator_initializer, acc);
2241 acc
2242 },
2243 SyntaxVariant::TypeConstDeclaration(x) => {
2244 let TypeConstDeclarationChildren { type_const_attribute_spec, type_const_modifiers, type_const_keyword, type_const_type_keyword, type_const_name, type_const_type_parameters, type_const_type_constraint, type_const_equal, type_const_type_specifier, type_const_semicolon } = *x;
2245 let acc = f(type_const_attribute_spec, acc);
2246 let acc = f(type_const_modifiers, acc);
2247 let acc = f(type_const_keyword, acc);
2248 let acc = f(type_const_type_keyword, acc);
2249 let acc = f(type_const_name, acc);
2250 let acc = f(type_const_type_parameters, acc);
2251 let acc = f(type_const_type_constraint, acc);
2252 let acc = f(type_const_equal, acc);
2253 let acc = f(type_const_type_specifier, acc);
2254 let acc = f(type_const_semicolon, acc);
2255 acc
2256 },
2257 SyntaxVariant::ContextConstDeclaration(x) => {
2258 let ContextConstDeclarationChildren { context_const_modifiers, context_const_const_keyword, context_const_ctx_keyword, context_const_name, context_const_type_parameters, context_const_constraint, context_const_equal, context_const_ctx_list, context_const_semicolon } = *x;
2259 let acc = f(context_const_modifiers, acc);
2260 let acc = f(context_const_const_keyword, acc);
2261 let acc = f(context_const_ctx_keyword, acc);
2262 let acc = f(context_const_name, acc);
2263 let acc = f(context_const_type_parameters, acc);
2264 let acc = f(context_const_constraint, acc);
2265 let acc = f(context_const_equal, acc);
2266 let acc = f(context_const_ctx_list, acc);
2267 let acc = f(context_const_semicolon, acc);
2268 acc
2269 },
2270 SyntaxVariant::DecoratedExpression(x) => {
2271 let DecoratedExpressionChildren { decorated_expression_decorator, decorated_expression_expression } = *x;
2272 let acc = f(decorated_expression_decorator, acc);
2273 let acc = f(decorated_expression_expression, acc);
2274 acc
2275 },
2276 SyntaxVariant::ParameterDeclaration(x) => {
2277 let ParameterDeclarationChildren { parameter_attribute, parameter_visibility, parameter_call_convention, parameter_type, parameter_name, parameter_default_value } = *x;
2278 let acc = f(parameter_attribute, acc);
2279 let acc = f(parameter_visibility, acc);
2280 let acc = f(parameter_call_convention, acc);
2281 let acc = f(parameter_type, acc);
2282 let acc = f(parameter_name, acc);
2283 let acc = f(parameter_default_value, acc);
2284 acc
2285 },
2286 SyntaxVariant::VariadicParameter(x) => {
2287 let VariadicParameterChildren { variadic_parameter_call_convention, variadic_parameter_type, variadic_parameter_ellipsis } = *x;
2288 let acc = f(variadic_parameter_call_convention, acc);
2289 let acc = f(variadic_parameter_type, acc);
2290 let acc = f(variadic_parameter_ellipsis, acc);
2291 acc
2292 },
2293 SyntaxVariant::OldAttributeSpecification(x) => {
2294 let OldAttributeSpecificationChildren { old_attribute_specification_left_double_angle, old_attribute_specification_attributes, old_attribute_specification_right_double_angle } = *x;
2295 let acc = f(old_attribute_specification_left_double_angle, acc);
2296 let acc = f(old_attribute_specification_attributes, acc);
2297 let acc = f(old_attribute_specification_right_double_angle, acc);
2298 acc
2299 },
2300 SyntaxVariant::AttributeSpecification(x) => {
2301 let AttributeSpecificationChildren { attribute_specification_attributes } = *x;
2302 let acc = f(attribute_specification_attributes, acc);
2303 acc
2304 },
2305 SyntaxVariant::Attribute(x) => {
2306 let AttributeChildren { attribute_at, attribute_attribute_name } = *x;
2307 let acc = f(attribute_at, acc);
2308 let acc = f(attribute_attribute_name, acc);
2309 acc
2310 },
2311 SyntaxVariant::InclusionExpression(x) => {
2312 let InclusionExpressionChildren { inclusion_require, inclusion_filename } = *x;
2313 let acc = f(inclusion_require, acc);
2314 let acc = f(inclusion_filename, acc);
2315 acc
2316 },
2317 SyntaxVariant::InclusionDirective(x) => {
2318 let InclusionDirectiveChildren { inclusion_expression, inclusion_semicolon } = *x;
2319 let acc = f(inclusion_expression, acc);
2320 let acc = f(inclusion_semicolon, acc);
2321 acc
2322 },
2323 SyntaxVariant::CompoundStatement(x) => {
2324 let CompoundStatementChildren { compound_left_brace, compound_statements, compound_right_brace } = *x;
2325 let acc = f(compound_left_brace, acc);
2326 let acc = f(compound_statements, acc);
2327 let acc = f(compound_right_brace, acc);
2328 acc
2329 },
2330 SyntaxVariant::ExpressionStatement(x) => {
2331 let ExpressionStatementChildren { expression_statement_expression, expression_statement_semicolon } = *x;
2332 let acc = f(expression_statement_expression, acc);
2333 let acc = f(expression_statement_semicolon, acc);
2334 acc
2335 },
2336 SyntaxVariant::MarkupSection(x) => {
2337 let MarkupSectionChildren { markup_hashbang, markup_suffix } = *x;
2338 let acc = f(markup_hashbang, acc);
2339 let acc = f(markup_suffix, acc);
2340 acc
2341 },
2342 SyntaxVariant::MarkupSuffix(x) => {
2343 let MarkupSuffixChildren { markup_suffix_less_than_question, markup_suffix_name } = *x;
2344 let acc = f(markup_suffix_less_than_question, acc);
2345 let acc = f(markup_suffix_name, acc);
2346 acc
2347 },
2348 SyntaxVariant::UnsetStatement(x) => {
2349 let UnsetStatementChildren { unset_keyword, unset_left_paren, unset_variables, unset_right_paren, unset_semicolon } = *x;
2350 let acc = f(unset_keyword, acc);
2351 let acc = f(unset_left_paren, acc);
2352 let acc = f(unset_variables, acc);
2353 let acc = f(unset_right_paren, acc);
2354 let acc = f(unset_semicolon, acc);
2355 acc
2356 },
2357 SyntaxVariant::UsingStatementBlockScoped(x) => {
2358 let UsingStatementBlockScopedChildren { using_block_await_keyword, using_block_using_keyword, using_block_left_paren, using_block_expressions, using_block_right_paren, using_block_body } = *x;
2359 let acc = f(using_block_await_keyword, acc);
2360 let acc = f(using_block_using_keyword, acc);
2361 let acc = f(using_block_left_paren, acc);
2362 let acc = f(using_block_expressions, acc);
2363 let acc = f(using_block_right_paren, acc);
2364 let acc = f(using_block_body, acc);
2365 acc
2366 },
2367 SyntaxVariant::UsingStatementFunctionScoped(x) => {
2368 let UsingStatementFunctionScopedChildren { using_function_await_keyword, using_function_using_keyword, using_function_expression, using_function_semicolon } = *x;
2369 let acc = f(using_function_await_keyword, acc);
2370 let acc = f(using_function_using_keyword, acc);
2371 let acc = f(using_function_expression, acc);
2372 let acc = f(using_function_semicolon, acc);
2373 acc
2374 },
2375 SyntaxVariant::WhileStatement(x) => {
2376 let WhileStatementChildren { while_keyword, while_left_paren, while_condition, while_right_paren, while_body } = *x;
2377 let acc = f(while_keyword, acc);
2378 let acc = f(while_left_paren, acc);
2379 let acc = f(while_condition, acc);
2380 let acc = f(while_right_paren, acc);
2381 let acc = f(while_body, acc);
2382 acc
2383 },
2384 SyntaxVariant::IfStatement(x) => {
2385 let IfStatementChildren { if_keyword, if_left_paren, if_condition, if_right_paren, if_statement, if_elseif_clauses, if_else_clause } = *x;
2386 let acc = f(if_keyword, acc);
2387 let acc = f(if_left_paren, acc);
2388 let acc = f(if_condition, acc);
2389 let acc = f(if_right_paren, acc);
2390 let acc = f(if_statement, acc);
2391 let acc = f(if_elseif_clauses, acc);
2392 let acc = f(if_else_clause, acc);
2393 acc
2394 },
2395 SyntaxVariant::ElseifClause(x) => {
2396 let ElseifClauseChildren { elseif_keyword, elseif_left_paren, elseif_condition, elseif_right_paren, elseif_statement } = *x;
2397 let acc = f(elseif_keyword, acc);
2398 let acc = f(elseif_left_paren, acc);
2399 let acc = f(elseif_condition, acc);
2400 let acc = f(elseif_right_paren, acc);
2401 let acc = f(elseif_statement, acc);
2402 acc
2403 },
2404 SyntaxVariant::ElseClause(x) => {
2405 let ElseClauseChildren { else_keyword, else_statement } = *x;
2406 let acc = f(else_keyword, acc);
2407 let acc = f(else_statement, acc);
2408 acc
2409 },
2410 SyntaxVariant::TryStatement(x) => {
2411 let TryStatementChildren { try_keyword, try_compound_statement, try_catch_clauses, try_finally_clause } = *x;
2412 let acc = f(try_keyword, acc);
2413 let acc = f(try_compound_statement, acc);
2414 let acc = f(try_catch_clauses, acc);
2415 let acc = f(try_finally_clause, acc);
2416 acc
2417 },
2418 SyntaxVariant::CatchClause(x) => {
2419 let CatchClauseChildren { catch_keyword, catch_left_paren, catch_type, catch_variable, catch_right_paren, catch_body } = *x;
2420 let acc = f(catch_keyword, acc);
2421 let acc = f(catch_left_paren, acc);
2422 let acc = f(catch_type, acc);
2423 let acc = f(catch_variable, acc);
2424 let acc = f(catch_right_paren, acc);
2425 let acc = f(catch_body, acc);
2426 acc
2427 },
2428 SyntaxVariant::FinallyClause(x) => {
2429 let FinallyClauseChildren { finally_keyword, finally_body } = *x;
2430 let acc = f(finally_keyword, acc);
2431 let acc = f(finally_body, acc);
2432 acc
2433 },
2434 SyntaxVariant::DoStatement(x) => {
2435 let DoStatementChildren { do_keyword, do_body, do_while_keyword, do_left_paren, do_condition, do_right_paren, do_semicolon } = *x;
2436 let acc = f(do_keyword, acc);
2437 let acc = f(do_body, acc);
2438 let acc = f(do_while_keyword, acc);
2439 let acc = f(do_left_paren, acc);
2440 let acc = f(do_condition, acc);
2441 let acc = f(do_right_paren, acc);
2442 let acc = f(do_semicolon, acc);
2443 acc
2444 },
2445 SyntaxVariant::ForStatement(x) => {
2446 let ForStatementChildren { for_keyword, for_left_paren, for_initializer, for_first_semicolon, for_control, for_second_semicolon, for_end_of_loop, for_right_paren, for_body } = *x;
2447 let acc = f(for_keyword, acc);
2448 let acc = f(for_left_paren, acc);
2449 let acc = f(for_initializer, acc);
2450 let acc = f(for_first_semicolon, acc);
2451 let acc = f(for_control, acc);
2452 let acc = f(for_second_semicolon, acc);
2453 let acc = f(for_end_of_loop, acc);
2454 let acc = f(for_right_paren, acc);
2455 let acc = f(for_body, acc);
2456 acc
2457 },
2458 SyntaxVariant::ForeachStatement(x) => {
2459 let ForeachStatementChildren { foreach_keyword, foreach_left_paren, foreach_collection, foreach_await_keyword, foreach_as, foreach_key, foreach_arrow, foreach_value, foreach_right_paren, foreach_body } = *x;
2460 let acc = f(foreach_keyword, acc);
2461 let acc = f(foreach_left_paren, acc);
2462 let acc = f(foreach_collection, acc);
2463 let acc = f(foreach_await_keyword, acc);
2464 let acc = f(foreach_as, acc);
2465 let acc = f(foreach_key, acc);
2466 let acc = f(foreach_arrow, acc);
2467 let acc = f(foreach_value, acc);
2468 let acc = f(foreach_right_paren, acc);
2469 let acc = f(foreach_body, acc);
2470 acc
2471 },
2472 SyntaxVariant::SwitchStatement(x) => {
2473 let SwitchStatementChildren { switch_keyword, switch_left_paren, switch_expression, switch_right_paren, switch_left_brace, switch_sections, switch_right_brace } = *x;
2474 let acc = f(switch_keyword, acc);
2475 let acc = f(switch_left_paren, acc);
2476 let acc = f(switch_expression, acc);
2477 let acc = f(switch_right_paren, acc);
2478 let acc = f(switch_left_brace, acc);
2479 let acc = f(switch_sections, acc);
2480 let acc = f(switch_right_brace, acc);
2481 acc
2482 },
2483 SyntaxVariant::SwitchSection(x) => {
2484 let SwitchSectionChildren { switch_section_labels, switch_section_statements, switch_section_fallthrough } = *x;
2485 let acc = f(switch_section_labels, acc);
2486 let acc = f(switch_section_statements, acc);
2487 let acc = f(switch_section_fallthrough, acc);
2488 acc
2489 },
2490 SyntaxVariant::SwitchFallthrough(x) => {
2491 let SwitchFallthroughChildren { fallthrough_keyword, fallthrough_semicolon } = *x;
2492 let acc = f(fallthrough_keyword, acc);
2493 let acc = f(fallthrough_semicolon, acc);
2494 acc
2495 },
2496 SyntaxVariant::CaseLabel(x) => {
2497 let CaseLabelChildren { case_keyword, case_expression, case_colon } = *x;
2498 let acc = f(case_keyword, acc);
2499 let acc = f(case_expression, acc);
2500 let acc = f(case_colon, acc);
2501 acc
2502 },
2503 SyntaxVariant::DefaultLabel(x) => {
2504 let DefaultLabelChildren { default_keyword, default_colon } = *x;
2505 let acc = f(default_keyword, acc);
2506 let acc = f(default_colon, acc);
2507 acc
2508 },
2509 SyntaxVariant::ReturnStatement(x) => {
2510 let ReturnStatementChildren { return_keyword, return_expression, return_semicolon } = *x;
2511 let acc = f(return_keyword, acc);
2512 let acc = f(return_expression, acc);
2513 let acc = f(return_semicolon, acc);
2514 acc
2515 },
2516 SyntaxVariant::YieldBreakStatement(x) => {
2517 let YieldBreakStatementChildren { yield_break_keyword, yield_break_break, yield_break_semicolon } = *x;
2518 let acc = f(yield_break_keyword, acc);
2519 let acc = f(yield_break_break, acc);
2520 let acc = f(yield_break_semicolon, acc);
2521 acc
2522 },
2523 SyntaxVariant::ThrowStatement(x) => {
2524 let ThrowStatementChildren { throw_keyword, throw_expression, throw_semicolon } = *x;
2525 let acc = f(throw_keyword, acc);
2526 let acc = f(throw_expression, acc);
2527 let acc = f(throw_semicolon, acc);
2528 acc
2529 },
2530 SyntaxVariant::BreakStatement(x) => {
2531 let BreakStatementChildren { break_keyword, break_semicolon } = *x;
2532 let acc = f(break_keyword, acc);
2533 let acc = f(break_semicolon, acc);
2534 acc
2535 },
2536 SyntaxVariant::ContinueStatement(x) => {
2537 let ContinueStatementChildren { continue_keyword, continue_semicolon } = *x;
2538 let acc = f(continue_keyword, acc);
2539 let acc = f(continue_semicolon, acc);
2540 acc
2541 },
2542 SyntaxVariant::EchoStatement(x) => {
2543 let EchoStatementChildren { echo_keyword, echo_expressions, echo_semicolon } = *x;
2544 let acc = f(echo_keyword, acc);
2545 let acc = f(echo_expressions, acc);
2546 let acc = f(echo_semicolon, acc);
2547 acc
2548 },
2549 SyntaxVariant::ConcurrentStatement(x) => {
2550 let ConcurrentStatementChildren { concurrent_keyword, concurrent_statement } = *x;
2551 let acc = f(concurrent_keyword, acc);
2552 let acc = f(concurrent_statement, acc);
2553 acc
2554 },
2555 SyntaxVariant::SimpleInitializer(x) => {
2556 let SimpleInitializerChildren { simple_initializer_equal, simple_initializer_value } = *x;
2557 let acc = f(simple_initializer_equal, acc);
2558 let acc = f(simple_initializer_value, acc);
2559 acc
2560 },
2561 SyntaxVariant::AnonymousClass(x) => {
2562 let AnonymousClassChildren { anonymous_class_class_keyword, anonymous_class_left_paren, anonymous_class_argument_list, anonymous_class_right_paren, anonymous_class_extends_keyword, anonymous_class_extends_list, anonymous_class_implements_keyword, anonymous_class_implements_list, anonymous_class_body } = *x;
2563 let acc = f(anonymous_class_class_keyword, acc);
2564 let acc = f(anonymous_class_left_paren, acc);
2565 let acc = f(anonymous_class_argument_list, acc);
2566 let acc = f(anonymous_class_right_paren, acc);
2567 let acc = f(anonymous_class_extends_keyword, acc);
2568 let acc = f(anonymous_class_extends_list, acc);
2569 let acc = f(anonymous_class_implements_keyword, acc);
2570 let acc = f(anonymous_class_implements_list, acc);
2571 let acc = f(anonymous_class_body, acc);
2572 acc
2573 },
2574 SyntaxVariant::AnonymousFunction(x) => {
2575 let AnonymousFunctionChildren { anonymous_attribute_spec, anonymous_static_keyword, anonymous_async_keyword, anonymous_function_keyword, anonymous_left_paren, anonymous_parameters, anonymous_right_paren, anonymous_ctx_list, anonymous_colon, anonymous_type, anonymous_use, anonymous_body } = *x;
2576 let acc = f(anonymous_attribute_spec, acc);
2577 let acc = f(anonymous_static_keyword, acc);
2578 let acc = f(anonymous_async_keyword, acc);
2579 let acc = f(anonymous_function_keyword, acc);
2580 let acc = f(anonymous_left_paren, acc);
2581 let acc = f(anonymous_parameters, acc);
2582 let acc = f(anonymous_right_paren, acc);
2583 let acc = f(anonymous_ctx_list, acc);
2584 let acc = f(anonymous_colon, acc);
2585 let acc = f(anonymous_type, acc);
2586 let acc = f(anonymous_use, acc);
2587 let acc = f(anonymous_body, acc);
2588 acc
2589 },
2590 SyntaxVariant::AnonymousFunctionUseClause(x) => {
2591 let AnonymousFunctionUseClauseChildren { anonymous_use_keyword, anonymous_use_left_paren, anonymous_use_variables, anonymous_use_right_paren } = *x;
2592 let acc = f(anonymous_use_keyword, acc);
2593 let acc = f(anonymous_use_left_paren, acc);
2594 let acc = f(anonymous_use_variables, acc);
2595 let acc = f(anonymous_use_right_paren, acc);
2596 acc
2597 },
2598 SyntaxVariant::LambdaExpression(x) => {
2599 let LambdaExpressionChildren { lambda_attribute_spec, lambda_async, lambda_signature, lambda_arrow, lambda_body } = *x;
2600 let acc = f(lambda_attribute_spec, acc);
2601 let acc = f(lambda_async, acc);
2602 let acc = f(lambda_signature, acc);
2603 let acc = f(lambda_arrow, acc);
2604 let acc = f(lambda_body, acc);
2605 acc
2606 },
2607 SyntaxVariant::LambdaSignature(x) => {
2608 let LambdaSignatureChildren { lambda_left_paren, lambda_parameters, lambda_right_paren, lambda_contexts, lambda_colon, lambda_type } = *x;
2609 let acc = f(lambda_left_paren, acc);
2610 let acc = f(lambda_parameters, acc);
2611 let acc = f(lambda_right_paren, acc);
2612 let acc = f(lambda_contexts, acc);
2613 let acc = f(lambda_colon, acc);
2614 let acc = f(lambda_type, acc);
2615 acc
2616 },
2617 SyntaxVariant::CastExpression(x) => {
2618 let CastExpressionChildren { cast_left_paren, cast_type, cast_right_paren, cast_operand } = *x;
2619 let acc = f(cast_left_paren, acc);
2620 let acc = f(cast_type, acc);
2621 let acc = f(cast_right_paren, acc);
2622 let acc = f(cast_operand, acc);
2623 acc
2624 },
2625 SyntaxVariant::ScopeResolutionExpression(x) => {
2626 let ScopeResolutionExpressionChildren { scope_resolution_qualifier, scope_resolution_operator, scope_resolution_name } = *x;
2627 let acc = f(scope_resolution_qualifier, acc);
2628 let acc = f(scope_resolution_operator, acc);
2629 let acc = f(scope_resolution_name, acc);
2630 acc
2631 },
2632 SyntaxVariant::MemberSelectionExpression(x) => {
2633 let MemberSelectionExpressionChildren { member_object, member_operator, member_name } = *x;
2634 let acc = f(member_object, acc);
2635 let acc = f(member_operator, acc);
2636 let acc = f(member_name, acc);
2637 acc
2638 },
2639 SyntaxVariant::SafeMemberSelectionExpression(x) => {
2640 let SafeMemberSelectionExpressionChildren { safe_member_object, safe_member_operator, safe_member_name } = *x;
2641 let acc = f(safe_member_object, acc);
2642 let acc = f(safe_member_operator, acc);
2643 let acc = f(safe_member_name, acc);
2644 acc
2645 },
2646 SyntaxVariant::EmbeddedMemberSelectionExpression(x) => {
2647 let EmbeddedMemberSelectionExpressionChildren { embedded_member_object, embedded_member_operator, embedded_member_name } = *x;
2648 let acc = f(embedded_member_object, acc);
2649 let acc = f(embedded_member_operator, acc);
2650 let acc = f(embedded_member_name, acc);
2651 acc
2652 },
2653 SyntaxVariant::YieldExpression(x) => {
2654 let YieldExpressionChildren { yield_keyword, yield_operand } = *x;
2655 let acc = f(yield_keyword, acc);
2656 let acc = f(yield_operand, acc);
2657 acc
2658 },
2659 SyntaxVariant::PrefixUnaryExpression(x) => {
2660 let PrefixUnaryExpressionChildren { prefix_unary_operator, prefix_unary_operand } = *x;
2661 let acc = f(prefix_unary_operator, acc);
2662 let acc = f(prefix_unary_operand, acc);
2663 acc
2664 },
2665 SyntaxVariant::PostfixUnaryExpression(x) => {
2666 let PostfixUnaryExpressionChildren { postfix_unary_operand, postfix_unary_operator } = *x;
2667 let acc = f(postfix_unary_operand, acc);
2668 let acc = f(postfix_unary_operator, acc);
2669 acc
2670 },
2671 SyntaxVariant::BinaryExpression(x) => {
2672 let BinaryExpressionChildren { binary_left_operand, binary_operator, binary_right_operand } = *x;
2673 let acc = f(binary_left_operand, acc);
2674 let acc = f(binary_operator, acc);
2675 let acc = f(binary_right_operand, acc);
2676 acc
2677 },
2678 SyntaxVariant::IsExpression(x) => {
2679 let IsExpressionChildren { is_left_operand, is_operator, is_right_operand } = *x;
2680 let acc = f(is_left_operand, acc);
2681 let acc = f(is_operator, acc);
2682 let acc = f(is_right_operand, acc);
2683 acc
2684 },
2685 SyntaxVariant::AsExpression(x) => {
2686 let AsExpressionChildren { as_left_operand, as_operator, as_right_operand } = *x;
2687 let acc = f(as_left_operand, acc);
2688 let acc = f(as_operator, acc);
2689 let acc = f(as_right_operand, acc);
2690 acc
2691 },
2692 SyntaxVariant::NullableAsExpression(x) => {
2693 let NullableAsExpressionChildren { nullable_as_left_operand, nullable_as_operator, nullable_as_right_operand } = *x;
2694 let acc = f(nullable_as_left_operand, acc);
2695 let acc = f(nullable_as_operator, acc);
2696 let acc = f(nullable_as_right_operand, acc);
2697 acc
2698 },
2699 SyntaxVariant::ConditionalExpression(x) => {
2700 let ConditionalExpressionChildren { conditional_test, conditional_question, conditional_consequence, conditional_colon, conditional_alternative } = *x;
2701 let acc = f(conditional_test, acc);
2702 let acc = f(conditional_question, acc);
2703 let acc = f(conditional_consequence, acc);
2704 let acc = f(conditional_colon, acc);
2705 let acc = f(conditional_alternative, acc);
2706 acc
2707 },
2708 SyntaxVariant::EvalExpression(x) => {
2709 let EvalExpressionChildren { eval_keyword, eval_left_paren, eval_argument, eval_right_paren } = *x;
2710 let acc = f(eval_keyword, acc);
2711 let acc = f(eval_left_paren, acc);
2712 let acc = f(eval_argument, acc);
2713 let acc = f(eval_right_paren, acc);
2714 acc
2715 },
2716 SyntaxVariant::DefineExpression(x) => {
2717 let DefineExpressionChildren { define_keyword, define_left_paren, define_argument_list, define_right_paren } = *x;
2718 let acc = f(define_keyword, acc);
2719 let acc = f(define_left_paren, acc);
2720 let acc = f(define_argument_list, acc);
2721 let acc = f(define_right_paren, acc);
2722 acc
2723 },
2724 SyntaxVariant::IssetExpression(x) => {
2725 let IssetExpressionChildren { isset_keyword, isset_left_paren, isset_argument_list, isset_right_paren } = *x;
2726 let acc = f(isset_keyword, acc);
2727 let acc = f(isset_left_paren, acc);
2728 let acc = f(isset_argument_list, acc);
2729 let acc = f(isset_right_paren, acc);
2730 acc
2731 },
2732 SyntaxVariant::FunctionCallExpression(x) => {
2733 let FunctionCallExpressionChildren { function_call_receiver, function_call_type_args, function_call_left_paren, function_call_argument_list, function_call_right_paren } = *x;
2734 let acc = f(function_call_receiver, acc);
2735 let acc = f(function_call_type_args, acc);
2736 let acc = f(function_call_left_paren, acc);
2737 let acc = f(function_call_argument_list, acc);
2738 let acc = f(function_call_right_paren, acc);
2739 acc
2740 },
2741 SyntaxVariant::FunctionPointerExpression(x) => {
2742 let FunctionPointerExpressionChildren { function_pointer_receiver, function_pointer_type_args } = *x;
2743 let acc = f(function_pointer_receiver, acc);
2744 let acc = f(function_pointer_type_args, acc);
2745 acc
2746 },
2747 SyntaxVariant::ParenthesizedExpression(x) => {
2748 let ParenthesizedExpressionChildren { parenthesized_expression_left_paren, parenthesized_expression_expression, parenthesized_expression_right_paren } = *x;
2749 let acc = f(parenthesized_expression_left_paren, acc);
2750 let acc = f(parenthesized_expression_expression, acc);
2751 let acc = f(parenthesized_expression_right_paren, acc);
2752 acc
2753 },
2754 SyntaxVariant::BracedExpression(x) => {
2755 let BracedExpressionChildren { braced_expression_left_brace, braced_expression_expression, braced_expression_right_brace } = *x;
2756 let acc = f(braced_expression_left_brace, acc);
2757 let acc = f(braced_expression_expression, acc);
2758 let acc = f(braced_expression_right_brace, acc);
2759 acc
2760 },
2761 SyntaxVariant::ETSpliceExpression(x) => {
2762 let ETSpliceExpressionChildren { et_splice_expression_dollar, et_splice_expression_left_brace, et_splice_expression_expression, et_splice_expression_right_brace } = *x;
2763 let acc = f(et_splice_expression_dollar, acc);
2764 let acc = f(et_splice_expression_left_brace, acc);
2765 let acc = f(et_splice_expression_expression, acc);
2766 let acc = f(et_splice_expression_right_brace, acc);
2767 acc
2768 },
2769 SyntaxVariant::EmbeddedBracedExpression(x) => {
2770 let EmbeddedBracedExpressionChildren { embedded_braced_expression_left_brace, embedded_braced_expression_expression, embedded_braced_expression_right_brace } = *x;
2771 let acc = f(embedded_braced_expression_left_brace, acc);
2772 let acc = f(embedded_braced_expression_expression, acc);
2773 let acc = f(embedded_braced_expression_right_brace, acc);
2774 acc
2775 },
2776 SyntaxVariant::ListExpression(x) => {
2777 let ListExpressionChildren { list_keyword, list_left_paren, list_members, list_right_paren } = *x;
2778 let acc = f(list_keyword, acc);
2779 let acc = f(list_left_paren, acc);
2780 let acc = f(list_members, acc);
2781 let acc = f(list_right_paren, acc);
2782 acc
2783 },
2784 SyntaxVariant::CollectionLiteralExpression(x) => {
2785 let CollectionLiteralExpressionChildren { collection_literal_name, collection_literal_left_brace, collection_literal_initializers, collection_literal_right_brace } = *x;
2786 let acc = f(collection_literal_name, acc);
2787 let acc = f(collection_literal_left_brace, acc);
2788 let acc = f(collection_literal_initializers, acc);
2789 let acc = f(collection_literal_right_brace, acc);
2790 acc
2791 },
2792 SyntaxVariant::ObjectCreationExpression(x) => {
2793 let ObjectCreationExpressionChildren { object_creation_new_keyword, object_creation_object } = *x;
2794 let acc = f(object_creation_new_keyword, acc);
2795 let acc = f(object_creation_object, acc);
2796 acc
2797 },
2798 SyntaxVariant::ConstructorCall(x) => {
2799 let ConstructorCallChildren { constructor_call_type, constructor_call_left_paren, constructor_call_argument_list, constructor_call_right_paren } = *x;
2800 let acc = f(constructor_call_type, acc);
2801 let acc = f(constructor_call_left_paren, acc);
2802 let acc = f(constructor_call_argument_list, acc);
2803 let acc = f(constructor_call_right_paren, acc);
2804 acc
2805 },
2806 SyntaxVariant::RecordCreationExpression(x) => {
2807 let RecordCreationExpressionChildren { record_creation_type, record_creation_left_bracket, record_creation_members, record_creation_right_bracket } = *x;
2808 let acc = f(record_creation_type, acc);
2809 let acc = f(record_creation_left_bracket, acc);
2810 let acc = f(record_creation_members, acc);
2811 let acc = f(record_creation_right_bracket, acc);
2812 acc
2813 },
2814 SyntaxVariant::DarrayIntrinsicExpression(x) => {
2815 let DarrayIntrinsicExpressionChildren { darray_intrinsic_keyword, darray_intrinsic_explicit_type, darray_intrinsic_left_bracket, darray_intrinsic_members, darray_intrinsic_right_bracket } = *x;
2816 let acc = f(darray_intrinsic_keyword, acc);
2817 let acc = f(darray_intrinsic_explicit_type, acc);
2818 let acc = f(darray_intrinsic_left_bracket, acc);
2819 let acc = f(darray_intrinsic_members, acc);
2820 let acc = f(darray_intrinsic_right_bracket, acc);
2821 acc
2822 },
2823 SyntaxVariant::DictionaryIntrinsicExpression(x) => {
2824 let DictionaryIntrinsicExpressionChildren { dictionary_intrinsic_keyword, dictionary_intrinsic_explicit_type, dictionary_intrinsic_left_bracket, dictionary_intrinsic_members, dictionary_intrinsic_right_bracket } = *x;
2825 let acc = f(dictionary_intrinsic_keyword, acc);
2826 let acc = f(dictionary_intrinsic_explicit_type, acc);
2827 let acc = f(dictionary_intrinsic_left_bracket, acc);
2828 let acc = f(dictionary_intrinsic_members, acc);
2829 let acc = f(dictionary_intrinsic_right_bracket, acc);
2830 acc
2831 },
2832 SyntaxVariant::KeysetIntrinsicExpression(x) => {
2833 let KeysetIntrinsicExpressionChildren { keyset_intrinsic_keyword, keyset_intrinsic_explicit_type, keyset_intrinsic_left_bracket, keyset_intrinsic_members, keyset_intrinsic_right_bracket } = *x;
2834 let acc = f(keyset_intrinsic_keyword, acc);
2835 let acc = f(keyset_intrinsic_explicit_type, acc);
2836 let acc = f(keyset_intrinsic_left_bracket, acc);
2837 let acc = f(keyset_intrinsic_members, acc);
2838 let acc = f(keyset_intrinsic_right_bracket, acc);
2839 acc
2840 },
2841 SyntaxVariant::VarrayIntrinsicExpression(x) => {
2842 let VarrayIntrinsicExpressionChildren { varray_intrinsic_keyword, varray_intrinsic_explicit_type, varray_intrinsic_left_bracket, varray_intrinsic_members, varray_intrinsic_right_bracket } = *x;
2843 let acc = f(varray_intrinsic_keyword, acc);
2844 let acc = f(varray_intrinsic_explicit_type, acc);
2845 let acc = f(varray_intrinsic_left_bracket, acc);
2846 let acc = f(varray_intrinsic_members, acc);
2847 let acc = f(varray_intrinsic_right_bracket, acc);
2848 acc
2849 },
2850 SyntaxVariant::VectorIntrinsicExpression(x) => {
2851 let VectorIntrinsicExpressionChildren { vector_intrinsic_keyword, vector_intrinsic_explicit_type, vector_intrinsic_left_bracket, vector_intrinsic_members, vector_intrinsic_right_bracket } = *x;
2852 let acc = f(vector_intrinsic_keyword, acc);
2853 let acc = f(vector_intrinsic_explicit_type, acc);
2854 let acc = f(vector_intrinsic_left_bracket, acc);
2855 let acc = f(vector_intrinsic_members, acc);
2856 let acc = f(vector_intrinsic_right_bracket, acc);
2857 acc
2858 },
2859 SyntaxVariant::ElementInitializer(x) => {
2860 let ElementInitializerChildren { element_key, element_arrow, element_value } = *x;
2861 let acc = f(element_key, acc);
2862 let acc = f(element_arrow, acc);
2863 let acc = f(element_value, acc);
2864 acc
2865 },
2866 SyntaxVariant::SubscriptExpression(x) => {
2867 let SubscriptExpressionChildren { subscript_receiver, subscript_left_bracket, subscript_index, subscript_right_bracket } = *x;
2868 let acc = f(subscript_receiver, acc);
2869 let acc = f(subscript_left_bracket, acc);
2870 let acc = f(subscript_index, acc);
2871 let acc = f(subscript_right_bracket, acc);
2872 acc
2873 },
2874 SyntaxVariant::EmbeddedSubscriptExpression(x) => {
2875 let EmbeddedSubscriptExpressionChildren { embedded_subscript_receiver, embedded_subscript_left_bracket, embedded_subscript_index, embedded_subscript_right_bracket } = *x;
2876 let acc = f(embedded_subscript_receiver, acc);
2877 let acc = f(embedded_subscript_left_bracket, acc);
2878 let acc = f(embedded_subscript_index, acc);
2879 let acc = f(embedded_subscript_right_bracket, acc);
2880 acc
2881 },
2882 SyntaxVariant::AwaitableCreationExpression(x) => {
2883 let AwaitableCreationExpressionChildren { awaitable_attribute_spec, awaitable_async, awaitable_compound_statement } = *x;
2884 let acc = f(awaitable_attribute_spec, acc);
2885 let acc = f(awaitable_async, acc);
2886 let acc = f(awaitable_compound_statement, acc);
2887 acc
2888 },
2889 SyntaxVariant::XHPChildrenDeclaration(x) => {
2890 let XHPChildrenDeclarationChildren { xhp_children_keyword, xhp_children_expression, xhp_children_semicolon } = *x;
2891 let acc = f(xhp_children_keyword, acc);
2892 let acc = f(xhp_children_expression, acc);
2893 let acc = f(xhp_children_semicolon, acc);
2894 acc
2895 },
2896 SyntaxVariant::XHPChildrenParenthesizedList(x) => {
2897 let XHPChildrenParenthesizedListChildren { xhp_children_list_left_paren, xhp_children_list_xhp_children, xhp_children_list_right_paren } = *x;
2898 let acc = f(xhp_children_list_left_paren, acc);
2899 let acc = f(xhp_children_list_xhp_children, acc);
2900 let acc = f(xhp_children_list_right_paren, acc);
2901 acc
2902 },
2903 SyntaxVariant::XHPCategoryDeclaration(x) => {
2904 let XHPCategoryDeclarationChildren { xhp_category_keyword, xhp_category_categories, xhp_category_semicolon } = *x;
2905 let acc = f(xhp_category_keyword, acc);
2906 let acc = f(xhp_category_categories, acc);
2907 let acc = f(xhp_category_semicolon, acc);
2908 acc
2909 },
2910 SyntaxVariant::XHPEnumType(x) => {
2911 let XHPEnumTypeChildren { xhp_enum_keyword, xhp_enum_left_brace, xhp_enum_values, xhp_enum_right_brace } = *x;
2912 let acc = f(xhp_enum_keyword, acc);
2913 let acc = f(xhp_enum_left_brace, acc);
2914 let acc = f(xhp_enum_values, acc);
2915 let acc = f(xhp_enum_right_brace, acc);
2916 acc
2917 },
2918 SyntaxVariant::XHPLateinit(x) => {
2919 let XHPLateinitChildren { xhp_lateinit_at, xhp_lateinit_keyword } = *x;
2920 let acc = f(xhp_lateinit_at, acc);
2921 let acc = f(xhp_lateinit_keyword, acc);
2922 acc
2923 },
2924 SyntaxVariant::XHPRequired(x) => {
2925 let XHPRequiredChildren { xhp_required_at, xhp_required_keyword } = *x;
2926 let acc = f(xhp_required_at, acc);
2927 let acc = f(xhp_required_keyword, acc);
2928 acc
2929 },
2930 SyntaxVariant::XHPClassAttributeDeclaration(x) => {
2931 let XHPClassAttributeDeclarationChildren { xhp_attribute_keyword, xhp_attribute_attributes, xhp_attribute_semicolon } = *x;
2932 let acc = f(xhp_attribute_keyword, acc);
2933 let acc = f(xhp_attribute_attributes, acc);
2934 let acc = f(xhp_attribute_semicolon, acc);
2935 acc
2936 },
2937 SyntaxVariant::XHPClassAttribute(x) => {
2938 let XHPClassAttributeChildren { xhp_attribute_decl_type, xhp_attribute_decl_name, xhp_attribute_decl_initializer, xhp_attribute_decl_required } = *x;
2939 let acc = f(xhp_attribute_decl_type, acc);
2940 let acc = f(xhp_attribute_decl_name, acc);
2941 let acc = f(xhp_attribute_decl_initializer, acc);
2942 let acc = f(xhp_attribute_decl_required, acc);
2943 acc
2944 },
2945 SyntaxVariant::XHPSimpleClassAttribute(x) => {
2946 let XHPSimpleClassAttributeChildren { xhp_simple_class_attribute_type } = *x;
2947 let acc = f(xhp_simple_class_attribute_type, acc);
2948 acc
2949 },
2950 SyntaxVariant::XHPSimpleAttribute(x) => {
2951 let XHPSimpleAttributeChildren { xhp_simple_attribute_name, xhp_simple_attribute_equal, xhp_simple_attribute_expression } = *x;
2952 let acc = f(xhp_simple_attribute_name, acc);
2953 let acc = f(xhp_simple_attribute_equal, acc);
2954 let acc = f(xhp_simple_attribute_expression, acc);
2955 acc
2956 },
2957 SyntaxVariant::XHPSpreadAttribute(x) => {
2958 let XHPSpreadAttributeChildren { xhp_spread_attribute_left_brace, xhp_spread_attribute_spread_operator, xhp_spread_attribute_expression, xhp_spread_attribute_right_brace } = *x;
2959 let acc = f(xhp_spread_attribute_left_brace, acc);
2960 let acc = f(xhp_spread_attribute_spread_operator, acc);
2961 let acc = f(xhp_spread_attribute_expression, acc);
2962 let acc = f(xhp_spread_attribute_right_brace, acc);
2963 acc
2964 },
2965 SyntaxVariant::XHPOpen(x) => {
2966 let XHPOpenChildren { xhp_open_left_angle, xhp_open_name, xhp_open_attributes, xhp_open_right_angle } = *x;
2967 let acc = f(xhp_open_left_angle, acc);
2968 let acc = f(xhp_open_name, acc);
2969 let acc = f(xhp_open_attributes, acc);
2970 let acc = f(xhp_open_right_angle, acc);
2971 acc
2972 },
2973 SyntaxVariant::XHPExpression(x) => {
2974 let XHPExpressionChildren { xhp_open, xhp_body, xhp_close } = *x;
2975 let acc = f(xhp_open, acc);
2976 let acc = f(xhp_body, acc);
2977 let acc = f(xhp_close, acc);
2978 acc
2979 },
2980 SyntaxVariant::XHPClose(x) => {
2981 let XHPCloseChildren { xhp_close_left_angle, xhp_close_name, xhp_close_right_angle } = *x;
2982 let acc = f(xhp_close_left_angle, acc);
2983 let acc = f(xhp_close_name, acc);
2984 let acc = f(xhp_close_right_angle, acc);
2985 acc
2986 },
2987 SyntaxVariant::TypeConstant(x) => {
2988 let TypeConstantChildren { type_constant_left_type, type_constant_separator, type_constant_right_type } = *x;
2989 let acc = f(type_constant_left_type, acc);
2990 let acc = f(type_constant_separator, acc);
2991 let acc = f(type_constant_right_type, acc);
2992 acc
2993 },
2994 SyntaxVariant::VectorTypeSpecifier(x) => {
2995 let VectorTypeSpecifierChildren { vector_type_keyword, vector_type_left_angle, vector_type_type, vector_type_trailing_comma, vector_type_right_angle } = *x;
2996 let acc = f(vector_type_keyword, acc);
2997 let acc = f(vector_type_left_angle, acc);
2998 let acc = f(vector_type_type, acc);
2999 let acc = f(vector_type_trailing_comma, acc);
3000 let acc = f(vector_type_right_angle, acc);
3001 acc
3002 },
3003 SyntaxVariant::KeysetTypeSpecifier(x) => {
3004 let KeysetTypeSpecifierChildren { keyset_type_keyword, keyset_type_left_angle, keyset_type_type, keyset_type_trailing_comma, keyset_type_right_angle } = *x;
3005 let acc = f(keyset_type_keyword, acc);
3006 let acc = f(keyset_type_left_angle, acc);
3007 let acc = f(keyset_type_type, acc);
3008 let acc = f(keyset_type_trailing_comma, acc);
3009 let acc = f(keyset_type_right_angle, acc);
3010 acc
3011 },
3012 SyntaxVariant::TupleTypeExplicitSpecifier(x) => {
3013 let TupleTypeExplicitSpecifierChildren { tuple_type_keyword, tuple_type_left_angle, tuple_type_types, tuple_type_right_angle } = *x;
3014 let acc = f(tuple_type_keyword, acc);
3015 let acc = f(tuple_type_left_angle, acc);
3016 let acc = f(tuple_type_types, acc);
3017 let acc = f(tuple_type_right_angle, acc);
3018 acc
3019 },
3020 SyntaxVariant::VarrayTypeSpecifier(x) => {
3021 let VarrayTypeSpecifierChildren { varray_keyword, varray_left_angle, varray_type, varray_trailing_comma, varray_right_angle } = *x;
3022 let acc = f(varray_keyword, acc);
3023 let acc = f(varray_left_angle, acc);
3024 let acc = f(varray_type, acc);
3025 let acc = f(varray_trailing_comma, acc);
3026 let acc = f(varray_right_angle, acc);
3027 acc
3028 },
3029 SyntaxVariant::FunctionCtxTypeSpecifier(x) => {
3030 let FunctionCtxTypeSpecifierChildren { function_ctx_type_keyword, function_ctx_type_variable } = *x;
3031 let acc = f(function_ctx_type_keyword, acc);
3032 let acc = f(function_ctx_type_variable, acc);
3033 acc
3034 },
3035 SyntaxVariant::TypeParameter(x) => {
3036 let TypeParameterChildren { type_attribute_spec, type_reified, type_variance, type_name, type_param_params, type_constraints } = *x;
3037 let acc = f(type_attribute_spec, acc);
3038 let acc = f(type_reified, acc);
3039 let acc = f(type_variance, acc);
3040 let acc = f(type_name, acc);
3041 let acc = f(type_param_params, acc);
3042 let acc = f(type_constraints, acc);
3043 acc
3044 },
3045 SyntaxVariant::TypeConstraint(x) => {
3046 let TypeConstraintChildren { constraint_keyword, constraint_type } = *x;
3047 let acc = f(constraint_keyword, acc);
3048 let acc = f(constraint_type, acc);
3049 acc
3050 },
3051 SyntaxVariant::ContextConstraint(x) => {
3052 let ContextConstraintChildren { ctx_constraint_keyword, ctx_constraint_ctx_list } = *x;
3053 let acc = f(ctx_constraint_keyword, acc);
3054 let acc = f(ctx_constraint_ctx_list, acc);
3055 acc
3056 },
3057 SyntaxVariant::DarrayTypeSpecifier(x) => {
3058 let DarrayTypeSpecifierChildren { darray_keyword, darray_left_angle, darray_key, darray_comma, darray_value, darray_trailing_comma, darray_right_angle } = *x;
3059 let acc = f(darray_keyword, acc);
3060 let acc = f(darray_left_angle, acc);
3061 let acc = f(darray_key, acc);
3062 let acc = f(darray_comma, acc);
3063 let acc = f(darray_value, acc);
3064 let acc = f(darray_trailing_comma, acc);
3065 let acc = f(darray_right_angle, acc);
3066 acc
3067 },
3068 SyntaxVariant::DictionaryTypeSpecifier(x) => {
3069 let DictionaryTypeSpecifierChildren { dictionary_type_keyword, dictionary_type_left_angle, dictionary_type_members, dictionary_type_right_angle } = *x;
3070 let acc = f(dictionary_type_keyword, acc);
3071 let acc = f(dictionary_type_left_angle, acc);
3072 let acc = f(dictionary_type_members, acc);
3073 let acc = f(dictionary_type_right_angle, acc);
3074 acc
3075 },
3076 SyntaxVariant::ClosureTypeSpecifier(x) => {
3077 let ClosureTypeSpecifierChildren { closure_outer_left_paren, closure_function_keyword, closure_inner_left_paren, closure_parameter_list, closure_inner_right_paren, closure_contexts, closure_colon, closure_return_type, closure_outer_right_paren } = *x;
3078 let acc = f(closure_outer_left_paren, acc);
3079 let acc = f(closure_function_keyword, acc);
3080 let acc = f(closure_inner_left_paren, acc);
3081 let acc = f(closure_parameter_list, acc);
3082 let acc = f(closure_inner_right_paren, acc);
3083 let acc = f(closure_contexts, acc);
3084 let acc = f(closure_colon, acc);
3085 let acc = f(closure_return_type, acc);
3086 let acc = f(closure_outer_right_paren, acc);
3087 acc
3088 },
3089 SyntaxVariant::ClosureParameterTypeSpecifier(x) => {
3090 let ClosureParameterTypeSpecifierChildren { closure_parameter_call_convention, closure_parameter_type } = *x;
3091 let acc = f(closure_parameter_call_convention, acc);
3092 let acc = f(closure_parameter_type, acc);
3093 acc
3094 },
3095 SyntaxVariant::ClassnameTypeSpecifier(x) => {
3096 let ClassnameTypeSpecifierChildren { classname_keyword, classname_left_angle, classname_type, classname_trailing_comma, classname_right_angle } = *x;
3097 let acc = f(classname_keyword, acc);
3098 let acc = f(classname_left_angle, acc);
3099 let acc = f(classname_type, acc);
3100 let acc = f(classname_trailing_comma, acc);
3101 let acc = f(classname_right_angle, acc);
3102 acc
3103 },
3104 SyntaxVariant::FieldSpecifier(x) => {
3105 let FieldSpecifierChildren { field_question, field_name, field_arrow, field_type } = *x;
3106 let acc = f(field_question, acc);
3107 let acc = f(field_name, acc);
3108 let acc = f(field_arrow, acc);
3109 let acc = f(field_type, acc);
3110 acc
3111 },
3112 SyntaxVariant::FieldInitializer(x) => {
3113 let FieldInitializerChildren { field_initializer_name, field_initializer_arrow, field_initializer_value } = *x;
3114 let acc = f(field_initializer_name, acc);
3115 let acc = f(field_initializer_arrow, acc);
3116 let acc = f(field_initializer_value, acc);
3117 acc
3118 },
3119 SyntaxVariant::ShapeTypeSpecifier(x) => {
3120 let ShapeTypeSpecifierChildren { shape_type_keyword, shape_type_left_paren, shape_type_fields, shape_type_ellipsis, shape_type_right_paren } = *x;
3121 let acc = f(shape_type_keyword, acc);
3122 let acc = f(shape_type_left_paren, acc);
3123 let acc = f(shape_type_fields, acc);
3124 let acc = f(shape_type_ellipsis, acc);
3125 let acc = f(shape_type_right_paren, acc);
3126 acc
3127 },
3128 SyntaxVariant::ShapeExpression(x) => {
3129 let ShapeExpressionChildren { shape_expression_keyword, shape_expression_left_paren, shape_expression_fields, shape_expression_right_paren } = *x;
3130 let acc = f(shape_expression_keyword, acc);
3131 let acc = f(shape_expression_left_paren, acc);
3132 let acc = f(shape_expression_fields, acc);
3133 let acc = f(shape_expression_right_paren, acc);
3134 acc
3135 },
3136 SyntaxVariant::TupleExpression(x) => {
3137 let TupleExpressionChildren { tuple_expression_keyword, tuple_expression_left_paren, tuple_expression_items, tuple_expression_right_paren } = *x;
3138 let acc = f(tuple_expression_keyword, acc);
3139 let acc = f(tuple_expression_left_paren, acc);
3140 let acc = f(tuple_expression_items, acc);
3141 let acc = f(tuple_expression_right_paren, acc);
3142 acc
3143 },
3144 SyntaxVariant::GenericTypeSpecifier(x) => {
3145 let GenericTypeSpecifierChildren { generic_class_type, generic_argument_list } = *x;
3146 let acc = f(generic_class_type, acc);
3147 let acc = f(generic_argument_list, acc);
3148 acc
3149 },
3150 SyntaxVariant::NullableTypeSpecifier(x) => {
3151 let NullableTypeSpecifierChildren { nullable_question, nullable_type } = *x;
3152 let acc = f(nullable_question, acc);
3153 let acc = f(nullable_type, acc);
3154 acc
3155 },
3156 SyntaxVariant::LikeTypeSpecifier(x) => {
3157 let LikeTypeSpecifierChildren { like_tilde, like_type } = *x;
3158 let acc = f(like_tilde, acc);
3159 let acc = f(like_type, acc);
3160 acc
3161 },
3162 SyntaxVariant::SoftTypeSpecifier(x) => {
3163 let SoftTypeSpecifierChildren { soft_at, soft_type } = *x;
3164 let acc = f(soft_at, acc);
3165 let acc = f(soft_type, acc);
3166 acc
3167 },
3168 SyntaxVariant::AttributizedSpecifier(x) => {
3169 let AttributizedSpecifierChildren { attributized_specifier_attribute_spec, attributized_specifier_type } = *x;
3170 let acc = f(attributized_specifier_attribute_spec, acc);
3171 let acc = f(attributized_specifier_type, acc);
3172 acc
3173 },
3174 SyntaxVariant::ReifiedTypeArgument(x) => {
3175 let ReifiedTypeArgumentChildren { reified_type_argument_reified, reified_type_argument_type } = *x;
3176 let acc = f(reified_type_argument_reified, acc);
3177 let acc = f(reified_type_argument_type, acc);
3178 acc
3179 },
3180 SyntaxVariant::TypeArguments(x) => {
3181 let TypeArgumentsChildren { type_arguments_left_angle, type_arguments_types, type_arguments_right_angle } = *x;
3182 let acc = f(type_arguments_left_angle, acc);
3183 let acc = f(type_arguments_types, acc);
3184 let acc = f(type_arguments_right_angle, acc);
3185 acc
3186 },
3187 SyntaxVariant::TypeParameters(x) => {
3188 let TypeParametersChildren { type_parameters_left_angle, type_parameters_parameters, type_parameters_right_angle } = *x;
3189 let acc = f(type_parameters_left_angle, acc);
3190 let acc = f(type_parameters_parameters, acc);
3191 let acc = f(type_parameters_right_angle, acc);
3192 acc
3193 },
3194 SyntaxVariant::TupleTypeSpecifier(x) => {
3195 let TupleTypeSpecifierChildren { tuple_left_paren, tuple_types, tuple_right_paren } = *x;
3196 let acc = f(tuple_left_paren, acc);
3197 let acc = f(tuple_types, acc);
3198 let acc = f(tuple_right_paren, acc);
3199 acc
3200 },
3201 SyntaxVariant::UnionTypeSpecifier(x) => {
3202 let UnionTypeSpecifierChildren { union_left_paren, union_types, union_right_paren } = *x;
3203 let acc = f(union_left_paren, acc);
3204 let acc = f(union_types, acc);
3205 let acc = f(union_right_paren, acc);
3206 acc
3207 },
3208 SyntaxVariant::IntersectionTypeSpecifier(x) => {
3209 let IntersectionTypeSpecifierChildren { intersection_left_paren, intersection_types, intersection_right_paren } = *x;
3210 let acc = f(intersection_left_paren, acc);
3211 let acc = f(intersection_types, acc);
3212 let acc = f(intersection_right_paren, acc);
3213 acc
3214 },
3215 SyntaxVariant::ErrorSyntax(x) => {
3216 let ErrorSyntaxChildren { error_error } = *x;
3217 let acc = f(error_error, acc);
3218 acc
3219 },
3220 SyntaxVariant::ListItem(x) => {
3221 let ListItemChildren { list_item, list_separator } = *x;
3222 let acc = f(list_item, acc);
3223 let acc = f(list_separator, acc);
3224 acc
3225 },
3226 SyntaxVariant::EnumAtomExpression(x) => {
3227 let EnumAtomExpressionChildren { enum_atom_hash, enum_atom_expression } = *x;
3228 let acc = f(enum_atom_hash, acc);
3229 let acc = f(enum_atom_expression, acc);
3230 acc
3231 },
3233 }
3234 }
3236 pub fn kind(&self) -> SyntaxKind {
3237 match &self.syntax {
3238 SyntaxVariant::Missing => SyntaxKind::Missing,
3239 SyntaxVariant::Token (t) => SyntaxKind::Token(t.kind()),
3240 SyntaxVariant::SyntaxList (_) => SyntaxKind::SyntaxList,
3241 SyntaxVariant::EndOfFile {..} => SyntaxKind::EndOfFile,
3242 SyntaxVariant::Script {..} => SyntaxKind::Script,
3243 SyntaxVariant::QualifiedName {..} => SyntaxKind::QualifiedName,
3244 SyntaxVariant::SimpleTypeSpecifier {..} => SyntaxKind::SimpleTypeSpecifier,
3245 SyntaxVariant::LiteralExpression {..} => SyntaxKind::LiteralExpression,
3246 SyntaxVariant::PrefixedStringExpression {..} => SyntaxKind::PrefixedStringExpression,
3247 SyntaxVariant::PrefixedCodeExpression {..} => SyntaxKind::PrefixedCodeExpression,
3248 SyntaxVariant::VariableExpression {..} => SyntaxKind::VariableExpression,
3249 SyntaxVariant::PipeVariableExpression {..} => SyntaxKind::PipeVariableExpression,
3250 SyntaxVariant::FileAttributeSpecification {..} => SyntaxKind::FileAttributeSpecification,
3251 SyntaxVariant::EnumDeclaration {..} => SyntaxKind::EnumDeclaration,
3252 SyntaxVariant::EnumUse {..} => SyntaxKind::EnumUse,
3253 SyntaxVariant::Enumerator {..} => SyntaxKind::Enumerator,
3254 SyntaxVariant::EnumClassDeclaration {..} => SyntaxKind::EnumClassDeclaration,
3255 SyntaxVariant::EnumClassEnumerator {..} => SyntaxKind::EnumClassEnumerator,
3256 SyntaxVariant::RecordDeclaration {..} => SyntaxKind::RecordDeclaration,
3257 SyntaxVariant::RecordField {..} => SyntaxKind::RecordField,
3258 SyntaxVariant::AliasDeclaration {..} => SyntaxKind::AliasDeclaration,
3259 SyntaxVariant::PropertyDeclaration {..} => SyntaxKind::PropertyDeclaration,
3260 SyntaxVariant::PropertyDeclarator {..} => SyntaxKind::PropertyDeclarator,
3261 SyntaxVariant::NamespaceDeclaration {..} => SyntaxKind::NamespaceDeclaration,
3262 SyntaxVariant::NamespaceDeclarationHeader {..} => SyntaxKind::NamespaceDeclarationHeader,
3263 SyntaxVariant::NamespaceBody {..} => SyntaxKind::NamespaceBody,
3264 SyntaxVariant::NamespaceEmptyBody {..} => SyntaxKind::NamespaceEmptyBody,
3265 SyntaxVariant::NamespaceUseDeclaration {..} => SyntaxKind::NamespaceUseDeclaration,
3266 SyntaxVariant::NamespaceGroupUseDeclaration {..} => SyntaxKind::NamespaceGroupUseDeclaration,
3267 SyntaxVariant::NamespaceUseClause {..} => SyntaxKind::NamespaceUseClause,
3268 SyntaxVariant::FunctionDeclaration {..} => SyntaxKind::FunctionDeclaration,
3269 SyntaxVariant::FunctionDeclarationHeader {..} => SyntaxKind::FunctionDeclarationHeader,
3270 SyntaxVariant::Contexts {..} => SyntaxKind::Contexts,
3271 SyntaxVariant::WhereClause {..} => SyntaxKind::WhereClause,
3272 SyntaxVariant::WhereConstraint {..} => SyntaxKind::WhereConstraint,
3273 SyntaxVariant::MethodishDeclaration {..} => SyntaxKind::MethodishDeclaration,
3274 SyntaxVariant::MethodishTraitResolution {..} => SyntaxKind::MethodishTraitResolution,
3275 SyntaxVariant::ClassishDeclaration {..} => SyntaxKind::ClassishDeclaration,
3276 SyntaxVariant::ClassishBody {..} => SyntaxKind::ClassishBody,
3277 SyntaxVariant::TraitUsePrecedenceItem {..} => SyntaxKind::TraitUsePrecedenceItem,
3278 SyntaxVariant::TraitUseAliasItem {..} => SyntaxKind::TraitUseAliasItem,
3279 SyntaxVariant::TraitUseConflictResolution {..} => SyntaxKind::TraitUseConflictResolution,
3280 SyntaxVariant::TraitUse {..} => SyntaxKind::TraitUse,
3281 SyntaxVariant::RequireClause {..} => SyntaxKind::RequireClause,
3282 SyntaxVariant::ConstDeclaration {..} => SyntaxKind::ConstDeclaration,
3283 SyntaxVariant::ConstantDeclarator {..} => SyntaxKind::ConstantDeclarator,
3284 SyntaxVariant::TypeConstDeclaration {..} => SyntaxKind::TypeConstDeclaration,
3285 SyntaxVariant::ContextConstDeclaration {..} => SyntaxKind::ContextConstDeclaration,
3286 SyntaxVariant::DecoratedExpression {..} => SyntaxKind::DecoratedExpression,
3287 SyntaxVariant::ParameterDeclaration {..} => SyntaxKind::ParameterDeclaration,
3288 SyntaxVariant::VariadicParameter {..} => SyntaxKind::VariadicParameter,
3289 SyntaxVariant::OldAttributeSpecification {..} => SyntaxKind::OldAttributeSpecification,
3290 SyntaxVariant::AttributeSpecification {..} => SyntaxKind::AttributeSpecification,
3291 SyntaxVariant::Attribute {..} => SyntaxKind::Attribute,
3292 SyntaxVariant::InclusionExpression {..} => SyntaxKind::InclusionExpression,
3293 SyntaxVariant::InclusionDirective {..} => SyntaxKind::InclusionDirective,
3294 SyntaxVariant::CompoundStatement {..} => SyntaxKind::CompoundStatement,
3295 SyntaxVariant::ExpressionStatement {..} => SyntaxKind::ExpressionStatement,
3296 SyntaxVariant::MarkupSection {..} => SyntaxKind::MarkupSection,
3297 SyntaxVariant::MarkupSuffix {..} => SyntaxKind::MarkupSuffix,
3298 SyntaxVariant::UnsetStatement {..} => SyntaxKind::UnsetStatement,
3299 SyntaxVariant::UsingStatementBlockScoped {..} => SyntaxKind::UsingStatementBlockScoped,
3300 SyntaxVariant::UsingStatementFunctionScoped {..} => SyntaxKind::UsingStatementFunctionScoped,
3301 SyntaxVariant::WhileStatement {..} => SyntaxKind::WhileStatement,
3302 SyntaxVariant::IfStatement {..} => SyntaxKind::IfStatement,
3303 SyntaxVariant::ElseifClause {..} => SyntaxKind::ElseifClause,
3304 SyntaxVariant::ElseClause {..} => SyntaxKind::ElseClause,
3305 SyntaxVariant::TryStatement {..} => SyntaxKind::TryStatement,
3306 SyntaxVariant::CatchClause {..} => SyntaxKind::CatchClause,
3307 SyntaxVariant::FinallyClause {..} => SyntaxKind::FinallyClause,
3308 SyntaxVariant::DoStatement {..} => SyntaxKind::DoStatement,
3309 SyntaxVariant::ForStatement {..} => SyntaxKind::ForStatement,
3310 SyntaxVariant::ForeachStatement {..} => SyntaxKind::ForeachStatement,
3311 SyntaxVariant::SwitchStatement {..} => SyntaxKind::SwitchStatement,
3312 SyntaxVariant::SwitchSection {..} => SyntaxKind::SwitchSection,
3313 SyntaxVariant::SwitchFallthrough {..} => SyntaxKind::SwitchFallthrough,
3314 SyntaxVariant::CaseLabel {..} => SyntaxKind::CaseLabel,
3315 SyntaxVariant::DefaultLabel {..} => SyntaxKind::DefaultLabel,
3316 SyntaxVariant::ReturnStatement {..} => SyntaxKind::ReturnStatement,
3317 SyntaxVariant::YieldBreakStatement {..} => SyntaxKind::YieldBreakStatement,
3318 SyntaxVariant::ThrowStatement {..} => SyntaxKind::ThrowStatement,
3319 SyntaxVariant::BreakStatement {..} => SyntaxKind::BreakStatement,
3320 SyntaxVariant::ContinueStatement {..} => SyntaxKind::ContinueStatement,
3321 SyntaxVariant::EchoStatement {..} => SyntaxKind::EchoStatement,
3322 SyntaxVariant::ConcurrentStatement {..} => SyntaxKind::ConcurrentStatement,
3323 SyntaxVariant::SimpleInitializer {..} => SyntaxKind::SimpleInitializer,
3324 SyntaxVariant::AnonymousClass {..} => SyntaxKind::AnonymousClass,
3325 SyntaxVariant::AnonymousFunction {..} => SyntaxKind::AnonymousFunction,
3326 SyntaxVariant::AnonymousFunctionUseClause {..} => SyntaxKind::AnonymousFunctionUseClause,
3327 SyntaxVariant::LambdaExpression {..} => SyntaxKind::LambdaExpression,
3328 SyntaxVariant::LambdaSignature {..} => SyntaxKind::LambdaSignature,
3329 SyntaxVariant::CastExpression {..} => SyntaxKind::CastExpression,
3330 SyntaxVariant::ScopeResolutionExpression {..} => SyntaxKind::ScopeResolutionExpression,
3331 SyntaxVariant::MemberSelectionExpression {..} => SyntaxKind::MemberSelectionExpression,
3332 SyntaxVariant::SafeMemberSelectionExpression {..} => SyntaxKind::SafeMemberSelectionExpression,
3333 SyntaxVariant::EmbeddedMemberSelectionExpression {..} => SyntaxKind::EmbeddedMemberSelectionExpression,
3334 SyntaxVariant::YieldExpression {..} => SyntaxKind::YieldExpression,
3335 SyntaxVariant::PrefixUnaryExpression {..} => SyntaxKind::PrefixUnaryExpression,
3336 SyntaxVariant::PostfixUnaryExpression {..} => SyntaxKind::PostfixUnaryExpression,
3337 SyntaxVariant::BinaryExpression {..} => SyntaxKind::BinaryExpression,
3338 SyntaxVariant::IsExpression {..} => SyntaxKind::IsExpression,
3339 SyntaxVariant::AsExpression {..} => SyntaxKind::AsExpression,
3340 SyntaxVariant::NullableAsExpression {..} => SyntaxKind::NullableAsExpression,
3341 SyntaxVariant::ConditionalExpression {..} => SyntaxKind::ConditionalExpression,
3342 SyntaxVariant::EvalExpression {..} => SyntaxKind::EvalExpression,
3343 SyntaxVariant::DefineExpression {..} => SyntaxKind::DefineExpression,
3344 SyntaxVariant::IssetExpression {..} => SyntaxKind::IssetExpression,
3345 SyntaxVariant::FunctionCallExpression {..} => SyntaxKind::FunctionCallExpression,
3346 SyntaxVariant::FunctionPointerExpression {..} => SyntaxKind::FunctionPointerExpression,
3347 SyntaxVariant::ParenthesizedExpression {..} => SyntaxKind::ParenthesizedExpression,
3348 SyntaxVariant::BracedExpression {..} => SyntaxKind::BracedExpression,
3349 SyntaxVariant::ETSpliceExpression {..} => SyntaxKind::ETSpliceExpression,
3350 SyntaxVariant::EmbeddedBracedExpression {..} => SyntaxKind::EmbeddedBracedExpression,
3351 SyntaxVariant::ListExpression {..} => SyntaxKind::ListExpression,
3352 SyntaxVariant::CollectionLiteralExpression {..} => SyntaxKind::CollectionLiteralExpression,
3353 SyntaxVariant::ObjectCreationExpression {..} => SyntaxKind::ObjectCreationExpression,
3354 SyntaxVariant::ConstructorCall {..} => SyntaxKind::ConstructorCall,
3355 SyntaxVariant::RecordCreationExpression {..} => SyntaxKind::RecordCreationExpression,
3356 SyntaxVariant::DarrayIntrinsicExpression {..} => SyntaxKind::DarrayIntrinsicExpression,
3357 SyntaxVariant::DictionaryIntrinsicExpression {..} => SyntaxKind::DictionaryIntrinsicExpression,
3358 SyntaxVariant::KeysetIntrinsicExpression {..} => SyntaxKind::KeysetIntrinsicExpression,
3359 SyntaxVariant::VarrayIntrinsicExpression {..} => SyntaxKind::VarrayIntrinsicExpression,
3360 SyntaxVariant::VectorIntrinsicExpression {..} => SyntaxKind::VectorIntrinsicExpression,
3361 SyntaxVariant::ElementInitializer {..} => SyntaxKind::ElementInitializer,
3362 SyntaxVariant::SubscriptExpression {..} => SyntaxKind::SubscriptExpression,
3363 SyntaxVariant::EmbeddedSubscriptExpression {..} => SyntaxKind::EmbeddedSubscriptExpression,
3364 SyntaxVariant::AwaitableCreationExpression {..} => SyntaxKind::AwaitableCreationExpression,
3365 SyntaxVariant::XHPChildrenDeclaration {..} => SyntaxKind::XHPChildrenDeclaration,
3366 SyntaxVariant::XHPChildrenParenthesizedList {..} => SyntaxKind::XHPChildrenParenthesizedList,
3367 SyntaxVariant::XHPCategoryDeclaration {..} => SyntaxKind::XHPCategoryDeclaration,
3368 SyntaxVariant::XHPEnumType {..} => SyntaxKind::XHPEnumType,
3369 SyntaxVariant::XHPLateinit {..} => SyntaxKind::XHPLateinit,
3370 SyntaxVariant::XHPRequired {..} => SyntaxKind::XHPRequired,
3371 SyntaxVariant::XHPClassAttributeDeclaration {..} => SyntaxKind::XHPClassAttributeDeclaration,
3372 SyntaxVariant::XHPClassAttribute {..} => SyntaxKind::XHPClassAttribute,
3373 SyntaxVariant::XHPSimpleClassAttribute {..} => SyntaxKind::XHPSimpleClassAttribute,
3374 SyntaxVariant::XHPSimpleAttribute {..} => SyntaxKind::XHPSimpleAttribute,
3375 SyntaxVariant::XHPSpreadAttribute {..} => SyntaxKind::XHPSpreadAttribute,
3376 SyntaxVariant::XHPOpen {..} => SyntaxKind::XHPOpen,
3377 SyntaxVariant::XHPExpression {..} => SyntaxKind::XHPExpression,
3378 SyntaxVariant::XHPClose {..} => SyntaxKind::XHPClose,
3379 SyntaxVariant::TypeConstant {..} => SyntaxKind::TypeConstant,
3380 SyntaxVariant::VectorTypeSpecifier {..} => SyntaxKind::VectorTypeSpecifier,
3381 SyntaxVariant::KeysetTypeSpecifier {..} => SyntaxKind::KeysetTypeSpecifier,
3382 SyntaxVariant::TupleTypeExplicitSpecifier {..} => SyntaxKind::TupleTypeExplicitSpecifier,
3383 SyntaxVariant::VarrayTypeSpecifier {..} => SyntaxKind::VarrayTypeSpecifier,
3384 SyntaxVariant::FunctionCtxTypeSpecifier {..} => SyntaxKind::FunctionCtxTypeSpecifier,
3385 SyntaxVariant::TypeParameter {..} => SyntaxKind::TypeParameter,
3386 SyntaxVariant::TypeConstraint {..} => SyntaxKind::TypeConstraint,
3387 SyntaxVariant::ContextConstraint {..} => SyntaxKind::ContextConstraint,
3388 SyntaxVariant::DarrayTypeSpecifier {..} => SyntaxKind::DarrayTypeSpecifier,
3389 SyntaxVariant::DictionaryTypeSpecifier {..} => SyntaxKind::DictionaryTypeSpecifier,
3390 SyntaxVariant::ClosureTypeSpecifier {..} => SyntaxKind::ClosureTypeSpecifier,
3391 SyntaxVariant::ClosureParameterTypeSpecifier {..} => SyntaxKind::ClosureParameterTypeSpecifier,
3392 SyntaxVariant::ClassnameTypeSpecifier {..} => SyntaxKind::ClassnameTypeSpecifier,
3393 SyntaxVariant::FieldSpecifier {..} => SyntaxKind::FieldSpecifier,
3394 SyntaxVariant::FieldInitializer {..} => SyntaxKind::FieldInitializer,
3395 SyntaxVariant::ShapeTypeSpecifier {..} => SyntaxKind::ShapeTypeSpecifier,
3396 SyntaxVariant::ShapeExpression {..} => SyntaxKind::ShapeExpression,
3397 SyntaxVariant::TupleExpression {..} => SyntaxKind::TupleExpression,
3398 SyntaxVariant::GenericTypeSpecifier {..} => SyntaxKind::GenericTypeSpecifier,
3399 SyntaxVariant::NullableTypeSpecifier {..} => SyntaxKind::NullableTypeSpecifier,
3400 SyntaxVariant::LikeTypeSpecifier {..} => SyntaxKind::LikeTypeSpecifier,
3401 SyntaxVariant::SoftTypeSpecifier {..} => SyntaxKind::SoftTypeSpecifier,
3402 SyntaxVariant::AttributizedSpecifier {..} => SyntaxKind::AttributizedSpecifier,
3403 SyntaxVariant::ReifiedTypeArgument {..} => SyntaxKind::ReifiedTypeArgument,
3404 SyntaxVariant::TypeArguments {..} => SyntaxKind::TypeArguments,
3405 SyntaxVariant::TypeParameters {..} => SyntaxKind::TypeParameters,
3406 SyntaxVariant::TupleTypeSpecifier {..} => SyntaxKind::TupleTypeSpecifier,
3407 SyntaxVariant::UnionTypeSpecifier {..} => SyntaxKind::UnionTypeSpecifier,
3408 SyntaxVariant::IntersectionTypeSpecifier {..} => SyntaxKind::IntersectionTypeSpecifier,
3409 SyntaxVariant::ErrorSyntax {..} => SyntaxKind::ErrorSyntax,
3410 SyntaxVariant::ListItem {..} => SyntaxKind::ListItem,
3411 SyntaxVariant::EnumAtomExpression {..} => SyntaxKind::EnumAtomExpression,
3412 }
3413 }
3415 pub fn from_children(kind : SyntaxKind, mut ts : Vec<Self>) -> SyntaxVariant<T, V> {
3416 match (kind, ts.len()) {
3417 (SyntaxKind::Missing, 0) => SyntaxVariant::Missing,
3418 (SyntaxKind::SyntaxList, _) => SyntaxVariant::SyntaxList(ts),
3419 (SyntaxKind::EndOfFile, 1) => SyntaxVariant::EndOfFile(Box::new(EndOfFileChildren {
3420 end_of_file_token: ts.pop().unwrap(),
3422 })),
3423 (SyntaxKind::Script, 1) => SyntaxVariant::Script(Box::new(ScriptChildren {
3424 script_declarations: ts.pop().unwrap(),
3426 })),
3427 (SyntaxKind::QualifiedName, 1) => SyntaxVariant::QualifiedName(Box::new(QualifiedNameChildren {
3428 qualified_name_parts: ts.pop().unwrap(),
3430 })),
3431 (SyntaxKind::SimpleTypeSpecifier, 1) => SyntaxVariant::SimpleTypeSpecifier(Box::new(SimpleTypeSpecifierChildren {
3432 simple_type_specifier: ts.pop().unwrap(),
3434 })),
3435 (SyntaxKind::LiteralExpression, 1) => SyntaxVariant::LiteralExpression(Box::new(LiteralExpressionChildren {
3436 literal_expression: ts.pop().unwrap(),
3438 })),
3439 (SyntaxKind::PrefixedStringExpression, 2) => SyntaxVariant::PrefixedStringExpression(Box::new(PrefixedStringExpressionChildren {
3440 prefixed_string_str: ts.pop().unwrap(),
3441 prefixed_string_name: ts.pop().unwrap(),
3443 })),
3444 (SyntaxKind::PrefixedCodeExpression, 4) => SyntaxVariant::PrefixedCodeExpression(Box::new(PrefixedCodeExpressionChildren {
3445 prefixed_code_right_backtick: ts.pop().unwrap(),
3446 prefixed_code_expression: ts.pop().unwrap(),
3447 prefixed_code_left_backtick: ts.pop().unwrap(),
3448 prefixed_code_prefix: ts.pop().unwrap(),
3450 })),
3451 (SyntaxKind::VariableExpression, 1) => SyntaxVariant::VariableExpression(Box::new(VariableExpressionChildren {
3452 variable_expression: ts.pop().unwrap(),
3454 })),
3455 (SyntaxKind::PipeVariableExpression, 1) => SyntaxVariant::PipeVariableExpression(Box::new(PipeVariableExpressionChildren {
3456 pipe_variable_expression: ts.pop().unwrap(),
3458 })),
3459 (SyntaxKind::FileAttributeSpecification, 5) => SyntaxVariant::FileAttributeSpecification(Box::new(FileAttributeSpecificationChildren {
3460 file_attribute_specification_right_double_angle: ts.pop().unwrap(),
3461 file_attribute_specification_attributes: ts.pop().unwrap(),
3462 file_attribute_specification_colon: ts.pop().unwrap(),
3463 file_attribute_specification_keyword: ts.pop().unwrap(),
3464 file_attribute_specification_left_double_angle: ts.pop().unwrap(),
3466 })),
3467 (SyntaxKind::EnumDeclaration, 10) => SyntaxVariant::EnumDeclaration(Box::new(EnumDeclarationChildren {
3468 enum_right_brace: ts.pop().unwrap(),
3469 enum_enumerators: ts.pop().unwrap(),
3470 enum_use_clauses: ts.pop().unwrap(),
3471 enum_left_brace: ts.pop().unwrap(),
3472 enum_type: ts.pop().unwrap(),
3473 enum_base: ts.pop().unwrap(),
3474 enum_colon: ts.pop().unwrap(),
3475 enum_name: ts.pop().unwrap(),
3476 enum_keyword: ts.pop().unwrap(),
3477 enum_attribute_spec: ts.pop().unwrap(),
3479 })),
3480 (SyntaxKind::EnumUse, 3) => SyntaxVariant::EnumUse(Box::new(EnumUseChildren {
3481 enum_use_semicolon: ts.pop().unwrap(),
3482 enum_use_names: ts.pop().unwrap(),
3483 enum_use_keyword: ts.pop().unwrap(),
3485 })),
3486 (SyntaxKind::Enumerator, 4) => SyntaxVariant::Enumerator(Box::new(EnumeratorChildren {
3487 enumerator_semicolon: ts.pop().unwrap(),
3488 enumerator_value: ts.pop().unwrap(),
3489 enumerator_equal: ts.pop().unwrap(),
3490 enumerator_name: ts.pop().unwrap(),
3492 })),
3493 (SyntaxKind::EnumClassDeclaration, 11) => SyntaxVariant::EnumClassDeclaration(Box::new(EnumClassDeclarationChildren {
3494 enum_class_right_brace: ts.pop().unwrap(),
3495 enum_class_elements: ts.pop().unwrap(),
3496 enum_class_left_brace: ts.pop().unwrap(),
3497 enum_class_extends_list: ts.pop().unwrap(),
3498 enum_class_extends: ts.pop().unwrap(),
3499 enum_class_base: ts.pop().unwrap(),
3500 enum_class_colon: ts.pop().unwrap(),
3501 enum_class_name: ts.pop().unwrap(),
3502 enum_class_class_keyword: ts.pop().unwrap(),
3503 enum_class_enum_keyword: ts.pop().unwrap(),
3504 enum_class_attribute_spec: ts.pop().unwrap(),
3506 })),
3507 (SyntaxKind::EnumClassEnumerator, 5) => SyntaxVariant::EnumClassEnumerator(Box::new(EnumClassEnumeratorChildren {
3508 enum_class_enumerator_semicolon: ts.pop().unwrap(),
3509 enum_class_enumerator_initial_value: ts.pop().unwrap(),
3510 enum_class_enumerator_equal: ts.pop().unwrap(),
3511 enum_class_enumerator_name: ts.pop().unwrap(),
3512 enum_class_enumerator_type: ts.pop().unwrap(),
3514 })),
3515 (SyntaxKind::RecordDeclaration, 9) => SyntaxVariant::RecordDeclaration(Box::new(RecordDeclarationChildren {
3516 record_right_brace: ts.pop().unwrap(),
3517 record_fields: ts.pop().unwrap(),
3518 record_left_brace: ts.pop().unwrap(),
3519 record_extends_opt: ts.pop().unwrap(),
3520 record_extends_keyword: ts.pop().unwrap(),
3521 record_name: ts.pop().unwrap(),
3522 record_keyword: ts.pop().unwrap(),
3523 record_modifier: ts.pop().unwrap(),
3524 record_attribute_spec: ts.pop().unwrap(),
3526 })),
3527 (SyntaxKind::RecordField, 4) => SyntaxVariant::RecordField(Box::new(RecordFieldChildren {
3528 record_field_semi: ts.pop().unwrap(),
3529 record_field_init: ts.pop().unwrap(),
3530 record_field_name: ts.pop().unwrap(),
3531 record_field_type: ts.pop().unwrap(),
3533 })),
3534 (SyntaxKind::AliasDeclaration, 8) => SyntaxVariant::AliasDeclaration(Box::new(AliasDeclarationChildren {
3535 alias_semicolon: ts.pop().unwrap(),
3536 alias_type: ts.pop().unwrap(),
3537 alias_equal: ts.pop().unwrap(),
3538 alias_constraint: ts.pop().unwrap(),
3539 alias_generic_parameter: ts.pop().unwrap(),
3540 alias_name: ts.pop().unwrap(),
3541 alias_keyword: ts.pop().unwrap(),
3542 alias_attribute_spec: ts.pop().unwrap(),
3544 })),
3545 (SyntaxKind::PropertyDeclaration, 5) => SyntaxVariant::PropertyDeclaration(Box::new(PropertyDeclarationChildren {
3546 property_semicolon: ts.pop().unwrap(),
3547 property_declarators: ts.pop().unwrap(),
3548 property_type: ts.pop().unwrap(),
3549 property_modifiers: ts.pop().unwrap(),
3550 property_attribute_spec: ts.pop().unwrap(),
3552 })),
3553 (SyntaxKind::PropertyDeclarator, 2) => SyntaxVariant::PropertyDeclarator(Box::new(PropertyDeclaratorChildren {
3554 property_initializer: ts.pop().unwrap(),
3555 property_name: ts.pop().unwrap(),
3557 })),
3558 (SyntaxKind::NamespaceDeclaration, 2) => SyntaxVariant::NamespaceDeclaration(Box::new(NamespaceDeclarationChildren {
3559 namespace_body: ts.pop().unwrap(),
3560 namespace_header: ts.pop().unwrap(),
3562 })),
3563 (SyntaxKind::NamespaceDeclarationHeader, 2) => SyntaxVariant::NamespaceDeclarationHeader(Box::new(NamespaceDeclarationHeaderChildren {
3564 namespace_name: ts.pop().unwrap(),
3565 namespace_keyword: ts.pop().unwrap(),
3567 })),
3568 (SyntaxKind::NamespaceBody, 3) => SyntaxVariant::NamespaceBody(Box::new(NamespaceBodyChildren {
3569 namespace_right_brace: ts.pop().unwrap(),
3570 namespace_declarations: ts.pop().unwrap(),
3571 namespace_left_brace: ts.pop().unwrap(),
3573 })),
3574 (SyntaxKind::NamespaceEmptyBody, 1) => SyntaxVariant::NamespaceEmptyBody(Box::new(NamespaceEmptyBodyChildren {
3575 namespace_semicolon: ts.pop().unwrap(),
3577 })),
3578 (SyntaxKind::NamespaceUseDeclaration, 4) => SyntaxVariant::NamespaceUseDeclaration(Box::new(NamespaceUseDeclarationChildren {
3579 namespace_use_semicolon: ts.pop().unwrap(),
3580 namespace_use_clauses: ts.pop().unwrap(),
3581 namespace_use_kind: ts.pop().unwrap(),
3582 namespace_use_keyword: ts.pop().unwrap(),
3584 })),
3585 (SyntaxKind::NamespaceGroupUseDeclaration, 7) => SyntaxVariant::NamespaceGroupUseDeclaration(Box::new(NamespaceGroupUseDeclarationChildren {
3586 namespace_group_use_semicolon: ts.pop().unwrap(),
3587 namespace_group_use_right_brace: ts.pop().unwrap(),
3588 namespace_group_use_clauses: ts.pop().unwrap(),
3589 namespace_group_use_left_brace: ts.pop().unwrap(),
3590 namespace_group_use_prefix: ts.pop().unwrap(),
3591 namespace_group_use_kind: ts.pop().unwrap(),
3592 namespace_group_use_keyword: ts.pop().unwrap(),
3594 })),
3595 (SyntaxKind::NamespaceUseClause, 4) => SyntaxVariant::NamespaceUseClause(Box::new(NamespaceUseClauseChildren {
3596 namespace_use_alias: ts.pop().unwrap(),
3597 namespace_use_as: ts.pop().unwrap(),
3598 namespace_use_name: ts.pop().unwrap(),
3599 namespace_use_clause_kind: ts.pop().unwrap(),
3601 })),
3602 (SyntaxKind::FunctionDeclaration, 3) => SyntaxVariant::FunctionDeclaration(Box::new(FunctionDeclarationChildren {
3603 function_body: ts.pop().unwrap(),
3604 function_declaration_header: ts.pop().unwrap(),
3605 function_attribute_spec: ts.pop().unwrap(),
3607 })),
3608 (SyntaxKind::FunctionDeclarationHeader, 11) => SyntaxVariant::FunctionDeclarationHeader(Box::new(FunctionDeclarationHeaderChildren {
3609 function_where_clause: ts.pop().unwrap(),
3610 function_type: ts.pop().unwrap(),
3611 function_colon: ts.pop().unwrap(),
3612 function_contexts: ts.pop().unwrap(),
3613 function_right_paren: ts.pop().unwrap(),
3614 function_parameter_list: ts.pop().unwrap(),
3615 function_left_paren: ts.pop().unwrap(),
3616 function_type_parameter_list: ts.pop().unwrap(),
3617 function_name: ts.pop().unwrap(),
3618 function_keyword: ts.pop().unwrap(),
3619 function_modifiers: ts.pop().unwrap(),
3621 })),
3622 (SyntaxKind::Contexts, 3) => SyntaxVariant::Contexts(Box::new(ContextsChildren {
3623 contexts_right_bracket: ts.pop().unwrap(),
3624 contexts_types: ts.pop().unwrap(),
3625 contexts_left_bracket: ts.pop().unwrap(),
3627 })),
3628 (SyntaxKind::WhereClause, 2) => SyntaxVariant::WhereClause(Box::new(WhereClauseChildren {
3629 where_clause_constraints: ts.pop().unwrap(),
3630 where_clause_keyword: ts.pop().unwrap(),
3632 })),
3633 (SyntaxKind::WhereConstraint, 3) => SyntaxVariant::WhereConstraint(Box::new(WhereConstraintChildren {
3634 where_constraint_right_type: ts.pop().unwrap(),
3635 where_constraint_operator: ts.pop().unwrap(),
3636 where_constraint_left_type: ts.pop().unwrap(),
3638 })),
3639 (SyntaxKind::MethodishDeclaration, 4) => SyntaxVariant::MethodishDeclaration(Box::new(MethodishDeclarationChildren {
3640 methodish_semicolon: ts.pop().unwrap(),
3641 methodish_function_body: ts.pop().unwrap(),
3642 methodish_function_decl_header: ts.pop().unwrap(),
3643 methodish_attribute: ts.pop().unwrap(),
3645 })),
3646 (SyntaxKind::MethodishTraitResolution, 5) => SyntaxVariant::MethodishTraitResolution(Box::new(MethodishTraitResolutionChildren {
3647 methodish_trait_semicolon: ts.pop().unwrap(),
3648 methodish_trait_name: ts.pop().unwrap(),
3649 methodish_trait_equal: ts.pop().unwrap(),
3650 methodish_trait_function_decl_header: ts.pop().unwrap(),
3651 methodish_trait_attribute: ts.pop().unwrap(),
3653 })),
3654 (SyntaxKind::ClassishDeclaration, 12) => SyntaxVariant::ClassishDeclaration(Box::new(ClassishDeclarationChildren {
3655 classish_body: ts.pop().unwrap(),
3656 classish_where_clause: ts.pop().unwrap(),
3657 classish_implements_list: ts.pop().unwrap(),
3658 classish_implements_keyword: ts.pop().unwrap(),
3659 classish_extends_list: ts.pop().unwrap(),
3660 classish_extends_keyword: ts.pop().unwrap(),
3661 classish_type_parameters: ts.pop().unwrap(),
3662 classish_name: ts.pop().unwrap(),
3663 classish_keyword: ts.pop().unwrap(),
3664 classish_xhp: ts.pop().unwrap(),
3665 classish_modifiers: ts.pop().unwrap(),
3666 classish_attribute: ts.pop().unwrap(),
3668 })),
3669 (SyntaxKind::ClassishBody, 3) => SyntaxVariant::ClassishBody(Box::new(ClassishBodyChildren {
3670 classish_body_right_brace: ts.pop().unwrap(),
3671 classish_body_elements: ts.pop().unwrap(),
3672 classish_body_left_brace: ts.pop().unwrap(),
3674 })),
3675 (SyntaxKind::TraitUsePrecedenceItem, 3) => SyntaxVariant::TraitUsePrecedenceItem(Box::new(TraitUsePrecedenceItemChildren {
3676 trait_use_precedence_item_removed_names: ts.pop().unwrap(),
3677 trait_use_precedence_item_keyword: ts.pop().unwrap(),
3678 trait_use_precedence_item_name: ts.pop().unwrap(),
3680 })),
3681 (SyntaxKind::TraitUseAliasItem, 4) => SyntaxVariant::TraitUseAliasItem(Box::new(TraitUseAliasItemChildren {
3682 trait_use_alias_item_aliased_name: ts.pop().unwrap(),
3683 trait_use_alias_item_modifiers: ts.pop().unwrap(),
3684 trait_use_alias_item_keyword: ts.pop().unwrap(),
3685 trait_use_alias_item_aliasing_name: ts.pop().unwrap(),
3687 })),
3688 (SyntaxKind::TraitUseConflictResolution, 5) => SyntaxVariant::TraitUseConflictResolution(Box::new(TraitUseConflictResolutionChildren {
3689 trait_use_conflict_resolution_right_brace: ts.pop().unwrap(),
3690 trait_use_conflict_resolution_clauses: ts.pop().unwrap(),
3691 trait_use_conflict_resolution_left_brace: ts.pop().unwrap(),
3692 trait_use_conflict_resolution_names: ts.pop().unwrap(),
3693 trait_use_conflict_resolution_keyword: ts.pop().unwrap(),
3695 })),
3696 (SyntaxKind::TraitUse, 3) => SyntaxVariant::TraitUse(Box::new(TraitUseChildren {
3697 trait_use_semicolon: ts.pop().unwrap(),
3698 trait_use_names: ts.pop().unwrap(),
3699 trait_use_keyword: ts.pop().unwrap(),
3701 })),
3702 (SyntaxKind::RequireClause, 4) => SyntaxVariant::RequireClause(Box::new(RequireClauseChildren {
3703 require_semicolon: ts.pop().unwrap(),
3704 require_name: ts.pop().unwrap(),
3705 require_kind: ts.pop().unwrap(),
3706 require_keyword: ts.pop().unwrap(),
3708 })),
3709 (SyntaxKind::ConstDeclaration, 5) => SyntaxVariant::ConstDeclaration(Box::new(ConstDeclarationChildren {
3710 const_semicolon: ts.pop().unwrap(),
3711 const_declarators: ts.pop().unwrap(),
3712 const_type_specifier: ts.pop().unwrap(),
3713 const_keyword: ts.pop().unwrap(),
3714 const_modifiers: ts.pop().unwrap(),
3716 })),
3717 (SyntaxKind::ConstantDeclarator, 2) => SyntaxVariant::ConstantDeclarator(Box::new(ConstantDeclaratorChildren {
3718 constant_declarator_initializer: ts.pop().unwrap(),
3719 constant_declarator_name: ts.pop().unwrap(),
3721 })),
3722 (SyntaxKind::TypeConstDeclaration, 10) => SyntaxVariant::TypeConstDeclaration(Box::new(TypeConstDeclarationChildren {
3723 type_const_semicolon: ts.pop().unwrap(),
3724 type_const_type_specifier: ts.pop().unwrap(),
3725 type_const_equal: ts.pop().unwrap(),
3726 type_const_type_constraint: ts.pop().unwrap(),
3727 type_const_type_parameters: ts.pop().unwrap(),
3728 type_const_name: ts.pop().unwrap(),
3729 type_const_type_keyword: ts.pop().unwrap(),
3730 type_const_keyword: ts.pop().unwrap(),
3731 type_const_modifiers: ts.pop().unwrap(),
3732 type_const_attribute_spec: ts.pop().unwrap(),
3734 })),
3735 (SyntaxKind::ContextConstDeclaration, 9) => SyntaxVariant::ContextConstDeclaration(Box::new(ContextConstDeclarationChildren {
3736 context_const_semicolon: ts.pop().unwrap(),
3737 context_const_ctx_list: ts.pop().unwrap(),
3738 context_const_equal: ts.pop().unwrap(),
3739 context_const_constraint: ts.pop().unwrap(),
3740 context_const_type_parameters: ts.pop().unwrap(),
3741 context_const_name: ts.pop().unwrap(),
3742 context_const_ctx_keyword: ts.pop().unwrap(),
3743 context_const_const_keyword: ts.pop().unwrap(),
3744 context_const_modifiers: ts.pop().unwrap(),
3746 })),
3747 (SyntaxKind::DecoratedExpression, 2) => SyntaxVariant::DecoratedExpression(Box::new(DecoratedExpressionChildren {
3748 decorated_expression_expression: ts.pop().unwrap(),
3749 decorated_expression_decorator: ts.pop().unwrap(),
3751 })),
3752 (SyntaxKind::ParameterDeclaration, 6) => SyntaxVariant::ParameterDeclaration(Box::new(ParameterDeclarationChildren {
3753 parameter_default_value: ts.pop().unwrap(),
3754 parameter_name: ts.pop().unwrap(),
3755 parameter_type: ts.pop().unwrap(),
3756 parameter_call_convention: ts.pop().unwrap(),
3757 parameter_visibility: ts.pop().unwrap(),
3758 parameter_attribute: ts.pop().unwrap(),
3760 })),
3761 (SyntaxKind::VariadicParameter, 3) => SyntaxVariant::VariadicParameter(Box::new(VariadicParameterChildren {
3762 variadic_parameter_ellipsis: ts.pop().unwrap(),
3763 variadic_parameter_type: ts.pop().unwrap(),
3764 variadic_parameter_call_convention: ts.pop().unwrap(),
3766 })),
3767 (SyntaxKind::OldAttributeSpecification, 3) => SyntaxVariant::OldAttributeSpecification(Box::new(OldAttributeSpecificationChildren {
3768 old_attribute_specification_right_double_angle: ts.pop().unwrap(),
3769 old_attribute_specification_attributes: ts.pop().unwrap(),
3770 old_attribute_specification_left_double_angle: ts.pop().unwrap(),
3772 })),
3773 (SyntaxKind::AttributeSpecification, 1) => SyntaxVariant::AttributeSpecification(Box::new(AttributeSpecificationChildren {
3774 attribute_specification_attributes: ts.pop().unwrap(),
3776 })),
3777 (SyntaxKind::Attribute, 2) => SyntaxVariant::Attribute(Box::new(AttributeChildren {
3778 attribute_attribute_name: ts.pop().unwrap(),
3779 attribute_at: ts.pop().unwrap(),
3781 })),
3782 (SyntaxKind::InclusionExpression, 2) => SyntaxVariant::InclusionExpression(Box::new(InclusionExpressionChildren {
3783 inclusion_filename: ts.pop().unwrap(),
3784 inclusion_require: ts.pop().unwrap(),
3786 })),
3787 (SyntaxKind::InclusionDirective, 2) => SyntaxVariant::InclusionDirective(Box::new(InclusionDirectiveChildren {
3788 inclusion_semicolon: ts.pop().unwrap(),
3789 inclusion_expression: ts.pop().unwrap(),
3791 })),
3792 (SyntaxKind::CompoundStatement, 3) => SyntaxVariant::CompoundStatement(Box::new(CompoundStatementChildren {
3793 compound_right_brace: ts.pop().unwrap(),
3794 compound_statements: ts.pop().unwrap(),
3795 compound_left_brace: ts.pop().unwrap(),
3797 })),
3798 (SyntaxKind::ExpressionStatement, 2) => SyntaxVariant::ExpressionStatement(Box::new(ExpressionStatementChildren {
3799 expression_statement_semicolon: ts.pop().unwrap(),
3800 expression_statement_expression: ts.pop().unwrap(),
3802 })),
3803 (SyntaxKind::MarkupSection, 2) => SyntaxVariant::MarkupSection(Box::new(MarkupSectionChildren {
3804 markup_suffix: ts.pop().unwrap(),
3805 markup_hashbang: ts.pop().unwrap(),
3807 })),
3808 (SyntaxKind::MarkupSuffix, 2) => SyntaxVariant::MarkupSuffix(Box::new(MarkupSuffixChildren {
3809 markup_suffix_name: ts.pop().unwrap(),
3810 markup_suffix_less_than_question: ts.pop().unwrap(),
3812 })),
3813 (SyntaxKind::UnsetStatement, 5) => SyntaxVariant::UnsetStatement(Box::new(UnsetStatementChildren {
3814 unset_semicolon: ts.pop().unwrap(),
3815 unset_right_paren: ts.pop().unwrap(),
3816 unset_variables: ts.pop().unwrap(),
3817 unset_left_paren: ts.pop().unwrap(),
3818 unset_keyword: ts.pop().unwrap(),
3820 })),
3821 (SyntaxKind::UsingStatementBlockScoped, 6) => SyntaxVariant::UsingStatementBlockScoped(Box::new(UsingStatementBlockScopedChildren {
3822 using_block_body: ts.pop().unwrap(),
3823 using_block_right_paren: ts.pop().unwrap(),
3824 using_block_expressions: ts.pop().unwrap(),
3825 using_block_left_paren: ts.pop().unwrap(),
3826 using_block_using_keyword: ts.pop().unwrap(),
3827 using_block_await_keyword: ts.pop().unwrap(),
3829 })),
3830 (SyntaxKind::UsingStatementFunctionScoped, 4) => SyntaxVariant::UsingStatementFunctionScoped(Box::new(UsingStatementFunctionScopedChildren {
3831 using_function_semicolon: ts.pop().unwrap(),
3832 using_function_expression: ts.pop().unwrap(),
3833 using_function_using_keyword: ts.pop().unwrap(),
3834 using_function_await_keyword: ts.pop().unwrap(),
3836 })),
3837 (SyntaxKind::WhileStatement, 5) => SyntaxVariant::WhileStatement(Box::new(WhileStatementChildren {
3838 while_body: ts.pop().unwrap(),
3839 while_right_paren: ts.pop().unwrap(),
3840 while_condition: ts.pop().unwrap(),
3841 while_left_paren: ts.pop().unwrap(),
3842 while_keyword: ts.pop().unwrap(),
3844 })),
3845 (SyntaxKind::IfStatement, 7) => SyntaxVariant::IfStatement(Box::new(IfStatementChildren {
3846 if_else_clause: ts.pop().unwrap(),
3847 if_elseif_clauses: ts.pop().unwrap(),
3848 if_statement: ts.pop().unwrap(),
3849 if_right_paren: ts.pop().unwrap(),
3850 if_condition: ts.pop().unwrap(),
3851 if_left_paren: ts.pop().unwrap(),
3852 if_keyword: ts.pop().unwrap(),
3854 })),
3855 (SyntaxKind::ElseifClause, 5) => SyntaxVariant::ElseifClause(Box::new(ElseifClauseChildren {
3856 elseif_statement: ts.pop().unwrap(),
3857 elseif_right_paren: ts.pop().unwrap(),
3858 elseif_condition: ts.pop().unwrap(),
3859 elseif_left_paren: ts.pop().unwrap(),
3860 elseif_keyword: ts.pop().unwrap(),
3862 })),
3863 (SyntaxKind::ElseClause, 2) => SyntaxVariant::ElseClause(Box::new(ElseClauseChildren {
3864 else_statement: ts.pop().unwrap(),
3865 else_keyword: ts.pop().unwrap(),
3867 })),
3868 (SyntaxKind::TryStatement, 4) => SyntaxVariant::TryStatement(Box::new(TryStatementChildren {
3869 try_finally_clause: ts.pop().unwrap(),
3870 try_catch_clauses: ts.pop().unwrap(),
3871 try_compound_statement: ts.pop().unwrap(),
3872 try_keyword: ts.pop().unwrap(),
3874 })),
3875 (SyntaxKind::CatchClause, 6) => SyntaxVariant::CatchClause(Box::new(CatchClauseChildren {
3876 catch_body: ts.pop().unwrap(),
3877 catch_right_paren: ts.pop().unwrap(),
3878 catch_variable: ts.pop().unwrap(),
3879 catch_type: ts.pop().unwrap(),
3880 catch_left_paren: ts.pop().unwrap(),
3881 catch_keyword: ts.pop().unwrap(),
3883 })),
3884 (SyntaxKind::FinallyClause, 2) => SyntaxVariant::FinallyClause(Box::new(FinallyClauseChildren {
3885 finally_body: ts.pop().unwrap(),
3886 finally_keyword: ts.pop().unwrap(),
3888 })),
3889 (SyntaxKind::DoStatement, 7) => SyntaxVariant::DoStatement(Box::new(DoStatementChildren {
3890 do_semicolon: ts.pop().unwrap(),
3891 do_right_paren: ts.pop().unwrap(),
3892 do_condition: ts.pop().unwrap(),
3893 do_left_paren: ts.pop().unwrap(),
3894 do_while_keyword: ts.pop().unwrap(),
3895 do_body: ts.pop().unwrap(),
3896 do_keyword: ts.pop().unwrap(),
3898 })),
3899 (SyntaxKind::ForStatement, 9) => SyntaxVariant::ForStatement(Box::new(ForStatementChildren {
3900 for_body: ts.pop().unwrap(),
3901 for_right_paren: ts.pop().unwrap(),
3902 for_end_of_loop: ts.pop().unwrap(),
3903 for_second_semicolon: ts.pop().unwrap(),
3904 for_control: ts.pop().unwrap(),
3905 for_first_semicolon: ts.pop().unwrap(),
3906 for_initializer: ts.pop().unwrap(),
3907 for_left_paren: ts.pop().unwrap(),
3908 for_keyword: ts.pop().unwrap(),
3910 })),
3911 (SyntaxKind::ForeachStatement, 10) => SyntaxVariant::ForeachStatement(Box::new(ForeachStatementChildren {
3912 foreach_body: ts.pop().unwrap(),
3913 foreach_right_paren: ts.pop().unwrap(),
3914 foreach_value: ts.pop().unwrap(),
3915 foreach_arrow: ts.pop().unwrap(),
3916 foreach_key: ts.pop().unwrap(),
3917 foreach_as: ts.pop().unwrap(),
3918 foreach_await_keyword: ts.pop().unwrap(),
3919 foreach_collection: ts.pop().unwrap(),
3920 foreach_left_paren: ts.pop().unwrap(),
3921 foreach_keyword: ts.pop().unwrap(),
3923 })),
3924 (SyntaxKind::SwitchStatement, 7) => SyntaxVariant::SwitchStatement(Box::new(SwitchStatementChildren {
3925 switch_right_brace: ts.pop().unwrap(),
3926 switch_sections: ts.pop().unwrap(),
3927 switch_left_brace: ts.pop().unwrap(),
3928 switch_right_paren: ts.pop().unwrap(),
3929 switch_expression: ts.pop().unwrap(),
3930 switch_left_paren: ts.pop().unwrap(),
3931 switch_keyword: ts.pop().unwrap(),
3933 })),
3934 (SyntaxKind::SwitchSection, 3) => SyntaxVariant::SwitchSection(Box::new(SwitchSectionChildren {
3935 switch_section_fallthrough: ts.pop().unwrap(),
3936 switch_section_statements: ts.pop().unwrap(),
3937 switch_section_labels: ts.pop().unwrap(),
3939 })),
3940 (SyntaxKind::SwitchFallthrough, 2) => SyntaxVariant::SwitchFallthrough(Box::new(SwitchFallthroughChildren {
3941 fallthrough_semicolon: ts.pop().unwrap(),
3942 fallthrough_keyword: ts.pop().unwrap(),
3944 })),
3945 (SyntaxKind::CaseLabel, 3) => SyntaxVariant::CaseLabel(Box::new(CaseLabelChildren {
3946 case_colon: ts.pop().unwrap(),
3947 case_expression: ts.pop().unwrap(),
3948 case_keyword: ts.pop().unwrap(),
3950 })),
3951 (SyntaxKind::DefaultLabel, 2) => SyntaxVariant::DefaultLabel(Box::new(DefaultLabelChildren {
3952 default_colon: ts.pop().unwrap(),
3953 default_keyword: ts.pop().unwrap(),
3955 })),
3956 (SyntaxKind::ReturnStatement, 3) => SyntaxVariant::ReturnStatement(Box::new(ReturnStatementChildren {
3957 return_semicolon: ts.pop().unwrap(),
3958 return_expression: ts.pop().unwrap(),
3959 return_keyword: ts.pop().unwrap(),
3961 })),
3962 (SyntaxKind::YieldBreakStatement, 3) => SyntaxVariant::YieldBreakStatement(Box::new(YieldBreakStatementChildren {
3963 yield_break_semicolon: ts.pop().unwrap(),
3964 yield_break_break: ts.pop().unwrap(),
3965 yield_break_keyword: ts.pop().unwrap(),
3967 })),
3968 (SyntaxKind::ThrowStatement, 3) => SyntaxVariant::ThrowStatement(Box::new(ThrowStatementChildren {
3969 throw_semicolon: ts.pop().unwrap(),
3970 throw_expression: ts.pop().unwrap(),
3971 throw_keyword: ts.pop().unwrap(),
3973 })),
3974 (SyntaxKind::BreakStatement, 2) => SyntaxVariant::BreakStatement(Box::new(BreakStatementChildren {
3975 break_semicolon: ts.pop().unwrap(),
3976 break_keyword: ts.pop().unwrap(),
3978 })),
3979 (SyntaxKind::ContinueStatement, 2) => SyntaxVariant::ContinueStatement(Box::new(ContinueStatementChildren {
3980 continue_semicolon: ts.pop().unwrap(),
3981 continue_keyword: ts.pop().unwrap(),
3983 })),
3984 (SyntaxKind::EchoStatement, 3) => SyntaxVariant::EchoStatement(Box::new(EchoStatementChildren {
3985 echo_semicolon: ts.pop().unwrap(),
3986 echo_expressions: ts.pop().unwrap(),
3987 echo_keyword: ts.pop().unwrap(),
3989 })),
3990 (SyntaxKind::ConcurrentStatement, 2) => SyntaxVariant::ConcurrentStatement(Box::new(ConcurrentStatementChildren {
3991 concurrent_statement: ts.pop().unwrap(),
3992 concurrent_keyword: ts.pop().unwrap(),
3994 })),
3995 (SyntaxKind::SimpleInitializer, 2) => SyntaxVariant::SimpleInitializer(Box::new(SimpleInitializerChildren {
3996 simple_initializer_value: ts.pop().unwrap(),
3997 simple_initializer_equal: ts.pop().unwrap(),
3999 })),
4000 (SyntaxKind::AnonymousClass, 9) => SyntaxVariant::AnonymousClass(Box::new(AnonymousClassChildren {
4001 anonymous_class_body: ts.pop().unwrap(),
4002 anonymous_class_implements_list: ts.pop().unwrap(),
4003 anonymous_class_implements_keyword: ts.pop().unwrap(),
4004 anonymous_class_extends_list: ts.pop().unwrap(),
4005 anonymous_class_extends_keyword: ts.pop().unwrap(),
4006 anonymous_class_right_paren: ts.pop().unwrap(),
4007 anonymous_class_argument_list: ts.pop().unwrap(),
4008 anonymous_class_left_paren: ts.pop().unwrap(),
4009 anonymous_class_class_keyword: ts.pop().unwrap(),
4011 })),
4012 (SyntaxKind::AnonymousFunction, 12) => SyntaxVariant::AnonymousFunction(Box::new(AnonymousFunctionChildren {
4013 anonymous_body: ts.pop().unwrap(),
4014 anonymous_use: ts.pop().unwrap(),
4015 anonymous_type: ts.pop().unwrap(),
4016 anonymous_colon: ts.pop().unwrap(),
4017 anonymous_ctx_list: ts.pop().unwrap(),
4018 anonymous_right_paren: ts.pop().unwrap(),
4019 anonymous_parameters: ts.pop().unwrap(),
4020 anonymous_left_paren: ts.pop().unwrap(),
4021 anonymous_function_keyword: ts.pop().unwrap(),
4022 anonymous_async_keyword: ts.pop().unwrap(),
4023 anonymous_static_keyword: ts.pop().unwrap(),
4024 anonymous_attribute_spec: ts.pop().unwrap(),
4026 })),
4027 (SyntaxKind::AnonymousFunctionUseClause, 4) => SyntaxVariant::AnonymousFunctionUseClause(Box::new(AnonymousFunctionUseClauseChildren {
4028 anonymous_use_right_paren: ts.pop().unwrap(),
4029 anonymous_use_variables: ts.pop().unwrap(),
4030 anonymous_use_left_paren: ts.pop().unwrap(),
4031 anonymous_use_keyword: ts.pop().unwrap(),
4033 })),
4034 (SyntaxKind::LambdaExpression, 5) => SyntaxVariant::LambdaExpression(Box::new(LambdaExpressionChildren {
4035 lambda_body: ts.pop().unwrap(),
4036 lambda_arrow: ts.pop().unwrap(),
4037 lambda_signature: ts.pop().unwrap(),
4038 lambda_async: ts.pop().unwrap(),
4039 lambda_attribute_spec: ts.pop().unwrap(),
4041 })),
4042 (SyntaxKind::LambdaSignature, 6) => SyntaxVariant::LambdaSignature(Box::new(LambdaSignatureChildren {
4043 lambda_type: ts.pop().unwrap(),
4044 lambda_colon: ts.pop().unwrap(),
4045 lambda_contexts: ts.pop().unwrap(),
4046 lambda_right_paren: ts.pop().unwrap(),
4047 lambda_parameters: ts.pop().unwrap(),
4048 lambda_left_paren: ts.pop().unwrap(),
4050 })),
4051 (SyntaxKind::CastExpression, 4) => SyntaxVariant::CastExpression(Box::new(CastExpressionChildren {
4052 cast_operand: ts.pop().unwrap(),
4053 cast_right_paren: ts.pop().unwrap(),
4054 cast_type: ts.pop().unwrap(),
4055 cast_left_paren: ts.pop().unwrap(),
4057 })),
4058 (SyntaxKind::ScopeResolutionExpression, 3) => SyntaxVariant::ScopeResolutionExpression(Box::new(ScopeResolutionExpressionChildren {
4059 scope_resolution_name: ts.pop().unwrap(),
4060 scope_resolution_operator: ts.pop().unwrap(),
4061 scope_resolution_qualifier: ts.pop().unwrap(),
4063 })),
4064 (SyntaxKind::MemberSelectionExpression, 3) => SyntaxVariant::MemberSelectionExpression(Box::new(MemberSelectionExpressionChildren {
4065 member_name: ts.pop().unwrap(),
4066 member_operator: ts.pop().unwrap(),
4067 member_object: ts.pop().unwrap(),
4069 })),
4070 (SyntaxKind::SafeMemberSelectionExpression, 3) => SyntaxVariant::SafeMemberSelectionExpression(Box::new(SafeMemberSelectionExpressionChildren {
4071 safe_member_name: ts.pop().unwrap(),
4072 safe_member_operator: ts.pop().unwrap(),
4073 safe_member_object: ts.pop().unwrap(),
4075 })),
4076 (SyntaxKind::EmbeddedMemberSelectionExpression, 3) => SyntaxVariant::EmbeddedMemberSelectionExpression(Box::new(EmbeddedMemberSelectionExpressionChildren {
4077 embedded_member_name: ts.pop().unwrap(),
4078 embedded_member_operator: ts.pop().unwrap(),
4079 embedded_member_object: ts.pop().unwrap(),
4081 })),
4082 (SyntaxKind::YieldExpression, 2) => SyntaxVariant::YieldExpression(Box::new(YieldExpressionChildren {
4083 yield_operand: ts.pop().unwrap(),
4084 yield_keyword: ts.pop().unwrap(),
4086 })),
4087 (SyntaxKind::PrefixUnaryExpression, 2) => SyntaxVariant::PrefixUnaryExpression(Box::new(PrefixUnaryExpressionChildren {
4088 prefix_unary_operand: ts.pop().unwrap(),
4089 prefix_unary_operator: ts.pop().unwrap(),
4091 })),
4092 (SyntaxKind::PostfixUnaryExpression, 2) => SyntaxVariant::PostfixUnaryExpression(Box::new(PostfixUnaryExpressionChildren {
4093 postfix_unary_operator: ts.pop().unwrap(),
4094 postfix_unary_operand: ts.pop().unwrap(),
4096 })),
4097 (SyntaxKind::BinaryExpression, 3) => SyntaxVariant::BinaryExpression(Box::new(BinaryExpressionChildren {
4098 binary_right_operand: ts.pop().unwrap(),
4099 binary_operator: ts.pop().unwrap(),
4100 binary_left_operand: ts.pop().unwrap(),
4102 })),
4103 (SyntaxKind::IsExpression, 3) => SyntaxVariant::IsExpression(Box::new(IsExpressionChildren {
4104 is_right_operand: ts.pop().unwrap(),
4105 is_operator: ts.pop().unwrap(),
4106 is_left_operand: ts.pop().unwrap(),
4108 })),
4109 (SyntaxKind::AsExpression, 3) => SyntaxVariant::AsExpression(Box::new(AsExpressionChildren {
4110 as_right_operand: ts.pop().unwrap(),
4111 as_operator: ts.pop().unwrap(),
4112 as_left_operand: ts.pop().unwrap(),
4114 })),
4115 (SyntaxKind::NullableAsExpression, 3) => SyntaxVariant::NullableAsExpression(Box::new(NullableAsExpressionChildren {
4116 nullable_as_right_operand: ts.pop().unwrap(),
4117 nullable_as_operator: ts.pop().unwrap(),
4118 nullable_as_left_operand: ts.pop().unwrap(),
4120 })),
4121 (SyntaxKind::ConditionalExpression, 5) => SyntaxVariant::ConditionalExpression(Box::new(ConditionalExpressionChildren {
4122 conditional_alternative: ts.pop().unwrap(),
4123 conditional_colon: ts.pop().unwrap(),
4124 conditional_consequence: ts.pop().unwrap(),
4125 conditional_question: ts.pop().unwrap(),
4126 conditional_test: ts.pop().unwrap(),
4128 })),
4129 (SyntaxKind::EvalExpression, 4) => SyntaxVariant::EvalExpression(Box::new(EvalExpressionChildren {
4130 eval_right_paren: ts.pop().unwrap(),
4131 eval_argument: ts.pop().unwrap(),
4132 eval_left_paren: ts.pop().unwrap(),
4133 eval_keyword: ts.pop().unwrap(),
4135 })),
4136 (SyntaxKind::DefineExpression, 4) => SyntaxVariant::DefineExpression(Box::new(DefineExpressionChildren {
4137 define_right_paren: ts.pop().unwrap(),
4138 define_argument_list: ts.pop().unwrap(),
4139 define_left_paren: ts.pop().unwrap(),
4140 define_keyword: ts.pop().unwrap(),
4142 })),
4143 (SyntaxKind::IssetExpression, 4) => SyntaxVariant::IssetExpression(Box::new(IssetExpressionChildren {
4144 isset_right_paren: ts.pop().unwrap(),
4145 isset_argument_list: ts.pop().unwrap(),
4146 isset_left_paren: ts.pop().unwrap(),
4147 isset_keyword: ts.pop().unwrap(),
4149 })),
4150 (SyntaxKind::FunctionCallExpression, 5) => SyntaxVariant::FunctionCallExpression(Box::new(FunctionCallExpressionChildren {
4151 function_call_right_paren: ts.pop().unwrap(),
4152 function_call_argument_list: ts.pop().unwrap(),
4153 function_call_left_paren: ts.pop().unwrap(),
4154 function_call_type_args: ts.pop().unwrap(),
4155 function_call_receiver: ts.pop().unwrap(),
4157 })),
4158 (SyntaxKind::FunctionPointerExpression, 2) => SyntaxVariant::FunctionPointerExpression(Box::new(FunctionPointerExpressionChildren {
4159 function_pointer_type_args: ts.pop().unwrap(),
4160 function_pointer_receiver: ts.pop().unwrap(),
4162 })),
4163 (SyntaxKind::ParenthesizedExpression, 3) => SyntaxVariant::ParenthesizedExpression(Box::new(ParenthesizedExpressionChildren {
4164 parenthesized_expression_right_paren: ts.pop().unwrap(),
4165 parenthesized_expression_expression: ts.pop().unwrap(),
4166 parenthesized_expression_left_paren: ts.pop().unwrap(),
4168 })),
4169 (SyntaxKind::BracedExpression, 3) => SyntaxVariant::BracedExpression(Box::new(BracedExpressionChildren {
4170 braced_expression_right_brace: ts.pop().unwrap(),
4171 braced_expression_expression: ts.pop().unwrap(),
4172 braced_expression_left_brace: ts.pop().unwrap(),
4174 })),
4175 (SyntaxKind::ETSpliceExpression, 4) => SyntaxVariant::ETSpliceExpression(Box::new(ETSpliceExpressionChildren {
4176 et_splice_expression_right_brace: ts.pop().unwrap(),
4177 et_splice_expression_expression: ts.pop().unwrap(),
4178 et_splice_expression_left_brace: ts.pop().unwrap(),
4179 et_splice_expression_dollar: ts.pop().unwrap(),
4181 })),
4182 (SyntaxKind::EmbeddedBracedExpression, 3) => SyntaxVariant::EmbeddedBracedExpression(Box::new(EmbeddedBracedExpressionChildren {
4183 embedded_braced_expression_right_brace: ts.pop().unwrap(),
4184 embedded_braced_expression_expression: ts.pop().unwrap(),
4185 embedded_braced_expression_left_brace: ts.pop().unwrap(),
4187 })),
4188 (SyntaxKind::ListExpression, 4) => SyntaxVariant::ListExpression(Box::new(ListExpressionChildren {
4189 list_right_paren: ts.pop().unwrap(),
4190 list_members: ts.pop().unwrap(),
4191 list_left_paren: ts.pop().unwrap(),
4192 list_keyword: ts.pop().unwrap(),
4194 })),
4195 (SyntaxKind::CollectionLiteralExpression, 4) => SyntaxVariant::CollectionLiteralExpression(Box::new(CollectionLiteralExpressionChildren {
4196 collection_literal_right_brace: ts.pop().unwrap(),
4197 collection_literal_initializers: ts.pop().unwrap(),
4198 collection_literal_left_brace: ts.pop().unwrap(),
4199 collection_literal_name: ts.pop().unwrap(),
4201 })),
4202 (SyntaxKind::ObjectCreationExpression, 2) => SyntaxVariant::ObjectCreationExpression(Box::new(ObjectCreationExpressionChildren {
4203 object_creation_object: ts.pop().unwrap(),
4204 object_creation_new_keyword: ts.pop().unwrap(),
4206 })),
4207 (SyntaxKind::ConstructorCall, 4) => SyntaxVariant::ConstructorCall(Box::new(ConstructorCallChildren {
4208 constructor_call_right_paren: ts.pop().unwrap(),
4209 constructor_call_argument_list: ts.pop().unwrap(),
4210 constructor_call_left_paren: ts.pop().unwrap(),
4211 constructor_call_type: ts.pop().unwrap(),
4213 })),
4214 (SyntaxKind::RecordCreationExpression, 4) => SyntaxVariant::RecordCreationExpression(Box::new(RecordCreationExpressionChildren {
4215 record_creation_right_bracket: ts.pop().unwrap(),
4216 record_creation_members: ts.pop().unwrap(),
4217 record_creation_left_bracket: ts.pop().unwrap(),
4218 record_creation_type: ts.pop().unwrap(),
4220 })),
4221 (SyntaxKind::DarrayIntrinsicExpression, 5) => SyntaxVariant::DarrayIntrinsicExpression(Box::new(DarrayIntrinsicExpressionChildren {
4222 darray_intrinsic_right_bracket: ts.pop().unwrap(),
4223 darray_intrinsic_members: ts.pop().unwrap(),
4224 darray_intrinsic_left_bracket: ts.pop().unwrap(),
4225 darray_intrinsic_explicit_type: ts.pop().unwrap(),
4226 darray_intrinsic_keyword: ts.pop().unwrap(),
4228 })),
4229 (SyntaxKind::DictionaryIntrinsicExpression, 5) => SyntaxVariant::DictionaryIntrinsicExpression(Box::new(DictionaryIntrinsicExpressionChildren {
4230 dictionary_intrinsic_right_bracket: ts.pop().unwrap(),
4231 dictionary_intrinsic_members: ts.pop().unwrap(),
4232 dictionary_intrinsic_left_bracket: ts.pop().unwrap(),
4233 dictionary_intrinsic_explicit_type: ts.pop().unwrap(),
4234 dictionary_intrinsic_keyword: ts.pop().unwrap(),
4236 })),
4237 (SyntaxKind::KeysetIntrinsicExpression, 5) => SyntaxVariant::KeysetIntrinsicExpression(Box::new(KeysetIntrinsicExpressionChildren {
4238 keyset_intrinsic_right_bracket: ts.pop().unwrap(),
4239 keyset_intrinsic_members: ts.pop().unwrap(),
4240 keyset_intrinsic_left_bracket: ts.pop().unwrap(),
4241 keyset_intrinsic_explicit_type: ts.pop().unwrap(),
4242 keyset_intrinsic_keyword: ts.pop().unwrap(),
4244 })),
4245 (SyntaxKind::VarrayIntrinsicExpression, 5) => SyntaxVariant::VarrayIntrinsicExpression(Box::new(VarrayIntrinsicExpressionChildren {
4246 varray_intrinsic_right_bracket: ts.pop().unwrap(),
4247 varray_intrinsic_members: ts.pop().unwrap(),
4248 varray_intrinsic_left_bracket: ts.pop().unwrap(),
4249 varray_intrinsic_explicit_type: ts.pop().unwrap(),
4250 varray_intrinsic_keyword: ts.pop().unwrap(),
4252 })),
4253 (SyntaxKind::VectorIntrinsicExpression, 5) => SyntaxVariant::VectorIntrinsicExpression(Box::new(VectorIntrinsicExpressionChildren {
4254 vector_intrinsic_right_bracket: ts.pop().unwrap(),
4255 vector_intrinsic_members: ts.pop().unwrap(),
4256 vector_intrinsic_left_bracket: ts.pop().unwrap(),
4257 vector_intrinsic_explicit_type: ts.pop().unwrap(),
4258 vector_intrinsic_keyword: ts.pop().unwrap(),
4260 })),
4261 (SyntaxKind::ElementInitializer, 3) => SyntaxVariant::ElementInitializer(Box::new(ElementInitializerChildren {
4262 element_value: ts.pop().unwrap(),
4263 element_arrow: ts.pop().unwrap(),
4264 element_key: ts.pop().unwrap(),
4266 })),
4267 (SyntaxKind::SubscriptExpression, 4) => SyntaxVariant::SubscriptExpression(Box::new(SubscriptExpressionChildren {
4268 subscript_right_bracket: ts.pop().unwrap(),
4269 subscript_index: ts.pop().unwrap(),
4270 subscript_left_bracket: ts.pop().unwrap(),
4271 subscript_receiver: ts.pop().unwrap(),
4273 })),
4274 (SyntaxKind::EmbeddedSubscriptExpression, 4) => SyntaxVariant::EmbeddedSubscriptExpression(Box::new(EmbeddedSubscriptExpressionChildren {
4275 embedded_subscript_right_bracket: ts.pop().unwrap(),
4276 embedded_subscript_index: ts.pop().unwrap(),
4277 embedded_subscript_left_bracket: ts.pop().unwrap(),
4278 embedded_subscript_receiver: ts.pop().unwrap(),
4280 })),
4281 (SyntaxKind::AwaitableCreationExpression, 3) => SyntaxVariant::AwaitableCreationExpression(Box::new(AwaitableCreationExpressionChildren {
4282 awaitable_compound_statement: ts.pop().unwrap(),
4283 awaitable_async: ts.pop().unwrap(),
4284 awaitable_attribute_spec: ts.pop().unwrap(),
4286 })),
4287 (SyntaxKind::XHPChildrenDeclaration, 3) => SyntaxVariant::XHPChildrenDeclaration(Box::new(XHPChildrenDeclarationChildren {
4288 xhp_children_semicolon: ts.pop().unwrap(),
4289 xhp_children_expression: ts.pop().unwrap(),
4290 xhp_children_keyword: ts.pop().unwrap(),
4292 })),
4293 (SyntaxKind::XHPChildrenParenthesizedList, 3) => SyntaxVariant::XHPChildrenParenthesizedList(Box::new(XHPChildrenParenthesizedListChildren {
4294 xhp_children_list_right_paren: ts.pop().unwrap(),
4295 xhp_children_list_xhp_children: ts.pop().unwrap(),
4296 xhp_children_list_left_paren: ts.pop().unwrap(),
4298 })),
4299 (SyntaxKind::XHPCategoryDeclaration, 3) => SyntaxVariant::XHPCategoryDeclaration(Box::new(XHPCategoryDeclarationChildren {
4300 xhp_category_semicolon: ts.pop().unwrap(),
4301 xhp_category_categories: ts.pop().unwrap(),
4302 xhp_category_keyword: ts.pop().unwrap(),
4304 })),
4305 (SyntaxKind::XHPEnumType, 4) => SyntaxVariant::XHPEnumType(Box::new(XHPEnumTypeChildren {
4306 xhp_enum_right_brace: ts.pop().unwrap(),
4307 xhp_enum_values: ts.pop().unwrap(),
4308 xhp_enum_left_brace: ts.pop().unwrap(),
4309 xhp_enum_keyword: ts.pop().unwrap(),
4311 })),
4312 (SyntaxKind::XHPLateinit, 2) => SyntaxVariant::XHPLateinit(Box::new(XHPLateinitChildren {
4313 xhp_lateinit_keyword: ts.pop().unwrap(),
4314 xhp_lateinit_at: ts.pop().unwrap(),
4316 })),
4317 (SyntaxKind::XHPRequired, 2) => SyntaxVariant::XHPRequired(Box::new(XHPRequiredChildren {
4318 xhp_required_keyword: ts.pop().unwrap(),
4319 xhp_required_at: ts.pop().unwrap(),
4321 })),
4322 (SyntaxKind::XHPClassAttributeDeclaration, 3) => SyntaxVariant::XHPClassAttributeDeclaration(Box::new(XHPClassAttributeDeclarationChildren {
4323 xhp_attribute_semicolon: ts.pop().unwrap(),
4324 xhp_attribute_attributes: ts.pop().unwrap(),
4325 xhp_attribute_keyword: ts.pop().unwrap(),
4327 })),
4328 (SyntaxKind::XHPClassAttribute, 4) => SyntaxVariant::XHPClassAttribute(Box::new(XHPClassAttributeChildren {
4329 xhp_attribute_decl_required: ts.pop().unwrap(),
4330 xhp_attribute_decl_initializer: ts.pop().unwrap(),
4331 xhp_attribute_decl_name: ts.pop().unwrap(),
4332 xhp_attribute_decl_type: ts.pop().unwrap(),
4334 })),
4335 (SyntaxKind::XHPSimpleClassAttribute, 1) => SyntaxVariant::XHPSimpleClassAttribute(Box::new(XHPSimpleClassAttributeChildren {
4336 xhp_simple_class_attribute_type: ts.pop().unwrap(),
4338 })),
4339 (SyntaxKind::XHPSimpleAttribute, 3) => SyntaxVariant::XHPSimpleAttribute(Box::new(XHPSimpleAttributeChildren {
4340 xhp_simple_attribute_expression: ts.pop().unwrap(),
4341 xhp_simple_attribute_equal: ts.pop().unwrap(),
4342 xhp_simple_attribute_name: ts.pop().unwrap(),
4344 })),
4345 (SyntaxKind::XHPSpreadAttribute, 4) => SyntaxVariant::XHPSpreadAttribute(Box::new(XHPSpreadAttributeChildren {
4346 xhp_spread_attribute_right_brace: ts.pop().unwrap(),
4347 xhp_spread_attribute_expression: ts.pop().unwrap(),
4348 xhp_spread_attribute_spread_operator: ts.pop().unwrap(),
4349 xhp_spread_attribute_left_brace: ts.pop().unwrap(),
4351 })),
4352 (SyntaxKind::XHPOpen, 4) => SyntaxVariant::XHPOpen(Box::new(XHPOpenChildren {
4353 xhp_open_right_angle: ts.pop().unwrap(),
4354 xhp_open_attributes: ts.pop().unwrap(),
4355 xhp_open_name: ts.pop().unwrap(),
4356 xhp_open_left_angle: ts.pop().unwrap(),
4358 })),
4359 (SyntaxKind::XHPExpression, 3) => SyntaxVariant::XHPExpression(Box::new(XHPExpressionChildren {
4360 xhp_close: ts.pop().unwrap(),
4361 xhp_body: ts.pop().unwrap(),
4362 xhp_open: ts.pop().unwrap(),
4364 })),
4365 (SyntaxKind::XHPClose, 3) => SyntaxVariant::XHPClose(Box::new(XHPCloseChildren {
4366 xhp_close_right_angle: ts.pop().unwrap(),
4367 xhp_close_name: ts.pop().unwrap(),
4368 xhp_close_left_angle: ts.pop().unwrap(),
4370 })),
4371 (SyntaxKind::TypeConstant, 3) => SyntaxVariant::TypeConstant(Box::new(TypeConstantChildren {
4372 type_constant_right_type: ts.pop().unwrap(),
4373 type_constant_separator: ts.pop().unwrap(),
4374 type_constant_left_type: ts.pop().unwrap(),
4376 })),
4377 (SyntaxKind::VectorTypeSpecifier, 5) => SyntaxVariant::VectorTypeSpecifier(Box::new(VectorTypeSpecifierChildren {
4378 vector_type_right_angle: ts.pop().unwrap(),
4379 vector_type_trailing_comma: ts.pop().unwrap(),
4380 vector_type_type: ts.pop().unwrap(),
4381 vector_type_left_angle: ts.pop().unwrap(),
4382 vector_type_keyword: ts.pop().unwrap(),
4384 })),
4385 (SyntaxKind::KeysetTypeSpecifier, 5) => SyntaxVariant::KeysetTypeSpecifier(Box::new(KeysetTypeSpecifierChildren {
4386 keyset_type_right_angle: ts.pop().unwrap(),
4387 keyset_type_trailing_comma: ts.pop().unwrap(),
4388 keyset_type_type: ts.pop().unwrap(),
4389 keyset_type_left_angle: ts.pop().unwrap(),
4390 keyset_type_keyword: ts.pop().unwrap(),
4392 })),
4393 (SyntaxKind::TupleTypeExplicitSpecifier, 4) => SyntaxVariant::TupleTypeExplicitSpecifier(Box::new(TupleTypeExplicitSpecifierChildren {
4394 tuple_type_right_angle: ts.pop().unwrap(),
4395 tuple_type_types: ts.pop().unwrap(),
4396 tuple_type_left_angle: ts.pop().unwrap(),
4397 tuple_type_keyword: ts.pop().unwrap(),
4399 })),
4400 (SyntaxKind::VarrayTypeSpecifier, 5) => SyntaxVariant::VarrayTypeSpecifier(Box::new(VarrayTypeSpecifierChildren {
4401 varray_right_angle: ts.pop().unwrap(),
4402 varray_trailing_comma: ts.pop().unwrap(),
4403 varray_type: ts.pop().unwrap(),
4404 varray_left_angle: ts.pop().unwrap(),
4405 varray_keyword: ts.pop().unwrap(),
4407 })),
4408 (SyntaxKind::FunctionCtxTypeSpecifier, 2) => SyntaxVariant::FunctionCtxTypeSpecifier(Box::new(FunctionCtxTypeSpecifierChildren {
4409 function_ctx_type_variable: ts.pop().unwrap(),
4410 function_ctx_type_keyword: ts.pop().unwrap(),
4412 })),
4413 (SyntaxKind::TypeParameter, 6) => SyntaxVariant::TypeParameter(Box::new(TypeParameterChildren {
4414 type_constraints: ts.pop().unwrap(),
4415 type_param_params: ts.pop().unwrap(),
4416 type_name: ts.pop().unwrap(),
4417 type_variance: ts.pop().unwrap(),
4418 type_reified: ts.pop().unwrap(),
4419 type_attribute_spec: ts.pop().unwrap(),
4421 })),
4422 (SyntaxKind::TypeConstraint, 2) => SyntaxVariant::TypeConstraint(Box::new(TypeConstraintChildren {
4423 constraint_type: ts.pop().unwrap(),
4424 constraint_keyword: ts.pop().unwrap(),
4426 })),
4427 (SyntaxKind::ContextConstraint, 2) => SyntaxVariant::ContextConstraint(Box::new(ContextConstraintChildren {
4428 ctx_constraint_ctx_list: ts.pop().unwrap(),
4429 ctx_constraint_keyword: ts.pop().unwrap(),
4431 })),
4432 (SyntaxKind::DarrayTypeSpecifier, 7) => SyntaxVariant::DarrayTypeSpecifier(Box::new(DarrayTypeSpecifierChildren {
4433 darray_right_angle: ts.pop().unwrap(),
4434 darray_trailing_comma: ts.pop().unwrap(),
4435 darray_value: ts.pop().unwrap(),
4436 darray_comma: ts.pop().unwrap(),
4437 darray_key: ts.pop().unwrap(),
4438 darray_left_angle: ts.pop().unwrap(),
4439 darray_keyword: ts.pop().unwrap(),
4441 })),
4442 (SyntaxKind::DictionaryTypeSpecifier, 4) => SyntaxVariant::DictionaryTypeSpecifier(Box::new(DictionaryTypeSpecifierChildren {
4443 dictionary_type_right_angle: ts.pop().unwrap(),
4444 dictionary_type_members: ts.pop().unwrap(),
4445 dictionary_type_left_angle: ts.pop().unwrap(),
4446 dictionary_type_keyword: ts.pop().unwrap(),
4448 })),
4449 (SyntaxKind::ClosureTypeSpecifier, 9) => SyntaxVariant::ClosureTypeSpecifier(Box::new(ClosureTypeSpecifierChildren {
4450 closure_outer_right_paren: ts.pop().unwrap(),
4451 closure_return_type: ts.pop().unwrap(),
4452 closure_colon: ts.pop().unwrap(),
4453 closure_contexts: ts.pop().unwrap(),
4454 closure_inner_right_paren: ts.pop().unwrap(),
4455 closure_parameter_list: ts.pop().unwrap(),
4456 closure_inner_left_paren: ts.pop().unwrap(),
4457 closure_function_keyword: ts.pop().unwrap(),
4458 closure_outer_left_paren: ts.pop().unwrap(),
4460 })),
4461 (SyntaxKind::ClosureParameterTypeSpecifier, 2) => SyntaxVariant::ClosureParameterTypeSpecifier(Box::new(ClosureParameterTypeSpecifierChildren {
4462 closure_parameter_type: ts.pop().unwrap(),
4463 closure_parameter_call_convention: ts.pop().unwrap(),
4465 })),
4466 (SyntaxKind::ClassnameTypeSpecifier, 5) => SyntaxVariant::ClassnameTypeSpecifier(Box::new(ClassnameTypeSpecifierChildren {
4467 classname_right_angle: ts.pop().unwrap(),
4468 classname_trailing_comma: ts.pop().unwrap(),
4469 classname_type: ts.pop().unwrap(),
4470 classname_left_angle: ts.pop().unwrap(),
4471 classname_keyword: ts.pop().unwrap(),
4473 })),
4474 (SyntaxKind::FieldSpecifier, 4) => SyntaxVariant::FieldSpecifier(Box::new(FieldSpecifierChildren {
4475 field_type: ts.pop().unwrap(),
4476 field_arrow: ts.pop().unwrap(),
4477 field_name: ts.pop().unwrap(),
4478 field_question: ts.pop().unwrap(),
4480 })),
4481 (SyntaxKind::FieldInitializer, 3) => SyntaxVariant::FieldInitializer(Box::new(FieldInitializerChildren {
4482 field_initializer_value: ts.pop().unwrap(),
4483 field_initializer_arrow: ts.pop().unwrap(),
4484 field_initializer_name: ts.pop().unwrap(),
4486 })),
4487 (SyntaxKind::ShapeTypeSpecifier, 5) => SyntaxVariant::ShapeTypeSpecifier(Box::new(ShapeTypeSpecifierChildren {
4488 shape_type_right_paren: ts.pop().unwrap(),
4489 shape_type_ellipsis: ts.pop().unwrap(),
4490 shape_type_fields: ts.pop().unwrap(),
4491 shape_type_left_paren: ts.pop().unwrap(),
4492 shape_type_keyword: ts.pop().unwrap(),
4494 })),
4495 (SyntaxKind::ShapeExpression, 4) => SyntaxVariant::ShapeExpression(Box::new(ShapeExpressionChildren {
4496 shape_expression_right_paren: ts.pop().unwrap(),
4497 shape_expression_fields: ts.pop().unwrap(),
4498 shape_expression_left_paren: ts.pop().unwrap(),
4499 shape_expression_keyword: ts.pop().unwrap(),
4501 })),
4502 (SyntaxKind::TupleExpression, 4) => SyntaxVariant::TupleExpression(Box::new(TupleExpressionChildren {
4503 tuple_expression_right_paren: ts.pop().unwrap(),
4504 tuple_expression_items: ts.pop().unwrap(),
4505 tuple_expression_left_paren: ts.pop().unwrap(),
4506 tuple_expression_keyword: ts.pop().unwrap(),
4508 })),
4509 (SyntaxKind::GenericTypeSpecifier, 2) => SyntaxVariant::GenericTypeSpecifier(Box::new(GenericTypeSpecifierChildren {
4510 generic_argument_list: ts.pop().unwrap(),
4511 generic_class_type: ts.pop().unwrap(),
4513 })),
4514 (SyntaxKind::NullableTypeSpecifier, 2) => SyntaxVariant::NullableTypeSpecifier(Box::new(NullableTypeSpecifierChildren {
4515 nullable_type: ts.pop().unwrap(),
4516 nullable_question: ts.pop().unwrap(),
4518 })),
4519 (SyntaxKind::LikeTypeSpecifier, 2) => SyntaxVariant::LikeTypeSpecifier(Box::new(LikeTypeSpecifierChildren {
4520 like_type: ts.pop().unwrap(),
4521 like_tilde: ts.pop().unwrap(),
4523 })),
4524 (SyntaxKind::SoftTypeSpecifier, 2) => SyntaxVariant::SoftTypeSpecifier(Box::new(SoftTypeSpecifierChildren {
4525 soft_type: ts.pop().unwrap(),
4526 soft_at: ts.pop().unwrap(),
4528 })),
4529 (SyntaxKind::AttributizedSpecifier, 2) => SyntaxVariant::AttributizedSpecifier(Box::new(AttributizedSpecifierChildren {
4530 attributized_specifier_type: ts.pop().unwrap(),
4531 attributized_specifier_attribute_spec: ts.pop().unwrap(),
4533 })),
4534 (SyntaxKind::ReifiedTypeArgument, 2) => SyntaxVariant::ReifiedTypeArgument(Box::new(ReifiedTypeArgumentChildren {
4535 reified_type_argument_type: ts.pop().unwrap(),
4536 reified_type_argument_reified: ts.pop().unwrap(),
4538 })),
4539 (SyntaxKind::TypeArguments, 3) => SyntaxVariant::TypeArguments(Box::new(TypeArgumentsChildren {
4540 type_arguments_right_angle: ts.pop().unwrap(),
4541 type_arguments_types: ts.pop().unwrap(),
4542 type_arguments_left_angle: ts.pop().unwrap(),
4544 })),
4545 (SyntaxKind::TypeParameters, 3) => SyntaxVariant::TypeParameters(Box::new(TypeParametersChildren {
4546 type_parameters_right_angle: ts.pop().unwrap(),
4547 type_parameters_parameters: ts.pop().unwrap(),
4548 type_parameters_left_angle: ts.pop().unwrap(),
4550 })),
4551 (SyntaxKind::TupleTypeSpecifier, 3) => SyntaxVariant::TupleTypeSpecifier(Box::new(TupleTypeSpecifierChildren {
4552 tuple_right_paren: ts.pop().unwrap(),
4553 tuple_types: ts.pop().unwrap(),
4554 tuple_left_paren: ts.pop().unwrap(),
4556 })),
4557 (SyntaxKind::UnionTypeSpecifier, 3) => SyntaxVariant::UnionTypeSpecifier(Box::new(UnionTypeSpecifierChildren {
4558 union_right_paren: ts.pop().unwrap(),
4559 union_types: ts.pop().unwrap(),
4560 union_left_paren: ts.pop().unwrap(),
4562 })),
4563 (SyntaxKind::IntersectionTypeSpecifier, 3) => SyntaxVariant::IntersectionTypeSpecifier(Box::new(IntersectionTypeSpecifierChildren {
4564 intersection_right_paren: ts.pop().unwrap(),
4565 intersection_types: ts.pop().unwrap(),
4566 intersection_left_paren: ts.pop().unwrap(),
4568 })),
4569 (SyntaxKind::ErrorSyntax, 1) => SyntaxVariant::ErrorSyntax(Box::new(ErrorSyntaxChildren {
4570 error_error: ts.pop().unwrap(),
4572 })),
4573 (SyntaxKind::ListItem, 2) => SyntaxVariant::ListItem(Box::new(ListItemChildren {
4574 list_separator: ts.pop().unwrap(),
4575 list_item: ts.pop().unwrap(),
4577 })),
4578 (SyntaxKind::EnumAtomExpression, 2) => SyntaxVariant::EnumAtomExpression(Box::new(EnumAtomExpressionChildren {
4579 enum_atom_expression: ts.pop().unwrap(),
4580 enum_atom_hash: ts.pop().unwrap(),
4582 })),
4583 _ => panic!("from_children called with wrong number of children"),
4584 }
4585 }
4586 }
4588 #[derive(Debug, Clone)]
4589 pub struct EndOfFileChildren<T, V> {
4590 pub end_of_file_token: Syntax<T, V>,
4591 }
4593 #[derive(Debug, Clone)]
4594 pub struct ScriptChildren<T, V> {
4595 pub script_declarations: Syntax<T, V>,
4596 }
4598 #[derive(Debug, Clone)]
4599 pub struct QualifiedNameChildren<T, V> {
4600 pub qualified_name_parts: Syntax<T, V>,
4601 }
4603 #[derive(Debug, Clone)]
4604 pub struct SimpleTypeSpecifierChildren<T, V> {
4605 pub simple_type_specifier: Syntax<T, V>,
4606 }
4608 #[derive(Debug, Clone)]
4609 pub struct LiteralExpressionChildren<T, V> {
4610 pub literal_expression: Syntax<T, V>,
4611 }
4613 #[derive(Debug, Clone)]
4614 pub struct PrefixedStringExpressionChildren<T, V> {
4615 pub prefixed_string_name: Syntax<T, V>,
4616 pub prefixed_string_str: Syntax<T, V>,
4617 }
4619 #[derive(Debug, Clone)]
4620 pub struct PrefixedCodeExpressionChildren<T, V> {
4621 pub prefixed_code_prefix: Syntax<T, V>,
4622 pub prefixed_code_left_backtick: Syntax<T, V>,
4623 pub prefixed_code_expression: Syntax<T, V>,
4624 pub prefixed_code_right_backtick: Syntax<T, V>,
4625 }
4627 #[derive(Debug, Clone)]
4628 pub struct VariableExpressionChildren<T, V> {
4629 pub variable_expression: Syntax<T, V>,
4630 }
4632 #[derive(Debug, Clone)]
4633 pub struct PipeVariableExpressionChildren<T, V> {
4634 pub pipe_variable_expression: Syntax<T, V>,
4635 }
4637 #[derive(Debug, Clone)]
4638 pub struct FileAttributeSpecificationChildren<T, V> {
4639 pub file_attribute_specification_left_double_angle: Syntax<T, V>,
4640 pub file_attribute_specification_keyword: Syntax<T, V>,
4641 pub file_attribute_specification_colon: Syntax<T, V>,
4642 pub file_attribute_specification_attributes: Syntax<T, V>,
4643 pub file_attribute_specification_right_double_angle: Syntax<T, V>,
4644 }
4646 #[derive(Debug, Clone)]
4647 pub struct EnumDeclarationChildren<T, V> {
4648 pub enum_attribute_spec: Syntax<T, V>,
4649 pub enum_keyword: Syntax<T, V>,
4650 pub enum_name: Syntax<T, V>,
4651 pub enum_colon: Syntax<T, V>,
4652 pub enum_base: Syntax<T, V>,
4653 pub enum_type: Syntax<T, V>,
4654 pub enum_left_brace: Syntax<T, V>,
4655 pub enum_use_clauses: Syntax<T, V>,
4656 pub enum_enumerators: Syntax<T, V>,
4657 pub enum_right_brace: Syntax<T, V>,
4658 }
4660 #[derive(Debug, Clone)]
4661 pub struct EnumUseChildren<T, V> {
4662 pub enum_use_keyword: Syntax<T, V>,
4663 pub enum_use_names: Syntax<T, V>,
4664 pub enum_use_semicolon: Syntax<T, V>,
4665 }
4667 #[derive(Debug, Clone)]
4668 pub struct EnumeratorChildren<T, V> {
4669 pub enumerator_name: Syntax<T, V>,
4670 pub enumerator_equal: Syntax<T, V>,
4671 pub enumerator_value: Syntax<T, V>,
4672 pub enumerator_semicolon: Syntax<T, V>,
4673 }
4675 #[derive(Debug, Clone)]
4676 pub struct EnumClassDeclarationChildren<T, V> {
4677 pub enum_class_attribute_spec: Syntax<T, V>,
4678 pub enum_class_enum_keyword: Syntax<T, V>,
4679 pub enum_class_class_keyword: Syntax<T, V>,
4680 pub enum_class_name: Syntax<T, V>,
4681 pub enum_class_colon: Syntax<T, V>,
4682 pub enum_class_base: Syntax<T, V>,
4683 pub enum_class_extends: Syntax<T, V>,
4684 pub enum_class_extends_list: Syntax<T, V>,
4685 pub enum_class_left_brace: Syntax<T, V>,
4686 pub enum_class_elements: Syntax<T, V>,
4687 pub enum_class_right_brace: Syntax<T, V>,
4688 }
4690 #[derive(Debug, Clone)]
4691 pub struct EnumClassEnumeratorChildren<T, V> {
4692 pub enum_class_enumerator_type: Syntax<T, V>,
4693 pub enum_class_enumerator_name: Syntax<T, V>,
4694 pub enum_class_enumerator_equal: Syntax<T, V>,
4695 pub enum_class_enumerator_initial_value: Syntax<T, V>,
4696 pub enum_class_enumerator_semicolon: Syntax<T, V>,
4697 }
4699 #[derive(Debug, Clone)]
4700 pub struct RecordDeclarationChildren<T, V> {
4701 pub record_attribute_spec: Syntax<T, V>,
4702 pub record_modifier: Syntax<T, V>,
4703 pub record_keyword: Syntax<T, V>,
4704 pub record_name: Syntax<T, V>,
4705 pub record_extends_keyword: Syntax<T, V>,
4706 pub record_extends_opt: Syntax<T, V>,
4707 pub record_left_brace: Syntax<T, V>,
4708 pub record_fields: Syntax<T, V>,
4709 pub record_right_brace: Syntax<T, V>,
4710 }
4712 #[derive(Debug, Clone)]
4713 pub struct RecordFieldChildren<T, V> {
4714 pub record_field_type: Syntax<T, V>,
4715 pub record_field_name: Syntax<T, V>,
4716 pub record_field_init: Syntax<T, V>,
4717 pub record_field_semi: Syntax<T, V>,
4718 }
4720 #[derive(Debug, Clone)]
4721 pub struct AliasDeclarationChildren<T, V> {
4722 pub alias_attribute_spec: Syntax<T, V>,
4723 pub alias_keyword: Syntax<T, V>,
4724 pub alias_name: Syntax<T, V>,
4725 pub alias_generic_parameter: Syntax<T, V>,
4726 pub alias_constraint: Syntax<T, V>,
4727 pub alias_equal: Syntax<T, V>,
4728 pub alias_type: Syntax<T, V>,
4729 pub alias_semicolon: Syntax<T, V>,
4730 }
4732 #[derive(Debug, Clone)]
4733 pub struct PropertyDeclarationChildren<T, V> {
4734 pub property_attribute_spec: Syntax<T, V>,
4735 pub property_modifiers: Syntax<T, V>,
4736 pub property_type: Syntax<T, V>,
4737 pub property_declarators: Syntax<T, V>,
4738 pub property_semicolon: Syntax<T, V>,
4739 }
4741 #[derive(Debug, Clone)]
4742 pub struct PropertyDeclaratorChildren<T, V> {
4743 pub property_name: Syntax<T, V>,
4744 pub property_initializer: Syntax<T, V>,
4745 }
4747 #[derive(Debug, Clone)]
4748 pub struct NamespaceDeclarationChildren<T, V> {
4749 pub namespace_header: Syntax<T, V>,
4750 pub namespace_body: Syntax<T, V>,
4751 }
4753 #[derive(Debug, Clone)]
4754 pub struct NamespaceDeclarationHeaderChildren<T, V> {
4755 pub namespace_keyword: Syntax<T, V>,
4756 pub namespace_name: Syntax<T, V>,
4757 }
4759 #[derive(Debug, Clone)]
4760 pub struct NamespaceBodyChildren<T, V> {
4761 pub namespace_left_brace: Syntax<T, V>,
4762 pub namespace_declarations: Syntax<T, V>,
4763 pub namespace_right_brace: Syntax<T, V>,
4764 }
4766 #[derive(Debug, Clone)]
4767 pub struct NamespaceEmptyBodyChildren<T, V> {
4768 pub namespace_semicolon: Syntax<T, V>,
4769 }
4771 #[derive(Debug, Clone)]
4772 pub struct NamespaceUseDeclarationChildren<T, V> {
4773 pub namespace_use_keyword: Syntax<T, V>,
4774 pub namespace_use_kind: Syntax<T, V>,
4775 pub namespace_use_clauses: Syntax<T, V>,
4776 pub namespace_use_semicolon: Syntax<T, V>,
4777 }
4779 #[derive(Debug, Clone)]
4780 pub struct NamespaceGroupUseDeclarationChildren<T, V> {
4781 pub namespace_group_use_keyword: Syntax<T, V>,
4782 pub namespace_group_use_kind: Syntax<T, V>,
4783 pub namespace_group_use_prefix: Syntax<T, V>,
4784 pub namespace_group_use_left_brace: Syntax<T, V>,
4785 pub namespace_group_use_clauses: Syntax<T, V>,
4786 pub namespace_group_use_right_brace: Syntax<T, V>,
4787 pub namespace_group_use_semicolon: Syntax<T, V>,
4788 }
4790 #[derive(Debug, Clone)]
4791 pub struct NamespaceUseClauseChildren<T, V> {
4792 pub namespace_use_clause_kind: Syntax<T, V>,
4793 pub namespace_use_name: Syntax<T, V>,
4794 pub namespace_use_as: Syntax<T, V>,
4795 pub namespace_use_alias: Syntax<T, V>,
4796 }
4798 #[derive(Debug, Clone)]
4799 pub struct FunctionDeclarationChildren<T, V> {
4800 pub function_attribute_spec: Syntax<T, V>,
4801 pub function_declaration_header: Syntax<T, V>,
4802 pub function_body: Syntax<T, V>,
4803 }
4805 #[derive(Debug, Clone)]
4806 pub struct FunctionDeclarationHeaderChildren<T, V> {
4807 pub function_modifiers: Syntax<T, V>,
4808 pub function_keyword: Syntax<T, V>,
4809 pub function_name: Syntax<T, V>,
4810 pub function_type_parameter_list: Syntax<T, V>,
4811 pub function_left_paren: Syntax<T, V>,
4812 pub function_parameter_list: Syntax<T, V>,
4813 pub function_right_paren: Syntax<T, V>,
4814 pub function_contexts: Syntax<T, V>,
4815 pub function_colon: Syntax<T, V>,
4816 pub function_type: Syntax<T, V>,
4817 pub function_where_clause: Syntax<T, V>,
4818 }
4820 #[derive(Debug, Clone)]
4821 pub struct ContextsChildren<T, V> {
4822 pub contexts_left_bracket: Syntax<T, V>,
4823 pub contexts_types: Syntax<T, V>,
4824 pub contexts_right_bracket: Syntax<T, V>,
4825 }
4827 #[derive(Debug, Clone)]
4828 pub struct WhereClauseChildren<T, V> {
4829 pub where_clause_keyword: Syntax<T, V>,
4830 pub where_clause_constraints: Syntax<T, V>,
4831 }
4833 #[derive(Debug, Clone)]
4834 pub struct WhereConstraintChildren<T, V> {
4835 pub where_constraint_left_type: Syntax<T, V>,
4836 pub where_constraint_operator: Syntax<T, V>,
4837 pub where_constraint_right_type: Syntax<T, V>,
4838 }
4840 #[derive(Debug, Clone)]
4841 pub struct MethodishDeclarationChildren<T, V> {
4842 pub methodish_attribute: Syntax<T, V>,
4843 pub methodish_function_decl_header: Syntax<T, V>,
4844 pub methodish_function_body: Syntax<T, V>,
4845 pub methodish_semicolon: Syntax<T, V>,
4846 }
4848 #[derive(Debug, Clone)]
4849 pub struct MethodishTraitResolutionChildren<T, V> {
4850 pub methodish_trait_attribute: Syntax<T, V>,
4851 pub methodish_trait_function_decl_header: Syntax<T, V>,
4852 pub methodish_trait_equal: Syntax<T, V>,
4853 pub methodish_trait_name: Syntax<T, V>,
4854 pub methodish_trait_semicolon: Syntax<T, V>,
4855 }
4857 #[derive(Debug, Clone)]
4858 pub struct ClassishDeclarationChildren<T, V> {
4859 pub classish_attribute: Syntax<T, V>,
4860 pub classish_modifiers: Syntax<T, V>,
4861 pub classish_xhp: Syntax<T, V>,
4862 pub classish_keyword: Syntax<T, V>,
4863 pub classish_name: Syntax<T, V>,
4864 pub classish_type_parameters: Syntax<T, V>,
4865 pub classish_extends_keyword: Syntax<T, V>,
4866 pub classish_extends_list: Syntax<T, V>,
4867 pub classish_implements_keyword: Syntax<T, V>,
4868 pub classish_implements_list: Syntax<T, V>,
4869 pub classish_where_clause: Syntax<T, V>,
4870 pub classish_body: Syntax<T, V>,
4871 }
4873 #[derive(Debug, Clone)]
4874 pub struct ClassishBodyChildren<T, V> {
4875 pub classish_body_left_brace: Syntax<T, V>,
4876 pub classish_body_elements: Syntax<T, V>,
4877 pub classish_body_right_brace: Syntax<T, V>,
4878 }
4880 #[derive(Debug, Clone)]
4881 pub struct TraitUsePrecedenceItemChildren<T, V> {
4882 pub trait_use_precedence_item_name: Syntax<T, V>,
4883 pub trait_use_precedence_item_keyword: Syntax<T, V>,
4884 pub trait_use_precedence_item_removed_names: Syntax<T, V>,
4885 }
4887 #[derive(Debug, Clone)]
4888 pub struct TraitUseAliasItemChildren<T, V> {
4889 pub trait_use_alias_item_aliasing_name: Syntax<T, V>,
4890 pub trait_use_alias_item_keyword: Syntax<T, V>,
4891 pub trait_use_alias_item_modifiers: Syntax<T, V>,
4892 pub trait_use_alias_item_aliased_name: Syntax<T, V>,
4893 }
4895 #[derive(Debug, Clone)]
4896 pub struct TraitUseConflictResolutionChildren<T, V> {
4897 pub trait_use_conflict_resolution_keyword: Syntax<T, V>,
4898 pub trait_use_conflict_resolution_names: Syntax<T, V>,
4899 pub trait_use_conflict_resolution_left_brace: Syntax<T, V>,
4900 pub trait_use_conflict_resolution_clauses: Syntax<T, V>,
4901 pub trait_use_conflict_resolution_right_brace: Syntax<T, V>,
4902 }
4904 #[derive(Debug, Clone)]
4905 pub struct TraitUseChildren<T, V> {
4906 pub trait_use_keyword: Syntax<T, V>,
4907 pub trait_use_names: Syntax<T, V>,
4908 pub trait_use_semicolon: Syntax<T, V>,
4909 }
4911 #[derive(Debug, Clone)]
4912 pub struct RequireClauseChildren<T, V> {
4913 pub require_keyword: Syntax<T, V>,
4914 pub require_kind: Syntax<T, V>,
4915 pub require_name: Syntax<T, V>,
4916 pub require_semicolon: Syntax<T, V>,
4917 }
4919 #[derive(Debug, Clone)]
4920 pub struct ConstDeclarationChildren<T, V> {
4921 pub const_modifiers: Syntax<T, V>,
4922 pub const_keyword: Syntax<T, V>,
4923 pub const_type_specifier: Syntax<T, V>,
4924 pub const_declarators: Syntax<T, V>,
4925 pub const_semicolon: Syntax<T, V>,
4926 }
4928 #[derive(Debug, Clone)]
4929 pub struct ConstantDeclaratorChildren<T, V> {
4930 pub constant_declarator_name: Syntax<T, V>,
4931 pub constant_declarator_initializer: Syntax<T, V>,
4932 }
4934 #[derive(Debug, Clone)]
4935 pub struct TypeConstDeclarationChildren<T, V> {
4936 pub type_const_attribute_spec: Syntax<T, V>,
4937 pub type_const_modifiers: Syntax<T, V>,
4938 pub type_const_keyword: Syntax<T, V>,
4939 pub type_const_type_keyword: Syntax<T, V>,
4940 pub type_const_name: Syntax<T, V>,
4941 pub type_const_type_parameters: Syntax<T, V>,
4942 pub type_const_type_constraint: Syntax<T, V>,
4943 pub type_const_equal: Syntax<T, V>,
4944 pub type_const_type_specifier: Syntax<T, V>,
4945 pub type_const_semicolon: Syntax<T, V>,
4946 }
4948 #[derive(Debug, Clone)]
4949 pub struct ContextConstDeclarationChildren<T, V> {
4950 pub context_const_modifiers: Syntax<T, V>,
4951 pub context_const_const_keyword: Syntax<T, V>,
4952 pub context_const_ctx_keyword: Syntax<T, V>,
4953 pub context_const_name: Syntax<T, V>,
4954 pub context_const_type_parameters: Syntax<T, V>,
4955 pub context_const_constraint: Syntax<T, V>,
4956 pub context_const_equal: Syntax<T, V>,
4957 pub context_const_ctx_list: Syntax<T, V>,
4958 pub context_const_semicolon: Syntax<T, V>,
4959 }
4961 #[derive(Debug, Clone)]
4962 pub struct DecoratedExpressionChildren<T, V> {
4963 pub decorated_expression_decorator: Syntax<T, V>,
4964 pub decorated_expression_expression: Syntax<T, V>,
4965 }
4967 #[derive(Debug, Clone)]
4968 pub struct ParameterDeclarationChildren<T, V> {
4969 pub parameter_attribute: Syntax<T, V>,
4970 pub parameter_visibility: Syntax<T, V>,
4971 pub parameter_call_convention: Syntax<T, V>,
4972 pub parameter_type: Syntax<T, V>,
4973 pub parameter_name: Syntax<T, V>,
4974 pub parameter_default_value: Syntax<T, V>,
4975 }
4977 #[derive(Debug, Clone)]
4978 pub struct VariadicParameterChildren<T, V> {
4979 pub variadic_parameter_call_convention: Syntax<T, V>,
4980 pub variadic_parameter_type: Syntax<T, V>,
4981 pub variadic_parameter_ellipsis: Syntax<T, V>,
4982 }
4984 #[derive(Debug, Clone)]
4985 pub struct OldAttributeSpecificationChildren<T, V> {
4986 pub old_attribute_specification_left_double_angle: Syntax<T, V>,
4987 pub old_attribute_specification_attributes: Syntax<T, V>,
4988 pub old_attribute_specification_right_double_angle: Syntax<T, V>,
4989 }
4991 #[derive(Debug, Clone)]
4992 pub struct AttributeSpecificationChildren<T, V> {
4993 pub attribute_specification_attributes: Syntax<T, V>,
4994 }
4996 #[derive(Debug, Clone)]
4997 pub struct AttributeChildren<T, V> {
4998 pub attribute_at: Syntax<T, V>,
4999 pub attribute_attribute_name: Syntax<T, V>,
5000 }
5002 #[derive(Debug, Clone)]
5003 pub struct InclusionExpressionChildren<T, V> {
5004 pub inclusion_require: Syntax<T, V>,
5005 pub inclusion_filename: Syntax<T, V>,
5006 }
5008 #[derive(Debug, Clone)]
5009 pub struct InclusionDirectiveChildren<T, V> {
5010 pub inclusion_expression: Syntax<T, V>,
5011 pub inclusion_semicolon: Syntax<T, V>,
5012 }
5014 #[derive(Debug, Clone)]
5015 pub struct CompoundStatementChildren<T, V> {
5016 pub compound_left_brace: Syntax<T, V>,
5017 pub compound_statements: Syntax<T, V>,
5018 pub compound_right_brace: Syntax<T, V>,
5019 }
5021 #[derive(Debug, Clone)]
5022 pub struct ExpressionStatementChildren<T, V> {
5023 pub expression_statement_expression: Syntax<T, V>,
5024 pub expression_statement_semicolon: Syntax<T, V>,
5025 }
5027 #[derive(Debug, Clone)]
5028 pub struct MarkupSectionChildren<T, V> {
5029 pub markup_hashbang: Syntax<T, V>,
5030 pub markup_suffix: Syntax<T, V>,
5031 }
5033 #[derive(Debug, Clone)]
5034 pub struct MarkupSuffixChildren<T, V> {
5035 pub markup_suffix_less_than_question: Syntax<T, V>,
5036 pub markup_suffix_name: Syntax<T, V>,
5037 }
5039 #[derive(Debug, Clone)]
5040 pub struct UnsetStatementChildren<T, V> {
5041 pub unset_keyword: Syntax<T, V>,
5042 pub unset_left_paren: Syntax<T, V>,
5043 pub unset_variables: Syntax<T, V>,
5044 pub unset_right_paren: Syntax<T, V>,
5045 pub unset_semicolon: Syntax<T, V>,
5046 }
5048 #[derive(Debug, Clone)]
5049 pub struct UsingStatementBlockScopedChildren<T, V> {
5050 pub using_block_await_keyword: Syntax<T, V>,
5051 pub using_block_using_keyword: Syntax<T, V>,
5052 pub using_block_left_paren: Syntax<T, V>,
5053 pub using_block_expressions: Syntax<T, V>,
5054 pub using_block_right_paren: Syntax<T, V>,
5055 pub using_block_body: Syntax<T, V>,
5056 }
5058 #[derive(Debug, Clone)]
5059 pub struct UsingStatementFunctionScopedChildren<T, V> {
5060 pub using_function_await_keyword: Syntax<T, V>,
5061 pub using_function_using_keyword: Syntax<T, V>,
5062 pub using_function_expression: Syntax<T, V>,
5063 pub using_function_semicolon: Syntax<T, V>,
5064 }
5066 #[derive(Debug, Clone)]
5067 pub struct WhileStatementChildren<T, V> {
5068 pub while_keyword: Syntax<T, V>,
5069 pub while_left_paren: Syntax<T, V>,
5070 pub while_condition: Syntax<T, V>,
5071 pub while_right_paren: Syntax<T, V>,
5072 pub while_body: Syntax<T, V>,
5073 }
5075 #[derive(Debug, Clone)]
5076 pub struct IfStatementChildren<T, V> {
5077 pub if_keyword: Syntax<T, V>,
5078 pub if_left_paren: Syntax<T, V>,
5079 pub if_condition: Syntax<T, V>,
5080 pub if_right_paren: Syntax<T, V>,
5081 pub if_statement: Syntax<T, V>,
5082 pub if_elseif_clauses: Syntax<T, V>,
5083 pub if_else_clause: Syntax<T, V>,
5084 }
5086 #[derive(Debug, Clone)]
5087 pub struct ElseifClauseChildren<T, V> {
5088 pub elseif_keyword: Syntax<T, V>,
5089 pub elseif_left_paren: Syntax<T, V>,
5090 pub elseif_condition: Syntax<T, V>,
5091 pub elseif_right_paren: Syntax<T, V>,
5092 pub elseif_statement: Syntax<T, V>,
5093 }
5095 #[derive(Debug, Clone)]
5096 pub struct ElseClauseChildren<T, V> {
5097 pub else_keyword: Syntax<T, V>,
5098 pub else_statement: Syntax<T, V>,
5099 }
5101 #[derive(Debug, Clone)]
5102 pub struct TryStatementChildren<T, V> {
5103 pub try_keyword: Syntax<T, V>,
5104 pub try_compound_statement: Syntax<T, V>,
5105 pub try_catch_clauses: Syntax<T, V>,
5106 pub try_finally_clause: Syntax<T, V>,
5107 }
5109 #[derive(Debug, Clone)]
5110 pub struct CatchClauseChildren<T, V> {
5111 pub catch_keyword: Syntax<T, V>,
5112 pub catch_left_paren: Syntax<T, V>,
5113 pub catch_type: Syntax<T, V>,
5114 pub catch_variable: Syntax<T, V>,
5115 pub catch_right_paren: Syntax<T, V>,
5116 pub catch_body: Syntax<T, V>,
5117 }
5119 #[derive(Debug, Clone)]
5120 pub struct FinallyClauseChildren<T, V> {
5121 pub finally_keyword: Syntax<T, V>,
5122 pub finally_body: Syntax<T, V>,
5123 }
5125 #[derive(Debug, Clone)]
5126 pub struct DoStatementChildren<T, V> {
5127 pub do_keyword: Syntax<T, V>,
5128 pub do_body: Syntax<T, V>,
5129 pub do_while_keyword: Syntax<T, V>,
5130 pub do_left_paren: Syntax<T, V>,
5131 pub do_condition: Syntax<T, V>,
5132 pub do_right_paren: Syntax<T, V>,
5133 pub do_semicolon: Syntax<T, V>,
5134 }
5136 #[derive(Debug, Clone)]
5137 pub struct ForStatementChildren<T, V> {
5138 pub for_keyword: Syntax<T, V>,
5139 pub for_left_paren: Syntax<T, V>,
5140 pub for_initializer: Syntax<T, V>,
5141 pub for_first_semicolon: Syntax<T, V>,
5142 pub for_control: Syntax<T, V>,
5143 pub for_second_semicolon: Syntax<T, V>,
5144 pub for_end_of_loop: Syntax<T, V>,
5145 pub for_right_paren: Syntax<T, V>,
5146 pub for_body: Syntax<T, V>,
5147 }
5149 #[derive(Debug, Clone)]
5150 pub struct ForeachStatementChildren<T, V> {
5151 pub foreach_keyword: Syntax<T, V>,
5152 pub foreach_left_paren: Syntax<T, V>,
5153 pub foreach_collection: Syntax<T, V>,
5154 pub foreach_await_keyword: Syntax<T, V>,
5155 pub foreach_as: Syntax<T, V>,
5156 pub foreach_key: Syntax<T, V>,
5157 pub foreach_arrow: Syntax<T, V>,
5158 pub foreach_value: Syntax<T, V>,
5159 pub foreach_right_paren: Syntax<T, V>,
5160 pub foreach_body: Syntax<T, V>,
5161 }
5163 #[derive(Debug, Clone)]
5164 pub struct SwitchStatementChildren<T, V> {
5165 pub switch_keyword: Syntax<T, V>,
5166 pub switch_left_paren: Syntax<T, V>,
5167 pub switch_expression: Syntax<T, V>,
5168 pub switch_right_paren: Syntax<T, V>,
5169 pub switch_left_brace: Syntax<T, V>,
5170 pub switch_sections: Syntax<T, V>,
5171 pub switch_right_brace: Syntax<T, V>,
5172 }
5174 #[derive(Debug, Clone)]
5175 pub struct SwitchSectionChildren<T, V> {
5176 pub switch_section_labels: Syntax<T, V>,
5177 pub switch_section_statements: Syntax<T, V>,
5178 pub switch_section_fallthrough: Syntax<T, V>,
5179 }
5181 #[derive(Debug, Clone)]
5182 pub struct SwitchFallthroughChildren<T, V> {
5183 pub fallthrough_keyword: Syntax<T, V>,
5184 pub fallthrough_semicolon: Syntax<T, V>,
5185 }
5187 #[derive(Debug, Clone)]
5188 pub struct CaseLabelChildren<T, V> {
5189 pub case_keyword: Syntax<T, V>,
5190 pub case_expression: Syntax<T, V>,
5191 pub case_colon: Syntax<T, V>,
5192 }
5194 #[derive(Debug, Clone)]
5195 pub struct DefaultLabelChildren<T, V> {
5196 pub default_keyword: Syntax<T, V>,
5197 pub default_colon: Syntax<T, V>,
5198 }
5200 #[derive(Debug, Clone)]
5201 pub struct ReturnStatementChildren<T, V> {
5202 pub return_keyword: Syntax<T, V>,
5203 pub return_expression: Syntax<T, V>,
5204 pub return_semicolon: Syntax<T, V>,
5205 }
5207 #[derive(Debug, Clone)]
5208 pub struct YieldBreakStatementChildren<T, V> {
5209 pub yield_break_keyword: Syntax<T, V>,
5210 pub yield_break_break: Syntax<T, V>,
5211 pub yield_break_semicolon: Syntax<T, V>,
5212 }
5214 #[derive(Debug, Clone)]
5215 pub struct ThrowStatementChildren<T, V> {
5216 pub throw_keyword: Syntax<T, V>,
5217 pub throw_expression: Syntax<T, V>,
5218 pub throw_semicolon: Syntax<T, V>,
5219 }
5221 #[derive(Debug, Clone)]
5222 pub struct BreakStatementChildren<T, V> {
5223 pub break_keyword: Syntax<T, V>,
5224 pub break_semicolon: Syntax<T, V>,
5225 }
5227 #[derive(Debug, Clone)]
5228 pub struct ContinueStatementChildren<T, V> {
5229 pub continue_keyword: Syntax<T, V>,
5230 pub continue_semicolon: Syntax<T, V>,
5231 }
5233 #[derive(Debug, Clone)]
5234 pub struct EchoStatementChildren<T, V> {
5235 pub echo_keyword: Syntax<T, V>,
5236 pub echo_expressions: Syntax<T, V>,
5237 pub echo_semicolon: Syntax<T, V>,
5238 }
5240 #[derive(Debug, Clone)]
5241 pub struct ConcurrentStatementChildren<T, V> {
5242 pub concurrent_keyword: Syntax<T, V>,
5243 pub concurrent_statement: Syntax<T, V>,
5244 }
5246 #[derive(Debug, Clone)]
5247 pub struct SimpleInitializerChildren<T, V> {
5248 pub simple_initializer_equal: Syntax<T, V>,
5249 pub simple_initializer_value: Syntax<T, V>,
5250 }
5252 #[derive(Debug, Clone)]
5253 pub struct AnonymousClassChildren<T, V> {
5254 pub anonymous_class_class_keyword: Syntax<T, V>,
5255 pub anonymous_class_left_paren: Syntax<T, V>,
5256 pub anonymous_class_argument_list: Syntax<T, V>,
5257 pub anonymous_class_right_paren: Syntax<T, V>,
5258 pub anonymous_class_extends_keyword: Syntax<T, V>,
5259 pub anonymous_class_extends_list: Syntax<T, V>,
5260 pub anonymous_class_implements_keyword: Syntax<T, V>,
5261 pub anonymous_class_implements_list: Syntax<T, V>,
5262 pub anonymous_class_body: Syntax<T, V>,
5263 }
5265 #[derive(Debug, Clone)]
5266 pub struct AnonymousFunctionChildren<T, V> {
5267 pub anonymous_attribute_spec: Syntax<T, V>,
5268 pub anonymous_static_keyword: Syntax<T, V>,
5269 pub anonymous_async_keyword: Syntax<T, V>,
5270 pub anonymous_function_keyword: Syntax<T, V>,
5271 pub anonymous_left_paren: Syntax<T, V>,
5272 pub anonymous_parameters: Syntax<T, V>,
5273 pub anonymous_right_paren: Syntax<T, V>,
5274 pub anonymous_ctx_list: Syntax<T, V>,
5275 pub anonymous_colon: Syntax<T, V>,
5276 pub anonymous_type: Syntax<T, V>,
5277 pub anonymous_use: Syntax<T, V>,
5278 pub anonymous_body: Syntax<T, V>,
5279 }
5281 #[derive(Debug, Clone)]
5282 pub struct AnonymousFunctionUseClauseChildren<T, V> {
5283 pub anonymous_use_keyword: Syntax<T, V>,
5284 pub anonymous_use_left_paren: Syntax<T, V>,
5285 pub anonymous_use_variables: Syntax<T, V>,
5286 pub anonymous_use_right_paren: Syntax<T, V>,
5287 }
5289 #[derive(Debug, Clone)]
5290 pub struct LambdaExpressionChildren<T, V> {
5291 pub lambda_attribute_spec: Syntax<T, V>,
5292 pub lambda_async: Syntax<T, V>,
5293 pub lambda_signature: Syntax<T, V>,
5294 pub lambda_arrow: Syntax<T, V>,
5295 pub lambda_body: Syntax<T, V>,
5296 }
5298 #[derive(Debug, Clone)]
5299 pub struct LambdaSignatureChildren<T, V> {
5300 pub lambda_left_paren: Syntax<T, V>,
5301 pub lambda_parameters: Syntax<T, V>,
5302 pub lambda_right_paren: Syntax<T, V>,
5303 pub lambda_contexts: Syntax<T, V>,
5304 pub lambda_colon: Syntax<T, V>,
5305 pub lambda_type: Syntax<T, V>,
5306 }
5308 #[derive(Debug, Clone)]
5309 pub struct CastExpressionChildren<T, V> {
5310 pub cast_left_paren: Syntax<T, V>,
5311 pub cast_type: Syntax<T, V>,
5312 pub cast_right_paren: Syntax<T, V>,
5313 pub cast_operand: Syntax<T, V>,
5314 }
5316 #[derive(Debug, Clone)]
5317 pub struct ScopeResolutionExpressionChildren<T, V> {
5318 pub scope_resolution_qualifier: Syntax<T, V>,
5319 pub scope_resolution_operator: Syntax<T, V>,
5320 pub scope_resolution_name: Syntax<T, V>,
5321 }
5323 #[derive(Debug, Clone)]
5324 pub struct MemberSelectionExpressionChildren<T, V> {
5325 pub member_object: Syntax<T, V>,
5326 pub member_operator: Syntax<T, V>,
5327 pub member_name: Syntax<T, V>,
5328 }
5330 #[derive(Debug, Clone)]
5331 pub struct SafeMemberSelectionExpressionChildren<T, V> {
5332 pub safe_member_object: Syntax<T, V>,
5333 pub safe_member_operator: Syntax<T, V>,
5334 pub safe_member_name: Syntax<T, V>,
5335 }
5337 #[derive(Debug, Clone)]
5338 pub struct EmbeddedMemberSelectionExpressionChildren<T, V> {
5339 pub embedded_member_object: Syntax<T, V>,
5340 pub embedded_member_operator: Syntax<T, V>,
5341 pub embedded_member_name: Syntax<T, V>,
5342 }
5344 #[derive(Debug, Clone)]
5345 pub struct YieldExpressionChildren<T, V> {
5346 pub yield_keyword: Syntax<T, V>,
5347 pub yield_operand: Syntax<T, V>,
5348 }
5350 #[derive(Debug, Clone)]
5351 pub struct PrefixUnaryExpressionChildren<T, V> {
5352 pub prefix_unary_operator: Syntax<T, V>,
5353 pub prefix_unary_operand: Syntax<T, V>,
5354 }
5356 #[derive(Debug, Clone)]
5357 pub struct PostfixUnaryExpressionChildren<T, V> {
5358 pub postfix_unary_operand: Syntax<T, V>,
5359 pub postfix_unary_operator: Syntax<T, V>,
5360 }
5362 #[derive(Debug, Clone)]
5363 pub struct BinaryExpressionChildren<T, V> {
5364 pub binary_left_operand: Syntax<T, V>,
5365 pub binary_operator: Syntax<T, V>,
5366 pub binary_right_operand: Syntax<T, V>,
5367 }
5369 #[derive(Debug, Clone)]
5370 pub struct IsExpressionChildren<T, V> {
5371 pub is_left_operand: Syntax<T, V>,
5372 pub is_operator: Syntax<T, V>,
5373 pub is_right_operand: Syntax<T, V>,
5374 }
5376 #[derive(Debug, Clone)]
5377 pub struct AsExpressionChildren<T, V> {
5378 pub as_left_operand: Syntax<T, V>,
5379 pub as_operator: Syntax<T, V>,
5380 pub as_right_operand: Syntax<T, V>,
5381 }
5383 #[derive(Debug, Clone)]
5384 pub struct NullableAsExpressionChildren<T, V> {
5385 pub nullable_as_left_operand: Syntax<T, V>,
5386 pub nullable_as_operator: Syntax<T, V>,
5387 pub nullable_as_right_operand: Syntax<T, V>,
5388 }
5390 #[derive(Debug, Clone)]
5391 pub struct ConditionalExpressionChildren<T, V> {
5392 pub conditional_test: Syntax<T, V>,
5393 pub conditional_question: Syntax<T, V>,
5394 pub conditional_consequence: Syntax<T, V>,
5395 pub conditional_colon: Syntax<T, V>,
5396 pub conditional_alternative: Syntax<T, V>,
5397 }
5399 #[derive(Debug, Clone)]
5400 pub struct EvalExpressionChildren<T, V> {
5401 pub eval_keyword: Syntax<T, V>,
5402 pub eval_left_paren: Syntax<T, V>,
5403 pub eval_argument: Syntax<T, V>,
5404 pub eval_right_paren: Syntax<T, V>,
5405 }
5407 #[derive(Debug, Clone)]
5408 pub struct DefineExpressionChildren<T, V> {
5409 pub define_keyword: Syntax<T, V>,
5410 pub define_left_paren: Syntax<T, V>,
5411 pub define_argument_list: Syntax<T, V>,
5412 pub define_right_paren: Syntax<T, V>,
5413 }
5415 #[derive(Debug, Clone)]
5416 pub struct IssetExpressionChildren<T, V> {
5417 pub isset_keyword: Syntax<T, V>,
5418 pub isset_left_paren: Syntax<T, V>,
5419 pub isset_argument_list: Syntax<T, V>,
5420 pub isset_right_paren: Syntax<T, V>,
5421 }
5423 #[derive(Debug, Clone)]
5424 pub struct FunctionCallExpressionChildren<T, V> {
5425 pub function_call_receiver: Syntax<T, V>,
5426 pub function_call_type_args: Syntax<T, V>,
5427 pub function_call_left_paren: Syntax<T, V>,
5428 pub function_call_argument_list: Syntax<T, V>,
5429 pub function_call_right_paren: Syntax<T, V>,
5430 }
5432 #[derive(Debug, Clone)]
5433 pub struct FunctionPointerExpressionChildren<T, V> {
5434 pub function_pointer_receiver: Syntax<T, V>,
5435 pub function_pointer_type_args: Syntax<T, V>,
5436 }
5438 #[derive(Debug, Clone)]
5439 pub struct ParenthesizedExpressionChildren<T, V> {
5440 pub parenthesized_expression_left_paren: Syntax<T, V>,
5441 pub parenthesized_expression_expression: Syntax<T, V>,
5442 pub parenthesized_expression_right_paren: Syntax<T, V>,
5443 }
5445 #[derive(Debug, Clone)]
5446 pub struct BracedExpressionChildren<T, V> {
5447 pub braced_expression_left_brace: Syntax<T, V>,
5448 pub braced_expression_expression: Syntax<T, V>,
5449 pub braced_expression_right_brace: Syntax<T, V>,
5450 }
5452 #[derive(Debug, Clone)]
5453 pub struct ETSpliceExpressionChildren<T, V> {
5454 pub et_splice_expression_dollar: Syntax<T, V>,
5455 pub et_splice_expression_left_brace: Syntax<T, V>,
5456 pub et_splice_expression_expression: Syntax<T, V>,
5457 pub et_splice_expression_right_brace: Syntax<T, V>,
5458 }
5460 #[derive(Debug, Clone)]
5461 pub struct EmbeddedBracedExpressionChildren<T, V> {
5462 pub embedded_braced_expression_left_brace: Syntax<T, V>,
5463 pub embedded_braced_expression_expression: Syntax<T, V>,
5464 pub embedded_braced_expression_right_brace: Syntax<T, V>,
5465 }
5467 #[derive(Debug, Clone)]
5468 pub struct ListExpressionChildren<T, V> {
5469 pub list_keyword: Syntax<T, V>,
5470 pub list_left_paren: Syntax<T, V>,
5471 pub list_members: Syntax<T, V>,
5472 pub list_right_paren: Syntax<T, V>,
5473 }
5475 #[derive(Debug, Clone)]
5476 pub struct CollectionLiteralExpressionChildren<T, V> {
5477 pub collection_literal_name: Syntax<T, V>,
5478 pub collection_literal_left_brace: Syntax<T, V>,
5479 pub collection_literal_initializers: Syntax<T, V>,
5480 pub collection_literal_right_brace: Syntax<T, V>,
5481 }
5483 #[derive(Debug, Clone)]
5484 pub struct ObjectCreationExpressionChildren<T, V> {
5485 pub object_creation_new_keyword: Syntax<T, V>,
5486 pub object_creation_object: Syntax<T, V>,
5487 }
5489 #[derive(Debug, Clone)]
5490 pub struct ConstructorCallChildren<T, V> {
5491 pub constructor_call_type: Syntax<T, V>,
5492 pub constructor_call_left_paren: Syntax<T, V>,
5493 pub constructor_call_argument_list: Syntax<T, V>,
5494 pub constructor_call_right_paren: Syntax<T, V>,
5495 }
5497 #[derive(Debug, Clone)]
5498 pub struct RecordCreationExpressionChildren<T, V> {
5499 pub record_creation_type: Syntax<T, V>,
5500 pub record_creation_left_bracket: Syntax<T, V>,
5501 pub record_creation_members: Syntax<T, V>,
5502 pub record_creation_right_bracket: Syntax<T, V>,
5503 }
5505 #[derive(Debug, Clone)]
5506 pub struct DarrayIntrinsicExpressionChildren<T, V> {
5507 pub darray_intrinsic_keyword: Syntax<T, V>,
5508 pub darray_intrinsic_explicit_type: Syntax<T, V>,
5509 pub darray_intrinsic_left_bracket: Syntax<T, V>,
5510 pub darray_intrinsic_members: Syntax<T, V>,
5511 pub darray_intrinsic_right_bracket: Syntax<T, V>,
5512 }
5514 #[derive(Debug, Clone)]
5515 pub struct DictionaryIntrinsicExpressionChildren<T, V> {
5516 pub dictionary_intrinsic_keyword: Syntax<T, V>,
5517 pub dictionary_intrinsic_explicit_type: Syntax<T, V>,
5518 pub dictionary_intrinsic_left_bracket: Syntax<T, V>,
5519 pub dictionary_intrinsic_members: Syntax<T, V>,
5520 pub dictionary_intrinsic_right_bracket: Syntax<T, V>,
5521 }
5523 #[derive(Debug, Clone)]
5524 pub struct KeysetIntrinsicExpressionChildren<T, V> {
5525 pub keyset_intrinsic_keyword: Syntax<T, V>,
5526 pub keyset_intrinsic_explicit_type: Syntax<T, V>,
5527 pub keyset_intrinsic_left_bracket: Syntax<T, V>,
5528 pub keyset_intrinsic_members: Syntax<T, V>,
5529 pub keyset_intrinsic_right_bracket: Syntax<T, V>,
5530 }
5532 #[derive(Debug, Clone)]
5533 pub struct VarrayIntrinsicExpressionChildren<T, V> {
5534 pub varray_intrinsic_keyword: Syntax<T, V>,
5535 pub varray_intrinsic_explicit_type: Syntax<T, V>,
5536 pub varray_intrinsic_left_bracket: Syntax<T, V>,
5537 pub varray_intrinsic_members: Syntax<T, V>,
5538 pub varray_intrinsic_right_bracket: Syntax<T, V>,
5539 }
5541 #[derive(Debug, Clone)]
5542 pub struct VectorIntrinsicExpressionChildren<T, V> {
5543 pub vector_intrinsic_keyword: Syntax<T, V>,
5544 pub vector_intrinsic_explicit_type: Syntax<T, V>,
5545 pub vector_intrinsic_left_bracket: Syntax<T, V>,
5546 pub vector_intrinsic_members: Syntax<T, V>,
5547 pub vector_intrinsic_right_bracket: Syntax<T, V>,
5548 }
5550 #[derive(Debug, Clone)]
5551 pub struct ElementInitializerChildren<T, V> {
5552 pub element_key: Syntax<T, V>,
5553 pub element_arrow: Syntax<T, V>,
5554 pub element_value: Syntax<T, V>,
5555 }
5557 #[derive(Debug, Clone)]
5558 pub struct SubscriptExpressionChildren<T, V> {
5559 pub subscript_receiver: Syntax<T, V>,
5560 pub subscript_left_bracket: Syntax<T, V>,
5561 pub subscript_index: Syntax<T, V>,
5562 pub subscript_right_bracket: Syntax<T, V>,
5563 }
5565 #[derive(Debug, Clone)]
5566 pub struct EmbeddedSubscriptExpressionChildren<T, V> {
5567 pub embedded_subscript_receiver: Syntax<T, V>,
5568 pub embedded_subscript_left_bracket: Syntax<T, V>,
5569 pub embedded_subscript_index: Syntax<T, V>,
5570 pub embedded_subscript_right_bracket: Syntax<T, V>,
5571 }
5573 #[derive(Debug, Clone)]
5574 pub struct AwaitableCreationExpressionChildren<T, V> {
5575 pub awaitable_attribute_spec: Syntax<T, V>,
5576 pub awaitable_async: Syntax<T, V>,
5577 pub awaitable_compound_statement: Syntax<T, V>,
5578 }
5580 #[derive(Debug, Clone)]
5581 pub struct XHPChildrenDeclarationChildren<T, V> {
5582 pub xhp_children_keyword: Syntax<T, V>,
5583 pub xhp_children_expression: Syntax<T, V>,
5584 pub xhp_children_semicolon: Syntax<T, V>,
5585 }
5587 #[derive(Debug, Clone)]
5588 pub struct XHPChildrenParenthesizedListChildren<T, V> {
5589 pub xhp_children_list_left_paren: Syntax<T, V>,
5590 pub xhp_children_list_xhp_children: Syntax<T, V>,
5591 pub xhp_children_list_right_paren: Syntax<T, V>,
5592 }
5594 #[derive(Debug, Clone)]
5595 pub struct XHPCategoryDeclarationChildren<T, V> {
5596 pub xhp_category_keyword: Syntax<T, V>,
5597 pub xhp_category_categories: Syntax<T, V>,
5598 pub xhp_category_semicolon: Syntax<T, V>,
5599 }
5601 #[derive(Debug, Clone)]
5602 pub struct XHPEnumTypeChildren<T, V> {
5603 pub xhp_enum_keyword: Syntax<T, V>,
5604 pub xhp_enum_left_brace: Syntax<T, V>,
5605 pub xhp_enum_values: Syntax<T, V>,
5606 pub xhp_enum_right_brace: Syntax<T, V>,
5607 }
5609 #[derive(Debug, Clone)]
5610 pub struct XHPLateinitChildren<T, V> {
5611 pub xhp_lateinit_at: Syntax<T, V>,
5612 pub xhp_lateinit_keyword: Syntax<T, V>,
5613 }
5615 #[derive(Debug, Clone)]
5616 pub struct XHPRequiredChildren<T, V> {
5617 pub xhp_required_at: Syntax<T, V>,
5618 pub xhp_required_keyword: Syntax<T, V>,
5619 }
5621 #[derive(Debug, Clone)]
5622 pub struct XHPClassAttributeDeclarationChildren<T, V> {
5623 pub xhp_attribute_keyword: Syntax<T, V>,
5624 pub xhp_attribute_attributes: Syntax<T, V>,
5625 pub xhp_attribute_semicolon: Syntax<T, V>,
5626 }
5628 #[derive(Debug, Clone)]
5629 pub struct XHPClassAttributeChildren<T, V> {
5630 pub xhp_attribute_decl_type: Syntax<T, V>,
5631 pub xhp_attribute_decl_name: Syntax<T, V>,
5632 pub xhp_attribute_decl_initializer: Syntax<T, V>,
5633 pub xhp_attribute_decl_required: Syntax<T, V>,
5634 }
5636 #[derive(Debug, Clone)]
5637 pub struct XHPSimpleClassAttributeChildren<T, V> {
5638 pub xhp_simple_class_attribute_type: Syntax<T, V>,
5639 }
5641 #[derive(Debug, Clone)]
5642 pub struct XHPSimpleAttributeChildren<T, V> {
5643 pub xhp_simple_attribute_name: Syntax<T, V>,
5644 pub xhp_simple_attribute_equal: Syntax<T, V>,
5645 pub xhp_simple_attribute_expression: Syntax<T, V>,
5646 }
5648 #[derive(Debug, Clone)]
5649 pub struct XHPSpreadAttributeChildren<T, V> {
5650 pub xhp_spread_attribute_left_brace: Syntax<T, V>,
5651 pub xhp_spread_attribute_spread_operator: Syntax<T, V>,
5652 pub xhp_spread_attribute_expression: Syntax<T, V>,
5653 pub xhp_spread_attribute_right_brace: Syntax<T, V>,
5654 }
5656 #[derive(Debug, Clone)]
5657 pub struct XHPOpenChildren<T, V> {
5658 pub xhp_open_left_angle: Syntax<T, V>,
5659 pub xhp_open_name: Syntax<T, V>,
5660 pub xhp_open_attributes: Syntax<T, V>,
5661 pub xhp_open_right_angle: Syntax<T, V>,
5662 }
5664 #[derive(Debug, Clone)]
5665 pub struct XHPExpressionChildren<T, V> {
5666 pub xhp_open: Syntax<T, V>,
5667 pub xhp_body: Syntax<T, V>,
5668 pub xhp_close: Syntax<T, V>,
5669 }
5671 #[derive(Debug, Clone)]
5672 pub struct XHPCloseChildren<T, V> {
5673 pub xhp_close_left_angle: Syntax<T, V>,
5674 pub xhp_close_name: Syntax<T, V>,
5675 pub xhp_close_right_angle: Syntax<T, V>,
5676 }
5678 #[derive(Debug, Clone)]
5679 pub struct TypeConstantChildren<T, V> {
5680 pub type_constant_left_type: Syntax<T, V>,
5681 pub type_constant_separator: Syntax<T, V>,
5682 pub type_constant_right_type: Syntax<T, V>,
5683 }
5685 #[derive(Debug, Clone)]
5686 pub struct VectorTypeSpecifierChildren<T, V> {
5687 pub vector_type_keyword: Syntax<T, V>,
5688 pub vector_type_left_angle: Syntax<T, V>,
5689 pub vector_type_type: Syntax<T, V>,
5690 pub vector_type_trailing_comma: Syntax<T, V>,
5691 pub vector_type_right_angle: Syntax<T, V>,
5692 }
5694 #[derive(Debug, Clone)]
5695 pub struct KeysetTypeSpecifierChildren<T, V> {
5696 pub keyset_type_keyword: Syntax<T, V>,
5697 pub keyset_type_left_angle: Syntax<T, V>,
5698 pub keyset_type_type: Syntax<T, V>,
5699 pub keyset_type_trailing_comma: Syntax<T, V>,
5700 pub keyset_type_right_angle: Syntax<T, V>,
5701 }
5703 #[derive(Debug, Clone)]
5704 pub struct TupleTypeExplicitSpecifierChildren<T, V> {
5705 pub tuple_type_keyword: Syntax<T, V>,
5706 pub tuple_type_left_angle: Syntax<T, V>,
5707 pub tuple_type_types: Syntax<T, V>,
5708 pub tuple_type_right_angle: Syntax<T, V>,
5709 }
5711 #[derive(Debug, Clone)]
5712 pub struct VarrayTypeSpecifierChildren<T, V> {
5713 pub varray_keyword: Syntax<T, V>,
5714 pub varray_left_angle: Syntax<T, V>,
5715 pub varray_type: Syntax<T, V>,
5716 pub varray_trailing_comma: Syntax<T, V>,
5717 pub varray_right_angle: Syntax<T, V>,
5718 }
5720 #[derive(Debug, Clone)]
5721 pub struct FunctionCtxTypeSpecifierChildren<T, V> {
5722 pub function_ctx_type_keyword: Syntax<T, V>,
5723 pub function_ctx_type_variable: Syntax<T, V>,
5724 }
5726 #[derive(Debug, Clone)]
5727 pub struct TypeParameterChildren<T, V> {
5728 pub type_attribute_spec: Syntax<T, V>,
5729 pub type_reified: Syntax<T, V>,
5730 pub type_variance: Syntax<T, V>,
5731 pub type_name: Syntax<T, V>,
5732 pub type_param_params: Syntax<T, V>,
5733 pub type_constraints: Syntax<T, V>,
5734 }
5736 #[derive(Debug, Clone)]
5737 pub struct TypeConstraintChildren<T, V> {
5738 pub constraint_keyword: Syntax<T, V>,
5739 pub constraint_type: Syntax<T, V>,
5740 }
5742 #[derive(Debug, Clone)]
5743 pub struct ContextConstraintChildren<T, V> {
5744 pub ctx_constraint_keyword: Syntax<T, V>,
5745 pub ctx_constraint_ctx_list: Syntax<T, V>,
5746 }
5748 #[derive(Debug, Clone)]
5749 pub struct DarrayTypeSpecifierChildren<T, V> {
5750 pub darray_keyword: Syntax<T, V>,
5751 pub darray_left_angle: Syntax<T, V>,
5752 pub darray_key: Syntax<T, V>,
5753 pub darray_comma: Syntax<T, V>,
5754 pub darray_value: Syntax<T, V>,
5755 pub darray_trailing_comma: Syntax<T, V>,
5756 pub darray_right_angle: Syntax<T, V>,
5757 }
5759 #[derive(Debug, Clone)]
5760 pub struct DictionaryTypeSpecifierChildren<T, V> {
5761 pub dictionary_type_keyword: Syntax<T, V>,
5762 pub dictionary_type_left_angle: Syntax<T, V>,
5763 pub dictionary_type_members: Syntax<T, V>,
5764 pub dictionary_type_right_angle: Syntax<T, V>,
5765 }
5767 #[derive(Debug, Clone)]
5768 pub struct ClosureTypeSpecifierChildren<T, V> {
5769 pub closure_outer_left_paren: Syntax<T, V>,
5770 pub closure_function_keyword: Syntax<T, V>,
5771 pub closure_inner_left_paren: Syntax<T, V>,
5772 pub closure_parameter_list: Syntax<T, V>,
5773 pub closure_inner_right_paren: Syntax<T, V>,
5774 pub closure_contexts: Syntax<T, V>,
5775 pub closure_colon: Syntax<T, V>,
5776 pub closure_return_type: Syntax<T, V>,
5777 pub closure_outer_right_paren: Syntax<T, V>,
5778 }
5780 #[derive(Debug, Clone)]
5781 pub struct ClosureParameterTypeSpecifierChildren<T, V> {
5782 pub closure_parameter_call_convention: Syntax<T, V>,
5783 pub closure_parameter_type: Syntax<T, V>,
5784 }
5786 #[derive(Debug, Clone)]
5787 pub struct ClassnameTypeSpecifierChildren<T, V> {
5788 pub classname_keyword: Syntax<T, V>,
5789 pub classname_left_angle: Syntax<T, V>,
5790 pub classname_type: Syntax<T, V>,
5791 pub classname_trailing_comma: Syntax<T, V>,
5792 pub classname_right_angle: Syntax<T, V>,
5793 }
5795 #[derive(Debug, Clone)]
5796 pub struct FieldSpecifierChildren<T, V> {
5797 pub field_question: Syntax<T, V>,
5798 pub field_name: Syntax<T, V>,
5799 pub field_arrow: Syntax<T, V>,
5800 pub field_type: Syntax<T, V>,
5801 }
5803 #[derive(Debug, Clone)]
5804 pub struct FieldInitializerChildren<T, V> {
5805 pub field_initializer_name: Syntax<T, V>,
5806 pub field_initializer_arrow: Syntax<T, V>,
5807 pub field_initializer_value: Syntax<T, V>,
5808 }
5810 #[derive(Debug, Clone)]
5811 pub struct ShapeTypeSpecifierChildren<T, V> {
5812 pub shape_type_keyword: Syntax<T, V>,
5813 pub shape_type_left_paren: Syntax<T, V>,
5814 pub shape_type_fields: Syntax<T, V>,
5815 pub shape_type_ellipsis: Syntax<T, V>,
5816 pub shape_type_right_paren: Syntax<T, V>,
5817 }
5819 #[derive(Debug, Clone)]
5820 pub struct ShapeExpressionChildren<T, V> {
5821 pub shape_expression_keyword: Syntax<T, V>,
5822 pub shape_expression_left_paren: Syntax<T, V>,
5823 pub shape_expression_fields: Syntax<T, V>,
5824 pub shape_expression_right_paren: Syntax<T, V>,
5825 }
5827 #[derive(Debug, Clone)]
5828 pub struct TupleExpressionChildren<T, V> {
5829 pub tuple_expression_keyword: Syntax<T, V>,
5830 pub tuple_expression_left_paren: Syntax<T, V>,
5831 pub tuple_expression_items: Syntax<T, V>,
5832 pub tuple_expression_right_paren: Syntax<T, V>,
5833 }
5835 #[derive(Debug, Clone)]
5836 pub struct GenericTypeSpecifierChildren<T, V> {
5837 pub generic_class_type: Syntax<T, V>,
5838 pub generic_argument_list: Syntax<T, V>,
5839 }
5841 #[derive(Debug, Clone)]
5842 pub struct NullableTypeSpecifierChildren<T, V> {
5843 pub nullable_question: Syntax<T, V>,
5844 pub nullable_type: Syntax<T, V>,
5845 }
5847 #[derive(Debug, Clone)]
5848 pub struct LikeTypeSpecifierChildren<T, V> {
5849 pub like_tilde: Syntax<T, V>,
5850 pub like_type: Syntax<T, V>,
5851 }
5853 #[derive(Debug, Clone)]
5854 pub struct SoftTypeSpecifierChildren<T, V> {
5855 pub soft_at: Syntax<T, V>,
5856 pub soft_type: Syntax<T, V>,
5857 }
5859 #[derive(Debug, Clone)]
5860 pub struct AttributizedSpecifierChildren<T, V> {
5861 pub attributized_specifier_attribute_spec: Syntax<T, V>,
5862 pub attributized_specifier_type: Syntax<T, V>,
5863 }
5865 #[derive(Debug, Clone)]
5866 pub struct ReifiedTypeArgumentChildren<T, V> {
5867 pub reified_type_argument_reified: Syntax<T, V>,
5868 pub reified_type_argument_type: Syntax<T, V>,
5869 }
5871 #[derive(Debug, Clone)]
5872 pub struct TypeArgumentsChildren<T, V> {
5873 pub type_arguments_left_angle: Syntax<T, V>,
5874 pub type_arguments_types: Syntax<T, V>,
5875 pub type_arguments_right_angle: Syntax<T, V>,
5876 }
5878 #[derive(Debug, Clone)]
5879 pub struct TypeParametersChildren<T, V> {
5880 pub type_parameters_left_angle: Syntax<T, V>,
5881 pub type_parameters_parameters: Syntax<T, V>,
5882 pub type_parameters_right_angle: Syntax<T, V>,
5883 }
5885 #[derive(Debug, Clone)]
5886 pub struct TupleTypeSpecifierChildren<T, V> {
5887 pub tuple_left_paren: Syntax<T, V>,
5888 pub tuple_types: Syntax<T, V>,
5889 pub tuple_right_paren: Syntax<T, V>,
5890 }
5892 #[derive(Debug, Clone)]
5893 pub struct UnionTypeSpecifierChildren<T, V> {
5894 pub union_left_paren: Syntax<T, V>,
5895 pub union_types: Syntax<T, V>,
5896 pub union_right_paren: Syntax<T, V>,
5897 }
5899 #[derive(Debug, Clone)]
5900 pub struct IntersectionTypeSpecifierChildren<T, V> {
5901 pub intersection_left_paren: Syntax<T, V>,
5902 pub intersection_types: Syntax<T, V>,
5903 pub intersection_right_paren: Syntax<T, V>,
5904 }
5906 #[derive(Debug, Clone)]
5907 pub struct ErrorSyntaxChildren<T, V> {
5908 pub error_error: Syntax<T, V>,
5909 }
5911 #[derive(Debug, Clone)]
5912 pub struct ListItemChildren<T, V> {
5913 pub list_item: Syntax<T, V>,
5914 pub list_separator: Syntax<T, V>,
5915 }
5917 #[derive(Debug, Clone)]
5918 pub struct EnumAtomExpressionChildren<T, V> {
5919 pub enum_atom_hash: Syntax<T, V>,
5920 pub enum_atom_expression: Syntax<T, V>,
5921 }
5924 #[derive(Debug, Clone)]
5925 pub enum SyntaxVariant<T, V> {
5926 Token(Box<T>),
5927 Missing,
5928 SyntaxList(Vec<Syntax<T, V>>),
5929 EndOfFile(Box<EndOfFileChildren<T, V>>),
5930 Script(Box<ScriptChildren<T, V>>),
5931 QualifiedName(Box<QualifiedNameChildren<T, V>>),
5932 SimpleTypeSpecifier(Box<SimpleTypeSpecifierChildren<T, V>>),
5933 LiteralExpression(Box<LiteralExpressionChildren<T, V>>),
5934 PrefixedStringExpression(Box<PrefixedStringExpressionChildren<T, V>>),
5935 PrefixedCodeExpression(Box<PrefixedCodeExpressionChildren<T, V>>),
5936 VariableExpression(Box<VariableExpressionChildren<T, V>>),
5937 PipeVariableExpression(Box<PipeVariableExpressionChildren<T, V>>),
5938 FileAttributeSpecification(Box<FileAttributeSpecificationChildren<T, V>>),
5939 EnumDeclaration(Box<EnumDeclarationChildren<T, V>>),
5940 EnumUse(Box<EnumUseChildren<T, V>>),
5941 Enumerator(Box<EnumeratorChildren<T, V>>),
5942 EnumClassDeclaration(Box<EnumClassDeclarationChildren<T, V>>),
5943 EnumClassEnumerator(Box<EnumClassEnumeratorChildren<T, V>>),
5944 RecordDeclaration(Box<RecordDeclarationChildren<T, V>>),
5945 RecordField(Box<RecordFieldChildren<T, V>>),
5946 AliasDeclaration(Box<AliasDeclarationChildren<T, V>>),
5947 PropertyDeclaration(Box<PropertyDeclarationChildren<T, V>>),
5948 PropertyDeclarator(Box<PropertyDeclaratorChildren<T, V>>),
5949 NamespaceDeclaration(Box<NamespaceDeclarationChildren<T, V>>),
5950 NamespaceDeclarationHeader(Box<NamespaceDeclarationHeaderChildren<T, V>>),
5951 NamespaceBody(Box<NamespaceBodyChildren<T, V>>),
5952 NamespaceEmptyBody(Box<NamespaceEmptyBodyChildren<T, V>>),
5953 NamespaceUseDeclaration(Box<NamespaceUseDeclarationChildren<T, V>>),
5954 NamespaceGroupUseDeclaration(Box<NamespaceGroupUseDeclarationChildren<T, V>>),
5955 NamespaceUseClause(Box<NamespaceUseClauseChildren<T, V>>),
5956 FunctionDeclaration(Box<FunctionDeclarationChildren<T, V>>),
5957 FunctionDeclarationHeader(Box<FunctionDeclarationHeaderChildren<T, V>>),
5958 Contexts(Box<ContextsChildren<T, V>>),
5959 WhereClause(Box<WhereClauseChildren<T, V>>),
5960 WhereConstraint(Box<WhereConstraintChildren<T, V>>),
5961 MethodishDeclaration(Box<MethodishDeclarationChildren<T, V>>),
5962 MethodishTraitResolution(Box<MethodishTraitResolutionChildren<T, V>>),
5963 ClassishDeclaration(Box<ClassishDeclarationChildren<T, V>>),
5964 ClassishBody(Box<ClassishBodyChildren<T, V>>),
5965 TraitUsePrecedenceItem(Box<TraitUsePrecedenceItemChildren<T, V>>),
5966 TraitUseAliasItem(Box<TraitUseAliasItemChildren<T, V>>),
5967 TraitUseConflictResolution(Box<TraitUseConflictResolutionChildren<T, V>>),
5968 TraitUse(Box<TraitUseChildren<T, V>>),
5969 RequireClause(Box<RequireClauseChildren<T, V>>),
5970 ConstDeclaration(Box<ConstDeclarationChildren<T, V>>),
5971 ConstantDeclarator(Box<ConstantDeclaratorChildren<T, V>>),
5972 TypeConstDeclaration(Box<TypeConstDeclarationChildren<T, V>>),
5973 ContextConstDeclaration(Box<ContextConstDeclarationChildren<T, V>>),
5974 DecoratedExpression(Box<DecoratedExpressionChildren<T, V>>),
5975 ParameterDeclaration(Box<ParameterDeclarationChildren<T, V>>),
5976 VariadicParameter(Box<VariadicParameterChildren<T, V>>),
5977 OldAttributeSpecification(Box<OldAttributeSpecificationChildren<T, V>>),
5978 AttributeSpecification(Box<AttributeSpecificationChildren<T, V>>),
5979 Attribute(Box<AttributeChildren<T, V>>),
5980 InclusionExpression(Box<InclusionExpressionChildren<T, V>>),
5981 InclusionDirective(Box<InclusionDirectiveChildren<T, V>>),
5982 CompoundStatement(Box<CompoundStatementChildren<T, V>>),
5983 ExpressionStatement(Box<ExpressionStatementChildren<T, V>>),
5984 MarkupSection(Box<MarkupSectionChildren<T, V>>),
5985 MarkupSuffix(Box<MarkupSuffixChildren<T, V>>),
5986 UnsetStatement(Box<UnsetStatementChildren<T, V>>),
5987 UsingStatementBlockScoped(Box<UsingStatementBlockScopedChildren<T, V>>),
5988 UsingStatementFunctionScoped(Box<UsingStatementFunctionScopedChildren<T, V>>),
5989 WhileStatement(Box<WhileStatementChildren<T, V>>),
5990 IfStatement(Box<IfStatementChildren<T, V>>),
5991 ElseifClause(Box<ElseifClauseChildren<T, V>>),
5992 ElseClause(Box<ElseClauseChildren<T, V>>),
5993 TryStatement(Box<TryStatementChildren<T, V>>),
5994 CatchClause(Box<CatchClauseChildren<T, V>>),
5995 FinallyClause(Box<FinallyClauseChildren<T, V>>),
5996 DoStatement(Box<DoStatementChildren<T, V>>),
5997 ForStatement(Box<ForStatementChildren<T, V>>),
5998 ForeachStatement(Box<ForeachStatementChildren<T, V>>),
5999 SwitchStatement(Box<SwitchStatementChildren<T, V>>),
6000 SwitchSection(Box<SwitchSectionChildren<T, V>>),
6001 SwitchFallthrough(Box<SwitchFallthroughChildren<T, V>>),
6002 CaseLabel(Box<CaseLabelChildren<T, V>>),
6003 DefaultLabel(Box<DefaultLabelChildren<T, V>>),
6004 ReturnStatement(Box<ReturnStatementChildren<T, V>>),
6005 YieldBreakStatement(Box<YieldBreakStatementChildren<T, V>>),
6006 ThrowStatement(Box<ThrowStatementChildren<T, V>>),
6007 BreakStatement(Box<BreakStatementChildren<T, V>>),
6008 ContinueStatement(Box<ContinueStatementChildren<T, V>>),
6009 EchoStatement(Box<EchoStatementChildren<T, V>>),
6010 ConcurrentStatement(Box<ConcurrentStatementChildren<T, V>>),
6011 SimpleInitializer(Box<SimpleInitializerChildren<T, V>>),
6012 AnonymousClass(Box<AnonymousClassChildren<T, V>>),
6013 AnonymousFunction(Box<AnonymousFunctionChildren<T, V>>),
6014 AnonymousFunctionUseClause(Box<AnonymousFunctionUseClauseChildren<T, V>>),
6015 LambdaExpression(Box<LambdaExpressionChildren<T, V>>),
6016 LambdaSignature(Box<LambdaSignatureChildren<T, V>>),
6017 CastExpression(Box<CastExpressionChildren<T, V>>),
6018 ScopeResolutionExpression(Box<ScopeResolutionExpressionChildren<T, V>>),
6019 MemberSelectionExpression(Box<MemberSelectionExpressionChildren<T, V>>),
6020 SafeMemberSelectionExpression(Box<SafeMemberSelectionExpressionChildren<T, V>>),
6021 EmbeddedMemberSelectionExpression(Box<EmbeddedMemberSelectionExpressionChildren<T, V>>),
6022 YieldExpression(Box<YieldExpressionChildren<T, V>>),
6023 PrefixUnaryExpression(Box<PrefixUnaryExpressionChildren<T, V>>),
6024 PostfixUnaryExpression(Box<PostfixUnaryExpressionChildren<T, V>>),
6025 BinaryExpression(Box<BinaryExpressionChildren<T, V>>),
6026 IsExpression(Box<IsExpressionChildren<T, V>>),
6027 AsExpression(Box<AsExpressionChildren<T, V>>),
6028 NullableAsExpression(Box<NullableAsExpressionChildren<T, V>>),
6029 ConditionalExpression(Box<ConditionalExpressionChildren<T, V>>),
6030 EvalExpression(Box<EvalExpressionChildren<T, V>>),
6031 DefineExpression(Box<DefineExpressionChildren<T, V>>),
6032 IssetExpression(Box<IssetExpressionChildren<T, V>>),
6033 FunctionCallExpression(Box<FunctionCallExpressionChildren<T, V>>),
6034 FunctionPointerExpression(Box<FunctionPointerExpressionChildren<T, V>>),
6035 ParenthesizedExpression(Box<ParenthesizedExpressionChildren<T, V>>),
6036 BracedExpression(Box<BracedExpressionChildren<T, V>>),
6037 ETSpliceExpression(Box<ETSpliceExpressionChildren<T, V>>),
6038 EmbeddedBracedExpression(Box<EmbeddedBracedExpressionChildren<T, V>>),
6039 ListExpression(Box<ListExpressionChildren<T, V>>),
6040 CollectionLiteralExpression(Box<CollectionLiteralExpressionChildren<T, V>>),
6041 ObjectCreationExpression(Box<ObjectCreationExpressionChildren<T, V>>),
6042 ConstructorCall(Box<ConstructorCallChildren<T, V>>),
6043 RecordCreationExpression(Box<RecordCreationExpressionChildren<T, V>>),
6044 DarrayIntrinsicExpression(Box<DarrayIntrinsicExpressionChildren<T, V>>),
6045 DictionaryIntrinsicExpression(Box<DictionaryIntrinsicExpressionChildren<T, V>>),
6046 KeysetIntrinsicExpression(Box<KeysetIntrinsicExpressionChildren<T, V>>),
6047 VarrayIntrinsicExpression(Box<VarrayIntrinsicExpressionChildren<T, V>>),
6048 VectorIntrinsicExpression(Box<VectorIntrinsicExpressionChildren<T, V>>),
6049 ElementInitializer(Box<ElementInitializerChildren<T, V>>),
6050 SubscriptExpression(Box<SubscriptExpressionChildren<T, V>>),
6051 EmbeddedSubscriptExpression(Box<EmbeddedSubscriptExpressionChildren<T, V>>),
6052 AwaitableCreationExpression(Box<AwaitableCreationExpressionChildren<T, V>>),
6053 XHPChildrenDeclaration(Box<XHPChildrenDeclarationChildren<T, V>>),
6054 XHPChildrenParenthesizedList(Box<XHPChildrenParenthesizedListChildren<T, V>>),
6055 XHPCategoryDeclaration(Box<XHPCategoryDeclarationChildren<T, V>>),
6056 XHPEnumType(Box<XHPEnumTypeChildren<T, V>>),
6057 XHPLateinit(Box<XHPLateinitChildren<T, V>>),
6058 XHPRequired(Box<XHPRequiredChildren<T, V>>),
6059 XHPClassAttributeDeclaration(Box<XHPClassAttributeDeclarationChildren<T, V>>),
6060 XHPClassAttribute(Box<XHPClassAttributeChildren<T, V>>),
6061 XHPSimpleClassAttribute(Box<XHPSimpleClassAttributeChildren<T, V>>),
6062 XHPSimpleAttribute(Box<XHPSimpleAttributeChildren<T, V>>),
6063 XHPSpreadAttribute(Box<XHPSpreadAttributeChildren<T, V>>),
6064 XHPOpen(Box<XHPOpenChildren<T, V>>),
6065 XHPExpression(Box<XHPExpressionChildren<T, V>>),
6066 XHPClose(Box<XHPCloseChildren<T, V>>),
6067 TypeConstant(Box<TypeConstantChildren<T, V>>),
6068 VectorTypeSpecifier(Box<VectorTypeSpecifierChildren<T, V>>),
6069 KeysetTypeSpecifier(Box<KeysetTypeSpecifierChildren<T, V>>),
6070 TupleTypeExplicitSpecifier(Box<TupleTypeExplicitSpecifierChildren<T, V>>),
6071 VarrayTypeSpecifier(Box<VarrayTypeSpecifierChildren<T, V>>),
6072 FunctionCtxTypeSpecifier(Box<FunctionCtxTypeSpecifierChildren<T, V>>),
6073 TypeParameter(Box<TypeParameterChildren<T, V>>),
6074 TypeConstraint(Box<TypeConstraintChildren<T, V>>),
6075 ContextConstraint(Box<ContextConstraintChildren<T, V>>),
6076 DarrayTypeSpecifier(Box<DarrayTypeSpecifierChildren<T, V>>),
6077 DictionaryTypeSpecifier(Box<DictionaryTypeSpecifierChildren<T, V>>),
6078 ClosureTypeSpecifier(Box<ClosureTypeSpecifierChildren<T, V>>),
6079 ClosureParameterTypeSpecifier(Box<ClosureParameterTypeSpecifierChildren<T, V>>),
6080 ClassnameTypeSpecifier(Box<ClassnameTypeSpecifierChildren<T, V>>),
6081 FieldSpecifier(Box<FieldSpecifierChildren<T, V>>),
6082 FieldInitializer(Box<FieldInitializerChildren<T, V>>),
6083 ShapeTypeSpecifier(Box<ShapeTypeSpecifierChildren<T, V>>),
6084 ShapeExpression(Box<ShapeExpressionChildren<T, V>>),
6085 TupleExpression(Box<TupleExpressionChildren<T, V>>),
6086 GenericTypeSpecifier(Box<GenericTypeSpecifierChildren<T, V>>),
6087 NullableTypeSpecifier(Box<NullableTypeSpecifierChildren<T, V>>),
6088 LikeTypeSpecifier(Box<LikeTypeSpecifierChildren<T, V>>),
6089 SoftTypeSpecifier(Box<SoftTypeSpecifierChildren<T, V>>),
6090 AttributizedSpecifier(Box<AttributizedSpecifierChildren<T, V>>),
6091 ReifiedTypeArgument(Box<ReifiedTypeArgumentChildren<T, V>>),
6092 TypeArguments(Box<TypeArgumentsChildren<T, V>>),
6093 TypeParameters(Box<TypeParametersChildren<T, V>>),
6094 TupleTypeSpecifier(Box<TupleTypeSpecifierChildren<T, V>>),
6095 UnionTypeSpecifier(Box<UnionTypeSpecifierChildren<T, V>>),
6096 IntersectionTypeSpecifier(Box<IntersectionTypeSpecifierChildren<T, V>>),
6097 ErrorSyntax(Box<ErrorSyntaxChildren<T, V>>),
6098 ListItem(Box<ListItemChildren<T, V>>),
6099 EnumAtomExpression(Box<EnumAtomExpressionChildren<T, V>>),
6100 }
6102 impl<'a, T, V> SyntaxChildrenIterator<'a, T, V> {
6103 pub fn next_impl(&mut self, direction : bool) -> Option<&'a Syntax<T, V>> {
6104 use SyntaxVariant::*;
6105 let get_index = |len| {
6106 let back_index_plus_1 = len - self.index_back;
6107 if back_index_plus_1 <= self.index {
6108 return None
6109 }
6110 if direction {
6111 Some (self.index)
6112 } else {
6113 Some (back_index_plus_1 - 1)
6114 }
6115 };
6116 let res = match &self.syntax {
6117 Missing => None,
6118 Token (_) => None,
6119 SyntaxList(elems) => {
6120 get_index(elems.len()).and_then(|x| elems.get(x))
6121 },
6122 EndOfFile(x) => {
6123 get_index(1).and_then(|index| { match index {
6124 0 => Some(&x.end_of_file_token),
6125 _ => None,
6126 }
6127 })
6128 },
6129 Script(x) => {
6130 get_index(1).and_then(|index| { match index {
6131 0 => Some(&x.script_declarations),
6132 _ => None,
6133 }
6134 })
6135 },
6136 QualifiedName(x) => {
6137 get_index(1).and_then(|index| { match index {
6138 0 => Some(&x.qualified_name_parts),
6139 _ => None,
6140 }
6141 })
6142 },
6143 SimpleTypeSpecifier(x) => {
6144 get_index(1).and_then(|index| { match index {
6145 0 => Some(&x.simple_type_specifier),
6146 _ => None,
6147 }
6148 })
6149 },
6150 LiteralExpression(x) => {
6151 get_index(1).and_then(|index| { match index {
6152 0 => Some(&x.literal_expression),
6153 _ => None,
6154 }
6155 })
6156 },
6157 PrefixedStringExpression(x) => {
6158 get_index(2).and_then(|index| { match index {
6159 0 => Some(&x.prefixed_string_name),
6160 1 => Some(&x.prefixed_string_str),
6161 _ => None,
6162 }
6163 })
6164 },
6165 PrefixedCodeExpression(x) => {
6166 get_index(4).and_then(|index| { match index {
6167 0 => Some(&x.prefixed_code_prefix),
6168 1 => Some(&x.prefixed_code_left_backtick),
6169 2 => Some(&x.prefixed_code_expression),
6170 3 => Some(&x.prefixed_code_right_backtick),
6171 _ => None,
6172 }
6173 })
6174 },
6175 VariableExpression(x) => {
6176 get_index(1).and_then(|index| { match index {
6177 0 => Some(&x.variable_expression),
6178 _ => None,
6179 }
6180 })
6181 },
6182 PipeVariableExpression(x) => {
6183 get_index(1).and_then(|index| { match index {
6184 0 => Some(&x.pipe_variable_expression),
6185 _ => None,
6186 }
6187 })
6188 },
6189 FileAttributeSpecification(x) => {
6190 get_index(5).and_then(|index| { match index {
6191 0 => Some(&x.file_attribute_specification_left_double_angle),
6192 1 => Some(&x.file_attribute_specification_keyword),
6193 2 => Some(&x.file_attribute_specification_colon),
6194 3 => Some(&x.file_attribute_specification_attributes),
6195 4 => Some(&x.file_attribute_specification_right_double_angle),
6196 _ => None,
6197 }
6198 })
6199 },
6200 EnumDeclaration(x) => {
6201 get_index(10).and_then(|index| { match index {
6202 0 => Some(&x.enum_attribute_spec),
6203 1 => Some(&x.enum_keyword),
6204 2 => Some(&x.enum_name),
6205 3 => Some(&x.enum_colon),
6206 4 => Some(&x.enum_base),
6207 5 => Some(&x.enum_type),
6208 6 => Some(&x.enum_left_brace),
6209 7 => Some(&x.enum_use_clauses),
6210 8 => Some(&x.enum_enumerators),
6211 9 => Some(&x.enum_right_brace),
6212 _ => None,
6213 }
6214 })
6215 },
6216 EnumUse(x) => {
6217 get_index(3).and_then(|index| { match index {
6218 0 => Some(&x.enum_use_keyword),
6219 1 => Some(&x.enum_use_names),
6220 2 => Some(&x.enum_use_semicolon),
6221 _ => None,
6222 }
6223 })
6224 },
6225 Enumerator(x) => {
6226 get_index(4).and_then(|index| { match index {
6227 0 => Some(&x.enumerator_name),
6228 1 => Some(&x.enumerator_equal),
6229 2 => Some(&x.enumerator_value),
6230 3 => Some(&x.enumerator_semicolon),
6231 _ => None,
6232 }
6233 })
6234 },
6235 EnumClassDeclaration(x) => {
6236 get_index(11).and_then(|index| { match index {
6237 0 => Some(&x.enum_class_attribute_spec),
6238 1 => Some(&x.enum_class_enum_keyword),
6239 2 => Some(&x.enum_class_class_keyword),
6240 3 => Some(&x.enum_class_name),
6241 4 => Some(&x.enum_class_colon),
6242 5 => Some(&x.enum_class_base),
6243 6 => Some(&x.enum_class_extends),
6244 7 => Some(&x.enum_class_extends_list),
6245 8 => Some(&x.enum_class_left_brace),
6246 9 => Some(&x.enum_class_elements),
6247 10 => Some(&x.enum_class_right_brace),
6248 _ => None,
6249 }
6250 })
6251 },
6252 EnumClassEnumerator(x) => {
6253 get_index(5).and_then(|index| { match index {
6254 0 => Some(&x.enum_class_enumerator_type),
6255 1 => Some(&x.enum_class_enumerator_name),
6256 2 => Some(&x.enum_class_enumerator_equal),
6257 3 => Some(&x.enum_class_enumerator_initial_value),
6258 4 => Some(&x.enum_class_enumerator_semicolon),
6259 _ => None,
6260 }
6261 })
6262 },
6263 RecordDeclaration(x) => {
6264 get_index(9).and_then(|index| { match index {
6265 0 => Some(&x.record_attribute_spec),
6266 1 => Some(&x.record_modifier),
6267 2 => Some(&x.record_keyword),
6268 3 => Some(&x.record_name),
6269 4 => Some(&x.record_extends_keyword),
6270 5 => Some(&x.record_extends_opt),
6271 6 => Some(&x.record_left_brace),
6272 7 => Some(&x.record_fields),
6273 8 => Some(&x.record_right_brace),
6274 _ => None,
6275 }
6276 })
6277 },
6278 RecordField(x) => {
6279 get_index(4).and_then(|index| { match index {
6280 0 => Some(&x.record_field_type),
6281 1 => Some(&x.record_field_name),
6282 2 => Some(&x.record_field_init),
6283 3 => Some(&x.record_field_semi),
6284 _ => None,
6285 }
6286 })
6287 },
6288 AliasDeclaration(x) => {
6289 get_index(8).and_then(|index| { match index {
6290 0 => Some(&x.alias_attribute_spec),
6291 1 => Some(&x.alias_keyword),
6292 2 => Some(&x.alias_name),
6293 3 => Some(&x.alias_generic_parameter),
6294 4 => Some(&x.alias_constraint),
6295 5 => Some(&x.alias_equal),
6296 6 => Some(&x.alias_type),
6297 7 => Some(&x.alias_semicolon),
6298 _ => None,
6299 }
6300 })
6301 },
6302 PropertyDeclaration(x) => {
6303 get_index(5).and_then(|index| { match index {
6304 0 => Some(&x.property_attribute_spec),
6305 1 => Some(&x.property_modifiers),
6306 2 => Some(&x.property_type),
6307 3 => Some(&x.property_declarators),
6308 4 => Some(&x.property_semicolon),
6309 _ => None,
6310 }
6311 })
6312 },
6313 PropertyDeclarator(x) => {
6314 get_index(2).and_then(|index| { match index {
6315 0 => Some(&x.property_name),
6316 1 => Some(&x.property_initializer),
6317 _ => None,
6318 }
6319 })
6320 },
6321 NamespaceDeclaration(x) => {
6322 get_index(2).and_then(|index| { match index {
6323 0 => Some(&x.namespace_header),
6324 1 => Some(&x.namespace_body),
6325 _ => None,
6326 }
6327 })
6328 },
6329 NamespaceDeclarationHeader(x) => {
6330 get_index(2).and_then(|index| { match index {
6331 0 => Some(&x.namespace_keyword),
6332 1 => Some(&x.namespace_name),
6333 _ => None,
6334 }
6335 })
6336 },
6337 NamespaceBody(x) => {
6338 get_index(3).and_then(|index| { match index {
6339 0 => Some(&x.namespace_left_brace),
6340 1 => Some(&x.namespace_declarations),
6341 2 => Some(&x.namespace_right_brace),
6342 _ => None,
6343 }
6344 })
6345 },
6346 NamespaceEmptyBody(x) => {
6347 get_index(1).and_then(|index| { match index {
6348 0 => Some(&x.namespace_semicolon),
6349 _ => None,
6350 }
6351 })
6352 },
6353 NamespaceUseDeclaration(x) => {
6354 get_index(4).and_then(|index| { match index {
6355 0 => Some(&x.namespace_use_keyword),
6356 1 => Some(&x.namespace_use_kind),
6357 2 => Some(&x.namespace_use_clauses),
6358 3 => Some(&x.namespace_use_semicolon),
6359 _ => None,
6360 }
6361 })
6362 },
6363 NamespaceGroupUseDeclaration(x) => {
6364 get_index(7).and_then(|index| { match index {
6365 0 => Some(&x.namespace_group_use_keyword),
6366 1 => Some(&x.namespace_group_use_kind),
6367 2 => Some(&x.namespace_group_use_prefix),
6368 3 => Some(&x.namespace_group_use_left_brace),
6369 4 => Some(&x.namespace_group_use_clauses),
6370 5 => Some(&x.namespace_group_use_right_brace),
6371 6 => Some(&x.namespace_group_use_semicolon),
6372 _ => None,
6373 }
6374 })
6375 },
6376 NamespaceUseClause(x) => {
6377 get_index(4).and_then(|index| { match index {
6378 0 => Some(&x.namespace_use_clause_kind),
6379 1 => Some(&x.namespace_use_name),
6380 2 => Some(&x.namespace_use_as),
6381 3 => Some(&x.namespace_use_alias),
6382 _ => None,
6383 }
6384 })
6385 },
6386 FunctionDeclaration(x) => {
6387 get_index(3).and_then(|index| { match index {
6388 0 => Some(&x.function_attribute_spec),
6389 1 => Some(&x.function_declaration_header),
6390 2 => Some(&x.function_body),
6391 _ => None,
6392 }
6393 })
6394 },
6395 FunctionDeclarationHeader(x) => {
6396 get_index(11).and_then(|index| { match index {
6397 0 => Some(&x.function_modifiers),
6398 1 => Some(&x.function_keyword),
6399 2 => Some(&x.function_name),
6400 3 => Some(&x.function_type_parameter_list),
6401 4 => Some(&x.function_left_paren),
6402 5 => Some(&x.function_parameter_list),
6403 6 => Some(&x.function_right_paren),
6404 7 => Some(&x.function_contexts),
6405 8 => Some(&x.function_colon),
6406 9 => Some(&x.function_type),
6407 10 => Some(&x.function_where_clause),
6408 _ => None,
6409 }
6410 })
6411 },
6412 Contexts(x) => {
6413 get_index(3).and_then(|index| { match index {
6414 0 => Some(&x.contexts_left_bracket),
6415 1 => Some(&x.contexts_types),
6416 2 => Some(&x.contexts_right_bracket),
6417 _ => None,
6418 }
6419 })
6420 },
6421 WhereClause(x) => {
6422 get_index(2).and_then(|index| { match index {
6423 0 => Some(&x.where_clause_keyword),
6424 1 => Some(&x.where_clause_constraints),
6425 _ => None,
6426 }
6427 })
6428 },
6429 WhereConstraint(x) => {
6430 get_index(3).and_then(|index| { match index {
6431 0 => Some(&x.where_constraint_left_type),
6432 1 => Some(&x.where_constraint_operator),
6433 2 => Some(&x.where_constraint_right_type),
6434 _ => None,
6435 }
6436 })
6437 },
6438 MethodishDeclaration(x) => {
6439 get_index(4).and_then(|index| { match index {
6440 0 => Some(&x.methodish_attribute),
6441 1 => Some(&x.methodish_function_decl_header),
6442 2 => Some(&x.methodish_function_body),
6443 3 => Some(&x.methodish_semicolon),
6444 _ => None,
6445 }
6446 })
6447 },
6448 MethodishTraitResolution(x) => {
6449 get_index(5).and_then(|index| { match index {
6450 0 => Some(&x.methodish_trait_attribute),
6451 1 => Some(&x.methodish_trait_function_decl_header),
6452 2 => Some(&x.methodish_trait_equal),
6453 3 => Some(&x.methodish_trait_name),
6454 4 => Some(&x.methodish_trait_semicolon),
6455 _ => None,
6456 }
6457 })
6458 },
6459 ClassishDeclaration(x) => {
6460 get_index(12).and_then(|index| { match index {
6461 0 => Some(&x.classish_attribute),
6462 1 => Some(&x.classish_modifiers),
6463 2 => Some(&x.classish_xhp),
6464 3 => Some(&x.classish_keyword),
6465 4 => Some(&x.classish_name),
6466 5 => Some(&x.classish_type_parameters),
6467 6 => Some(&x.classish_extends_keyword),
6468 7 => Some(&x.classish_extends_list),
6469 8 => Some(&x.classish_implements_keyword),
6470 9 => Some(&x.classish_implements_list),
6471 10 => Some(&x.classish_where_clause),
6472 11 => Some(&x.classish_body),
6473 _ => None,
6474 }
6475 })
6476 },
6477 ClassishBody(x) => {
6478 get_index(3).and_then(|index| { match index {
6479 0 => Some(&x.classish_body_left_brace),
6480 1 => Some(&x.classish_body_elements),
6481 2 => Some(&x.classish_body_right_brace),
6482 _ => None,
6483 }
6484 })
6485 },
6486 TraitUsePrecedenceItem(x) => {
6487 get_index(3).and_then(|index| { match index {
6488 0 => Some(&x.trait_use_precedence_item_name),
6489 1 => Some(&x.trait_use_precedence_item_keyword),
6490 2 => Some(&x.trait_use_precedence_item_removed_names),
6491 _ => None,
6492 }
6493 })
6494 },
6495 TraitUseAliasItem(x) => {
6496 get_index(4).and_then(|index| { match index {
6497 0 => Some(&x.trait_use_alias_item_aliasing_name),
6498 1 => Some(&x.trait_use_alias_item_keyword),
6499 2 => Some(&x.trait_use_alias_item_modifiers),
6500 3 => Some(&x.trait_use_alias_item_aliased_name),
6501 _ => None,
6502 }
6503 })
6504 },
6505 TraitUseConflictResolution(x) => {
6506 get_index(5).and_then(|index| { match index {
6507 0 => Some(&x.trait_use_conflict_resolution_keyword),
6508 1 => Some(&x.trait_use_conflict_resolution_names),
6509 2 => Some(&x.trait_use_conflict_resolution_left_brace),
6510 3 => Some(&x.trait_use_conflict_resolution_clauses),
6511 4 => Some(&x.trait_use_conflict_resolution_right_brace),
6512 _ => None,
6513 }
6514 })
6515 },
6516 TraitUse(x) => {
6517 get_index(3).and_then(|index| { match index {
6518 0 => Some(&x.trait_use_keyword),
6519 1 => Some(&x.trait_use_names),
6520 2 => Some(&x.trait_use_semicolon),
6521 _ => None,
6522 }
6523 })
6524 },
6525 RequireClause(x) => {
6526 get_index(4).and_then(|index| { match index {
6527 0 => Some(&x.require_keyword),
6528 1 => Some(&x.require_kind),
6529 2 => Some(&x.require_name),
6530 3 => Some(&x.require_semicolon),
6531 _ => None,
6532 }
6533 })
6534 },
6535 ConstDeclaration(x) => {
6536 get_index(5).and_then(|index| { match index {
6537 0 => Some(&x.const_modifiers),
6538 1 => Some(&x.const_keyword),
6539 2 => Some(&x.const_type_specifier),
6540 3 => Some(&x.const_declarators),
6541 4 => Some(&x.const_semicolon),
6542 _ => None,
6543 }
6544 })
6545 },
6546 ConstantDeclarator(x) => {
6547 get_index(2).and_then(|index| { match index {
6548 0 => Some(&x.constant_declarator_name),
6549 1 => Some(&x.constant_declarator_initializer),
6550 _ => None,
6551 }
6552 })
6553 },
6554 TypeConstDeclaration(x) => {
6555 get_index(10).and_then(|index| { match index {
6556 0 => Some(&x.type_const_attribute_spec),
6557 1 => Some(&x.type_const_modifiers),
6558 2 => Some(&x.type_const_keyword),
6559 3 => Some(&x.type_const_type_keyword),
6560 4 => Some(&x.type_const_name),
6561 5 => Some(&x.type_const_type_parameters),
6562 6 => Some(&x.type_const_type_constraint),
6563 7 => Some(&x.type_const_equal),
6564 8 => Some(&x.type_const_type_specifier),
6565 9 => Some(&x.type_const_semicolon),
6566 _ => None,
6567 }
6568 })
6569 },
6570 ContextConstDeclaration(x) => {
6571 get_index(9).and_then(|index| { match index {
6572 0 => Some(&x.context_const_modifiers),
6573 1 => Some(&x.context_const_const_keyword),
6574 2 => Some(&x.context_const_ctx_keyword),
6575 3 => Some(&x.context_const_name),
6576 4 => Some(&x.context_const_type_parameters),
6577 5 => Some(&x.context_const_constraint),
6578 6 => Some(&x.context_const_equal),
6579 7 => Some(&x.context_const_ctx_list),
6580 8 => Some(&x.context_const_semicolon),
6581 _ => None,
6582 }
6583 })
6584 },
6585 DecoratedExpression(x) => {
6586 get_index(2).and_then(|index| { match index {
6587 0 => Some(&x.decorated_expression_decorator),
6588 1 => Some(&x.decorated_expression_expression),
6589 _ => None,
6590 }
6591 })
6592 },
6593 ParameterDeclaration(x) => {
6594 get_index(6).and_then(|index| { match index {
6595 0 => Some(&x.parameter_attribute),
6596 1 => Some(&x.parameter_visibility),
6597 2 => Some(&x.parameter_call_convention),
6598 3 => Some(&x.parameter_type),
6599 4 => Some(&x.parameter_name),
6600 5 => Some(&x.parameter_default_value),
6601 _ => None,
6602 }
6603 })
6604 },
6605 VariadicParameter(x) => {
6606 get_index(3).and_then(|index| { match index {
6607 0 => Some(&x.variadic_parameter_call_convention),
6608 1 => Some(&x.variadic_parameter_type),
6609 2 => Some(&x.variadic_parameter_ellipsis),
6610 _ => None,
6611 }
6612 })
6613 },
6614 OldAttributeSpecification(x) => {
6615 get_index(3).and_then(|index| { match index {
6616 0 => Some(&x.old_attribute_specification_left_double_angle),
6617 1 => Some(&x.old_attribute_specification_attributes),
6618 2 => Some(&x.old_attribute_specification_right_double_angle),
6619 _ => None,
6620 }
6621 })
6622 },
6623 AttributeSpecification(x) => {
6624 get_index(1).and_then(|index| { match index {
6625 0 => Some(&x.attribute_specification_attributes),
6626 _ => None,
6627 }
6628 })
6629 },
6630 Attribute(x) => {
6631 get_index(2).and_then(|index| { match index {
6632 0 => Some(&x.attribute_at),
6633 1 => Some(&x.attribute_attribute_name),
6634 _ => None,
6635 }
6636 })
6637 },
6638 InclusionExpression(x) => {
6639 get_index(2).and_then(|index| { match index {
6640 0 => Some(&x.inclusion_require),
6641 1 => Some(&x.inclusion_filename),
6642 _ => None,
6643 }
6644 })
6645 },
6646 InclusionDirective(x) => {
6647 get_index(2).and_then(|index| { match index {
6648 0 => Some(&x.inclusion_expression),
6649 1 => Some(&x.inclusion_semicolon),
6650 _ => None,
6651 }
6652 })
6653 },
6654 CompoundStatement(x) => {
6655 get_index(3).and_then(|index| { match index {
6656 0 => Some(&x.compound_left_brace),
6657 1 => Some(&x.compound_statements),
6658 2 => Some(&x.compound_right_brace),
6659 _ => None,
6660 }
6661 })
6662 },
6663 ExpressionStatement(x) => {
6664 get_index(2).and_then(|index| { match index {
6665 0 => Some(&x.expression_statement_expression),
6666 1 => Some(&x.expression_statement_semicolon),
6667 _ => None,
6668 }
6669 })
6670 },
6671 MarkupSection(x) => {
6672 get_index(2).and_then(|index| { match index {
6673 0 => Some(&x.markup_hashbang),
6674 1 => Some(&x.markup_suffix),
6675 _ => None,
6676 }
6677 })
6678 },
6679 MarkupSuffix(x) => {
6680 get_index(2).and_then(|index| { match index {
6681 0 => Some(&x.markup_suffix_less_than_question),
6682 1 => Some(&x.markup_suffix_name),
6683 _ => None,
6684 }
6685 })
6686 },
6687 UnsetStatement(x) => {
6688 get_index(5).and_then(|index| { match index {
6689 0 => Some(&x.unset_keyword),
6690 1 => Some(&x.unset_left_paren),
6691 2 => Some(&x.unset_variables),
6692 3 => Some(&x.unset_right_paren),
6693 4 => Some(&x.unset_semicolon),
6694 _ => None,
6695 }
6696 })
6697 },
6698 UsingStatementBlockScoped(x) => {
6699 get_index(6).and_then(|index| { match index {
6700 0 => Some(&x.using_block_await_keyword),
6701 1 => Some(&x.using_block_using_keyword),
6702 2 => Some(&x.using_block_left_paren),
6703 3 => Some(&x.using_block_expressions),
6704 4 => Some(&x.using_block_right_paren),
6705 5 => Some(&x.using_block_body),
6706 _ => None,
6707 }
6708 })
6709 },
6710 UsingStatementFunctionScoped(x) => {
6711 get_index(4).and_then(|index| { match index {
6712 0 => Some(&x.using_function_await_keyword),
6713 1 => Some(&x.using_function_using_keyword),
6714 2 => Some(&x.using_function_expression),
6715 3 => Some(&x.using_function_semicolon),
6716 _ => None,
6717 }
6718 })
6719 },
6720 WhileStatement(x) => {
6721 get_index(5).and_then(|index| { match index {
6722 0 => Some(&x.while_keyword),
6723 1 => Some(&x.while_left_paren),
6724 2 => Some(&x.while_condition),
6725 3 => Some(&x.while_right_paren),
6726 4 => Some(&x.while_body),
6727 _ => None,
6728 }
6729 })
6730 },
6731 IfStatement(x) => {
6732 get_index(7).and_then(|index| { match index {
6733 0 => Some(&x.if_keyword),
6734 1 => Some(&x.if_left_paren),
6735 2 => Some(&x.if_condition),
6736 3 => Some(&x.if_right_paren),
6737 4 => Some(&x.if_statement),
6738 5 => Some(&x.if_elseif_clauses),
6739 6 => Some(&x.if_else_clause),
6740 _ => None,
6741 }
6742 })
6743 },
6744 ElseifClause(x) => {
6745 get_index(5).and_then(|index| { match index {
6746 0 => Some(&x.elseif_keyword),
6747 1 => Some(&x.elseif_left_paren),
6748 2 => Some(&x.elseif_condition),
6749 3 => Some(&x.elseif_right_paren),
6750 4 => Some(&x.elseif_statement),
6751 _ => None,
6752 }
6753 })
6754 },
6755 ElseClause(x) => {
6756 get_index(2).and_then(|index| { match index {
6757 0 => Some(&x.else_keyword),
6758 1 => Some(&x.else_statement),
6759 _ => None,
6760 }
6761 })
6762 },
6763 TryStatement(x) => {
6764 get_index(4).and_then(|index| { match index {
6765 0 => Some(&x.try_keyword),
6766 1 => Some(&x.try_compound_statement),
6767 2 => Some(&x.try_catch_clauses),
6768 3 => Some(&x.try_finally_clause),
6769 _ => None,
6770 }
6771 })
6772 },
6773 CatchClause(x) => {
6774 get_index(6).and_then(|index| { match index {
6775 0 => Some(&x.catch_keyword),
6776 1 => Some(&x.catch_left_paren),
6777 2 => Some(&x.catch_type),
6778 3 => Some(&x.catch_variable),
6779 4 => Some(&x.catch_right_paren),
6780 5 => Some(&x.catch_body),
6781 _ => None,
6782 }
6783 })
6784 },
6785 FinallyClause(x) => {
6786 get_index(2).and_then(|index| { match index {
6787 0 => Some(&x.finally_keyword),
6788 1 => Some(&x.finally_body),
6789 _ => None,
6790 }
6791 })
6792 },
6793 DoStatement(x) => {
6794 get_index(7).and_then(|index| { match index {
6795 0 => Some(&x.do_keyword),
6796 1 => Some(&x.do_body),
6797 2 => Some(&x.do_while_keyword),
6798 3 => Some(&x.do_left_paren),
6799 4 => Some(&x.do_condition),
6800 5 => Some(&x.do_right_paren),
6801 6 => Some(&x.do_semicolon),
6802 _ => None,
6803 }
6804 })
6805 },
6806 ForStatement(x) => {
6807 get_index(9).and_then(|index| { match index {
6808 0 => Some(&x.for_keyword),
6809 1 => Some(&x.for_left_paren),
6810 2 => Some(&x.for_initializer),
6811 3 => Some(&x.for_first_semicolon),
6812 4 => Some(&x.for_control),
6813 5 => Some(&x.for_second_semicolon),
6814 6 => Some(&x.for_end_of_loop),
6815 7 => Some(&x.for_right_paren),
6816 8 => Some(&x.for_body),
6817 _ => None,
6818 }
6819 })
6820 },
6821 ForeachStatement(x) => {
6822 get_index(10).and_then(|index| { match index {
6823 0 => Some(&x.foreach_keyword),
6824 1 => Some(&x.foreach_left_paren),
6825 2 => Some(&x.foreach_collection),
6826 3 => Some(&x.foreach_await_keyword),
6827 4 => Some(&x.foreach_as),
6828 5 => Some(&x.foreach_key),
6829 6 => Some(&x.foreach_arrow),
6830 7 => Some(&x.foreach_value),
6831 8 => Some(&x.foreach_right_paren),
6832 9 => Some(&x.foreach_body),
6833 _ => None,
6834 }
6835 })
6836 },
6837 SwitchStatement(x) => {
6838 get_index(7).and_then(|index| { match index {
6839 0 => Some(&x.switch_keyword),
6840 1 => Some(&x.switch_left_paren),
6841 2 => Some(&x.switch_expression),
6842 3 => Some(&x.switch_right_paren),
6843 4 => Some(&x.switch_left_brace),
6844 5 => Some(&x.switch_sections),
6845 6 => Some(&x.switch_right_brace),
6846 _ => None,
6847 }
6848 })
6849 },
6850 SwitchSection(x) => {
6851 get_index(3).and_then(|index| { match index {
6852 0 => Some(&x.switch_section_labels),
6853 1 => Some(&x.switch_section_statements),
6854 2 => Some(&x.switch_section_fallthrough),
6855 _ => None,
6856 }
6857 })
6858 },
6859 SwitchFallthrough(x) => {
6860 get_index(2).and_then(|index| { match index {
6861 0 => Some(&x.fallthrough_keyword),
6862 1 => Some(&x.fallthrough_semicolon),
6863 _ => None,
6864 }
6865 })
6866 },
6867 CaseLabel(x) => {
6868 get_index(3).and_then(|index| { match index {
6869 0 => Some(&x.case_keyword),
6870 1 => Some(&x.case_expression),
6871 2 => Some(&x.case_colon),
6872 _ => None,
6873 }
6874 })
6875 },
6876 DefaultLabel(x) => {
6877 get_index(2).and_then(|index| { match index {
6878 0 => Some(&x.default_keyword),
6879 1 => Some(&x.default_colon),
6880 _ => None,
6881 }
6882 })
6883 },
6884 ReturnStatement(x) => {
6885 get_index(3).and_then(|index| { match index {
6886 0 => Some(&x.return_keyword),
6887 1 => Some(&x.return_expression),
6888 2 => Some(&x.return_semicolon),
6889 _ => None,
6890 }
6891 })
6892 },
6893 YieldBreakStatement(x) => {
6894 get_index(3).and_then(|index| { match index {
6895 0 => Some(&x.yield_break_keyword),
6896 1 => Some(&x.yield_break_break),
6897 2 => Some(&x.yield_break_semicolon),
6898 _ => None,
6899 }
6900 })
6901 },
6902 ThrowStatement(x) => {
6903 get_index(3).and_then(|index| { match index {
6904 0 => Some(&x.throw_keyword),
6905 1 => Some(&x.throw_expression),
6906 2 => Some(&x.throw_semicolon),
6907 _ => None,
6908 }
6909 })
6910 },
6911 BreakStatement(x) => {
6912 get_index(2).and_then(|index| { match index {
6913 0 => Some(&x.break_keyword),
6914 1 => Some(&x.break_semicolon),
6915 _ => None,
6916 }
6917 })
6918 },
6919 ContinueStatement(x) => {
6920 get_index(2).and_then(|index| { match index {
6921 0 => Some(&x.continue_keyword),
6922 1 => Some(&x.continue_semicolon),
6923 _ => None,
6924 }
6925 })
6926 },
6927 EchoStatement(x) => {
6928 get_index(3).and_then(|index| { match index {
6929 0 => Some(&x.echo_keyword),
6930 1 => Some(&x.echo_expressions),
6931 2 => Some(&x.echo_semicolon),
6932 _ => None,
6933 }
6934 })
6935 },
6936 ConcurrentStatement(x) => {
6937 get_index(2).and_then(|index| { match index {
6938 0 => Some(&x.concurrent_keyword),
6939 1 => Some(&x.concurrent_statement),
6940 _ => None,
6941 }
6942 })
6943 },
6944 SimpleInitializer(x) => {
6945 get_index(2).and_then(|index| { match index {
6946 0 => Some(&x.simple_initializer_equal),
6947 1 => Some(&x.simple_initializer_value),
6948 _ => None,
6949 }
6950 })
6951 },
6952 AnonymousClass(x) => {
6953 get_index(9).and_then(|index| { match index {
6954 0 => Some(&x.anonymous_class_class_keyword),
6955 1 => Some(&x.anonymous_class_left_paren),
6956 2 => Some(&x.anonymous_class_argument_list),
6957 3 => Some(&x.anonymous_class_right_paren),
6958 4 => Some(&x.anonymous_class_extends_keyword),
6959 5 => Some(&x.anonymous_class_extends_list),
6960 6 => Some(&x.anonymous_class_implements_keyword),
6961 7 => Some(&x.anonymous_class_implements_list),
6962 8 => Some(&x.anonymous_class_body),
6963 _ => None,
6964 }
6965 })
6966 },
6967 AnonymousFunction(x) => {
6968 get_index(12).and_then(|index| { match index {
6969 0 => Some(&x.anonymous_attribute_spec),
6970 1 => Some(&x.anonymous_static_keyword),
6971 2 => Some(&x.anonymous_async_keyword),
6972 3 => Some(&x.anonymous_function_keyword),
6973 4 => Some(&x.anonymous_left_paren),
6974 5 => Some(&x.anonymous_parameters),
6975 6 => Some(&x.anonymous_right_paren),
6976 7 => Some(&x.anonymous_ctx_list),
6977 8 => Some(&x.anonymous_colon),
6978 9 => Some(&x.anonymous_type),
6979 10 => Some(&x.anonymous_use),
6980 11 => Some(&x.anonymous_body),
6981 _ => None,
6982 }
6983 })
6984 },
6985 AnonymousFunctionUseClause(x) => {
6986 get_index(4).and_then(|index| { match index {
6987 0 => Some(&x.anonymous_use_keyword),
6988 1 => Some(&x.anonymous_use_left_paren),
6989 2 => Some(&x.anonymous_use_variables),
6990 3 => Some(&x.anonymous_use_right_paren),
6991 _ => None,
6992 }
6993 })
6994 },
6995 LambdaExpression(x) => {
6996 get_index(5).and_then(|index| { match index {
6997 0 => Some(&x.lambda_attribute_spec),
6998 1 => Some(&x.lambda_async),
6999 2 => Some(&x.lambda_signature),
7000 3 => Some(&x.lambda_arrow),
7001 4 => Some(&x.lambda_body),
7002 _ => None,
7003 }
7004 })
7005 },
7006 LambdaSignature(x) => {
7007 get_index(6).and_then(|index| { match index {
7008 0 => Some(&x.lambda_left_paren),
7009 1 => Some(&x.lambda_parameters),
7010 2 => Some(&x.lambda_right_paren),
7011 3 => Some(&x.lambda_contexts),
7012 4 => Some(&x.lambda_colon),
7013 5 => Some(&x.lambda_type),
7014 _ => None,
7015 }
7016 })
7017 },
7018 CastExpression(x) => {
7019 get_index(4).and_then(|index| { match index {
7020 0 => Some(&x.cast_left_paren),
7021 1 => Some(&x.cast_type),
7022 2 => Some(&x.cast_right_paren),
7023 3 => Some(&x.cast_operand),
7024 _ => None,
7025 }
7026 })
7027 },
7028 ScopeResolutionExpression(x) => {
7029 get_index(3).and_then(|index| { match index {
7030 0 => Some(&x.scope_resolution_qualifier),
7031 1 => Some(&x.scope_resolution_operator),
7032 2 => Some(&x.scope_resolution_name),
7033 _ => None,
7034 }
7035 })
7036 },
7037 MemberSelectionExpression(x) => {
7038 get_index(3).and_then(|index| { match index {
7039 0 => Some(&x.member_object),
7040 1 => Some(&x.member_operator),
7041 2 => Some(&x.member_name),
7042 _ => None,
7043 }
7044 })
7045 },
7046 SafeMemberSelectionExpression(x) => {
7047 get_index(3).and_then(|index| { match index {
7048 0 => Some(&x.safe_member_object),
7049 1 => Some(&x.safe_member_operator),
7050 2 => Some(&x.safe_member_name),
7051 _ => None,
7052 }
7053 })
7054 },
7055 EmbeddedMemberSelectionExpression(x) => {
7056 get_index(3).and_then(|index| { match index {
7057 0 => Some(&x.embedded_member_object),
7058 1 => Some(&x.embedded_member_operator),
7059 2 => Some(&x.embedded_member_name),
7060 _ => None,
7061 }
7062 })
7063 },
7064 YieldExpression(x) => {
7065 get_index(2).and_then(|index| { match index {
7066 0 => Some(&x.yield_keyword),
7067 1 => Some(&x.yield_operand),
7068 _ => None,
7069 }
7070 })
7071 },
7072 PrefixUnaryExpression(x) => {
7073 get_index(2).and_then(|index| { match index {
7074 0 => Some(&x.prefix_unary_operator),
7075 1 => Some(&x.prefix_unary_operand),
7076 _ => None,
7077 }
7078 })
7079 },
7080 PostfixUnaryExpression(x) => {
7081 get_index(2).and_then(|index| { match index {
7082 0 => Some(&x.postfix_unary_operand),
7083 1 => Some(&x.postfix_unary_operator),
7084 _ => None,
7085 }
7086 })
7087 },
7088 BinaryExpression(x) => {
7089 get_index(3).and_then(|index| { match index {
7090 0 => Some(&x.binary_left_operand),
7091 1 => Some(&x.binary_operator),
7092 2 => Some(&x.binary_right_operand),
7093 _ => None,
7094 }
7095 })
7096 },
7097 IsExpression(x) => {
7098 get_index(3).and_then(|index| { match index {
7099 0 => Some(&x.is_left_operand),
7100 1 => Some(&x.is_operator),
7101 2 => Some(&x.is_right_operand),
7102 _ => None,
7103 }
7104 })
7105 },
7106 AsExpression(x) => {
7107 get_index(3).and_then(|index| { match index {
7108 0 => Some(&x.as_left_operand),
7109 1 => Some(&x.as_operator),
7110 2 => Some(&x.as_right_operand),
7111 _ => None,
7112 }
7113 })
7114 },
7115 NullableAsExpression(x) => {
7116 get_index(3).and_then(|index| { match index {
7117 0 => Some(&x.nullable_as_left_operand),
7118 1 => Some(&x.nullable_as_operator),
7119 2 => Some(&x.nullable_as_right_operand),
7120 _ => None,
7121 }
7122 })
7123 },
7124 ConditionalExpression(x) => {
7125 get_index(5).and_then(|index| { match index {
7126 0 => Some(&x.conditional_test),
7127 1 => Some(&x.conditional_question),
7128 2 => Some(&x.conditional_consequence),
7129 3 => Some(&x.conditional_colon),
7130 4 => Some(&x.conditional_alternative),
7131 _ => None,
7132 }
7133 })
7134 },
7135 EvalExpression(x) => {
7136 get_index(4).and_then(|index| { match index {
7137 0 => Some(&x.eval_keyword),
7138 1 => Some(&x.eval_left_paren),
7139 2 => Some(&x.eval_argument),
7140 3 => Some(&x.eval_right_paren),
7141 _ => None,
7142 }
7143 })
7144 },
7145 DefineExpression(x) => {
7146 get_index(4).and_then(|index| { match index {
7147 0 => Some(&x.define_keyword),
7148 1 => Some(&x.define_left_paren),
7149 2 => Some(&x.define_argument_list),
7150 3 => Some(&x.define_right_paren),
7151 _ => None,
7152 }
7153 })
7154 },
7155 IssetExpression(x) => {
7156 get_index(4).and_then(|index| { match index {
7157 0 => Some(&x.isset_keyword),
7158 1 => Some(&x.isset_left_paren),
7159 2 => Some(&x.isset_argument_list),
7160 3 => Some(&x.isset_right_paren),
7161 _ => None,
7162 }
7163 })
7164 },
7165 FunctionCallExpression(x) => {
7166 get_index(5).and_then(|index| { match index {
7167 0 => Some(&x.function_call_receiver),
7168 1 => Some(&x.function_call_type_args),
7169 2 => Some(&x.function_call_left_paren),
7170 3 => Some(&x.function_call_argument_list),
7171 4 => Some(&x.function_call_right_paren),
7172 _ => None,
7173 }
7174 })
7175 },
7176 FunctionPointerExpression(x) => {
7177 get_index(2).and_then(|index| { match index {
7178 0 => Some(&x.function_pointer_receiver),
7179 1 => Some(&x.function_pointer_type_args),
7180 _ => None,
7181 }
7182 })
7183 },
7184 ParenthesizedExpression(x) => {
7185 get_index(3).and_then(|index| { match index {
7186 0 => Some(&x.parenthesized_expression_left_paren),
7187 1 => Some(&x.parenthesized_expression_expression),
7188 2 => Some(&x.parenthesized_expression_right_paren),
7189 _ => None,
7190 }
7191 })
7192 },
7193 BracedExpression(x) => {
7194 get_index(3).and_then(|index| { match index {
7195 0 => Some(&x.braced_expression_left_brace),
7196 1 => Some(&x.braced_expression_expression),
7197 2 => Some(&x.braced_expression_right_brace),
7198 _ => None,
7199 }
7200 })
7201 },
7202 ETSpliceExpression(x) => {
7203 get_index(4).and_then(|index| { match index {
7204 0 => Some(&x.et_splice_expression_dollar),
7205 1 => Some(&x.et_splice_expression_left_brace),
7206 2 => Some(&x.et_splice_expression_expression),
7207 3 => Some(&x.et_splice_expression_right_brace),
7208 _ => None,
7209 }
7210 })
7211 },
7212 EmbeddedBracedExpression(x) => {
7213 get_index(3).and_then(|index| { match index {
7214 0 => Some(&x.embedded_braced_expression_left_brace),
7215 1 => Some(&x.embedded_braced_expression_expression),
7216 2 => Some(&x.embedded_braced_expression_right_brace),
7217 _ => None,
7218 }
7219 })
7220 },
7221 ListExpression(x) => {
7222 get_index(4).and_then(|index| { match index {
7223 0 => Some(&x.list_keyword),
7224 1 => Some(&x.list_left_paren),
7225 2 => Some(&x.list_members),
7226 3 => Some(&x.list_right_paren),
7227 _ => None,
7228 }
7229 })
7230 },
7231 CollectionLiteralExpression(x) => {
7232 get_index(4).and_then(|index| { match index {
7233 0 => Some(&x.collection_literal_name),
7234 1 => Some(&x.collection_literal_left_brace),
7235 2 => Some(&x.collection_literal_initializers),
7236 3 => Some(&x.collection_literal_right_brace),
7237 _ => None,
7238 }
7239 })
7240 },
7241 ObjectCreationExpression(x) => {
7242 get_index(2).and_then(|index| { match index {
7243 0 => Some(&x.object_creation_new_keyword),
7244 1 => Some(&x.object_creation_object),
7245 _ => None,
7246 }
7247 })
7248 },
7249 ConstructorCall(x) => {
7250 get_index(4).and_then(|index| { match index {
7251 0 => Some(&x.constructor_call_type),
7252 1 => Some(&x.constructor_call_left_paren),
7253 2 => Some(&x.constructor_call_argument_list),
7254 3 => Some(&x.constructor_call_right_paren),
7255 _ => None,
7256 }
7257 })
7258 },
7259 RecordCreationExpression(x) => {
7260 get_index(4).and_then(|index| { match index {
7261 0 => Some(&x.record_creation_type),
7262 1 => Some(&x.record_creation_left_bracket),
7263 2 => Some(&x.record_creation_members),
7264 3 => Some(&x.record_creation_right_bracket),
7265 _ => None,
7266 }
7267 })
7268 },
7269 DarrayIntrinsicExpression(x) => {
7270 get_index(5).and_then(|index| { match index {
7271 0 => Some(&x.darray_intrinsic_keyword),
7272 1 => Some(&x.darray_intrinsic_explicit_type),
7273 2 => Some(&x.darray_intrinsic_left_bracket),
7274 3 => Some(&x.darray_intrinsic_members),
7275 4 => Some(&x.darray_intrinsic_right_bracket),
7276 _ => None,
7277 }
7278 })
7279 },
7280 DictionaryIntrinsicExpression(x) => {
7281 get_index(5).and_then(|index| { match index {
7282 0 => Some(&x.dictionary_intrinsic_keyword),
7283 1 => Some(&x.dictionary_intrinsic_explicit_type),
7284 2 => Some(&x.dictionary_intrinsic_left_bracket),
7285 3 => Some(&x.dictionary_intrinsic_members),
7286 4 => Some(&x.dictionary_intrinsic_right_bracket),
7287 _ => None,
7288 }
7289 })
7290 },
7291 KeysetIntrinsicExpression(x) => {
7292 get_index(5).and_then(|index| { match index {
7293 0 => Some(&x.keyset_intrinsic_keyword),
7294 1 => Some(&x.keyset_intrinsic_explicit_type),
7295 2 => Some(&x.keyset_intrinsic_left_bracket),
7296 3 => Some(&x.keyset_intrinsic_members),
7297 4 => Some(&x.keyset_intrinsic_right_bracket),
7298 _ => None,
7299 }
7300 })
7301 },
7302 VarrayIntrinsicExpression(x) => {
7303 get_index(5).and_then(|index| { match index {
7304 0 => Some(&x.varray_intrinsic_keyword),
7305 1 => Some(&x.varray_intrinsic_explicit_type),
7306 2 => Some(&x.varray_intrinsic_left_bracket),
7307 3 => Some(&x.varray_intrinsic_members),
7308 4 => Some(&x.varray_intrinsic_right_bracket),
7309 _ => None,
7310 }
7311 })
7312 },
7313 VectorIntrinsicExpression(x) => {
7314 get_index(5).and_then(|index| { match index {
7315 0 => Some(&x.vector_intrinsic_keyword),
7316 1 => Some(&x.vector_intrinsic_explicit_type),
7317 2 => Some(&x.vector_intrinsic_left_bracket),
7318 3 => Some(&x.vector_intrinsic_members),
7319 4 => Some(&x.vector_intrinsic_right_bracket),
7320 _ => None,
7321 }
7322 })
7323 },
7324 ElementInitializer(x) => {
7325 get_index(3).and_then(|index| { match index {
7326 0 => Some(&x.element_key),
7327 1 => Some(&x.element_arrow),
7328 2 => Some(&x.element_value),
7329 _ => None,
7330 }
7331 })
7332 },
7333 SubscriptExpression(x) => {
7334 get_index(4).and_then(|index| { match index {
7335 0 => Some(&x.subscript_receiver),
7336 1 => Some(&x.subscript_left_bracket),
7337 2 => Some(&x.subscript_index),
7338 3 => Some(&x.subscript_right_bracket),
7339 _ => None,
7340 }
7341 })
7342 },
7343 EmbeddedSubscriptExpression(x) => {
7344 get_index(4).and_then(|index| { match index {
7345 0 => Some(&x.embedded_subscript_receiver),
7346 1 => Some(&x.embedded_subscript_left_bracket),
7347 2 => Some(&x.embedded_subscript_index),
7348 3 => Some(&x.embedded_subscript_right_bracket),
7349 _ => None,
7350 }
7351 })
7352 },
7353 AwaitableCreationExpression(x) => {
7354 get_index(3).and_then(|index| { match index {
7355 0 => Some(&x.awaitable_attribute_spec),
7356 1 => Some(&x.awaitable_async),
7357 2 => Some(&x.awaitable_compound_statement),
7358 _ => None,
7359 }
7360 })
7361 },
7362 XHPChildrenDeclaration(x) => {
7363 get_index(3).and_then(|index| { match index {
7364 0 => Some(&x.xhp_children_keyword),
7365 1 => Some(&x.xhp_children_expression),
7366 2 => Some(&x.xhp_children_semicolon),
7367 _ => None,
7368 }
7369 })
7370 },
7371 XHPChildrenParenthesizedList(x) => {
7372 get_index(3).and_then(|index| { match index {
7373 0 => Some(&x.xhp_children_list_left_paren),
7374 1 => Some(&x.xhp_children_list_xhp_children),
7375 2 => Some(&x.xhp_children_list_right_paren),
7376 _ => None,
7377 }
7378 })
7379 },
7380 XHPCategoryDeclaration(x) => {
7381 get_index(3).and_then(|index| { match index {
7382 0 => Some(&x.xhp_category_keyword),
7383 1 => Some(&x.xhp_category_categories),
7384 2 => Some(&x.xhp_category_semicolon),
7385 _ => None,
7386 }
7387 })
7388 },
7389 XHPEnumType(x) => {
7390 get_index(4).and_then(|index| { match index {
7391 0 => Some(&x.xhp_enum_keyword),
7392 1 => Some(&x.xhp_enum_left_brace),
7393 2 => Some(&x.xhp_enum_values),
7394 3 => Some(&x.xhp_enum_right_brace),
7395 _ => None,
7396 }
7397 })
7398 },
7399 XHPLateinit(x) => {
7400 get_index(2).and_then(|index| { match index {
7401 0 => Some(&x.xhp_lateinit_at),
7402 1 => Some(&x.xhp_lateinit_keyword),
7403 _ => None,
7404 }
7405 })
7406 },
7407 XHPRequired(x) => {
7408 get_index(2).and_then(|index| { match index {
7409 0 => Some(&x.xhp_required_at),
7410 1 => Some(&x.xhp_required_keyword),
7411 _ => None,
7412 }
7413 })
7414 },
7415 XHPClassAttributeDeclaration(x) => {
7416 get_index(3).and_then(|index| { match index {
7417 0 => Some(&x.xhp_attribute_keyword),
7418 1 => Some(&x.xhp_attribute_attributes),
7419 2 => Some(&x.xhp_attribute_semicolon),
7420 _ => None,
7421 }
7422 })
7423 },
7424 XHPClassAttribute(x) => {
7425 get_index(4).and_then(|index| { match index {
7426 0 => Some(&x.xhp_attribute_decl_type),
7427 1 => Some(&x.xhp_attribute_decl_name),
7428 2 => Some(&x.xhp_attribute_decl_initializer),
7429 3 => Some(&x.xhp_attribute_decl_required),
7430 _ => None,
7431 }
7432 })
7433 },
7434 XHPSimpleClassAttribute(x) => {
7435 get_index(1).and_then(|index| { match index {
7436 0 => Some(&x.xhp_simple_class_attribute_type),
7437 _ => None,
7438 }
7439 })
7440 },
7441 XHPSimpleAttribute(x) => {
7442 get_index(3).and_then(|index| { match index {
7443 0 => Some(&x.xhp_simple_attribute_name),
7444 1 => Some(&x.xhp_simple_attribute_equal),
7445 2 => Some(&x.xhp_simple_attribute_expression),
7446 _ => None,
7447 }
7448 })
7449 },
7450 XHPSpreadAttribute(x) => {
7451 get_index(4).and_then(|index| { match index {
7452 0 => Some(&x.xhp_spread_attribute_left_brace),
7453 1 => Some(&x.xhp_spread_attribute_spread_operator),
7454 2 => Some(&x.xhp_spread_attribute_expression),
7455 3 => Some(&x.xhp_spread_attribute_right_brace),
7456 _ => None,
7457 }
7458 })
7459 },
7460 XHPOpen(x) => {
7461 get_index(4).and_then(|index| { match index {
7462 0 => Some(&x.xhp_open_left_angle),
7463 1 => Some(&x.xhp_open_name),
7464 2 => Some(&x.xhp_open_attributes),
7465 3 => Some(&x.xhp_open_right_angle),
7466 _ => None,
7467 }
7468 })
7469 },
7470 XHPExpression(x) => {
7471 get_index(3).and_then(|index| { match index {
7472 0 => Some(&x.xhp_open),
7473 1 => Some(&x.xhp_body),
7474 2 => Some(&x.xhp_close),
7475 _ => None,
7476 }
7477 })
7478 },
7479 XHPClose(x) => {
7480 get_index(3).and_then(|index| { match index {
7481 0 => Some(&x.xhp_close_left_angle),
7482 1 => Some(&x.xhp_close_name),
7483 2 => Some(&x.xhp_close_right_angle),
7484 _ => None,
7485 }
7486 })
7487 },
7488 TypeConstant(x) => {
7489 get_index(3).and_then(|index| { match index {
7490 0 => Some(&x.type_constant_left_type),
7491 1 => Some(&x.type_constant_separator),
7492 2 => Some(&x.type_constant_right_type),
7493 _ => None,
7494 }
7495 })
7496 },
7497 VectorTypeSpecifier(x) => {
7498 get_index(5).and_then(|index| { match index {
7499 0 => Some(&x.vector_type_keyword),
7500 1 => Some(&x.vector_type_left_angle),
7501 2 => Some(&x.vector_type_type),
7502 3 => Some(&x.vector_type_trailing_comma),
7503 4 => Some(&x.vector_type_right_angle),
7504 _ => None,
7505 }
7506 })
7507 },
7508 KeysetTypeSpecifier(x) => {
7509 get_index(5).and_then(|index| { match index {
7510 0 => Some(&x.keyset_type_keyword),
7511 1 => Some(&x.keyset_type_left_angle),
7512 2 => Some(&x.keyset_type_type),
7513 3 => Some(&x.keyset_type_trailing_comma),
7514 4 => Some(&x.keyset_type_right_angle),
7515 _ => None,
7516 }
7517 })
7518 },
7519 TupleTypeExplicitSpecifier(x) => {
7520 get_index(4).and_then(|index| { match index {
7521 0 => Some(&x.tuple_type_keyword),
7522 1 => Some(&x.tuple_type_left_angle),
7523 2 => Some(&x.tuple_type_types),
7524 3 => Some(&x.tuple_type_right_angle),
7525 _ => None,
7526 }
7527 })
7528 },
7529 VarrayTypeSpecifier(x) => {
7530 get_index(5).and_then(|index| { match index {
7531 0 => Some(&x.varray_keyword),
7532 1 => Some(&x.varray_left_angle),
7533 2 => Some(&x.varray_type),
7534 3 => Some(&x.varray_trailing_comma),
7535 4 => Some(&x.varray_right_angle),
7536 _ => None,
7537 }
7538 })
7539 },
7540 FunctionCtxTypeSpecifier(x) => {
7541 get_index(2).and_then(|index| { match index {
7542 0 => Some(&x.function_ctx_type_keyword),
7543 1 => Some(&x.function_ctx_type_variable),
7544 _ => None,
7545 }
7546 })
7547 },
7548 TypeParameter(x) => {
7549 get_index(6).and_then(|index| { match index {
7550 0 => Some(&x.type_attribute_spec),
7551 1 => Some(&x.type_reified),
7552 2 => Some(&x.type_variance),
7553 3 => Some(&x.type_name),
7554 4 => Some(&x.type_param_params),
7555 5 => Some(&x.type_constraints),
7556 _ => None,
7557 }
7558 })
7559 },
7560 TypeConstraint(x) => {
7561 get_index(2).and_then(|index| { match index {
7562 0 => Some(&x.constraint_keyword),
7563 1 => Some(&x.constraint_type),
7564 _ => None,
7565 }
7566 })
7567 },
7568 ContextConstraint(x) => {
7569 get_index(2).and_then(|index| { match index {
7570 0 => Some(&x.ctx_constraint_keyword),
7571 1 => Some(&x.ctx_constraint_ctx_list),
7572 _ => None,
7573 }
7574 })
7575 },
7576 DarrayTypeSpecifier(x) => {
7577 get_index(7).and_then(|index| { match index {
7578 0 => Some(&x.darray_keyword),
7579 1 => Some(&x.darray_left_angle),
7580 2 => Some(&x.darray_key),
7581 3 => Some(&x.darray_comma),
7582 4 => Some(&x.darray_value),
7583 5 => Some(&x.darray_trailing_comma),
7584 6 => Some(&x.darray_right_angle),
7585 _ => None,
7586 }
7587 })
7588 },
7589 DictionaryTypeSpecifier(x) => {
7590 get_index(4).and_then(|index| { match index {
7591 0 => Some(&x.dictionary_type_keyword),
7592 1 => Some(&x.dictionary_type_left_angle),
7593 2 => Some(&x.dictionary_type_members),
7594 3 => Some(&x.dictionary_type_right_angle),
7595 _ => None,
7596 }
7597 })
7598 },
7599 ClosureTypeSpecifier(x) => {
7600 get_index(9).and_then(|index| { match index {
7601 0 => Some(&x.closure_outer_left_paren),
7602 1 => Some(&x.closure_function_keyword),
7603 2 => Some(&x.closure_inner_left_paren),
7604 3 => Some(&x.closure_parameter_list),
7605 4 => Some(&x.closure_inner_right_paren),
7606 5 => Some(&x.closure_contexts),
7607 6 => Some(&x.closure_colon),
7608 7 => Some(&x.closure_return_type),
7609 8 => Some(&x.closure_outer_right_paren),
7610 _ => None,
7611 }
7612 })
7613 },
7614 ClosureParameterTypeSpecifier(x) => {
7615 get_index(2).and_then(|index| { match index {
7616 0 => Some(&x.closure_parameter_call_convention),
7617 1 => Some(&x.closure_parameter_type),
7618 _ => None,
7619 }
7620 })
7621 },
7622 ClassnameTypeSpecifier(x) => {
7623 get_index(5).and_then(|index| { match index {
7624 0 => Some(&x.classname_keyword),
7625 1 => Some(&x.classname_left_angle),
7626 2 => Some(&x.classname_type),
7627 3 => Some(&x.classname_trailing_comma),
7628 4 => Some(&x.classname_right_angle),
7629 _ => None,
7630 }
7631 })
7632 },
7633 FieldSpecifier(x) => {
7634 get_index(4).and_then(|index| { match index {
7635 0 => Some(&x.field_question),
7636 1 => Some(&x.field_name),
7637 2 => Some(&x.field_arrow),
7638 3 => Some(&x.field_type),
7639 _ => None,
7640 }
7641 })
7642 },
7643 FieldInitializer(x) => {
7644 get_index(3).and_then(|index| { match index {
7645 0 => Some(&x.field_initializer_name),
7646 1 => Some(&x.field_initializer_arrow),
7647 2 => Some(&x.field_initializer_value),
7648 _ => None,
7649 }
7650 })
7651 },
7652 ShapeTypeSpecifier(x) => {
7653 get_index(5).and_then(|index| { match index {
7654 0 => Some(&x.shape_type_keyword),
7655 1 => Some(&x.shape_type_left_paren),
7656 2 => Some(&x.shape_type_fields),
7657 3 => Some(&x.shape_type_ellipsis),
7658 4 => Some(&x.shape_type_right_paren),
7659 _ => None,
7660 }
7661 })
7662 },
7663 ShapeExpression(x) => {
7664 get_index(4).and_then(|index| { match index {
7665 0 => Some(&x.shape_expression_keyword),
7666 1 => Some(&x.shape_expression_left_paren),
7667 2 => Some(&x.shape_expression_fields),
7668 3 => Some(&x.shape_expression_right_paren),
7669 _ => None,
7670 }
7671 })
7672 },
7673 TupleExpression(x) => {
7674 get_index(4).and_then(|index| { match index {
7675 0 => Some(&x.tuple_expression_keyword),
7676 1 => Some(&x.tuple_expression_left_paren),
7677 2 => Some(&x.tuple_expression_items),
7678 3 => Some(&x.tuple_expression_right_paren),
7679 _ => None,
7680 }
7681 })
7682 },
7683 GenericTypeSpecifier(x) => {
7684 get_index(2).and_then(|index| { match index {
7685 0 => Some(&x.generic_class_type),
7686 1 => Some(&x.generic_argument_list),
7687 _ => None,
7688 }
7689 })
7690 },
7691 NullableTypeSpecifier(x) => {
7692 get_index(2).and_then(|index| { match index {
7693 0 => Some(&x.nullable_question),
7694 1 => Some(&x.nullable_type),
7695 _ => None,
7696 }
7697 })
7698 },
7699 LikeTypeSpecifier(x) => {
7700 get_index(2).and_then(|index| { match index {
7701 0 => Some(&x.like_tilde),
7702 1 => Some(&x.like_type),
7703 _ => None,
7704 }
7705 })
7706 },
7707 SoftTypeSpecifier(x) => {
7708 get_index(2).and_then(|index| { match index {
7709 0 => Some(&x.soft_at),
7710 1 => Some(&x.soft_type),
7711 _ => None,
7712 }
7713 })
7714 },
7715 AttributizedSpecifier(x) => {
7716 get_index(2).and_then(|index| { match index {
7717 0 => Some(&x.attributized_specifier_attribute_spec),
7718 1 => Some(&x.attributized_specifier_type),
7719 _ => None,
7720 }
7721 })
7722 },
7723 ReifiedTypeArgument(x) => {
7724 get_index(2).and_then(|index| { match index {
7725 0 => Some(&x.reified_type_argument_reified),
7726 1 => Some(&x.reified_type_argument_type),
7727 _ => None,
7728 }
7729 })
7730 },
7731 TypeArguments(x) => {
7732 get_index(3).and_then(|index| { match index {
7733 0 => Some(&x.type_arguments_left_angle),
7734 1 => Some(&x.type_arguments_types),
7735 2 => Some(&x.type_arguments_right_angle),
7736 _ => None,
7737 }
7738 })
7739 },
7740 TypeParameters(x) => {
7741 get_index(3).and_then(|index| { match index {
7742 0 => Some(&x.type_parameters_left_angle),
7743 1 => Some(&x.type_parameters_parameters),
7744 2 => Some(&x.type_parameters_right_angle),
7745 _ => None,
7746 }
7747 })
7748 },
7749 TupleTypeSpecifier(x) => {
7750 get_index(3).and_then(|index| { match index {
7751 0 => Some(&x.tuple_left_paren),
7752 1 => Some(&x.tuple_types),
7753 2 => Some(&x.tuple_right_paren),
7754 _ => None,
7755 }
7756 })
7757 },
7758 UnionTypeSpecifier(x) => {
7759 get_index(3).and_then(|index| { match index {
7760 0 => Some(&x.union_left_paren),
7761 1 => Some(&x.union_types),
7762 2 => Some(&x.union_right_paren),
7763 _ => None,
7764 }
7765 })
7766 },
7767 IntersectionTypeSpecifier(x) => {
7768 get_index(3).and_then(|index| { match index {
7769 0 => Some(&x.intersection_left_paren),
7770 1 => Some(&x.intersection_types),
7771 2 => Some(&x.intersection_right_paren),
7772 _ => None,
7773 }
7774 })
7775 },
7776 ErrorSyntax(x) => {
7777 get_index(1).and_then(|index| { match index {
7778 0 => Some(&x.error_error),
7779 _ => None,
7780 }
7781 })
7782 },
7783 ListItem(x) => {
7784 get_index(2).and_then(|index| { match index {
7785 0 => Some(&x.list_item),
7786 1 => Some(&x.list_separator),
7787 _ => None,
7788 }
7789 })
7790 },
7791 EnumAtomExpression(x) => {
7792 get_index(2).and_then(|index| { match index {
7793 0 => Some(&x.enum_atom_hash),
7794 1 => Some(&x.enum_atom_expression),
7795 _ => None,
7796 }
7797 })
7798 },
7800 };
7801 if res.is_some() {
7802 if direction {
7803 self.index = self.index + 1
7804 } else {
7805 self.index_back = self.index_back + 1
7806 }
7807 }
7808 res
7809 }
7810 }