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 88203 : DefaultASTVisitor::visit (AST::Crate &crate)
36 : {
37 88203 : visit_inner_attrs (crate);
38 472599 : for (auto &item : crate.items)
39 384398 : visit (item);
40 88201 : }
41 :
42 : void
43 35301238 : DefaultASTVisitor::visit (AST::Token &tok)
44 35301238 : {}
45 :
46 : void
47 4645397 : DefaultASTVisitor::visit (AST::DelimTokenTree &delim_tok_tree)
48 : {
49 41696705 : for (auto &token : delim_tok_tree.get_token_trees ())
50 37051308 : visit (token);
51 4645397 : }
52 :
53 : void
54 28749 : DefaultASTVisitor::visit (AST::AttrInputMetaItemContainer &input)
55 : {
56 58185 : for (auto &item : input.get_items ())
57 29436 : visit (item);
58 28749 : }
59 :
60 : void
61 27083317 : DefaultASTVisitor::visit (AST::IdentifierExpr &ident_expr)
62 : {
63 27083317 : visit_outer_attrs (ident_expr);
64 27083317 : }
65 :
66 : void
67 3398238 : DefaultASTVisitor::visit (AST::Lifetime &lifetime)
68 3398238 : {}
69 :
70 : void
71 174608 : DefaultASTVisitor::visit (AST::LifetimeParam &lifetime_param)
72 : {
73 174608 : visit_outer_attrs (lifetime_param);
74 174608 : visit (lifetime_param.get_lifetime ());
75 177628 : for (auto &lifetime_bound : lifetime_param.get_lifetime_bounds ())
76 3020 : visit (lifetime_bound);
77 174608 : }
78 :
79 : void
80 13097 : DefaultASTVisitor::visit (AST::ConstGenericParam &const_param)
81 : {
82 13097 : visit_outer_attrs (const_param);
83 13097 : if (const_param.has_type ())
84 13097 : visit (const_param.get_type ());
85 13097 : if (const_param.has_default_value ())
86 287 : visit (const_param.get_default_value_unchecked ());
87 13097 : }
88 :
89 : void
90 8133332 : DefaultASTVisitor::visit (AST::PathInExpression &path)
91 : {
92 8133332 : visit_outer_attrs (path);
93 :
94 8133332 : if (!path.is_lang_item ())
95 17465297 : for (auto &segment : path.get_segments ())
96 9361074 : visit (segment);
97 8133332 : }
98 :
99 : void
100 15971576 : DefaultASTVisitor::visit (AST::TypePathSegment &segment)
101 15971576 : {}
102 :
103 : void
104 29203 : DefaultASTVisitor::visit (GenericArgsBinding &binding)
105 : {
106 29203 : visit (binding.get_type ());
107 29203 : }
108 :
109 : void
110 1551722 : DefaultASTVisitor::visit (AST::TypePathSegmentGeneric &segment)
111 : {
112 1551722 : if (segment.has_generic_args ())
113 1551708 : visit (segment.get_generic_args ());
114 1551722 : }
115 :
116 : void
117 98016 : DefaultASTVisitor::visit (AST::TypePathFunction &tpf)
118 : {
119 237941 : for (auto &input : tpf.get_params ())
120 139925 : visit (input);
121 98016 : if (tpf.has_return_type ())
122 94737 : visit (tpf.get_return_type ());
123 98016 : }
124 :
125 : void
126 20555282 : DefaultASTVisitor::visit (AST::PathIdentSegment &segment)
127 20555282 : {}
128 :
129 : void
130 98016 : DefaultASTVisitor::visit (AST::TypePathSegmentFunction &segment)
131 : {
132 98016 : visit (segment.get_type_path_function ());
133 98016 : visit (segment.get_ident_segment ());
134 98016 : }
135 :
136 : void
137 1596764 : DefaultASTVisitor::visit (AST::GenericArgs &args)
138 : {
139 1755117 : for (auto &lifetime : args.get_lifetime_args ())
140 158353 : visit (lifetime);
141 :
142 3165962 : for (auto &generic : args.get_generic_args ())
143 1569198 : visit (generic);
144 :
145 1625637 : for (auto &binding : args.get_binding_args ())
146 28873 : visit (binding);
147 1596764 : }
148 :
149 : void
150 15648466 : DefaultASTVisitor::visit (AST::PathExprSegment &segment)
151 : {
152 15648466 : visit (segment.get_ident_segment ());
153 15648466 : if (segment.has_generic_args ())
154 63536 : visit (segment.get_generic_args ());
155 15648466 : }
156 : void
157 13259589 : DefaultASTVisitor::visit (AST::TypePath &path)
158 : {
159 27423466 : for (auto &segment : path.get_segments ())
160 14163877 : visit (segment);
161 13259589 : }
162 :
163 : void
164 24241 : DefaultASTVisitor::visit (AST::QualifiedPathInExpression &path)
165 : {
166 24241 : visit_outer_attrs (path);
167 24241 : visit (path.get_qualified_path_type ());
168 :
169 48482 : for (auto &segment : path.get_segments ())
170 24241 : visit (segment);
171 24241 : }
172 :
173 : void
174 562473 : DefaultASTVisitor::visit (AST::QualifiedPathType &path)
175 : {
176 562473 : visit (path.get_type ());
177 562473 : if (path.has_as_clause ())
178 544154 : visit (path.get_as_type_path ());
179 562473 : }
180 :
181 : void
182 644834 : DefaultASTVisitor::visit (AST::QualifiedPathInType &path)
183 : {
184 644834 : visit (path.get_qualified_path_type ());
185 644834 : visit (path.get_associated_segment ());
186 :
187 644834 : for (auto &segment : path.get_segments ())
188 0 : visit (segment);
189 644834 : }
190 :
191 : void
192 33743031 : DefaultASTVisitor::visit (AST::LiteralExpr &expr)
193 : {
194 33743031 : visit_outer_attrs (expr);
195 33743031 : }
196 :
197 : void
198 15796499 : DefaultASTVisitor::visit (AST::Attribute &attribute)
199 : {
200 15796499 : visit (attribute.get_path ());
201 15796499 : if (attribute.has_attr_input ())
202 13613300 : visit (attribute.get_attr_input ());
203 15796499 : }
204 :
205 : void
206 9305092 : DefaultASTVisitor::visit (AST::AttrInputLiteral &attr_input)
207 : {
208 9305092 : visit (attr_input.get_literal ());
209 9305092 : }
210 :
211 : void
212 214921 : DefaultASTVisitor::visit (AST::AttrInputExpr &attr_input)
213 : {
214 214921 : visit (attr_input.get_expr ());
215 214921 : }
216 :
217 : void
218 0 : DefaultASTVisitor::visit (AST::MetaItemLitExpr &meta_item)
219 : {
220 0 : visit (meta_item.get_literal ());
221 0 : }
222 :
223 : void
224 16367100 : DefaultASTVisitor::visit (AST::SimplePathSegment &segment)
225 16367100 : {}
226 :
227 : void
228 16244920 : DefaultASTVisitor::visit (AST::SimplePath &path)
229 : {
230 32612020 : for (auto &segment : path.get_segments ())
231 16367100 : visit (segment);
232 16244920 : }
233 :
234 : void
235 1 : DefaultASTVisitor::visit (AST::MetaItemPathExpr &meta_item)
236 : {
237 1 : visit (meta_item.get_path ());
238 1 : visit (meta_item.get_expr ());
239 1 : }
240 :
241 : void
242 1201806 : DefaultASTVisitor::visit (AST::BorrowExpr &expr)
243 : {
244 1201806 : visit_outer_attrs (expr);
245 1201806 : visit (expr.get_borrowed_expr ());
246 1201806 : }
247 :
248 : void
249 606680 : DefaultASTVisitor::visit (AST::DereferenceExpr &expr)
250 : {
251 606680 : visit_outer_attrs (expr);
252 606680 : visit (expr.get_dereferenced_expr ());
253 606680 : }
254 :
255 : void
256 83786 : DefaultASTVisitor::visit (AST::ErrorPropagationExpr &expr)
257 : {
258 83786 : visit_outer_attrs (expr);
259 83786 : visit (expr.get_propagating_expr ());
260 83786 : }
261 :
262 : void
263 187995 : DefaultASTVisitor::visit (AST::NegationExpr &expr)
264 : {
265 187995 : visit_outer_attrs (expr);
266 187995 : visit (expr.get_negated_expr ());
267 187995 : }
268 :
269 : void
270 6293043 : DefaultASTVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
271 : {
272 6293043 : visit_outer_attrs (expr);
273 6293043 : visit (expr.get_left_expr ());
274 6293043 : visit (expr.get_right_expr ());
275 6293043 : }
276 :
277 : void
278 575573 : DefaultASTVisitor::visit (AST::ComparisonExpr &expr)
279 : {
280 575573 : visit_outer_attrs (expr);
281 575573 : visit (expr.get_left_expr ());
282 575573 : visit (expr.get_right_expr ());
283 575573 : }
284 :
285 : void
286 143121 : DefaultASTVisitor::visit (AST::LazyBooleanExpr &expr)
287 : {
288 143121 : visit_outer_attrs (expr);
289 143121 : visit (expr.get_left_expr ());
290 143121 : visit (expr.get_right_expr ());
291 143121 : }
292 :
293 : void
294 959031 : DefaultASTVisitor::visit (AST::TypeCastExpr &expr)
295 : {
296 959031 : visit_outer_attrs (expr);
297 959031 : visit (expr.get_casted_expr ());
298 959031 : visit (expr.get_type_to_cast_to ());
299 959031 : }
300 :
301 : void
302 393944 : DefaultASTVisitor::visit (AST::AssignmentExpr &expr)
303 : {
304 393944 : visit_outer_attrs (expr);
305 393944 : visit (expr.get_left_expr ());
306 393944 : visit (expr.get_right_expr ());
307 393944 : }
308 :
309 : void
310 237522 : DefaultASTVisitor::visit (AST::CompoundAssignmentExpr &expr)
311 : {
312 237522 : visit_outer_attrs (expr);
313 237522 : visit (expr.get_left_expr ());
314 237522 : visit (expr.get_right_expr ());
315 237522 : }
316 :
317 : void
318 1148951 : DefaultASTVisitor::visit (AST::GroupedExpr &expr)
319 : {
320 1148951 : visit_outer_attrs (expr);
321 1148951 : visit_inner_attrs (expr);
322 1148951 : visit (expr.get_expr_in_parens ());
323 1148951 : }
324 :
325 : void
326 1293714 : DefaultASTVisitor::visit (AST::ArrayElemsValues &elems)
327 : {
328 13597388 : for (auto &value : elems.get_values ())
329 12303674 : visit (value);
330 1293714 : }
331 :
332 : void
333 11246 : DefaultASTVisitor::visit (AST::ArrayElemsCopied &elems)
334 : {
335 11246 : visit (elems.get_elem_to_copy ());
336 11246 : visit (elems.get_num_copies ());
337 11246 : }
338 :
339 : void
340 2510512 : DefaultASTVisitor::visit (AST::ArrayExpr &expr)
341 : {
342 2510512 : visit_outer_attrs (expr);
343 2510512 : visit_inner_attrs (expr);
344 2510512 : visit (expr.get_array_elems ());
345 2510512 : }
346 :
347 : void
348 165565 : DefaultASTVisitor::visit (AST::ArrayIndexExpr &expr)
349 : {
350 165565 : visit_outer_attrs (expr);
351 165565 : visit (expr.get_array_expr ());
352 165565 : visit (expr.get_index_expr ());
353 165565 : }
354 :
355 : void
356 444671 : DefaultASTVisitor::visit (AST::TupleExpr &expr)
357 : {
358 444671 : visit_outer_attrs (expr);
359 444671 : visit_inner_attrs (expr);
360 1272959 : for (auto &elem : expr.get_tuple_elems ())
361 828288 : visit (elem);
362 444671 : }
363 :
364 : void
365 795883 : DefaultASTVisitor::visit (AST::TupleIndexExpr &expr)
366 : {
367 795883 : visit_outer_attrs (expr);
368 795883 : visit (expr.get_tuple_expr ());
369 795883 : }
370 :
371 : void
372 4588 : DefaultASTVisitor::visit (AST::StructExprStruct &expr)
373 : {
374 4588 : visit_outer_attrs (expr);
375 4588 : visit_inner_attrs (expr);
376 4588 : visit (expr.get_struct_name ());
377 4588 : }
378 :
379 : void
380 48539 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifier &field)
381 48539 : {}
382 :
383 : void
384 180807 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifierValue &field)
385 : {
386 180807 : visit (field.get_value ());
387 180807 : }
388 :
389 : void
390 748 : DefaultASTVisitor::visit (AST::StructExprFieldIndexValue &field)
391 : {
392 748 : visit (field.get_value ());
393 748 : }
394 :
395 : void
396 1674 : DefaultASTVisitor::visit (AST::StructBase &base)
397 : {
398 1674 : visit (base.get_base_struct ());
399 1674 : }
400 :
401 : void
402 148350 : DefaultASTVisitor::visit (AST::StructExprStructFields &expr)
403 : {
404 148350 : visit_outer_attrs (expr);
405 148350 : visit_inner_attrs (expr);
406 148350 : visit (expr.get_struct_name ());
407 148350 : if (expr.has_struct_base ())
408 2132 : visit (expr.get_struct_base ());
409 429439 : for (auto &field : expr.get_fields ())
410 281089 : visit (field);
411 148350 : }
412 :
413 : void
414 0 : DefaultASTVisitor::visit (AST::StructExprStructBase &expr)
415 : {
416 0 : visit_outer_attrs (expr);
417 0 : visit_inner_attrs (expr);
418 0 : visit (expr.get_struct_name ());
419 0 : visit (expr.get_struct_base ());
420 0 : }
421 :
422 : void
423 10665490 : DefaultASTVisitor::visit (AST::CallExpr &expr)
424 : {
425 10665490 : visit_outer_attrs (expr);
426 10665490 : visit (expr.get_function_expr ());
427 37297744 : for (auto ¶m : expr.get_params ())
428 26632255 : visit (param);
429 10665489 : }
430 :
431 : void
432 6263151 : DefaultASTVisitor::visit (AST::MethodCallExpr &expr)
433 : {
434 6263151 : visit_outer_attrs (expr);
435 6263151 : visit (expr.get_receiver_expr ());
436 6263151 : visit (expr.get_method_name ());
437 7227096 : for (auto ¶m : expr.get_params ())
438 963945 : visit (param);
439 6263151 : }
440 :
441 : void
442 1033322 : DefaultASTVisitor::visit (AST::FieldAccessExpr &expr)
443 : {
444 1033322 : visit_outer_attrs (expr);
445 1033322 : visit (expr.get_receiver_expr ());
446 1033322 : }
447 :
448 : void
449 56611 : DefaultASTVisitor::visit (AST::ClosureExprInner &expr)
450 : {
451 56611 : visit_outer_attrs (expr);
452 122908 : for (auto ¶m : expr.get_params ())
453 66297 : visit (param);
454 56611 : visit (expr.get_definition_expr ());
455 56611 : }
456 :
457 : void
458 3456427 : DefaultASTVisitor::visit (AST::BlockExpr &expr)
459 : {
460 3456427 : visit_outer_attrs (expr);
461 3456427 : visit_inner_attrs (expr);
462 :
463 3456427 : if (expr.has_label ())
464 51 : visit (expr.get_label ());
465 :
466 5493129 : for (auto &stmt : expr.get_statements ())
467 2036705 : visit (stmt);
468 :
469 3456424 : if (expr.has_tail_expr ())
470 2921991 : visit (expr.get_tail_expr ());
471 3456422 : }
472 :
473 : void
474 280 : DefaultASTVisitor::visit (AST::ConstBlock &expr)
475 : {
476 280 : visit (expr.get_const_expr ());
477 280 : }
478 :
479 : void
480 68070 : DefaultASTVisitor::visit (AST::AnonConst &expr)
481 : {
482 68070 : if (!expr.is_deferred ())
483 67847 : visit (expr.get_inner_expr ());
484 68070 : }
485 :
486 : void
487 438 : DefaultASTVisitor::visit (AST::ClosureExprInnerTyped &expr)
488 : {
489 438 : visit_outer_attrs (expr);
490 953 : for (auto ¶m : expr.get_params ())
491 515 : visit (param);
492 438 : visit (expr.get_return_type ());
493 438 : visit (expr.get_definition_expr ());
494 438 : }
495 :
496 : void
497 92690 : DefaultASTVisitor::visit (AST::ClosureParam ¶m)
498 : {
499 92690 : visit_outer_attrs (param);
500 92690 : visit (param.get_pattern ());
501 92690 : if (param.has_type_given ())
502 5252 : visit (param.get_type ());
503 92690 : }
504 :
505 : void
506 1886 : DefaultASTVisitor::visit (AST::ContinueExpr &expr)
507 : {
508 1886 : visit_outer_attrs (expr);
509 1886 : if (expr.has_label ())
510 757 : visit (expr.get_label_unchecked ());
511 1886 : }
512 :
513 : void
514 14695 : DefaultASTVisitor::visit (AST::BreakExpr &expr)
515 : {
516 14695 : visit_outer_attrs (expr);
517 14695 : if (expr.has_label ())
518 809 : visit (expr.get_label_unchecked ());
519 :
520 14695 : if (expr.has_break_expr ())
521 630 : visit (expr.get_break_expr_unchecked ());
522 14694 : }
523 :
524 : void
525 53541 : DefaultASTVisitor::visit (AST::RangeFromToExpr &expr)
526 : {
527 53541 : visit (expr.get_from_expr ());
528 53541 : visit (expr.get_to_expr ());
529 53541 : }
530 :
531 : void
532 21948 : DefaultASTVisitor::visit (AST::RangeFromExpr &expr)
533 : {
534 21948 : visit (expr.get_from_expr ());
535 21948 : }
536 :
537 : void
538 34033 : DefaultASTVisitor::visit (AST::RangeToExpr &expr)
539 : {
540 34033 : visit (expr.get_to_expr ());
541 34033 : }
542 :
543 : void
544 14531 : DefaultASTVisitor::visit (AST::RangeFullExpr &expr)
545 14531 : {}
546 :
547 : void
548 1205 : DefaultASTVisitor::visit (AST::RangeFromToInclExpr &expr)
549 : {
550 1205 : visit (expr.get_from_expr ());
551 1205 : visit (expr.get_to_expr ());
552 1205 : }
553 :
554 : void
555 0 : DefaultASTVisitor::visit (AST::RangeToInclExpr &expr)
556 : {
557 0 : visit (expr.get_to_expr ());
558 0 : }
559 :
560 : void
561 140027 : DefaultASTVisitor::visit (AST::ReturnExpr &expr)
562 : {
563 140027 : visit_outer_attrs (expr);
564 140027 : if (expr.has_returned_expr ())
565 135724 : visit (expr.get_returned_expr ());
566 140027 : }
567 :
568 : void
569 7081 : DefaultASTVisitor::visit (AST::TryExpr &expr)
570 : {
571 7081 : visit_outer_attrs (expr);
572 7081 : visit (expr.get_block_expr ());
573 7081 : }
574 :
575 : void
576 69 : DefaultASTVisitor::visit (AST::BoxExpr &expr)
577 : {
578 69 : visit_outer_attrs (expr);
579 69 : visit (expr.get_boxed_expr ());
580 69 : }
581 :
582 : void
583 286384 : DefaultASTVisitor::visit (AST::UnsafeBlockExpr &expr)
584 : {
585 286384 : visit_outer_attrs (expr);
586 286384 : visit (expr.get_block_expr ());
587 286384 : }
588 :
589 : void
590 2529 : DefaultASTVisitor::visit (AST::LoopLabel &label)
591 : {
592 2529 : visit (label.get_lifetime ());
593 2529 : }
594 :
595 : void
596 9637 : DefaultASTVisitor::visit (AST::LoopExpr &expr)
597 : {
598 9637 : visit_outer_attrs (expr);
599 9637 : if (expr.has_loop_label ())
600 1125 : visit (expr.get_loop_label ());
601 9637 : visit (expr.get_loop_block ());
602 9636 : }
603 :
604 : void
605 26546 : DefaultASTVisitor::visit (AST::WhileLoopExpr &expr)
606 : {
607 26546 : visit_outer_attrs (expr);
608 26546 : if (expr.has_loop_label ())
609 117 : visit (expr.get_loop_label ());
610 26546 : visit (expr.get_predicate_expr ());
611 26546 : visit (expr.get_loop_block ());
612 26546 : }
613 :
614 : void
615 5358 : DefaultASTVisitor::visit (AST::WhileLetLoopExpr &expr)
616 : {
617 5358 : visit_outer_attrs (expr);
618 5358 : visit (expr.get_pattern ());
619 :
620 5358 : if (expr.has_loop_label ())
621 9 : visit (expr.get_loop_label ());
622 :
623 5358 : visit (expr.get_scrutinee_expr ());
624 5358 : visit (expr.get_loop_block ());
625 5358 : }
626 :
627 : void
628 26568 : DefaultASTVisitor::visit (AST::ForLoopExpr &expr)
629 : {
630 26568 : visit_outer_attrs (expr);
631 26568 : visit (expr.get_pattern ());
632 26568 : visit (expr.get_iterator_expr ());
633 26568 : if (expr.has_loop_label ())
634 0 : visit (expr.get_loop_label ());
635 26568 : visit (expr.get_loop_block ());
636 26568 : }
637 :
638 : void
639 424776 : DefaultASTVisitor::visit (AST::IfExpr &expr)
640 : {
641 424776 : visit_outer_attrs (expr);
642 424776 : visit (expr.get_condition_expr ());
643 424776 : visit (expr.get_if_block ());
644 424776 : }
645 :
646 : void
647 271221 : DefaultASTVisitor::visit (AST::IfExprConseqElse &expr)
648 : {
649 271221 : visit (reinterpret_cast<AST::IfExpr &> (expr));
650 271221 : visit (expr.get_else_block ());
651 271221 : }
652 :
653 : void
654 14421 : DefaultASTVisitor::visit (AST::IfLetExpr &expr)
655 : {
656 14421 : visit_outer_attrs (expr);
657 14421 : visit (expr.get_pattern ());
658 14421 : visit (expr.get_value_expr ());
659 14421 : visit (expr.get_if_block ());
660 14421 : }
661 :
662 : void
663 4920 : DefaultASTVisitor::visit (AST::IfLetExprConseqElse &expr)
664 : {
665 4920 : visit (reinterpret_cast<AST::IfLetExpr &> (expr));
666 4920 : visit (expr.get_else_block ());
667 4920 : }
668 :
669 : void
670 7775723 : DefaultASTVisitor::visit (AST::MatchArm &arm)
671 : {
672 7775723 : visit_outer_attrs (arm);
673 7775723 : visit (arm.get_pattern ());
674 7775723 : if (arm.has_match_arm_guard ())
675 6074 : visit (arm.get_guard_expr ());
676 7775723 : }
677 :
678 : void
679 7826825 : DefaultASTVisitor::visit (AST::MatchCase &arm)
680 : {
681 7826825 : visit (arm.get_arm ());
682 7826825 : visit (arm.get_expr ());
683 7826824 : }
684 :
685 : void
686 782088 : DefaultASTVisitor::visit (AST::MatchExpr &expr)
687 : {
688 782088 : visit_outer_attrs (expr);
689 782088 : visit_inner_attrs (expr);
690 782088 : visit (expr.get_scrutinee_expr ());
691 8608911 : for (auto &arm : expr.get_match_cases ())
692 7826825 : visit (arm);
693 782086 : }
694 :
695 : void
696 0 : DefaultASTVisitor::visit (AST::AwaitExpr &expr)
697 : {
698 0 : visit_outer_attrs (expr);
699 0 : visit (expr.get_awaited_expr ());
700 0 : }
701 :
702 : void
703 0 : DefaultASTVisitor::visit (AST::AsyncBlockExpr &expr)
704 : {
705 0 : visit_outer_attrs (expr);
706 0 : visit (expr.get_block_expr ());
707 0 : }
708 :
709 : void
710 345 : DefaultASTVisitor::visit (AST::InlineAsm &expr)
711 : {
712 345 : visit_outer_attrs (expr);
713 345 : using RegisterType = AST::InlineAsmOperand::RegisterType;
714 718 : for (auto &operand : expr.get_operands ())
715 : {
716 373 : switch (operand.get_register_type ())
717 : {
718 130 : case RegisterType::In:
719 130 : {
720 130 : visit (operand.get_in ().expr);
721 130 : break;
722 : }
723 217 : case RegisterType::Out:
724 217 : {
725 217 : visit (operand.get_out ().expr);
726 217 : break;
727 : }
728 0 : case RegisterType::InOut:
729 0 : {
730 0 : visit (operand.get_in_out ().expr);
731 0 : break;
732 : }
733 26 : case RegisterType::SplitInOut:
734 26 : {
735 26 : auto split = operand.get_split_in_out ();
736 26 : visit (split.in_expr);
737 26 : visit (split.out_expr);
738 26 : break;
739 26 : }
740 0 : case RegisterType::Const:
741 0 : {
742 0 : visit (operand.get_const ().anon_const.get_inner_expr ());
743 0 : break;
744 : }
745 0 : case RegisterType::Sym:
746 0 : {
747 0 : visit (operand.get_sym ().expr);
748 0 : break;
749 : }
750 0 : case RegisterType::Label:
751 0 : {
752 0 : visit (operand.get_label ().expr);
753 0 : break;
754 : }
755 : }
756 345 : }
757 345 : }
758 :
759 : void
760 2206 : DefaultASTVisitor::visit (AST::LlvmInlineAsm &expr)
761 : {
762 5198 : for (auto &output : expr.get_outputs ())
763 2992 : visit (output.expr);
764 :
765 4588 : for (auto &input : expr.get_inputs ())
766 2382 : visit (input.expr);
767 2206 : }
768 :
769 : void
770 685884 : DefaultASTVisitor::visit (AST::TypeParam ¶m)
771 : {
772 685884 : visit_outer_attrs (param);
773 880004 : for (auto &bound : param.get_type_param_bounds ())
774 194120 : visit (bound);
775 685884 : if (param.has_type ())
776 6378 : visit (param.get_type ());
777 685884 : }
778 :
779 : void
780 253 : DefaultASTVisitor::visit (AST::LifetimeWhereClauseItem &item)
781 : {
782 253 : visit (item.get_lifetime ());
783 506 : for (auto &bound : item.get_lifetime_bounds ())
784 253 : visit (bound);
785 253 : }
786 :
787 : void
788 182983 : DefaultASTVisitor::visit (AST::TypeBoundWhereClauseItem &item)
789 : {
790 183299 : for (auto &lifetime : item.get_for_lifetimes ())
791 316 : visit (lifetime);
792 182983 : visit (item.get_type ());
793 374248 : for (auto ¶m : item.get_type_param_bounds ())
794 191265 : visit (param);
795 182983 : }
796 :
797 : void
798 5860807 : DefaultASTVisitor::visit (AST::Visibility &vis)
799 : {
800 5860807 : if (vis.has_path ())
801 63460 : visit (vis.get_path ());
802 5860807 : }
803 :
804 : void
805 2970756 : DefaultASTVisitor::visit (AST::FunctionQualifiers &qualifiers)
806 2970756 : {}
807 :
808 : void
809 163165 : DefaultASTVisitor::visit (AST::WhereClause &where)
810 : {
811 385763 : for (auto &item : where.get_items ())
812 222598 : visit (item);
813 163165 : }
814 : void
815 2563309 : DefaultASTVisitor::visit (AST::FunctionParam ¶m)
816 : {
817 2563309 : visit_outer_attrs (param);
818 2563309 : if (param.has_name ())
819 2563309 : visit (param.get_pattern ());
820 :
821 2563309 : visit (param.get_type ());
822 2563309 : }
823 :
824 : void
825 1567200 : DefaultASTVisitor::visit (AST::SelfParam ¶m)
826 : {
827 1567200 : visit_outer_attrs (param);
828 :
829 1567200 : if (param.has_lifetime ())
830 731135 : visit (param.get_lifetime ());
831 :
832 1567200 : if (param.has_type ())
833 2440 : visit (param.get_type ());
834 1567200 : }
835 :
836 : void
837 47746 : DefaultASTVisitor::visit (AST::Module &module)
838 : {
839 47746 : visit_outer_attrs (module);
840 47746 : visit (module.get_visibility ());
841 47746 : visit_inner_attrs (module);
842 1326252 : for (auto &item : module.get_items ())
843 1278506 : visit (item);
844 47746 : }
845 :
846 : void
847 266 : DefaultASTVisitor::visit (AST::ExternCrate &crate)
848 : {
849 266 : visit_outer_attrs (crate);
850 266 : visit (crate.get_visibility ());
851 266 : }
852 :
853 : void
854 7456 : DefaultASTVisitor::visit (AST::UseTreeGlob &use_tree)
855 : {
856 7456 : visit (use_tree.get_path ());
857 7456 : }
858 :
859 : void
860 25172 : DefaultASTVisitor::visit (AST::UseTreeList &use_tree)
861 : {
862 25172 : visit (use_tree.get_path ());
863 25172 : }
864 :
865 : void
866 54197 : DefaultASTVisitor::visit (AST::UseTreeRebind &use_tree)
867 : {
868 54197 : visit (use_tree.get_path ());
869 54197 : }
870 :
871 : void
872 86910 : DefaultASTVisitor::visit (AST::UseDeclaration &use_decl)
873 : {
874 86910 : visit (use_decl.get_visibility ());
875 86910 : visit (use_decl.get_tree ());
876 86910 : }
877 :
878 : void
879 2352217 : DefaultASTVisitor::visit_function_params (AST::Function &function)
880 : {
881 6453430 : for (auto ¶m : function.get_function_params ())
882 4101213 : visit (param);
883 2352217 : }
884 :
885 : void
886 2383643 : DefaultASTVisitor::visit (AST::Function &function)
887 : {
888 2383643 : visit_outer_attrs (function);
889 2383643 : visit (function.get_visibility ());
890 2383643 : visit (function.get_qualifiers ());
891 2671982 : for (auto &generic : function.get_generic_params ())
892 288339 : visit (generic);
893 :
894 2383643 : visit_function_params (function);
895 :
896 2383643 : if (function.has_return_type ())
897 2023769 : visit (function.get_return_type ());
898 2383643 : if (function.has_where_clause ())
899 78584 : visit (function.get_where_clause ());
900 2383643 : if (function.has_body ())
901 2157747 : visit (*function.get_definition ());
902 2383641 : }
903 :
904 : void
905 475603 : DefaultASTVisitor::visit (AST::TypeAlias &type_alias)
906 : {
907 475603 : visit_outer_attrs (type_alias);
908 475603 : visit (type_alias.get_visibility ());
909 476085 : for (auto &generic : type_alias.get_generic_params ())
910 482 : visit (generic);
911 475603 : if (type_alias.has_where_clause ())
912 0 : visit (type_alias.get_where_clause ());
913 475603 : visit (type_alias.get_type_aliased ());
914 475603 : }
915 :
916 : void
917 104176 : DefaultASTVisitor::visit (AST::StructField &field)
918 : {
919 104176 : visit_outer_attrs (field);
920 104176 : visit (field.get_visibility ());
921 104176 : visit (field.get_field_type ());
922 104176 : }
923 :
924 : void
925 227934 : DefaultASTVisitor::visit (AST::StructStruct &struct_item)
926 : {
927 227934 : visit_outer_attrs (struct_item);
928 227934 : visit (struct_item.get_visibility ());
929 291602 : for (auto &generic : struct_item.get_generic_params ())
930 63668 : visit (generic);
931 227934 : if (struct_item.has_where_clause ())
932 2053 : visit (struct_item.get_where_clause ());
933 343697 : for (auto &field : struct_item.get_fields ())
934 115763 : visit (field);
935 227934 : }
936 :
937 : void
938 105587 : DefaultASTVisitor::visit (AST::TupleField &field)
939 : {
940 105587 : visit_outer_attrs (field);
941 105587 : visit (field.get_visibility ());
942 105587 : visit (field.get_field_type ());
943 105587 : }
944 :
945 : void
946 37923 : DefaultASTVisitor::visit (AST::TupleStruct &tuple_struct)
947 : {
948 37923 : visit_outer_attrs (tuple_struct);
949 37923 : visit (tuple_struct.get_visibility ());
950 52671 : for (auto &generic : tuple_struct.get_generic_params ())
951 14748 : visit (generic);
952 37923 : if (tuple_struct.has_where_clause ())
953 183 : visit (tuple_struct.get_where_clause ());
954 153867 : for (auto &field : tuple_struct.get_fields ())
955 115944 : visit (field);
956 37923 : }
957 :
958 : void
959 38955 : DefaultASTVisitor::visit (AST::EnumItem &item)
960 : {
961 38955 : visit_outer_attrs (item);
962 38955 : visit (item.get_visibility ());
963 38955 : }
964 :
965 : void
966 12520 : DefaultASTVisitor::visit (AST::EnumItemTuple &item)
967 : {
968 12520 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
969 26337 : for (auto &field : item.get_tuple_fields ())
970 13817 : visit (field);
971 12520 : }
972 :
973 : void
974 1688 : DefaultASTVisitor::visit (AST::EnumItemStruct &item)
975 : {
976 1688 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
977 4429 : for (auto &field : item.get_struct_fields ())
978 2741 : visit (field);
979 1688 : }
980 :
981 : void
982 6295 : DefaultASTVisitor::visit (AST::EnumItemDiscriminant &item)
983 : {
984 6295 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
985 6295 : visit (item.get_expr ());
986 6295 : }
987 :
988 : void
989 19732 : DefaultASTVisitor::visit (AST::Enum &enum_item)
990 : {
991 19732 : visit_outer_attrs (enum_item);
992 19732 : visit (enum_item.get_visibility ());
993 29123 : for (auto &generic : enum_item.get_generic_params ())
994 9391 : visit (generic);
995 19732 : if (enum_item.has_where_clause ())
996 0 : visit (enum_item.get_where_clause ());
997 69580 : for (auto &item : enum_item.get_variants ())
998 49848 : visit (item);
999 19732 : }
1000 :
1001 : void
1002 2516 : DefaultASTVisitor::visit (AST::Union &union_item)
1003 : {
1004 2516 : visit_outer_attrs (union_item);
1005 2516 : visit (union_item.get_visibility ());
1006 4361 : for (auto &generic : union_item.get_generic_params ())
1007 1845 : visit (generic);
1008 2516 : if (union_item.has_where_clause ())
1009 0 : visit (union_item.get_where_clause ());
1010 9592 : for (auto &variant : union_item.get_variants ())
1011 7076 : visit (variant);
1012 2516 : }
1013 :
1014 : void
1015 120124 : DefaultASTVisitor::visit (AST::ConstantItem &const_item)
1016 : {
1017 120124 : visit_outer_attrs (const_item);
1018 120124 : visit (const_item.get_visibility ());
1019 120124 : visit (const_item.get_type ());
1020 120124 : if (const_item.has_expr ())
1021 116050 : visit (const_item.get_expr ());
1022 120124 : }
1023 :
1024 : void
1025 6208 : DefaultASTVisitor::visit (AST::StaticItem &static_item)
1026 : {
1027 6208 : visit_outer_attrs (static_item);
1028 6208 : visit (static_item.get_visibility ());
1029 6208 : visit (static_item.get_type ());
1030 6208 : visit (static_item.get_expr ());
1031 6208 : }
1032 :
1033 : void
1034 28966 : DefaultASTVisitor::visit (AST::TraitItemType &item)
1035 : {
1036 28966 : visit_outer_attrs (item);
1037 29380 : for (auto &generic : item.get_generic_params ())
1038 414 : visit (generic);
1039 35219 : for (auto &bound : item.get_type_param_bounds ())
1040 6253 : visit (bound);
1041 28966 : }
1042 :
1043 : void
1044 56400 : DefaultASTVisitor::visit (AST::Trait &trait)
1045 : {
1046 56400 : visit_outer_attrs (trait);
1047 56400 : visit (trait.get_visibility ());
1048 :
1049 56400 : visit_inner_attrs (trait);
1050 :
1051 56400 : visit (trait.get_implicit_self ());
1052 :
1053 68695 : for (auto &generic : trait.get_generic_params ())
1054 12295 : visit (generic);
1055 :
1056 56400 : if (trait.has_where_clause ())
1057 91 : visit (trait.get_where_clause ());
1058 :
1059 69407 : for (auto &bound : trait.get_type_param_bounds ())
1060 13007 : visit (bound);
1061 :
1062 125269 : for (auto &item : trait.get_trait_items ())
1063 68869 : visit (item);
1064 56400 : }
1065 :
1066 : void
1067 32789 : DefaultASTVisitor::visit (AST::InherentImpl &impl)
1068 : {
1069 32789 : visit_outer_attrs (impl);
1070 32789 : visit (impl.get_visibility ());
1071 :
1072 56453 : for (auto &generic : impl.get_generic_params ())
1073 23664 : visit (generic);
1074 32789 : if (impl.has_where_clause ())
1075 236 : visit (impl.get_where_clause ());
1076 32789 : visit (impl.get_type ());
1077 32789 : visit_inner_attrs (impl);
1078 224287 : for (auto &item : impl.get_impl_items ())
1079 191498 : visit (item);
1080 32789 : }
1081 :
1082 : void
1083 529517 : DefaultASTVisitor::visit (AST::TraitImpl &impl)
1084 : {
1085 529517 : visit_outer_attrs (impl);
1086 529517 : visit (impl.get_visibility ());
1087 :
1088 1014106 : for (auto &generic : impl.get_generic_params ())
1089 484589 : visit (generic);
1090 529517 : if (impl.has_where_clause ())
1091 27265 : visit (impl.get_where_clause ());
1092 529517 : visit (impl.get_type ());
1093 529517 : visit (impl.get_trait_path ());
1094 529517 : visit_inner_attrs (impl);
1095 1276201 : for (auto &item : impl.get_impl_items ())
1096 746684 : visit (item);
1097 529517 : }
1098 :
1099 : void
1100 179 : DefaultASTVisitor::visit (AST::ExternalTypeItem &item)
1101 : {
1102 179 : visit_outer_attrs (item);
1103 179 : visit (item.get_visibility ());
1104 179 : }
1105 :
1106 : void
1107 16 : DefaultASTVisitor::visit (AST::ExternalStaticItem &item)
1108 : {
1109 16 : visit_outer_attrs (item);
1110 16 : visit (item.get_visibility ());
1111 16 : visit (item.get_type ());
1112 16 : }
1113 :
1114 : void
1115 29504 : DefaultASTVisitor::visit (AST::ExternBlock &block)
1116 : {
1117 29504 : visit_outer_attrs (block);
1118 29504 : visit (block.get_visibility ());
1119 29504 : visit_inner_attrs (block);
1120 159783 : for (auto &item : block.get_extern_items ())
1121 130279 : visit (item);
1122 29504 : }
1123 :
1124 : void
1125 221222 : DefaultASTVisitor::visit (AST::MacroMatchFragment &match)
1126 221222 : {}
1127 :
1128 : void
1129 29273 : DefaultASTVisitor::visit (AST::MacroMatchRepetition &match)
1130 : {
1131 71922 : for (auto &m : match.get_matches ())
1132 42649 : visit (m);
1133 29273 : }
1134 :
1135 : void
1136 112607 : DefaultASTVisitor::visit (AST::MacroMatcher &matcher)
1137 : {
1138 466063 : for (auto &m : matcher.get_matches ())
1139 353456 : visit (m);
1140 112607 : }
1141 :
1142 : void
1143 107122 : DefaultASTVisitor::visit (AST::MacroTranscriber &transcriber)
1144 : {
1145 107122 : visit (transcriber.get_token_tree ());
1146 107122 : }
1147 :
1148 : void
1149 107122 : DefaultASTVisitor::visit (AST::MacroRule &rule)
1150 : {
1151 107122 : visit (rule.get_matcher ());
1152 107122 : visit (rule.get_transcriber ());
1153 107122 : }
1154 : void
1155 97214 : DefaultASTVisitor::visit (AST::MacroRulesDefinition &rules_def)
1156 : {
1157 97214 : visit_outer_attrs (rules_def);
1158 204336 : for (auto &rule : rules_def.get_macro_rules ())
1159 107122 : visit (rule);
1160 97214 : }
1161 :
1162 : void
1163 280290 : DefaultASTVisitor::visit (AST::MacroInvocData &data)
1164 : {
1165 280290 : visit (data.get_path ());
1166 280290 : visit (data.get_delim_tok_tree ());
1167 280290 : }
1168 : void
1169 280290 : DefaultASTVisitor::visit (AST::MacroInvocation ¯o_invoc)
1170 : {
1171 280290 : visit_outer_attrs (macro_invoc);
1172 280290 : visit (macro_invoc.get_invoc_data ());
1173 280290 : }
1174 :
1175 : void
1176 2144 : DefaultASTVisitor::visit (AST::MetaItemPath &meta_item)
1177 : {
1178 2144 : visit (meta_item.get_path ());
1179 2144 : }
1180 :
1181 : void
1182 15701 : DefaultASTVisitor::visit (AST::MetaItemSeq &meta_item)
1183 : {
1184 15701 : visit (meta_item.get_path ());
1185 36049 : for (auto &inner : meta_item.get_seq ())
1186 20348 : visit (inner);
1187 15701 : }
1188 :
1189 : void
1190 11466 : DefaultASTVisitor::visit (AST::MetaWord &meta_item)
1191 11466 : {}
1192 :
1193 : void
1194 27527 : DefaultASTVisitor::visit (AST::MetaNameValueStr &meta_item)
1195 27527 : {}
1196 :
1197 : void
1198 0 : DefaultASTVisitor::visit (AST::MetaListPaths &meta_item)
1199 : {
1200 0 : for (auto &path : meta_item.get_paths ())
1201 0 : visit (path);
1202 0 : }
1203 :
1204 : void
1205 0 : DefaultASTVisitor::visit (AST::MetaListNameValueStr &meta_item)
1206 : {
1207 0 : for (auto &str : meta_item.get_values ())
1208 0 : visit (str);
1209 0 : }
1210 :
1211 : void
1212 10424750 : DefaultASTVisitor::visit (AST::LiteralPattern &pattern)
1213 10424750 : {}
1214 :
1215 : void
1216 1769352 : DefaultASTVisitor::visit (AST::IdentifierPattern &pattern)
1217 : {
1218 1769352 : if (pattern.has_subpattern ())
1219 2660 : visit (pattern.get_subpattern ());
1220 1769352 : }
1221 :
1222 : void
1223 1035319 : DefaultASTVisitor::visit (AST::WildcardPattern &pattern)
1224 1035319 : {}
1225 :
1226 : void
1227 3619 : DefaultASTVisitor::visit (AST::RestPattern &pattern)
1228 3619 : {}
1229 :
1230 : void
1231 47113 : DefaultASTVisitor::visit (AST::RangePatternBoundLiteral &bound)
1232 47113 : {}
1233 :
1234 : void
1235 357 : DefaultASTVisitor::visit (AST::RangePatternBoundPath &bound)
1236 : {
1237 357 : visit (bound.get_path ());
1238 357 : }
1239 :
1240 : void
1241 0 : DefaultASTVisitor::visit (AST::RangePatternBoundQualPath &bound)
1242 : {
1243 0 : visit (bound.get_qualified_path ());
1244 0 : }
1245 :
1246 : void
1247 18348 : DefaultASTVisitor::visit (AST::RangePattern &pattern)
1248 : {
1249 18348 : if (pattern.get_has_lower_bound ())
1250 18348 : visit (pattern.get_lower_bound ());
1251 18348 : if (pattern.get_has_upper_bound ())
1252 18348 : visit (pattern.get_upper_bound ());
1253 18348 : }
1254 :
1255 : void
1256 45257 : DefaultASTVisitor::visit (AST::ReferencePattern &pattern)
1257 : {
1258 45257 : visit (pattern.get_referenced_pattern ());
1259 45257 : }
1260 :
1261 : void
1262 390 : DefaultASTVisitor::visit (AST::StructPatternFieldTuplePat &field)
1263 : {
1264 390 : visit_outer_attrs (field);
1265 390 : visit (field.get_index_pattern ());
1266 390 : }
1267 :
1268 : void
1269 9885 : DefaultASTVisitor::visit (AST::StructPatternFieldIdentPat &field)
1270 : {
1271 9885 : visit_outer_attrs (field);
1272 9885 : visit (field.get_ident_pattern ());
1273 9885 : }
1274 :
1275 : void
1276 3358 : DefaultASTVisitor::visit (AST::StructPatternFieldIdent &field)
1277 : {
1278 3358 : visit_outer_attrs (field);
1279 3358 : }
1280 :
1281 : void
1282 10515 : DefaultASTVisitor::visit (AST::StructPatternElements &spe)
1283 : {
1284 25210 : for (auto &field : spe.get_struct_pattern_fields ())
1285 14695 : visit (field);
1286 10515 : for (auto &attribute : spe.get_etc_outer_attrs ())
1287 0 : visit (attribute);
1288 10515 : }
1289 :
1290 : void
1291 10515 : DefaultASTVisitor::visit (AST::StructPattern &pattern)
1292 : {
1293 10515 : visit (pattern.get_path ());
1294 10515 : visit (pattern.get_struct_pattern_elems ());
1295 10515 : }
1296 :
1297 : void
1298 183721 : DefaultASTVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
1299 : {
1300 374445 : for (auto &pattern : tuple_items.get_patterns ())
1301 190724 : visit (pattern);
1302 183721 : }
1303 :
1304 : void
1305 2164 : DefaultASTVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
1306 : {
1307 2787 : for (auto &lower : tuple_items.get_lower_patterns ())
1308 623 : visit (lower);
1309 2545 : for (auto &upper : tuple_items.get_upper_patterns ())
1310 381 : visit (upper);
1311 2164 : }
1312 :
1313 : void
1314 244992 : DefaultASTVisitor::visit (AST::TupleStructPattern &pattern)
1315 : {
1316 244992 : visit (pattern.get_path ());
1317 244992 : visit (pattern.get_items ());
1318 244992 : }
1319 :
1320 : void
1321 492020 : DefaultASTVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
1322 : {
1323 1617378 : for (auto &pattern : tuple_items.get_patterns ())
1324 1125358 : visit (pattern);
1325 492020 : }
1326 :
1327 : void
1328 638 : DefaultASTVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
1329 : {
1330 1189 : for (auto &lower : tuple_items.get_lower_patterns ())
1331 551 : visit (lower);
1332 1234 : for (auto &upper : tuple_items.get_upper_patterns ())
1333 596 : visit (upper);
1334 638 : }
1335 :
1336 : void
1337 667908 : DefaultASTVisitor::visit (AST::TuplePattern &pattern)
1338 : {
1339 667908 : visit (pattern.get_items ());
1340 667908 : }
1341 :
1342 : void
1343 816 : DefaultASTVisitor::visit (AST::GroupedPattern &pattern)
1344 : {
1345 816 : visit (pattern.get_pattern_in_parens ());
1346 816 : }
1347 :
1348 : void
1349 4215 : DefaultASTVisitor::visit (AST::SlicePattern &pattern)
1350 : {
1351 13199 : for (auto &pat : pattern.get_patterns ())
1352 8984 : visit (pat);
1353 4215 : }
1354 :
1355 : void
1356 10370 : DefaultASTVisitor::visit (AST::AltPattern &pattern)
1357 : {
1358 36270 : for (auto &alt : pattern.get_alts ())
1359 25900 : visit (alt);
1360 10370 : }
1361 :
1362 : void
1363 1474 : DefaultASTVisitor::visit (AST::EmptyStmt &stmt)
1364 1474 : {}
1365 :
1366 : void
1367 1060047 : DefaultASTVisitor::visit (AST::LetStmt &stmt)
1368 : {
1369 1060047 : visit_outer_attrs (stmt);
1370 1060047 : visit (stmt.get_pattern ());
1371 1060047 : if (stmt.has_type ())
1372 125374 : visit (stmt.get_type ());
1373 1060047 : if (stmt.has_init_expr ())
1374 1016320 : visit (stmt.get_init_expr ());
1375 1060047 : }
1376 :
1377 : void
1378 1415332 : DefaultASTVisitor::visit (AST::ExprStmt &stmt)
1379 : {
1380 1415332 : visit (stmt.get_expr ());
1381 1415330 : }
1382 :
1383 : void
1384 689013 : DefaultASTVisitor::visit (AST::TraitBound &bound)
1385 : {
1386 689328 : for (auto &lifetime : bound.get_for_lifetimes ())
1387 315 : visit (lifetime);
1388 689013 : visit (bound.get_type_path ());
1389 689013 : }
1390 :
1391 : void
1392 644 : DefaultASTVisitor::visit (AST::ImplTraitType &type)
1393 : {
1394 1932 : for (auto &bound : type.get_type_param_bounds ())
1395 1288 : visit (bound);
1396 644 : }
1397 :
1398 : void
1399 29907 : DefaultASTVisitor::visit (AST::TraitObjectType &type)
1400 : {
1401 73230 : for (auto &bound : type.get_type_param_bounds ())
1402 43323 : visit (bound);
1403 29907 : }
1404 :
1405 : void
1406 1826 : DefaultASTVisitor::visit (AST::ParenthesisedType &type)
1407 : {
1408 1826 : visit (type.get_type_in_parens ());
1409 1826 : }
1410 :
1411 : void
1412 35045 : DefaultASTVisitor::visit (AST::ImplTraitTypeOneBound &type)
1413 : {
1414 35045 : visit (type.get_trait_bound ());
1415 35045 : }
1416 :
1417 : void
1418 8673 : DefaultASTVisitor::visit (AST::TraitObjectTypeOneBound &type)
1419 : {
1420 8673 : visit (type.get_trait_bound ());
1421 8673 : }
1422 :
1423 : void
1424 187648 : DefaultASTVisitor::visit (AST::TupleType &type)
1425 : {
1426 605723 : for (auto &elem : type.get_elems ())
1427 418075 : visit (elem);
1428 187648 : }
1429 :
1430 : void
1431 16457 : DefaultASTVisitor::visit (AST::NeverType &type)
1432 16457 : {}
1433 :
1434 : void
1435 391194 : DefaultASTVisitor::visit (AST::RawPointerType &type)
1436 : {
1437 391194 : visit (type.get_type_pointed_to ());
1438 391194 : }
1439 :
1440 : void
1441 1612865 : DefaultASTVisitor::visit (AST::ReferenceType &type)
1442 : {
1443 1612865 : visit (type.get_lifetime ());
1444 1612865 : visit (type.get_base_type ());
1445 1612865 : }
1446 :
1447 : void
1448 67851 : DefaultASTVisitor::visit (AST::ArrayType &type)
1449 : {
1450 67851 : visit (type.get_elem_type ());
1451 67851 : visit (type.get_size_expr ());
1452 67851 : }
1453 :
1454 : void
1455 130578 : DefaultASTVisitor::visit (AST::SliceType &type)
1456 : {
1457 130578 : visit (type.get_elem_type ());
1458 130578 : }
1459 :
1460 : void
1461 60457 : DefaultASTVisitor::visit (AST::InferredType &type)
1462 60457 : {}
1463 :
1464 : void
1465 459933 : DefaultASTVisitor::visit (AST::MaybeNamedParam ¶m)
1466 : {
1467 459933 : visit_outer_attrs (param);
1468 459933 : visit (param.get_type ());
1469 459933 : }
1470 :
1471 : void
1472 78117 : DefaultASTVisitor::visit (AST::BareFunctionType &type)
1473 : {
1474 78181 : for (auto &lifetime : type.get_for_lifetimes ())
1475 64 : visit (lifetime);
1476 78117 : visit (type.get_function_qualifiers ());
1477 538050 : for (auto ¶m : type.get_function_params ())
1478 459933 : visit (param);
1479 78117 : if (type.is_variadic ())
1480 23352 : for (auto attr : type.get_variadic_attr ())
1481 0 : visit (attr);
1482 78117 : if (type.has_return_type ())
1483 76116 : visit (type.get_return_type ());
1484 78117 : }
1485 :
1486 : void
1487 0 : DefaultASTVisitor::visit (AST::FormatArgs &)
1488 : {
1489 : // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1490 0 : }
1491 :
1492 : void
1493 170 : DefaultASTVisitor::visit (AST::OffsetOf &offset_of)
1494 : {
1495 170 : visit (offset_of.get_type ());
1496 170 : }
1497 :
1498 : void
1499 13642 : DefaultASTVisitor::visit (AST::VariadicParam ¶m)
1500 : {
1501 13642 : if (param.has_pattern ())
1502 165 : visit (param.get_pattern ());
1503 13642 : }
1504 :
1505 : void
1506 4844 : ContextualASTVisitor::visit (AST::Crate &crate)
1507 : {
1508 4844 : ctx.enter (Kind::CRATE);
1509 4844 : DefaultASTVisitor::visit (crate);
1510 4844 : ctx.exit ();
1511 4844 : }
1512 :
1513 : void
1514 1298 : ContextualASTVisitor::visit (AST::InherentImpl &impl)
1515 : {
1516 1298 : ctx.enter (Kind::INHERENT_IMPL);
1517 1298 : DefaultASTVisitor::visit (impl);
1518 1298 : ctx.exit ();
1519 1298 : }
1520 :
1521 : void
1522 11566 : ContextualASTVisitor::visit (AST::TraitImpl &impl)
1523 : {
1524 11566 : ctx.enter (Kind::TRAIT_IMPL);
1525 11566 : DefaultASTVisitor::visit (impl);
1526 11566 : ctx.exit ();
1527 11566 : }
1528 :
1529 : void
1530 4139 : ContextualASTVisitor::visit (AST::Trait &trait)
1531 : {
1532 4139 : ctx.enter (Kind::TRAIT);
1533 4139 : DefaultASTVisitor::visit (trait);
1534 4139 : ctx.exit ();
1535 4139 : }
1536 :
1537 : } // namespace AST
1538 : } // namespace Rust
|
