1use std::marker::PhantomData;
2
3use crate::nodes::*;
4
5use super::node_processor::{NodePostProcessor, NodeProcessor};
6
7pub trait NodePostVisitor<T: NodeProcessor + NodePostProcessor> {
10 fn visit_block(block: &mut Block, processor: &mut T) {
11 processor.process_block(block);
12
13 block
14 .iter_mut_statements()
15 .for_each(|statement| Self::visit_statement(statement, processor));
16
17 if let Some(last_statement) = block.mutate_last_statement() {
18 Self::visit_last_statement(last_statement, processor);
19 };
20 processor.process_after_block(block);
21 }
22
23 fn visit_statement(statement: &mut Statement, processor: &mut T) {
24 processor.process_statement(statement);
25
26 match statement {
27 Statement::Assign(statement) => Self::visit_assign_statement(statement, processor),
28 Statement::Do(statement) => Self::visit_do_statement(statement, processor),
29 Statement::Call(statement) => Self::visit_function_call(statement, processor),
30 Statement::CompoundAssign(statement) => {
31 Self::visit_compound_assign(statement, processor)
32 }
33 Statement::Function(statement) => Self::visit_function_statement(statement, processor),
34 Statement::GenericFor(statement) => Self::visit_generic_for(statement, processor),
35 Statement::If(statement) => Self::visit_if_statement(statement, processor),
36 Statement::LocalAssign(statement) => Self::visit_local_assign(statement, processor),
37 Statement::LocalFunction(statement) => Self::visit_local_function(statement, processor),
38 Statement::NumericFor(statement) => Self::visit_numeric_for(statement, processor),
39 Statement::Repeat(statement) => Self::visit_repeat_statement(statement, processor),
40 Statement::While(statement) => Self::visit_while_statement(statement, processor),
41 Statement::TypeDeclaration(statement) => {
42 Self::visit_type_declaration(statement, processor)
43 }
44 };
45 processor.process_after_statement(statement);
46 }
47
48 fn visit_last_statement(last_statement: &mut LastStatement, processor: &mut T) {
49 processor.process_last_statement(last_statement);
50
51 if let LastStatement::Return(expressions) = last_statement {
52 expressions
53 .iter_mut_expressions()
54 .for_each(|expression| Self::visit_expression(expression, processor));
55 };
56 processor.process_after_last_statement(last_statement);
57 }
58
59 fn visit_expression(expression: &mut Expression, processor: &mut T) {
60 processor.process_expression(expression);
61
62 match expression {
63 Expression::Binary(expression) => {
64 Self::visit_binary_expression(expression, processor);
65 }
66 Expression::Call(expression) => Self::visit_function_call(expression, processor),
67 Expression::Field(field) => Self::visit_field_expression(field, processor),
68 Expression::Function(function) => Self::visit_function_expression(function, processor),
69 Expression::Identifier(identifier) => Self::visit_identifier(identifier, processor),
70 Expression::If(if_expression) => Self::visit_if_expression(if_expression, processor),
71 Expression::Index(index) => Self::visit_index_expression(index, processor),
72 Expression::Number(number) => Self::visit_number_expression(number, processor),
73 Expression::Parenthese(expression) => {
74 Self::visit_parenthese_expression(expression, processor);
75 }
76 Expression::String(string) => {
77 Self::visit_string_expression(string, processor);
78 }
79 Expression::InterpolatedString(interpolated_string) => {
80 Self::visit_interpolated_string_expression(interpolated_string, processor);
81 }
82 Expression::Table(table) => Self::visit_table(table, processor),
83 Expression::Unary(unary) => {
84 Self::visit_unary_expression(unary, processor);
85 }
86 Expression::TypeCast(type_cast) => {
87 Self::visit_type_cast_expression(type_cast, processor);
88 }
89 Expression::False(_)
90 | Expression::Nil(_)
91 | Expression::True(_)
92 | Expression::VariableArguments(_) => {}
93 }
94 processor.process_after_expression(expression);
95 }
96
97 fn visit_binary_expression(binary: &mut BinaryExpression, processor: &mut T) {
98 processor.process_binary_expression(binary);
99 Self::visit_expression(binary.mutate_left(), processor);
100 Self::visit_expression(binary.mutate_right(), processor);
101 processor.process_after_binary_expression(binary);
102 }
103
104 fn visit_number_expression(number: &mut NumberExpression, processor: &mut T) {
105 processor.process_number_expression(number);
106 processor.process_after_number_expression(number);
107 }
108
109 fn visit_parenthese_expression(parenthese: &mut ParentheseExpression, processor: &mut T) {
110 processor.process_parenthese_expression(parenthese);
111 Self::visit_expression(parenthese.mutate_inner_expression(), processor);
112 processor.process_after_parenthese_expression(parenthese);
113 }
114
115 fn visit_string_expression(string: &mut StringExpression, processor: &mut T) {
116 processor.process_string_expression(string);
117 processor.process_after_string_expression(string);
118 }
119
120 fn visit_interpolated_string_expression(
121 interpolated_string: &mut InterpolatedStringExpression,
122 processor: &mut T,
123 ) {
124 processor.process_interpolated_string_expression(interpolated_string);
125
126 for segment in interpolated_string.iter_mut_segments() {
127 match segment {
128 InterpolationSegment::String(_) => {}
129 InterpolationSegment::Value(value) => {
130 Self::visit_expression(value.mutate_expression(), processor)
131 }
132 }
133 }
134 processor.process_after_interpolated_string_expression(interpolated_string);
135 }
136
137 fn visit_unary_expression(unary: &mut UnaryExpression, processor: &mut T) {
138 processor.process_unary_expression(unary);
139 Self::visit_expression(unary.mutate_expression(), processor);
140 processor.process_after_unary_expression(unary);
141 }
142
143 fn visit_type_cast_expression(type_cast: &mut TypeCastExpression, processor: &mut T) {
144 processor.process_type_cast_expression(type_cast);
145
146 Self::visit_expression(type_cast.mutate_expression(), processor);
147 Self::visit_type(type_cast.mutate_type(), processor);
148 processor.process_after_type_cast_expression(type_cast);
149 }
150
151 fn visit_function_expression(function: &mut FunctionExpression, processor: &mut T) {
152 processor.process_function_expression(function);
153
154 processor.process_scope(function.mutate_block(), None);
155
156 Self::visit_block(function.mutate_block(), processor);
157
158 for r#type in function
159 .iter_mut_parameters()
160 .filter_map(TypedIdentifier::mutate_type)
161 {
162 Self::visit_type(r#type, processor);
163 }
164
165 if let Some(variadic_type) = function.mutate_variadic_type() {
166 Self::visit_function_variadic_type(variadic_type, processor);
167 }
168
169 if let Some(return_type) = function.mutate_return_type() {
170 Self::visit_function_return_type(return_type, processor);
171 }
172 processor.process_after_function_expression(function);
173 }
174
175 fn visit_assign_statement(statement: &mut AssignStatement, processor: &mut T) {
176 processor.process_assign_statement(statement);
177
178 statement
179 .mutate_variables()
180 .iter_mut()
181 .for_each(|variable| Self::visit_variable(variable, processor));
182
183 statement
184 .iter_mut_values()
185 .for_each(|expression| Self::visit_expression(expression, processor));
186 processor.process_after_assign_statement(statement);
187 }
188
189 fn visit_do_statement(statement: &mut DoStatement, processor: &mut T) {
190 processor.process_do_statement(statement);
191 processor.process_scope(statement.mutate_block(), None);
192 Self::visit_block(statement.mutate_block(), processor);
193 processor.process_after_do_statement(statement);
194 }
195
196 fn visit_compound_assign(statement: &mut CompoundAssignStatement, processor: &mut T) {
197 processor.process_compound_assign_statement(statement);
198 Self::visit_variable(statement.mutate_variable(), processor);
199 Self::visit_expression(statement.mutate_value(), processor);
200 processor.process_after_compound_assign_statement(statement);
201 }
202
203 fn visit_function_statement(statement: &mut FunctionStatement, processor: &mut T) {
204 processor.process_function_statement(statement);
205
206 Self::visit_identifier(
207 statement.mutate_function_name().mutate_identifier(),
208 processor,
209 );
210
211 processor.process_scope(statement.mutate_block(), None);
212 Self::visit_block(statement.mutate_block(), processor);
213
214 for r#type in statement
215 .iter_mut_parameters()
216 .filter_map(TypedIdentifier::mutate_type)
217 {
218 Self::visit_type(r#type, processor);
219 }
220
221 if let Some(variadic_type) = statement.mutate_variadic_type() {
222 Self::visit_function_variadic_type(variadic_type, processor);
223 }
224
225 if let Some(return_type) = statement.mutate_return_type() {
226 Self::visit_function_return_type(return_type, processor);
227 }
228 processor.process_after_function_statement(statement);
229 }
230
231 fn visit_generic_for(statement: &mut GenericForStatement, processor: &mut T) {
232 processor.process_generic_for_statement(statement);
233
234 statement
235 .iter_mut_expressions()
236 .for_each(|expression| Self::visit_expression(expression, processor));
237
238 processor.process_scope(statement.mutate_block(), None);
239 Self::visit_block(statement.mutate_block(), processor);
240
241 for r#type in statement
242 .iter_mut_identifiers()
243 .filter_map(TypedIdentifier::mutate_type)
244 {
245 Self::visit_type(r#type, processor);
246 }
247 processor.process_after_generic_for_statement(statement);
248 }
249
250 fn visit_if_statement(statement: &mut IfStatement, processor: &mut T) {
251 processor.process_if_statement(statement);
252
253 statement.mutate_branches().iter_mut().for_each(|branch| {
254 Self::visit_expression(branch.mutate_condition(), processor);
255 processor.process_scope(branch.mutate_block(), None);
256 Self::visit_block(branch.mutate_block(), processor);
257 });
258
259 if let Some(block) = statement.mutate_else_block() {
260 processor.process_scope(block, None);
261 Self::visit_block(block, processor);
262 }
263 processor.process_after_if_statement(statement);
264 }
265
266 fn visit_local_assign(statement: &mut LocalAssignStatement, processor: &mut T) {
267 processor.process_local_assign_statement(statement);
268
269 statement
270 .iter_mut_values()
271 .for_each(|value| Self::visit_expression(value, processor));
272
273 for r#type in statement
274 .iter_mut_variables()
275 .filter_map(TypedIdentifier::mutate_type)
276 {
277 Self::visit_type(r#type, processor);
278 }
279 processor.process_after_local_assign_statement(statement);
280 }
281
282 fn visit_local_function(statement: &mut LocalFunctionStatement, processor: &mut T) {
283 processor.process_local_function_statement(statement);
284 processor.process_scope(statement.mutate_block(), None);
285 Self::visit_block(statement.mutate_block(), processor);
286
287 for r#type in statement
288 .iter_mut_parameters()
289 .filter_map(TypedIdentifier::mutate_type)
290 {
291 Self::visit_type(r#type, processor);
292 }
293
294 if let Some(variadic_type) = statement.mutate_variadic_type() {
295 Self::visit_function_variadic_type(variadic_type, processor);
296 }
297
298 if let Some(return_type) = statement.mutate_return_type() {
299 Self::visit_function_return_type(return_type, processor);
300 }
301 processor.process_after_local_function_statement(statement);
302 }
303
304 fn visit_function_variadic_type(variadic_type: &mut FunctionVariadicType, processor: &mut T) {
305 match variadic_type {
306 FunctionVariadicType::Type(r#type) => {
307 Self::visit_type(r#type, processor);
308 }
309 FunctionVariadicType::GenericTypePack(generic) => {
310 Self::visit_generic_type_pack(generic, processor);
311 }
312 }
313 }
314
315 fn visit_generic_type_pack(generic: &mut GenericTypePack, processor: &mut T) {
316 processor.process_generic_type_pack(generic);
317 processor.process_after_generic_type_pack(generic);
318 }
319
320 fn visit_numeric_for(statement: &mut NumericForStatement, processor: &mut T) {
321 processor.process_numeric_for_statement(statement);
322
323 Self::visit_expression(statement.mutate_start(), processor);
324 Self::visit_expression(statement.mutate_end(), processor);
325
326 if let Some(step) = statement.mutate_step() {
327 Self::visit_expression(step, processor);
328 };
329
330 processor.process_scope(statement.mutate_block(), None);
331 Self::visit_block(statement.mutate_block(), processor);
332
333 if let Some(r#type) = statement.mutate_identifier().mutate_type() {
334 Self::visit_type(r#type, processor);
335 }
336 processor.process_after_numeric_for_statement(statement);
337 }
338
339 fn visit_repeat_statement(statement: &mut RepeatStatement, processor: &mut T) {
340 processor.process_repeat_statement(statement);
341
342 let (block, condition) = statement.mutate_block_and_condition();
343 processor.process_scope(block, Some(condition));
344
345 Self::visit_expression(statement.mutate_condition(), processor);
346 Self::visit_block(statement.mutate_block(), processor);
347 processor.process_after_repeat_statement(statement);
348 }
349
350 fn visit_while_statement(statement: &mut WhileStatement, processor: &mut T) {
351 processor.process_while_statement(statement);
352
353 Self::visit_expression(statement.mutate_condition(), processor);
354
355 processor.process_scope(statement.mutate_block(), None);
356 Self::visit_block(statement.mutate_block(), processor);
357 processor.process_after_while_statement(statement);
358 }
359
360 fn visit_type_declaration(statement: &mut TypeDeclarationStatement, processor: &mut T) {
361 processor.process_type_declaration(statement);
362
363 if let Some(generic_parameters) = statement.mutate_generic_parameters() {
364 for parameter in generic_parameters {
365 match parameter {
366 GenericParameterMutRef::TypeVariable(_) => {}
367 GenericParameterMutRef::TypeVariableWithDefault(type_variable) => {
368 Self::visit_type(type_variable.mutate_default_type(), processor);
369 }
370 GenericParameterMutRef::GenericTypePack(generic_type_pack) => {
371 Self::visit_generic_type_pack(generic_type_pack, processor);
372 }
373 GenericParameterMutRef::GenericTypePackWithDefault(
374 generic_type_pack_with_default,
375 ) => {
376 Self::visit_generic_type_pack(
377 generic_type_pack_with_default.mutate_generic_type_pack(),
378 processor,
379 );
380
381 match generic_type_pack_with_default.mutate_default_type() {
382 GenericTypePackDefault::TypePack(type_pack) => {
383 Self::visit_type_pack(type_pack, processor);
384 }
385 GenericTypePackDefault::VariadicTypePack(variadic_type_pack) => {
386 Self::visit_variadic_type_pack(variadic_type_pack, processor);
387 }
388 GenericTypePackDefault::GenericTypePack(generic_type_pack) => {
389 Self::visit_generic_type_pack(generic_type_pack, processor);
390 }
391 }
392 }
393 }
394 }
395 }
396
397 Self::visit_type(statement.mutate_type(), processor);
398 processor.process_after_type_declaration(statement);
399 }
400
401 fn visit_variable(variable: &mut Variable, processor: &mut T) {
402 processor.process_variable(variable);
403
404 match variable {
405 Variable::Identifier(identifier) => Self::visit_identifier(identifier, processor),
406 Variable::Field(field) => Self::visit_field_expression(field, processor),
407 Variable::Index(index) => Self::visit_index_expression(index, processor),
408 }
409 processor.process_after_variable(variable);
410 }
411
412 fn visit_identifier(identifier: &mut Identifier, processor: &mut T) {
413 processor.process_variable_expression(identifier);
414 processor.process_after_variable_expression(identifier);
415 }
416
417 fn visit_if_expression(if_expression: &mut IfExpression, processor: &mut T) {
418 processor.process_if_expression(if_expression);
419
420 Self::visit_expression(if_expression.mutate_condition(), processor);
421 Self::visit_expression(if_expression.mutate_result(), processor);
422
423 for branch in if_expression.iter_mut_branches() {
424 Self::visit_expression(branch.mutate_condition(), processor);
425 Self::visit_expression(branch.mutate_result(), processor);
426 }
427
428 Self::visit_expression(if_expression.mutate_else_result(), processor);
429 processor.process_after_if_expression(if_expression);
430 }
431
432 fn visit_field_expression(field: &mut FieldExpression, processor: &mut T) {
433 processor.process_field_expression(field);
434
435 Self::visit_prefix_expression(field.mutate_prefix(), processor);
436 processor.process_after_field_expression(field);
437 }
438
439 fn visit_index_expression(index: &mut IndexExpression, processor: &mut T) {
440 processor.process_index_expression(index);
441
442 Self::visit_prefix_expression(index.mutate_prefix(), processor);
443 Self::visit_expression(index.mutate_index(), processor);
444 processor.process_after_index_expression(index);
445 }
446
447 fn visit_function_call(call: &mut FunctionCall, processor: &mut T) {
448 processor.process_function_call(call);
449
450 Self::visit_prefix_expression(call.mutate_prefix(), processor);
451 Self::visit_arguments(call.mutate_arguments(), processor);
452 processor.process_after_function_call(call);
453 }
454
455 fn visit_arguments(arguments: &mut Arguments, processor: &mut T) {
456 match arguments {
457 Arguments::String(string) => Self::visit_string_expression(string, processor),
458 Arguments::Table(table) => Self::visit_table(table, processor),
459 Arguments::Tuple(expressions) => expressions
460 .iter_mut_values()
461 .for_each(|expression| Self::visit_expression(expression, processor)),
462 }
463 }
464
465 fn visit_table(table: &mut TableExpression, processor: &mut T) {
466 processor.process_table_expression(table);
467
468 table.iter_mut_entries().for_each(|entry| match entry {
469 TableEntry::Field(entry) => Self::visit_expression(entry.mutate_value(), processor),
470 TableEntry::Index(entry) => {
471 Self::visit_expression(entry.mutate_key(), processor);
472 Self::visit_expression(entry.mutate_value(), processor);
473 }
474 TableEntry::Value(value) => Self::visit_expression(value, processor),
475 });
476 processor.process_after_table_expression(table);
477 }
478
479 fn visit_prefix_expression(prefix: &mut Prefix, processor: &mut T) {
480 processor.process_prefix_expression(prefix);
481
482 match prefix {
483 Prefix::Call(call) => Self::visit_function_call(call, processor),
484 Prefix::Field(field) => Self::visit_field_expression(field, processor),
485 Prefix::Identifier(identifier) => Self::visit_identifier(identifier, processor),
486 Prefix::Index(index) => Self::visit_index_expression(index, processor),
487 Prefix::Parenthese(expression) => {
488 Self::visit_parenthese_expression(expression, processor)
489 }
490 };
491 processor.process_after_prefix_expression(prefix);
492 }
493
494 fn visit_type(r#type: &mut Type, processor: &mut T) {
495 processor.process_type(r#type);
496
497 match r#type {
498 Type::Name(type_name) => Self::visit_type_name(type_name, processor),
499 Type::Field(type_field) => Self::visit_type_field(type_field, processor),
500 Type::Array(array) => Self::visit_array_type(array, processor),
501 Type::Table(table) => Self::visit_table_type(table, processor),
502 Type::TypeOf(expression_type) => {
503 Self::visit_expression_type(expression_type, processor)
504 }
505 Type::Parenthese(parenthese) => Self::visit_parenthese_type(parenthese, processor),
506 Type::Function(function) => Self::visit_function_type(function, processor),
507 Type::Optional(optional) => Self::visit_optional_type(optional, processor),
508 Type::Intersection(intersection) => {
509 Self::visit_intersection_type(intersection, processor)
510 }
511 Type::Union(union) => Self::visit_union_type(union, processor),
512 Type::String(string) => Self::visit_string_type(string, processor),
513 Type::True(_) | Type::False(_) | Type::Nil(_) => {}
514 }
515 processor.process_after_type(r#type);
516 }
517
518 fn visit_type_name(type_name: &mut TypeName, processor: &mut T) {
519 processor.process_type_name(type_name);
520
521 if let Some(type_parameters) = type_name.mutate_type_parameters() {
522 for type_parameter in type_parameters {
523 match type_parameter {
524 TypeParameter::Type(next_type) => {
525 Self::visit_type(next_type, processor);
526 }
527 TypeParameter::TypePack(type_pack) => {
528 Self::visit_type_pack(type_pack, processor);
529 }
530 TypeParameter::VariadicTypePack(variadic_type_pack) => {
531 Self::visit_variadic_type_pack(variadic_type_pack, processor);
532 }
533 TypeParameter::GenericTypePack(generic_type_pack) => {
534 Self::visit_generic_type_pack(generic_type_pack, processor);
535 }
536 }
537 }
538 }
539 processor.process_after_type_name(type_name);
540 }
541
542 fn visit_type_field(type_field: &mut TypeField, processor: &mut T) {
543 processor.process_type_field(type_field);
544 Self::visit_type_name(type_field.mutate_type_name(), processor);
545 processor.process_after_type_field(type_field);
546 }
547
548 fn visit_array_type(array: &mut ArrayType, processor: &mut T) {
549 processor.process_array_type(array);
550 Self::visit_type(array.mutate_element_type(), processor);
551 processor.process_after_array_type(array);
552 }
553
554 fn visit_table_type(table: &mut TableType, processor: &mut T) {
555 processor.process_table_type(table);
556
557 for entry in table.iter_mut_entries() {
558 match entry {
559 TableEntryType::Property(property) => {
560 Self::visit_type(property.mutate_type(), processor);
561 }
562 TableEntryType::Literal(property) => {
563 Self::visit_string_type(property.mutate_string(), processor);
564 Self::visit_type(property.mutate_type(), processor);
565 }
566 TableEntryType::Indexer(indexer) => {
567 Self::visit_type(indexer.mutate_key_type(), processor);
568 Self::visit_type(indexer.mutate_value_type(), processor);
569 }
570 }
571 }
572 processor.process_after_table_type(table);
573 }
574
575 fn visit_expression_type(expression_type: &mut ExpressionType, processor: &mut T) {
576 processor.process_expression_type(expression_type);
577 Self::visit_expression(expression_type.mutate_expression(), processor);
578 processor.process_after_expression_type(expression_type);
579 }
580
581 fn visit_parenthese_type(parenthese: &mut ParentheseType, processor: &mut T) {
582 processor.process_parenthese_type(parenthese);
583 Self::visit_type(parenthese.mutate_inner_type(), processor);
584 processor.process_after_parenthese_type(parenthese);
585 }
586
587 fn visit_function_type(function: &mut FunctionType, processor: &mut T) {
588 processor.process_function_type(function);
589
590 for argument in function.iter_mut_arguments() {
591 Self::visit_type(argument.mutate_type(), processor);
592 }
593
594 if let Some(variadic_type) = function.mutate_variadic_argument_type() {
595 Self::visit_variadic_argument_type(variadic_type, processor);
596 }
597
598 Self::visit_function_return_type(function.mutate_return_type(), processor);
599
600 processor.process_after_function_type(function);
601 }
602
603 fn visit_optional_type(optional: &mut OptionalType, processor: &mut T) {
604 processor.process_optional_type(optional);
605 Self::visit_type(optional.mutate_inner_type(), processor);
606 processor.process_after_optional_type(optional);
607 }
608
609 fn visit_intersection_type(intersection: &mut IntersectionType, processor: &mut T) {
610 processor.process_intersection_type(intersection);
611
612 for r#type in intersection.iter_mut_types() {
613 Self::visit_type(r#type, processor);
614 }
615 processor.process_after_intersection_type(intersection);
616 }
617
618 fn visit_union_type(union: &mut UnionType, processor: &mut T) {
619 processor.process_union_type(union);
620
621 for r#type in union.iter_mut_types() {
622 Self::visit_type(r#type, processor);
623 }
624 processor.process_after_union_type(union);
625 }
626
627 fn visit_string_type(string: &mut StringType, processor: &mut T) {
628 processor.process_string_type(string);
629 processor.process_after_string_type(string);
630 }
631
632 fn visit_type_pack(type_pack: &mut TypePack, processor: &mut T) {
633 processor.process_type_pack(type_pack);
634
635 for next_type in type_pack.into_iter() {
636 Self::visit_type(next_type, processor)
637 }
638 if let Some(variadic_type) = type_pack.mutate_variadic_type() {
639 Self::visit_variadic_argument_type(variadic_type, processor);
640 }
641 processor.process_after_type_pack(type_pack);
642 }
643
644 fn visit_variadic_type_pack(variadic_type_pack: &mut VariadicTypePack, processor: &mut T) {
645 processor.process_variadic_type_pack(variadic_type_pack);
646 Self::visit_type(variadic_type_pack.mutate_type(), processor);
647 processor.process_after_variadic_type_pack(variadic_type_pack);
648 }
649
650 fn visit_variadic_argument_type(variadic_type: &mut VariadicArgumentType, processor: &mut T) {
651 match variadic_type {
652 VariadicArgumentType::VariadicTypePack(variadic_type_pack) => {
653 Self::visit_variadic_type_pack(variadic_type_pack, processor);
654 }
655 VariadicArgumentType::GenericTypePack(generic_type_pack) => {
656 Self::visit_generic_type_pack(generic_type_pack, processor);
657 }
658 }
659 }
660
661 fn visit_function_return_type(
662 function_return_type: &mut FunctionReturnType,
663 processor: &mut T,
664 ) {
665 match function_return_type {
666 FunctionReturnType::Type(next_type) => {
667 Self::visit_type(next_type, processor);
668 }
669 FunctionReturnType::TypePack(type_pack) => Self::visit_type_pack(type_pack, processor),
670 FunctionReturnType::VariadicTypePack(variadic_type_pack) => {
671 Self::visit_variadic_type_pack(variadic_type_pack, processor);
672 }
673 FunctionReturnType::GenericTypePack(generic_type_pack) => {
674 Self::visit_generic_type_pack(generic_type_pack, processor);
675 }
676 }
677 }
678}
679
680pub struct DefaultPostVisitor<T> {
682 _phantom: PhantomData<T>,
683}
684
685impl<T: NodeProcessor + NodePostProcessor> NodePostVisitor<T> for DefaultPostVisitor<T> {}