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