Line data Source code
1 : // Copyright (C) 2020-2026 Free Software Foundation, Inc.
2 :
3 : // This file is part of GCC.
4 :
5 : // GCC is free software; you can redistribute it and/or modify it under
6 : // the terms of the GNU General Public License as published by the Free
7 : // Software Foundation; either version 3, or (at your option) any later
8 : // version.
9 :
10 : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 : // for more details.
14 :
15 : // You should have received a copy of the GNU General Public License
16 : // along with GCC; see the file COPYING3. If not see
17 : // <http://www.gnu.org/licenses/>.
18 :
19 : #include "rust-ast-visitor.h"
20 : #include "rust-ast-full-decls.h"
21 : #include "rust-ast.h"
22 : #include "rust-builtin-ast-nodes.h"
23 : #include "rust-path.h"
24 : #include "rust-token.h"
25 : #include "rust-expr.h"
26 : #include "rust-macro.h"
27 : #include "rust-pattern.h"
28 : #include "rust-stmt.h"
29 : #include "rust-type.h"
30 :
31 : namespace Rust {
32 : namespace AST {
33 :
34 : void
35 62853 : DefaultASTVisitor::visit (AST::Crate &crate)
36 : {
37 62853 : visit_inner_attrs (crate);
38 332602 : for (auto &item : crate.items)
39 269750 : visit (item);
40 62852 : }
41 :
42 : void
43 950114 : DefaultASTVisitor::visit (AST::Token &tok)
44 950114 : {}
45 :
46 : void
47 192934 : DefaultASTVisitor::visit (AST::DelimTokenTree &delim_tok_tree)
48 : {
49 1205359 : for (auto &token : delim_tok_tree.get_token_trees ())
50 1012425 : visit (token);
51 192934 : }
52 :
53 : void
54 4917 : DefaultASTVisitor::visit (AST::AttrInputMetaItemContainer &input)
55 : {
56 9849 : for (auto &item : input.get_items ())
57 4932 : visit (item);
58 4917 : }
59 :
60 : void
61 431085 : DefaultASTVisitor::visit (AST::IdentifierExpr &ident_expr)
62 : {
63 431085 : visit_outer_attrs (ident_expr);
64 431085 : }
65 :
66 : void
67 177695 : DefaultASTVisitor::visit (AST::Lifetime &lifetime)
68 177695 : {}
69 :
70 : void
71 3410 : DefaultASTVisitor::visit (AST::LifetimeParam &lifetime_param)
72 : {
73 3410 : visit_outer_attrs (lifetime_param);
74 3410 : visit (lifetime_param.get_lifetime ());
75 3423 : for (auto &lifetime_bound : lifetime_param.get_lifetime_bounds ())
76 13 : visit (lifetime_bound);
77 3410 : }
78 :
79 : void
80 1252 : DefaultASTVisitor::visit (AST::ConstGenericParam &const_param)
81 : {
82 1252 : visit_outer_attrs (const_param);
83 1252 : if (const_param.has_type ())
84 1252 : visit (const_param.get_type ());
85 1252 : if (const_param.has_default_value ())
86 233 : visit (const_param.get_default_value_unchecked ());
87 1252 : }
88 :
89 : void
90 257833 : DefaultASTVisitor::visit (AST::PathInExpression &path)
91 : {
92 257833 : visit_outer_attrs (path);
93 :
94 257833 : if (!path.is_lang_item ())
95 612747 : for (auto &segment : path.get_segments ())
96 355912 : visit (segment);
97 257833 : }
98 :
99 : void
100 1038231 : DefaultASTVisitor::visit (AST::TypePathSegment &segment)
101 1038231 : {}
102 :
103 : void
104 851 : DefaultASTVisitor::visit (GenericArgsBinding &binding)
105 : {
106 851 : visit (binding.get_type ());
107 851 : }
108 :
109 : void
110 31863 : DefaultASTVisitor::visit (AST::TypePathSegmentGeneric &segment)
111 : {
112 31863 : if (segment.has_generic_args ())
113 31852 : visit (segment.get_generic_args ());
114 31863 : }
115 :
116 : void
117 379 : DefaultASTVisitor::visit (AST::TypePathFunction &tpf)
118 : {
119 782 : for (auto &input : tpf.get_params ())
120 403 : visit (input);
121 379 : if (tpf.has_return_type ())
122 355 : visit (tpf.get_return_type ());
123 379 : }
124 :
125 : void
126 450079 : DefaultASTVisitor::visit (AST::PathIdentSegment &segment)
127 450079 : {}
128 :
129 : void
130 379 : DefaultASTVisitor::visit (AST::TypePathSegmentFunction &segment)
131 : {
132 379 : visit (segment.get_type_path_function ());
133 379 : visit (segment.get_ident_segment ());
134 379 : }
135 :
136 : void
137 37750 : DefaultASTVisitor::visit (AST::GenericArgs &args)
138 : {
139 38153 : for (auto &lifetime : args.get_lifetime_args ())
140 403 : visit (lifetime);
141 :
142 77267 : for (auto &generic : args.get_generic_args ())
143 39517 : visit (generic);
144 :
145 38529 : for (auto &binding : args.get_binding_args ())
146 779 : visit (binding);
147 37750 : }
148 :
149 : void
150 406903 : DefaultASTVisitor::visit (AST::PathExprSegment &segment)
151 : {
152 406903 : visit (segment.get_ident_segment ());
153 406903 : if (segment.has_generic_args ())
154 9570 : visit (segment.get_generic_args ());
155 406903 : }
156 : void
157 874690 : DefaultASTVisitor::visit (AST::TypePath &path)
158 : {
159 1777728 : for (auto &segment : path.get_segments ())
160 903038 : visit (segment);
161 874690 : }
162 :
163 : void
164 1674 : DefaultASTVisitor::visit (AST::QualifiedPathInExpression &path)
165 : {
166 1674 : visit_outer_attrs (path);
167 1674 : visit (path.get_qualified_path_type ());
168 :
169 3348 : for (auto &segment : path.get_segments ())
170 1674 : visit (segment);
171 1674 : }
172 :
173 : void
174 6174 : DefaultASTVisitor::visit (AST::QualifiedPathType &path)
175 : {
176 6174 : visit (path.get_type ());
177 6174 : if (path.has_as_clause ())
178 5609 : visit (path.get_as_type_path ());
179 6174 : }
180 :
181 : void
182 4500 : DefaultASTVisitor::visit (AST::QualifiedPathInType &path)
183 : {
184 4500 : visit (path.get_qualified_path_type ());
185 4500 : visit (path.get_associated_segment ());
186 :
187 4500 : for (auto &segment : path.get_segments ())
188 0 : visit (segment);
189 4500 : }
190 :
191 : void
192 1345779 : DefaultASTVisitor::visit (AST::LiteralExpr &expr)
193 : {
194 1345779 : visit_outer_attrs (expr);
195 1345779 : }
196 :
197 : void
198 380705 : DefaultASTVisitor::visit (AST::Attribute &attribute)
199 : {
200 380705 : visit (attribute.get_path ());
201 380705 : if (attribute.has_attr_input ())
202 301415 : visit (attribute.get_attr_input ());
203 380705 : }
204 :
205 : void
206 155891 : DefaultASTVisitor::visit (AST::AttrInputLiteral &attr_input)
207 : {
208 155891 : visit (attr_input.get_literal ());
209 155891 : }
210 :
211 : void
212 31 : DefaultASTVisitor::visit (AST::AttrInputMacro &attr_input)
213 : {
214 31 : visit (attr_input.get_macro ());
215 31 : }
216 :
217 : void
218 5 : DefaultASTVisitor::visit (AST::AttrInputExpr &attr_input)
219 : {
220 5 : visit (attr_input.get_expr ());
221 5 : }
222 :
223 : void
224 0 : DefaultASTVisitor::visit (AST::MetaItemLitExpr &meta_item)
225 : {
226 0 : visit (meta_item.get_literal ());
227 0 : }
228 :
229 : void
230 402541 : DefaultASTVisitor::visit (AST::SimplePathSegment &segment)
231 402541 : {}
232 :
233 : void
234 363875 : DefaultASTVisitor::visit (AST::SimplePath &path)
235 : {
236 736621 : for (auto &segment : path.get_segments ())
237 372746 : visit (segment);
238 363875 : }
239 :
240 : void
241 1 : DefaultASTVisitor::visit (AST::MetaItemPathExpr &meta_item)
242 : {
243 1 : visit (meta_item.get_path ());
244 1 : visit (meta_item.get_expr ());
245 1 : }
246 :
247 : void
248 35395 : DefaultASTVisitor::visit (AST::BorrowExpr &expr)
249 : {
250 35395 : visit_outer_attrs (expr);
251 35395 : visit (expr.get_borrowed_expr ());
252 35395 : }
253 :
254 : void
255 42358 : DefaultASTVisitor::visit (AST::DereferenceExpr &expr)
256 : {
257 42358 : visit_outer_attrs (expr);
258 42358 : visit (expr.get_dereferenced_expr ());
259 42358 : }
260 :
261 : void
262 9 : DefaultASTVisitor::visit (AST::ErrorPropagationExpr &expr)
263 : {
264 9 : visit_outer_attrs (expr);
265 9 : visit (expr.get_propagating_expr ());
266 9 : }
267 :
268 : void
269 8070 : DefaultASTVisitor::visit (AST::NegationExpr &expr)
270 : {
271 8070 : visit_outer_attrs (expr);
272 8070 : visit (expr.get_negated_expr ());
273 8070 : }
274 :
275 : void
276 1627463 : DefaultASTVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
277 : {
278 1627463 : visit_outer_attrs (expr);
279 1627463 : visit (expr.get_left_expr ());
280 1627463 : visit (expr.get_right_expr ());
281 1627463 : }
282 :
283 : void
284 43456 : DefaultASTVisitor::visit (AST::ComparisonExpr &expr)
285 : {
286 43456 : visit_outer_attrs (expr);
287 43456 : visit (expr.get_left_expr ());
288 43456 : visit (expr.get_right_expr ());
289 43456 : }
290 :
291 : void
292 5376 : DefaultASTVisitor::visit (AST::LazyBooleanExpr &expr)
293 : {
294 5376 : visit_outer_attrs (expr);
295 5376 : visit (expr.get_left_expr ());
296 5376 : visit (expr.get_right_expr ());
297 5376 : }
298 :
299 : void
300 105677 : DefaultASTVisitor::visit (AST::TypeCastExpr &expr)
301 : {
302 105677 : visit_outer_attrs (expr);
303 105677 : visit (expr.get_casted_expr ());
304 105677 : visit (expr.get_type_to_cast_to ());
305 105677 : }
306 :
307 : void
308 39283 : DefaultASTVisitor::visit (AST::AssignmentExpr &expr)
309 : {
310 39283 : visit_outer_attrs (expr);
311 39283 : visit (expr.get_left_expr ());
312 39283 : visit (expr.get_right_expr ());
313 39283 : }
314 :
315 : void
316 12678 : DefaultASTVisitor::visit (AST::CompoundAssignmentExpr &expr)
317 : {
318 12678 : visit_outer_attrs (expr);
319 12678 : visit (expr.get_left_expr ());
320 12678 : visit (expr.get_right_expr ());
321 12678 : }
322 :
323 : void
324 5479 : DefaultASTVisitor::visit (AST::GroupedExpr &expr)
325 : {
326 5479 : visit_outer_attrs (expr);
327 5479 : visit_inner_attrs (expr);
328 5479 : visit (expr.get_expr_in_parens ());
329 5479 : }
330 :
331 : void
332 3008 : DefaultASTVisitor::visit (AST::ArrayElemsValues &elems)
333 : {
334 17150 : for (auto &value : elems.get_values ())
335 14142 : visit (value);
336 3008 : }
337 :
338 : void
339 1695 : DefaultASTVisitor::visit (AST::ArrayElemsCopied &elems)
340 : {
341 1695 : visit (elems.get_elem_to_copy ());
342 1695 : visit (elems.get_num_copies ());
343 1695 : }
344 :
345 : void
346 5867 : DefaultASTVisitor::visit (AST::ArrayExpr &expr)
347 : {
348 5867 : visit_outer_attrs (expr);
349 5867 : visit_inner_attrs (expr);
350 5867 : visit (expr.get_array_elems ());
351 5867 : }
352 :
353 : void
354 4370 : DefaultASTVisitor::visit (AST::ArrayIndexExpr &expr)
355 : {
356 4370 : visit_outer_attrs (expr);
357 4370 : visit (expr.get_array_expr ());
358 4370 : visit (expr.get_index_expr ());
359 4370 : }
360 :
361 : void
362 5685 : DefaultASTVisitor::visit (AST::TupleExpr &expr)
363 : {
364 5685 : visit_outer_attrs (expr);
365 5685 : visit_inner_attrs (expr);
366 15565 : for (auto &elem : expr.get_tuple_elems ())
367 9880 : visit (elem);
368 5685 : }
369 :
370 : void
371 14664 : DefaultASTVisitor::visit (AST::TupleIndexExpr &expr)
372 : {
373 14664 : visit_outer_attrs (expr);
374 14664 : visit (expr.get_tuple_expr ());
375 14664 : }
376 :
377 : void
378 726 : DefaultASTVisitor::visit (AST::StructExprStruct &expr)
379 : {
380 726 : visit_outer_attrs (expr);
381 726 : visit_inner_attrs (expr);
382 726 : visit (expr.get_struct_name ());
383 726 : }
384 :
385 : void
386 2609 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifier &field)
387 2609 : {}
388 :
389 : void
390 30560 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifierValue &field)
391 : {
392 30560 : visit (field.get_value ());
393 30560 : }
394 :
395 : void
396 616 : DefaultASTVisitor::visit (AST::StructExprFieldIndexValue &field)
397 : {
398 616 : visit (field.get_value ());
399 616 : }
400 :
401 : void
402 882 : DefaultASTVisitor::visit (AST::StructBase &base)
403 : {
404 882 : visit (base.get_base_struct ());
405 882 : }
406 :
407 : void
408 18180 : DefaultASTVisitor::visit (AST::StructExprStructFields &expr)
409 : {
410 18180 : visit_outer_attrs (expr);
411 18180 : visit_inner_attrs (expr);
412 18180 : visit (expr.get_struct_name ());
413 18180 : if (expr.has_struct_base ())
414 819 : visit (expr.get_struct_base ());
415 49887 : for (auto &field : expr.get_fields ())
416 31707 : visit (field);
417 18180 : }
418 :
419 : void
420 0 : DefaultASTVisitor::visit (AST::StructExprStructBase &expr)
421 : {
422 0 : visit_outer_attrs (expr);
423 0 : visit_inner_attrs (expr);
424 0 : visit (expr.get_struct_name ());
425 0 : visit (expr.get_struct_base ());
426 0 : }
427 :
428 : void
429 185239 : DefaultASTVisitor::visit (AST::CallExpr &expr)
430 : {
431 185239 : visit_outer_attrs (expr);
432 185239 : visit (expr.get_function_expr ());
433 407611 : for (auto ¶m : expr.get_params ())
434 222372 : visit (param);
435 185239 : }
436 :
437 : void
438 49317 : DefaultASTVisitor::visit (AST::MethodCallExpr &expr)
439 : {
440 49317 : visit_outer_attrs (expr);
441 49317 : visit (expr.get_receiver_expr ());
442 49317 : visit (expr.get_method_name ());
443 83429 : for (auto ¶m : expr.get_params ())
444 34112 : visit (param);
445 49317 : }
446 :
447 : void
448 83471 : DefaultASTVisitor::visit (AST::FieldAccessExpr &expr)
449 : {
450 83471 : visit_outer_attrs (expr);
451 83471 : visit (expr.get_receiver_expr ());
452 83471 : }
453 :
454 : void
455 279 : DefaultASTVisitor::visit (AST::ClosureExprInner &expr)
456 : {
457 279 : visit_outer_attrs (expr);
458 485 : for (auto ¶m : expr.get_params ())
459 206 : visit (param);
460 279 : visit (expr.get_definition_expr ());
461 279 : }
462 :
463 : void
464 336862 : DefaultASTVisitor::visit (AST::BlockExpr &expr)
465 : {
466 336862 : visit_outer_attrs (expr);
467 336862 : visit_inner_attrs (expr);
468 :
469 336862 : if (expr.has_label ())
470 0 : visit (expr.get_label ());
471 :
472 654530 : for (auto &stmt : expr.get_statements ())
473 317669 : visit (stmt);
474 :
475 336861 : if (expr.has_tail_expr ())
476 250090 : visit (expr.get_tail_expr ());
477 336861 : }
478 :
479 : void
480 181 : DefaultASTVisitor::visit (AST::ConstBlock &expr)
481 : {
482 181 : visit (expr.get_const_expr ());
483 181 : }
484 :
485 : void
486 12018 : DefaultASTVisitor::visit (AST::AnonConst &expr)
487 : {
488 12018 : if (!expr.is_deferred ())
489 11857 : visit (expr.get_inner_expr ());
490 12018 : }
491 :
492 : void
493 240 : DefaultASTVisitor::visit (AST::ClosureExprInnerTyped &expr)
494 : {
495 240 : visit_outer_attrs (expr);
496 536 : for (auto ¶m : expr.get_params ())
497 296 : visit (param);
498 240 : visit (expr.get_return_type ());
499 240 : visit (expr.get_definition_expr ());
500 240 : }
501 :
502 : void
503 880 : DefaultASTVisitor::visit (AST::ClosureParam ¶m)
504 : {
505 880 : visit_outer_attrs (param);
506 880 : visit (param.get_pattern ());
507 880 : if (param.has_type_given ())
508 812 : visit (param.get_type ());
509 880 : }
510 :
511 : void
512 170 : DefaultASTVisitor::visit (AST::ContinueExpr &expr)
513 : {
514 170 : visit_outer_attrs (expr);
515 170 : if (expr.has_label ())
516 30 : visit (expr.get_label_unchecked ());
517 170 : }
518 :
519 : void
520 1520 : DefaultASTVisitor::visit (AST::BreakExpr &expr)
521 : {
522 1520 : visit_outer_attrs (expr);
523 1520 : if (expr.has_label ())
524 330 : visit (expr.get_label_unchecked ());
525 :
526 1520 : if (expr.has_break_expr ())
527 468 : visit (expr.get_break_expr_unchecked ());
528 1519 : }
529 :
530 : void
531 1077 : DefaultASTVisitor::visit (AST::RangeFromToExpr &expr)
532 : {
533 1077 : visit (expr.get_from_expr ());
534 1077 : visit (expr.get_to_expr ());
535 1077 : }
536 :
537 : void
538 98 : DefaultASTVisitor::visit (AST::RangeFromExpr &expr)
539 : {
540 98 : visit (expr.get_from_expr ());
541 98 : }
542 :
543 : void
544 98 : DefaultASTVisitor::visit (AST::RangeToExpr &expr)
545 : {
546 98 : visit (expr.get_to_expr ());
547 98 : }
548 :
549 : void
550 0 : DefaultASTVisitor::visit (AST::RangeFullExpr &expr)
551 0 : {}
552 :
553 : void
554 98 : DefaultASTVisitor::visit (AST::RangeFromToInclExpr &expr)
555 : {
556 98 : visit (expr.get_from_expr ());
557 98 : visit (expr.get_to_expr ());
558 98 : }
559 :
560 : void
561 0 : DefaultASTVisitor::visit (AST::RangeToInclExpr &expr)
562 : {
563 0 : visit (expr.get_to_expr ());
564 0 : }
565 :
566 : void
567 8520 : DefaultASTVisitor::visit (AST::ReturnExpr &expr)
568 : {
569 8520 : visit_outer_attrs (expr);
570 8520 : if (expr.has_returned_expr ())
571 7827 : visit (expr.get_returned_expr ());
572 8520 : }
573 :
574 : void
575 9 : DefaultASTVisitor::visit (AST::TryExpr &expr)
576 : {
577 9 : visit_outer_attrs (expr);
578 9 : visit (expr.get_block_expr ());
579 9 : }
580 :
581 : void
582 14 : DefaultASTVisitor::visit (AST::BoxExpr &expr)
583 : {
584 14 : visit_outer_attrs (expr);
585 14 : visit (expr.get_boxed_expr ());
586 14 : }
587 :
588 : void
589 54023 : DefaultASTVisitor::visit (AST::UnsafeBlockExpr &expr)
590 : {
591 54023 : visit_outer_attrs (expr);
592 54023 : visit (expr.get_block_expr ());
593 54023 : }
594 :
595 : void
596 692 : DefaultASTVisitor::visit (AST::LoopLabel &label)
597 : {
598 692 : visit (label.get_lifetime ());
599 692 : }
600 :
601 : void
602 1585 : DefaultASTVisitor::visit (AST::LoopExpr &expr)
603 : {
604 1585 : visit_outer_attrs (expr);
605 1585 : if (expr.has_loop_label ())
606 462 : visit (expr.get_loop_label ());
607 1585 : visit (expr.get_loop_block ());
608 1585 : }
609 :
610 : void
611 1378 : DefaultASTVisitor::visit (AST::WhileLoopExpr &expr)
612 : {
613 1378 : visit_outer_attrs (expr);
614 1378 : if (expr.has_loop_label ())
615 26 : visit (expr.get_loop_label ());
616 1378 : visit (expr.get_predicate_expr ());
617 1378 : visit (expr.get_loop_block ());
618 1378 : }
619 :
620 : void
621 14 : DefaultASTVisitor::visit (AST::WhileLetLoopExpr &expr)
622 : {
623 14 : visit_outer_attrs (expr);
624 14 : visit (expr.get_pattern ());
625 :
626 14 : if (expr.has_loop_label ())
627 0 : visit (expr.get_loop_label ());
628 :
629 14 : visit (expr.get_scrutinee_expr ());
630 14 : visit (expr.get_loop_block ());
631 14 : }
632 :
633 : void
634 264 : DefaultASTVisitor::visit (AST::ForLoopExpr &expr)
635 : {
636 264 : visit_outer_attrs (expr);
637 264 : visit (expr.get_pattern ());
638 264 : visit (expr.get_iterator_expr ());
639 264 : if (expr.has_loop_label ())
640 0 : visit (expr.get_loop_label ());
641 264 : visit (expr.get_loop_block ());
642 264 : }
643 :
644 : void
645 27256 : DefaultASTVisitor::visit (AST::IfExpr &expr)
646 : {
647 27256 : visit_outer_attrs (expr);
648 27256 : visit (expr.get_condition_expr ());
649 27256 : visit (expr.get_if_block ());
650 27256 : }
651 :
652 : void
653 19371 : DefaultASTVisitor::visit (AST::IfExprConseqElse &expr)
654 : {
655 19371 : visit (reinterpret_cast<AST::IfExpr &> (expr));
656 19371 : visit (expr.get_else_block ());
657 19371 : }
658 :
659 : void
660 222 : DefaultASTVisitor::visit (AST::IfLetExpr &expr)
661 : {
662 222 : visit_outer_attrs (expr);
663 222 : visit (expr.get_pattern ());
664 222 : visit (expr.get_value_expr ());
665 222 : visit (expr.get_if_block ());
666 222 : }
667 :
668 : void
669 78 : DefaultASTVisitor::visit (AST::IfLetExprConseqElse &expr)
670 : {
671 78 : visit (reinterpret_cast<AST::IfLetExpr &> (expr));
672 78 : visit (expr.get_else_block ());
673 78 : }
674 :
675 : void
676 33372 : DefaultASTVisitor::visit (AST::MatchArm &arm)
677 : {
678 33372 : visit_outer_attrs (arm);
679 33372 : visit (arm.get_pattern ());
680 33372 : if (arm.has_match_arm_guard ())
681 11 : visit (arm.get_guard_expr ());
682 33372 : }
683 :
684 : void
685 35865 : DefaultASTVisitor::visit (AST::MatchCase &arm)
686 : {
687 35865 : visit (arm.get_arm ());
688 35865 : visit (arm.get_expr ());
689 35865 : }
690 :
691 : void
692 15453 : DefaultASTVisitor::visit (AST::MatchExpr &expr)
693 : {
694 15453 : visit_outer_attrs (expr);
695 15453 : visit_inner_attrs (expr);
696 15453 : visit (expr.get_scrutinee_expr ());
697 51318 : for (auto &arm : expr.get_match_cases ())
698 35865 : visit (arm);
699 15453 : }
700 :
701 : void
702 0 : DefaultASTVisitor::visit (AST::AwaitExpr &expr)
703 : {
704 0 : visit_outer_attrs (expr);
705 0 : visit (expr.get_awaited_expr ());
706 0 : }
707 :
708 : void
709 0 : DefaultASTVisitor::visit (AST::AsyncBlockExpr &expr)
710 : {
711 0 : visit_outer_attrs (expr);
712 0 : visit (expr.get_block_expr ());
713 0 : }
714 :
715 : void
716 289 : DefaultASTVisitor::visit (AST::InlineAsm &expr)
717 : {
718 289 : visit_outer_attrs (expr);
719 289 : using RegisterType = AST::InlineAsmOperand::RegisterType;
720 604 : for (auto &operand : expr.get_operands ())
721 : {
722 315 : switch (operand.get_register_type ())
723 : {
724 110 : case RegisterType::In:
725 110 : {
726 110 : visit (operand.get_in ().expr);
727 110 : break;
728 : }
729 183 : case RegisterType::Out:
730 183 : {
731 183 : visit (operand.get_out ().expr);
732 183 : break;
733 : }
734 0 : case RegisterType::InOut:
735 0 : {
736 0 : visit (operand.get_in_out ().expr);
737 0 : break;
738 : }
739 22 : case RegisterType::SplitInOut:
740 22 : {
741 22 : auto split = operand.get_split_in_out ();
742 22 : visit (split.in_expr);
743 22 : visit (split.out_expr);
744 22 : break;
745 22 : }
746 0 : case RegisterType::Const:
747 0 : {
748 0 : visit (operand.get_const ().anon_const.get_inner_expr ());
749 0 : break;
750 : }
751 0 : case RegisterType::Sym:
752 0 : {
753 0 : visit (operand.get_sym ().expr);
754 0 : break;
755 : }
756 0 : case RegisterType::Label:
757 0 : {
758 0 : visit (operand.get_label ().expr);
759 0 : break;
760 : }
761 : }
762 289 : }
763 289 : }
764 :
765 : void
766 22 : DefaultASTVisitor::visit (AST::LlvmInlineAsm &expr)
767 : {
768 22 : for (auto &output : expr.get_outputs ())
769 0 : visit (output.expr);
770 :
771 44 : for (auto &input : expr.get_inputs ())
772 22 : visit (input.expr);
773 22 : }
774 :
775 : void
776 114276 : DefaultASTVisitor::visit (AST::TypeParam ¶m)
777 : {
778 114276 : visit_outer_attrs (param);
779 125708 : for (auto &bound : param.get_type_param_bounds ())
780 11432 : visit (bound);
781 114276 : if (param.has_type ())
782 5294 : visit (param.get_type ());
783 114276 : }
784 :
785 : void
786 24 : DefaultASTVisitor::visit (AST::LifetimeWhereClauseItem &item)
787 : {
788 24 : visit (item.get_lifetime ());
789 48 : for (auto &bound : item.get_lifetime_bounds ())
790 24 : visit (bound);
791 24 : }
792 :
793 : void
794 4791 : DefaultASTVisitor::visit (AST::TypeBoundWhereClauseItem &item)
795 : {
796 4899 : for (auto &lifetime : item.get_for_lifetimes ())
797 108 : visit (lifetime);
798 4791 : visit (item.get_type ());
799 9582 : for (auto ¶m : item.get_type_param_bounds ())
800 4791 : visit (param);
801 4791 : }
802 :
803 : void
804 549109 : DefaultASTVisitor::visit (AST::Visibility &vis)
805 : {
806 549109 : if (vis.has_path ())
807 960 : visit (vis.get_path ());
808 549109 : }
809 :
810 : void
811 280663 : DefaultASTVisitor::visit (AST::FunctionQualifiers &qualifiers)
812 280663 : {}
813 :
814 : void
815 4731 : DefaultASTVisitor::visit (AST::WhereClause &where)
816 : {
817 9642 : for (auto &item : where.get_items ())
818 4911 : visit (item);
819 4731 : }
820 : void
821 159801 : DefaultASTVisitor::visit (AST::FunctionParam ¶m)
822 : {
823 159801 : visit_outer_attrs (param);
824 159801 : if (param.has_name ())
825 159801 : visit (param.get_pattern ());
826 :
827 159801 : visit (param.get_type ());
828 159801 : }
829 :
830 : void
831 124565 : DefaultASTVisitor::visit (AST::SelfParam ¶m)
832 : {
833 124565 : visit_outer_attrs (param);
834 :
835 124565 : if (param.has_lifetime ())
836 71944 : visit (param.get_lifetime ());
837 :
838 124565 : if (param.has_type ())
839 14 : visit (param.get_type ());
840 124565 : }
841 :
842 : void
843 16799 : DefaultASTVisitor::visit (AST::Module &module)
844 : {
845 16799 : visit_outer_attrs (module);
846 16799 : visit (module.get_visibility ());
847 16799 : visit_inner_attrs (module);
848 72389 : for (auto &item : module.get_items ())
849 55590 : visit (item);
850 16799 : }
851 :
852 : void
853 132 : DefaultASTVisitor::visit (AST::ExternCrate &crate)
854 : {
855 132 : visit_outer_attrs (crate);
856 132 : visit (crate.get_visibility ());
857 132 : }
858 :
859 : void
860 75 : DefaultASTVisitor::visit (AST::UseTreeGlob &use_tree)
861 : {
862 75 : visit (use_tree.get_path ());
863 75 : }
864 :
865 : void
866 1385 : DefaultASTVisitor::visit (AST::UseTreeList &use_tree)
867 : {
868 1385 : visit (use_tree.get_path ());
869 1385 : }
870 :
871 : void
872 4420 : DefaultASTVisitor::visit (AST::UseTreeRebind &use_tree)
873 : {
874 4420 : visit (use_tree.get_path ());
875 4420 : }
876 :
877 : void
878 5892 : DefaultASTVisitor::visit (AST::UseDeclaration &use_decl)
879 : {
880 5892 : visit (use_decl.get_visibility ());
881 5892 : visit (use_decl.get_tree ());
882 5892 : }
883 :
884 : void
885 243284 : DefaultASTVisitor::visit_function_params (AST::Function &function)
886 : {
887 518403 : for (auto ¶m : function.get_function_params ())
888 275119 : visit (param);
889 243284 : }
890 :
891 : void
892 261539 : DefaultASTVisitor::visit (AST::Function &function)
893 : {
894 261539 : visit_outer_attrs (function);
895 261539 : visit (function.get_visibility ());
896 261539 : visit (function.get_qualifiers ());
897 284907 : for (auto &generic : function.get_generic_params ())
898 23368 : visit (generic);
899 :
900 261539 : visit_function_params (function);
901 :
902 261539 : if (function.has_return_type ())
903 190966 : visit (function.get_return_type ());
904 261539 : if (function.has_where_clause ())
905 3265 : visit (function.get_where_clause ());
906 261539 : if (function.has_body ())
907 204540 : visit (*function.get_definition ());
908 261538 : }
909 :
910 : void
911 21057 : DefaultASTVisitor::visit (AST::TypeAlias &type_alias)
912 : {
913 21057 : visit_outer_attrs (type_alias);
914 21057 : visit (type_alias.get_visibility ());
915 21307 : for (auto &generic : type_alias.get_generic_params ())
916 250 : visit (generic);
917 21057 : if (type_alias.has_where_clause ())
918 0 : visit (type_alias.get_where_clause ());
919 21057 : visit (type_alias.get_type_aliased ());
920 21057 : }
921 :
922 : void
923 32960 : DefaultASTVisitor::visit (AST::StructField &field)
924 : {
925 32960 : visit_outer_attrs (field);
926 32960 : visit (field.get_visibility ());
927 32960 : visit (field.get_field_type ());
928 32960 : }
929 :
930 : void
931 23419 : DefaultASTVisitor::visit (AST::StructStruct &struct_item)
932 : {
933 23419 : visit_outer_attrs (struct_item);
934 23419 : visit (struct_item.get_visibility ());
935 31067 : for (auto &generic : struct_item.get_generic_params ())
936 7648 : visit (generic);
937 23419 : if (struct_item.has_where_clause ())
938 28 : visit (struct_item.get_where_clause ());
939 50447 : for (auto &field : struct_item.get_fields ())
940 27028 : visit (field);
941 23419 : }
942 :
943 : void
944 29140 : DefaultASTVisitor::visit (AST::TupleField &field)
945 : {
946 29140 : visit_outer_attrs (field);
947 29140 : visit (field.get_visibility ());
948 29140 : visit (field.get_field_type ());
949 29140 : }
950 :
951 : void
952 13287 : DefaultASTVisitor::visit (AST::TupleStruct &tuple_struct)
953 : {
954 13287 : visit_outer_attrs (tuple_struct);
955 13287 : visit (tuple_struct.get_visibility ());
956 18100 : for (auto &generic : tuple_struct.get_generic_params ())
957 4813 : visit (generic);
958 13287 : if (tuple_struct.has_where_clause ())
959 0 : visit (tuple_struct.get_where_clause ());
960 36804 : for (auto &field : tuple_struct.get_fields ())
961 23517 : visit (field);
962 13287 : }
963 :
964 : void
965 16278 : DefaultASTVisitor::visit (AST::EnumItem &item)
966 : {
967 16278 : visit_outer_attrs (item);
968 16278 : visit (item.get_visibility ());
969 16278 : }
970 :
971 : void
972 5300 : DefaultASTVisitor::visit (AST::EnumItemTuple &item)
973 : {
974 5300 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
975 10923 : for (auto &field : item.get_tuple_fields ())
976 5623 : visit (field);
977 5300 : }
978 :
979 : void
980 1078 : DefaultASTVisitor::visit (AST::EnumItemStruct &item)
981 : {
982 1078 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
983 2827 : for (auto &field : item.get_struct_fields ())
984 1749 : visit (field);
985 1078 : }
986 :
987 : void
988 4671 : DefaultASTVisitor::visit (AST::EnumItemDiscriminant &item)
989 : {
990 4671 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
991 4671 : visit (item.get_expr ());
992 4671 : }
993 :
994 : void
995 7710 : DefaultASTVisitor::visit (AST::Enum &enum_item)
996 : {
997 7710 : visit_outer_attrs (enum_item);
998 7710 : visit (enum_item.get_visibility ());
999 11869 : for (auto &generic : enum_item.get_generic_params ())
1000 4159 : visit (generic);
1001 7710 : if (enum_item.has_where_clause ())
1002 0 : visit (enum_item.get_where_clause ());
1003 25700 : for (auto &item : enum_item.get_variants ())
1004 17990 : visit (item);
1005 7710 : }
1006 :
1007 : void
1008 1456 : DefaultASTVisitor::visit (AST::Union &union_item)
1009 : {
1010 1456 : visit_outer_attrs (union_item);
1011 1456 : visit (union_item.get_visibility ());
1012 2452 : for (auto &generic : union_item.get_generic_params ())
1013 996 : visit (generic);
1014 1456 : if (union_item.has_where_clause ())
1015 0 : visit (union_item.get_where_clause ());
1016 5639 : for (auto &variant : union_item.get_variants ())
1017 4183 : visit (variant);
1018 1456 : }
1019 :
1020 : void
1021 7824 : DefaultASTVisitor::visit (AST::ConstantItem &const_item)
1022 : {
1023 7824 : visit_outer_attrs (const_item);
1024 7824 : visit (const_item.get_visibility ());
1025 7824 : visit (const_item.get_type ());
1026 7824 : if (const_item.has_expr ())
1027 7326 : visit (const_item.get_expr ());
1028 7824 : }
1029 :
1030 : void
1031 786 : DefaultASTVisitor::visit (AST::StaticItem &static_item)
1032 : {
1033 786 : visit_outer_attrs (static_item);
1034 786 : visit (static_item.get_visibility ());
1035 786 : visit (static_item.get_type ());
1036 786 : visit (static_item.get_expr ());
1037 786 : }
1038 :
1039 : void
1040 12563 : DefaultASTVisitor::visit (AST::TraitItemType &item)
1041 : {
1042 12563 : visit_outer_attrs (item);
1043 12698 : for (auto &generic : item.get_generic_params ())
1044 135 : visit (generic);
1045 13418 : for (auto &bound : item.get_type_param_bounds ())
1046 855 : visit (bound);
1047 12563 : }
1048 :
1049 : void
1050 31119 : DefaultASTVisitor::visit (AST::Trait &trait)
1051 : {
1052 31119 : visit_outer_attrs (trait);
1053 31119 : visit (trait.get_visibility ());
1054 :
1055 31119 : visit_inner_attrs (trait);
1056 :
1057 31119 : visit (trait.get_implicit_self ());
1058 :
1059 36714 : for (auto &generic : trait.get_generic_params ())
1060 5595 : visit (generic);
1061 :
1062 31119 : if (trait.has_where_clause ())
1063 63 : visit (trait.get_where_clause ());
1064 :
1065 36447 : for (auto &bound : trait.get_type_param_bounds ())
1066 5328 : visit (bound);
1067 :
1068 59623 : for (auto &item : trait.get_trait_items ())
1069 28504 : visit (item);
1070 31119 : }
1071 :
1072 : void
1073 7587 : DefaultASTVisitor::visit (AST::InherentImpl &impl)
1074 : {
1075 7587 : visit_outer_attrs (impl);
1076 7587 : visit (impl.get_visibility ());
1077 :
1078 10293 : for (auto &generic : impl.get_generic_params ())
1079 2706 : visit (generic);
1080 7587 : if (impl.has_where_clause ())
1081 8 : visit (impl.get_where_clause ());
1082 7587 : visit (impl.get_type ());
1083 7587 : visit_inner_attrs (impl);
1084 27867 : for (auto &item : impl.get_impl_items ())
1085 20280 : visit (item);
1086 7587 : }
1087 :
1088 : void
1089 34129 : DefaultASTVisitor::visit (AST::TraitImpl &impl)
1090 : {
1091 34129 : visit_outer_attrs (impl);
1092 34129 : visit (impl.get_visibility ());
1093 :
1094 40701 : for (auto &generic : impl.get_generic_params ())
1095 6572 : visit (generic);
1096 34129 : if (impl.has_where_clause ())
1097 712 : visit (impl.get_where_clause ());
1098 34129 : visit (impl.get_type ());
1099 34129 : visit (impl.get_trait_path ());
1100 34129 : visit_inner_attrs (impl);
1101 75538 : for (auto &item : impl.get_impl_items ())
1102 41409 : visit (item);
1103 34129 : }
1104 :
1105 : void
1106 10 : DefaultASTVisitor::visit (AST::ExternalTypeItem &item)
1107 : {
1108 10 : visit_outer_attrs (item);
1109 10 : visit (item.get_visibility ());
1110 10 : }
1111 :
1112 : void
1113 13 : DefaultASTVisitor::visit (AST::ExternalStaticItem &item)
1114 : {
1115 13 : visit_outer_attrs (item);
1116 13 : visit (item.get_visibility ());
1117 13 : visit (item.get_type ());
1118 13 : }
1119 :
1120 : void
1121 16927 : DefaultASTVisitor::visit (AST::ExternBlock &block)
1122 : {
1123 16927 : visit_outer_attrs (block);
1124 16927 : visit (block.get_visibility ());
1125 16927 : visit_inner_attrs (block);
1126 43199 : for (auto &item : block.get_extern_items ())
1127 26272 : visit (item);
1128 16927 : }
1129 :
1130 : void
1131 11110 : DefaultASTVisitor::visit (AST::MacroMatchFragment &match)
1132 11110 : {}
1133 :
1134 : void
1135 5292 : DefaultASTVisitor::visit (AST::MacroMatchRepetition &match)
1136 : {
1137 12787 : for (auto &m : match.get_matches ())
1138 7495 : visit (m);
1139 5292 : }
1140 :
1141 : void
1142 11335 : DefaultASTVisitor::visit (AST::MacroMatcher &matcher)
1143 : {
1144 25793 : for (auto &m : matcher.get_matches ())
1145 14458 : visit (m);
1146 11335 : }
1147 :
1148 : void
1149 10813 : DefaultASTVisitor::visit (AST::MacroTranscriber &transcriber)
1150 : {
1151 10813 : visit (transcriber.get_token_tree ());
1152 10813 : }
1153 :
1154 : void
1155 10813 : DefaultASTVisitor::visit (AST::MacroRule &rule)
1156 : {
1157 10813 : visit (rule.get_matcher ());
1158 10813 : visit (rule.get_transcriber ());
1159 10813 : }
1160 : void
1161 8574 : DefaultASTVisitor::visit (AST::MacroRulesDefinition &rules_def)
1162 : {
1163 8574 : visit_outer_attrs (rules_def);
1164 19387 : for (auto &rule : rules_def.get_macro_rules ())
1165 10813 : visit (rule);
1166 8574 : }
1167 :
1168 : void
1169 4238 : DefaultASTVisitor::visit (AST::MacroInvocData &data)
1170 : {
1171 4238 : visit (data.get_path ());
1172 4238 : visit (data.get_delim_tok_tree ());
1173 4238 : }
1174 : void
1175 4238 : DefaultASTVisitor::visit (AST::MacroInvocation ¯o_invoc)
1176 : {
1177 4238 : visit_outer_attrs (macro_invoc);
1178 4238 : visit (macro_invoc.get_invoc_data ());
1179 4238 : }
1180 :
1181 : void
1182 8 : DefaultASTVisitor::visit (AST::MetaItemPath &meta_item)
1183 : {
1184 8 : visit (meta_item.get_path ());
1185 8 : }
1186 :
1187 : void
1188 158 : DefaultASTVisitor::visit (AST::MetaItemSeq &meta_item)
1189 : {
1190 158 : visit (meta_item.get_path ());
1191 375 : for (auto &inner : meta_item.get_seq ())
1192 217 : visit (inner);
1193 158 : }
1194 :
1195 : void
1196 742 : DefaultASTVisitor::visit (AST::MetaWord &meta_item)
1197 742 : {}
1198 :
1199 : void
1200 4620 : DefaultASTVisitor::visit (AST::MetaNameValueStr &meta_item)
1201 4620 : {}
1202 :
1203 : void
1204 0 : DefaultASTVisitor::visit (AST::MetaListPaths &meta_item)
1205 : {
1206 0 : for (auto &path : meta_item.get_paths ())
1207 0 : visit (path);
1208 0 : }
1209 :
1210 : void
1211 0 : DefaultASTVisitor::visit (AST::MetaListNameValueStr &meta_item)
1212 : {
1213 0 : for (auto &str : meta_item.get_values ())
1214 0 : visit (str);
1215 0 : }
1216 :
1217 : void
1218 7237 : DefaultASTVisitor::visit (AST::LiteralPattern &pattern)
1219 7237 : {}
1220 :
1221 : void
1222 254882 : DefaultASTVisitor::visit (AST::IdentifierPattern &pattern)
1223 : {
1224 254882 : if (pattern.has_subpattern ())
1225 250 : visit (pattern.get_subpattern ());
1226 254882 : }
1227 :
1228 : void
1229 22497 : DefaultASTVisitor::visit (AST::WildcardPattern &pattern)
1230 22497 : {}
1231 :
1232 : void
1233 0 : DefaultASTVisitor::visit (AST::RestPattern &pattern)
1234 0 : {}
1235 :
1236 : void
1237 1654 : DefaultASTVisitor::visit (AST::RangePatternBoundLiteral &bound)
1238 1654 : {}
1239 :
1240 : void
1241 189 : DefaultASTVisitor::visit (AST::RangePatternBoundPath &bound)
1242 : {
1243 189 : visit (bound.get_path ());
1244 189 : }
1245 :
1246 : void
1247 0 : DefaultASTVisitor::visit (AST::RangePatternBoundQualPath &bound)
1248 : {
1249 0 : visit (bound.get_qualified_path ());
1250 0 : }
1251 :
1252 : void
1253 811 : DefaultASTVisitor::visit (AST::RangePattern &pattern)
1254 : {
1255 811 : if (pattern.get_has_lower_bound ())
1256 811 : visit (pattern.get_lower_bound ());
1257 811 : if (pattern.get_has_upper_bound ())
1258 811 : visit (pattern.get_upper_bound ());
1259 811 : }
1260 :
1261 : void
1262 2567 : DefaultASTVisitor::visit (AST::ReferencePattern &pattern)
1263 : {
1264 2567 : visit (pattern.get_referenced_pattern ());
1265 2567 : }
1266 :
1267 : void
1268 318 : DefaultASTVisitor::visit (AST::StructPatternFieldTuplePat &field)
1269 : {
1270 318 : visit_outer_attrs (field);
1271 318 : visit (field.get_index_pattern ());
1272 318 : }
1273 :
1274 : void
1275 1934 : DefaultASTVisitor::visit (AST::StructPatternFieldIdentPat &field)
1276 : {
1277 1934 : visit_outer_attrs (field);
1278 1934 : visit (field.get_ident_pattern ());
1279 1934 : }
1280 :
1281 : void
1282 902 : DefaultASTVisitor::visit (AST::StructPatternFieldIdent &field)
1283 : {
1284 902 : visit_outer_attrs (field);
1285 902 : }
1286 :
1287 : void
1288 1608 : DefaultASTVisitor::visit (AST::StructPatternElements &spe)
1289 : {
1290 4268 : for (auto &field : spe.get_struct_pattern_fields ())
1291 2660 : visit (field);
1292 1608 : for (auto &attribute : spe.get_etc_outer_attrs ())
1293 0 : visit (attribute);
1294 1608 : }
1295 :
1296 : void
1297 1608 : DefaultASTVisitor::visit (AST::StructPattern &pattern)
1298 : {
1299 1608 : visit (pattern.get_path ());
1300 1608 : visit (pattern.get_struct_pattern_elems ());
1301 1608 : }
1302 :
1303 : void
1304 15798 : DefaultASTVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
1305 : {
1306 33254 : for (auto &pattern : tuple_items.get_patterns ())
1307 17456 : visit (pattern);
1308 15798 : }
1309 :
1310 : void
1311 538 : DefaultASTVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
1312 : {
1313 966 : for (auto &lower : tuple_items.get_lower_patterns ())
1314 428 : visit (lower);
1315 794 : for (auto &upper : tuple_items.get_upper_patterns ())
1316 256 : visit (upper);
1317 538 : }
1318 :
1319 : void
1320 16336 : DefaultASTVisitor::visit (AST::TupleStructPattern &pattern)
1321 : {
1322 16336 : visit (pattern.get_path ());
1323 16336 : visit (pattern.get_items ());
1324 16336 : }
1325 :
1326 : void
1327 8397 : DefaultASTVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
1328 : {
1329 25397 : for (auto &pattern : tuple_items.get_patterns ())
1330 17000 : visit (pattern);
1331 8397 : }
1332 :
1333 : void
1334 372 : DefaultASTVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
1335 : {
1336 756 : for (auto &lower : tuple_items.get_lower_patterns ())
1337 384 : visit (lower);
1338 804 : for (auto &upper : tuple_items.get_upper_patterns ())
1339 432 : visit (upper);
1340 372 : }
1341 :
1342 : void
1343 8769 : DefaultASTVisitor::visit (AST::TuplePattern &pattern)
1344 : {
1345 8769 : visit (pattern.get_items ());
1346 8769 : }
1347 :
1348 : void
1349 616 : DefaultASTVisitor::visit (AST::GroupedPattern &pattern)
1350 : {
1351 616 : visit (pattern.get_pattern_in_parens ());
1352 616 : }
1353 :
1354 : void
1355 440 : DefaultASTVisitor::visit (AST::SlicePatternItemsNoRest &items)
1356 : {
1357 1320 : for (auto &item : items.get_patterns ())
1358 880 : visit (item);
1359 440 : }
1360 :
1361 : void
1362 612 : DefaultASTVisitor::visit (AST::SlicePatternItemsHasRest &items)
1363 : {
1364 1212 : for (auto &item : items.get_lower_patterns ())
1365 600 : visit (item);
1366 1212 : for (auto &item : items.get_upper_patterns ())
1367 600 : visit (item);
1368 612 : }
1369 :
1370 : void
1371 1052 : DefaultASTVisitor::visit (AST::SlicePattern &pattern)
1372 : {
1373 1052 : visit (pattern.get_items ());
1374 1052 : }
1375 :
1376 : void
1377 2865 : DefaultASTVisitor::visit (AST::AltPattern &pattern)
1378 : {
1379 8893 : for (auto &alt : pattern.get_alts ())
1380 6028 : visit (alt);
1381 2865 : }
1382 :
1383 : void
1384 896 : DefaultASTVisitor::visit (AST::EmptyStmt &stmt)
1385 896 : {}
1386 :
1387 : void
1388 191771 : DefaultASTVisitor::visit (AST::LetStmt &stmt)
1389 : {
1390 191771 : visit_outer_attrs (stmt);
1391 191771 : visit (stmt.get_pattern ());
1392 191771 : if (stmt.has_type ())
1393 29291 : visit (stmt.get_type ());
1394 191771 : if (stmt.has_init_expr ())
1395 176316 : visit (stmt.get_init_expr ());
1396 191771 : }
1397 :
1398 : void
1399 156806 : DefaultASTVisitor::visit (AST::ExprStmt &stmt)
1400 : {
1401 156806 : visit (stmt.get_expr ());
1402 156805 : }
1403 :
1404 : void
1405 23315 : DefaultASTVisitor::visit (AST::TraitBound &bound)
1406 : {
1407 23469 : for (auto &lifetime : bound.get_for_lifetimes ())
1408 154 : visit (lifetime);
1409 23315 : visit (bound.get_type_path ());
1410 23315 : }
1411 :
1412 : void
1413 0 : DefaultASTVisitor::visit (AST::ImplTraitType &type)
1414 : {
1415 0 : for (auto &bound : type.get_type_param_bounds ())
1416 0 : visit (bound);
1417 0 : }
1418 :
1419 : void
1420 173 : DefaultASTVisitor::visit (AST::TraitObjectType &type)
1421 : {
1422 614 : for (auto &bound : type.get_type_param_bounds ())
1423 441 : visit (bound);
1424 173 : }
1425 :
1426 : void
1427 101 : DefaultASTVisitor::visit (AST::ParenthesisedType &type)
1428 : {
1429 101 : visit (type.get_type_in_parens ());
1430 101 : }
1431 :
1432 : void
1433 1324 : DefaultASTVisitor::visit (AST::ImplTraitTypeOneBound &type)
1434 : {
1435 1324 : visit (type.get_trait_bound ());
1436 1324 : }
1437 :
1438 : void
1439 2216 : DefaultASTVisitor::visit (AST::TraitObjectTypeOneBound &type)
1440 : {
1441 2216 : visit (type.get_trait_bound ());
1442 2216 : }
1443 :
1444 : void
1445 6214 : DefaultASTVisitor::visit (AST::TupleType &type)
1446 : {
1447 15871 : for (auto &elem : type.get_elems ())
1448 9657 : visit (elem);
1449 6214 : }
1450 :
1451 : void
1452 851 : DefaultASTVisitor::visit (AST::NeverType &type)
1453 851 : {}
1454 :
1455 : void
1456 117432 : DefaultASTVisitor::visit (AST::RawPointerType &type)
1457 : {
1458 117432 : visit (type.get_type_pointed_to ());
1459 117432 : }
1460 :
1461 : void
1462 80885 : DefaultASTVisitor::visit (AST::ReferenceType &type)
1463 : {
1464 80885 : visit (type.get_lifetime ());
1465 80885 : visit (type.get_base_type ());
1466 80885 : }
1467 :
1468 : void
1469 11837 : DefaultASTVisitor::visit (AST::ArrayType &type)
1470 : {
1471 11837 : visit (type.get_elem_type ());
1472 11837 : visit (type.get_size_expr ());
1473 11837 : }
1474 :
1475 : void
1476 12987 : DefaultASTVisitor::visit (AST::SliceType &type)
1477 : {
1478 12987 : visit (type.get_elem_type ());
1479 12987 : }
1480 :
1481 : void
1482 4428 : DefaultASTVisitor::visit (AST::InferredType &type)
1483 4428 : {}
1484 :
1485 : void
1486 728 : DefaultASTVisitor::visit (AST::MaybeNamedParam ¶m)
1487 : {
1488 728 : visit_outer_attrs (param);
1489 728 : visit (param.get_type ());
1490 728 : }
1491 :
1492 : void
1493 916 : DefaultASTVisitor::visit (AST::BareFunctionType &type)
1494 : {
1495 956 : for (auto &lifetime : type.get_for_lifetimes ())
1496 40 : visit (lifetime);
1497 916 : visit (type.get_function_qualifiers ());
1498 1644 : for (auto ¶m : type.get_function_params ())
1499 728 : visit (param);
1500 916 : if (type.is_variadic ())
1501 0 : for (auto attr : type.get_variadic_attr ())
1502 0 : visit (attr);
1503 916 : if (type.has_return_type ())
1504 679 : visit (type.get_return_type ());
1505 916 : }
1506 :
1507 : void
1508 0 : DefaultASTVisitor::visit (AST::FormatArgs &)
1509 : {
1510 : // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1511 0 : }
1512 :
1513 : void
1514 139 : DefaultASTVisitor::visit (AST::OffsetOf &offset_of)
1515 : {
1516 139 : visit (offset_of.get_type ());
1517 139 : }
1518 :
1519 : void
1520 10293 : DefaultASTVisitor::visit (AST::VariadicParam ¶m)
1521 : {
1522 10293 : if (param.has_pattern ())
1523 132 : visit (param.get_pattern ());
1524 10293 : }
1525 :
1526 : void
1527 4521 : ContextualASTVisitor::visit (AST::Crate &crate)
1528 : {
1529 4521 : ctx.enter (Kind::CRATE);
1530 4521 : DefaultASTVisitor::visit (crate);
1531 4521 : ctx.exit ();
1532 4521 : }
1533 :
1534 : void
1535 971 : ContextualASTVisitor::visit (AST::InherentImpl &impl)
1536 : {
1537 971 : ctx.enter (Kind::INHERENT_IMPL);
1538 971 : DefaultASTVisitor::visit (impl);
1539 971 : ctx.exit ();
1540 971 : }
1541 :
1542 : void
1543 4739 : ContextualASTVisitor::visit (AST::TraitImpl &impl)
1544 : {
1545 4739 : ctx.enter (Kind::TRAIT_IMPL);
1546 4739 : DefaultASTVisitor::visit (impl);
1547 4739 : ctx.exit ();
1548 4739 : }
1549 :
1550 : void
1551 3742 : ContextualASTVisitor::visit (AST::Trait &trait)
1552 : {
1553 3742 : ctx.enter (Kind::TRAIT);
1554 3742 : DefaultASTVisitor::visit (trait);
1555 3742 : ctx.exit ();
1556 3742 : }
1557 :
1558 : } // namespace AST
1559 : } // namespace Rust
|
