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