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 89356 : DefaultASTVisitor::visit (AST::Crate &crate)
36 : {
37 89356 : visit_inner_attrs (crate);
38 479492 : for (auto &item : crate.items)
39 390138 : visit (item);
40 89354 : }
41 :
42 : void
43 32762233 : DefaultASTVisitor::visit (AST::Token &tok)
44 32762233 : {}
45 :
46 : void
47 4340789 : DefaultASTVisitor::visit (AST::DelimTokenTree &delim_tok_tree)
48 : {
49 38639856 : for (auto &token : delim_tok_tree.get_token_trees ())
50 34299067 : visit (token);
51 4340789 : }
52 :
53 : void
54 29193 : DefaultASTVisitor::visit (AST::AttrInputMetaItemContainer &input)
55 : {
56 59073 : for (auto &item : input.get_items ())
57 29880 : visit (item);
58 29193 : }
59 :
60 : void
61 27223303 : DefaultASTVisitor::visit (AST::IdentifierExpr &ident_expr)
62 : {
63 27223303 : visit_outer_attrs (ident_expr);
64 27223303 : }
65 :
66 : void
67 3417337 : DefaultASTVisitor::visit (AST::Lifetime &lifetime)
68 3417337 : {}
69 :
70 : void
71 174785 : DefaultASTVisitor::visit (AST::LifetimeParam &lifetime_param)
72 : {
73 174785 : visit_outer_attrs (lifetime_param);
74 174785 : visit (lifetime_param.get_lifetime ());
75 177807 : for (auto &lifetime_bound : lifetime_param.get_lifetime_bounds ())
76 3022 : visit (lifetime_bound);
77 174785 : }
78 :
79 : void
80 13151 : DefaultASTVisitor::visit (AST::ConstGenericParam &const_param)
81 : {
82 13151 : visit_outer_attrs (const_param);
83 13151 : if (const_param.has_type ())
84 13151 : visit (const_param.get_type ());
85 13151 : if (const_param.has_default_value ())
86 319 : visit (const_param.get_default_value_unchecked ());
87 13151 : }
88 :
89 : void
90 8225927 : DefaultASTVisitor::visit (AST::PathInExpression &path)
91 : {
92 8225927 : visit_outer_attrs (path);
93 :
94 8225927 : if (!path.is_lang_item ())
95 17664590 : for (auto &segment : path.get_segments ())
96 9469414 : visit (segment);
97 8225927 : }
98 :
99 : void
100 16046033 : DefaultASTVisitor::visit (AST::TypePathSegment &segment)
101 16046033 : {}
102 :
103 : void
104 29450 : DefaultASTVisitor::visit (GenericArgsBinding &binding)
105 : {
106 29450 : visit (binding.get_type ());
107 29450 : }
108 :
109 : void
110 1559646 : DefaultASTVisitor::visit (AST::TypePathSegmentGeneric &segment)
111 : {
112 1559646 : if (segment.has_generic_args ())
113 1559632 : visit (segment.get_generic_args ());
114 1559646 : }
115 :
116 : void
117 98424 : DefaultASTVisitor::visit (AST::TypePathFunction &tpf)
118 : {
119 238964 : for (auto &input : tpf.get_params ())
120 140540 : visit (input);
121 98424 : if (tpf.has_return_type ())
122 95133 : visit (tpf.get_return_type ());
123 98424 : }
124 :
125 : void
126 20693329 : DefaultASTVisitor::visit (AST::PathIdentSegment &segment)
127 20693329 : {}
128 :
129 : void
130 98424 : DefaultASTVisitor::visit (AST::TypePathSegmentFunction &segment)
131 : {
132 98424 : visit (segment.get_type_path_function ());
133 98424 : visit (segment.get_ident_segment ());
134 98424 : }
135 :
136 : void
137 1605593 : DefaultASTVisitor::visit (AST::GenericArgs &args)
138 : {
139 1764741 : for (auto &lifetime : args.get_lifetime_args ())
140 159148 : visit (lifetime);
141 :
142 3183396 : for (auto &generic : args.get_generic_args ())
143 1577803 : visit (generic);
144 :
145 1634713 : for (auto &binding : args.get_binding_args ())
146 29120 : visit (binding);
147 1605593 : }
148 :
149 : void
150 15785628 : DefaultASTVisitor::visit (AST::PathExprSegment &segment)
151 : {
152 15785628 : visit (segment.get_ident_segment ());
153 15785628 : if (segment.has_generic_args ())
154 64528 : visit (segment.get_generic_args ());
155 15785628 : }
156 : void
157 13334073 : DefaultASTVisitor::visit (AST::TypePath &path)
158 : {
159 27576801 : for (auto &segment : path.get_segments ())
160 14242728 : visit (segment);
161 13334073 : }
162 :
163 : void
164 24326 : DefaultASTVisitor::visit (AST::QualifiedPathInExpression &path)
165 : {
166 24326 : visit_outer_attrs (path);
167 24326 : visit (path.get_qualified_path_type ());
168 :
169 48652 : for (auto &segment : path.get_segments ())
170 24326 : visit (segment);
171 24326 : }
172 :
173 : void
174 564360 : DefaultASTVisitor::visit (AST::QualifiedPathType &path)
175 : {
176 564360 : visit (path.get_type ());
177 564360 : if (path.has_as_clause ())
178 545964 : visit (path.get_as_type_path ());
179 564360 : }
180 :
181 : void
182 646636 : DefaultASTVisitor::visit (AST::QualifiedPathInType &path)
183 : {
184 646636 : visit (path.get_qualified_path_type ());
185 646636 : visit (path.get_associated_segment ());
186 :
187 646636 : for (auto &segment : path.get_segments ())
188 0 : visit (segment);
189 646636 : }
190 :
191 : void
192 34086372 : DefaultASTVisitor::visit (AST::LiteralExpr &expr)
193 : {
194 34086372 : visit_outer_attrs (expr);
195 34086372 : }
196 :
197 : void
198 17794354 : DefaultASTVisitor::visit (AST::Attribute &attribute)
199 : {
200 17794354 : visit (attribute.get_path ());
201 17794354 : if (attribute.has_attr_input ())
202 15270508 : visit (attribute.get_attr_input ());
203 17794354 : }
204 :
205 : void
206 9539843 : DefaultASTVisitor::visit (AST::AttrInputLiteral &attr_input)
207 : {
208 9539843 : visit (attr_input.get_literal ());
209 9539843 : }
210 :
211 : void
212 23001 : DefaultASTVisitor::visit (AST::AttrInputExpr &attr_input)
213 : {
214 23001 : visit (attr_input.get_expr ());
215 23001 : }
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 18266555 : DefaultASTVisitor::visit (AST::SimplePathSegment &segment)
225 18266555 : {}
226 :
227 : void
228 18144083 : DefaultASTVisitor::visit (AST::SimplePath &path)
229 : {
230 36410638 : for (auto &segment : path.get_segments ())
231 18266555 : visit (segment);
232 18144083 : }
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 1206310 : DefaultASTVisitor::visit (AST::BorrowExpr &expr)
243 : {
244 1206310 : visit_outer_attrs (expr);
245 1206310 : visit (expr.get_borrowed_expr ());
246 1206310 : }
247 :
248 : void
249 615887 : DefaultASTVisitor::visit (AST::DereferenceExpr &expr)
250 : {
251 615887 : visit_outer_attrs (expr);
252 615887 : visit (expr.get_dereferenced_expr ());
253 615887 : }
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 188579 : DefaultASTVisitor::visit (AST::NegationExpr &expr)
264 : {
265 188579 : visit_outer_attrs (expr);
266 188579 : visit (expr.get_negated_expr ());
267 188579 : }
268 :
269 : void
270 6314661 : DefaultASTVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
271 : {
272 6314661 : visit_outer_attrs (expr);
273 6314661 : visit (expr.get_left_expr ());
274 6314661 : visit (expr.get_right_expr ());
275 6314661 : }
276 :
277 : void
278 580487 : DefaultASTVisitor::visit (AST::ComparisonExpr &expr)
279 : {
280 580487 : visit_outer_attrs (expr);
281 580487 : visit (expr.get_left_expr ());
282 580487 : visit (expr.get_right_expr ());
283 580487 : }
284 :
285 : void
286 144246 : DefaultASTVisitor::visit (AST::LazyBooleanExpr &expr)
287 : {
288 144246 : visit_outer_attrs (expr);
289 144246 : visit (expr.get_left_expr ());
290 144246 : visit (expr.get_right_expr ());
291 144246 : }
292 :
293 : void
294 967409 : DefaultASTVisitor::visit (AST::TypeCastExpr &expr)
295 : {
296 967409 : visit_outer_attrs (expr);
297 967409 : visit (expr.get_casted_expr ());
298 967409 : visit (expr.get_type_to_cast_to ());
299 967409 : }
300 :
301 : void
302 396065 : DefaultASTVisitor::visit (AST::AssignmentExpr &expr)
303 : {
304 396065 : visit_outer_attrs (expr);
305 396065 : visit (expr.get_left_expr ());
306 396065 : visit (expr.get_right_expr ());
307 396065 : }
308 :
309 : void
310 238805 : DefaultASTVisitor::visit (AST::CompoundAssignmentExpr &expr)
311 : {
312 238805 : visit_outer_attrs (expr);
313 238805 : visit (expr.get_left_expr ());
314 238805 : visit (expr.get_right_expr ());
315 238805 : }
316 :
317 : void
318 1155332 : DefaultASTVisitor::visit (AST::GroupedExpr &expr)
319 : {
320 1155332 : visit_outer_attrs (expr);
321 1155332 : visit_inner_attrs (expr);
322 1155332 : visit (expr.get_expr_in_parens ());
323 1155332 : }
324 :
325 : void
326 1303539 : DefaultASTVisitor::visit (AST::ArrayElemsValues &elems)
327 : {
328 13710116 : for (auto &value : elems.get_values ())
329 12406577 : visit (value);
330 1303539 : }
331 :
332 : void
333 11476 : DefaultASTVisitor::visit (AST::ArrayElemsCopied &elems)
334 : {
335 11476 : visit (elems.get_elem_to_copy ());
336 11476 : visit (elems.get_num_copies ());
337 11476 : }
338 :
339 : void
340 2520591 : DefaultASTVisitor::visit (AST::ArrayExpr &expr)
341 : {
342 2520591 : visit_outer_attrs (expr);
343 2520591 : visit_inner_attrs (expr);
344 2520591 : visit (expr.get_array_elems ());
345 2520591 : }
346 :
347 : void
348 166119 : DefaultASTVisitor::visit (AST::ArrayIndexExpr &expr)
349 : {
350 166119 : visit_outer_attrs (expr);
351 166119 : visit (expr.get_array_expr ());
352 166119 : visit (expr.get_index_expr ());
353 166119 : }
354 :
355 : void
356 445930 : DefaultASTVisitor::visit (AST::TupleExpr &expr)
357 : {
358 445930 : visit_outer_attrs (expr);
359 445930 : visit_inner_attrs (expr);
360 1275880 : for (auto &elem : expr.get_tuple_elems ())
361 829950 : visit (elem);
362 445930 : }
363 :
364 : void
365 800379 : DefaultASTVisitor::visit (AST::TupleIndexExpr &expr)
366 : {
367 800379 : visit_outer_attrs (expr);
368 800379 : visit (expr.get_tuple_expr ());
369 800379 : }
370 :
371 : void
372 4611 : DefaultASTVisitor::visit (AST::StructExprStruct &expr)
373 : {
374 4611 : visit_outer_attrs (expr);
375 4611 : visit_inner_attrs (expr);
376 4611 : visit (expr.get_struct_name ());
377 4611 : }
378 :
379 : void
380 48952 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifier &field)
381 48952 : {}
382 :
383 : void
384 182621 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifierValue &field)
385 : {
386 182621 : visit (field.get_value ());
387 182621 : }
388 :
389 : void
390 748 : DefaultASTVisitor::visit (AST::StructExprFieldIndexValue &field)
391 : {
392 748 : visit (field.get_value ());
393 748 : }
394 :
395 : void
396 1677 : DefaultASTVisitor::visit (AST::StructBase &base)
397 : {
398 1677 : visit (base.get_base_struct ());
399 1677 : }
400 :
401 : void
402 149899 : DefaultASTVisitor::visit (AST::StructExprStructFields &expr)
403 : {
404 149899 : visit_outer_attrs (expr);
405 149899 : visit_inner_attrs (expr);
406 149899 : visit (expr.get_struct_name ());
407 149899 : if (expr.has_struct_base ())
408 2135 : visit (expr.get_struct_base ());
409 433399 : for (auto &field : expr.get_fields ())
410 283500 : visit (field);
411 149899 : }
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 10733234 : DefaultASTVisitor::visit (AST::CallExpr &expr)
424 : {
425 10733234 : visit_outer_attrs (expr);
426 10733234 : visit (expr.get_function_expr ());
427 37536362 : for (auto ¶m : expr.get_params ())
428 26803129 : visit (param);
429 10733233 : }
430 :
431 : void
432 6291888 : DefaultASTVisitor::visit (AST::MethodCallExpr &expr)
433 : {
434 6291888 : visit_outer_attrs (expr);
435 6291888 : visit (expr.get_receiver_expr ());
436 6291888 : visit (expr.get_method_name ());
437 7261737 : for (auto ¶m : expr.get_params ())
438 969849 : visit (param);
439 6291888 : }
440 :
441 : void
442 1041262 : DefaultASTVisitor::visit (AST::FieldAccessExpr &expr)
443 : {
444 1041262 : visit_outer_attrs (expr);
445 1041262 : visit (expr.get_receiver_expr ());
446 1041262 : }
447 :
448 : void
449 56911 : DefaultASTVisitor::visit (AST::ClosureExprInner &expr)
450 : {
451 56911 : visit_outer_attrs (expr);
452 123565 : for (auto ¶m : expr.get_params ())
453 66654 : visit (param);
454 56911 : visit (expr.get_definition_expr ());
455 56911 : }
456 :
457 : void
458 3490289 : DefaultASTVisitor::visit (AST::BlockExpr &expr)
459 : {
460 3490289 : visit_outer_attrs (expr);
461 3490289 : visit_inner_attrs (expr);
462 :
463 3490289 : if (expr.has_label ())
464 51 : visit (expr.get_label ());
465 :
466 5546923 : for (auto &stmt : expr.get_statements ())
467 2056637 : visit (stmt);
468 :
469 3490286 : if (expr.has_tail_expr ())
470 2950278 : visit (expr.get_tail_expr ());
471 3490284 : }
472 :
473 : void
474 280 : DefaultASTVisitor::visit (AST::ConstBlock &expr)
475 : {
476 280 : visit (expr.get_const_expr ());
477 280 : }
478 :
479 : void
480 69106 : DefaultASTVisitor::visit (AST::AnonConst &expr)
481 : {
482 69106 : if (!expr.is_deferred ())
483 68883 : visit (expr.get_inner_expr ());
484 69106 : }
485 :
486 : void
487 439 : DefaultASTVisitor::visit (AST::ClosureExprInnerTyped &expr)
488 : {
489 439 : visit_outer_attrs (expr);
490 955 : for (auto ¶m : expr.get_params ())
491 516 : visit (param);
492 439 : visit (expr.get_return_type ());
493 439 : visit (expr.get_definition_expr ());
494 439 : }
495 :
496 : void
497 93048 : DefaultASTVisitor::visit (AST::ClosureParam ¶m)
498 : {
499 93048 : visit_outer_attrs (param);
500 93048 : visit (param.get_pattern ());
501 93048 : if (param.has_type_given ())
502 5269 : visit (param.get_type ());
503 93048 : }
504 :
505 : void
506 1946 : DefaultASTVisitor::visit (AST::ContinueExpr &expr)
507 : {
508 1946 : visit_outer_attrs (expr);
509 1946 : if (expr.has_label ())
510 765 : visit (expr.get_label_unchecked ());
511 1946 : }
512 :
513 : void
514 14987 : DefaultASTVisitor::visit (AST::BreakExpr &expr)
515 : {
516 14987 : visit_outer_attrs (expr);
517 14987 : if (expr.has_label ())
518 831 : visit (expr.get_label_unchecked ());
519 :
520 14987 : if (expr.has_break_expr ())
521 668 : visit (expr.get_break_expr_unchecked ());
522 14986 : }
523 :
524 : void
525 53662 : DefaultASTVisitor::visit (AST::RangeFromToExpr &expr)
526 : {
527 53662 : visit (expr.get_from_expr ());
528 53662 : visit (expr.get_to_expr ());
529 53662 : }
530 :
531 : void
532 22004 : DefaultASTVisitor::visit (AST::RangeFromExpr &expr)
533 : {
534 22004 : visit (expr.get_from_expr ());
535 22004 : }
536 :
537 : void
538 34144 : DefaultASTVisitor::visit (AST::RangeToExpr &expr)
539 : {
540 34144 : visit (expr.get_to_expr ());
541 34144 : }
542 :
543 : void
544 14584 : DefaultASTVisitor::visit (AST::RangeFullExpr &expr)
545 14584 : {}
546 :
547 : void
548 1211 : DefaultASTVisitor::visit (AST::RangeFromToInclExpr &expr)
549 : {
550 1211 : visit (expr.get_from_expr ());
551 1211 : visit (expr.get_to_expr ());
552 1211 : }
553 :
554 : void
555 0 : DefaultASTVisitor::visit (AST::RangeToInclExpr &expr)
556 : {
557 0 : visit (expr.get_to_expr ());
558 0 : }
559 :
560 : void
561 140970 : DefaultASTVisitor::visit (AST::ReturnExpr &expr)
562 : {
563 140970 : visit_outer_attrs (expr);
564 140970 : if (expr.has_returned_expr ())
565 136581 : visit (expr.get_returned_expr ());
566 140970 : }
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 127 : DefaultASTVisitor::visit (AST::BoxExpr &expr)
577 : {
578 127 : visit_outer_attrs (expr);
579 127 : visit (expr.get_boxed_expr ());
580 127 : }
581 :
582 : void
583 290393 : DefaultASTVisitor::visit (AST::UnsafeBlockExpr &expr)
584 : {
585 290393 : visit_outer_attrs (expr);
586 290393 : visit (expr.get_block_expr ());
587 290393 : }
588 :
589 : void
590 2580 : DefaultASTVisitor::visit (AST::LoopLabel &label)
591 : {
592 2580 : visit (label.get_lifetime ());
593 2580 : }
594 :
595 : void
596 9916 : DefaultASTVisitor::visit (AST::LoopExpr &expr)
597 : {
598 9916 : visit_outer_attrs (expr);
599 9916 : if (expr.has_loop_label ())
600 1146 : visit (expr.get_loop_label ());
601 9916 : visit (expr.get_loop_block ());
602 9915 : }
603 :
604 : void
605 26723 : DefaultASTVisitor::visit (AST::WhileLoopExpr &expr)
606 : {
607 26723 : visit_outer_attrs (expr);
608 26723 : if (expr.has_loop_label ())
609 119 : visit (expr.get_loop_label ());
610 26723 : visit (expr.get_predicate_expr ());
611 26723 : visit (expr.get_loop_block ());
612 26723 : }
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 427741 : DefaultASTVisitor::visit (AST::IfExpr &expr)
640 : {
641 427741 : visit_outer_attrs (expr);
642 427741 : visit (expr.get_condition_expr ());
643 427741 : visit (expr.get_if_block ());
644 427741 : }
645 :
646 : void
647 273362 : DefaultASTVisitor::visit (AST::IfExprConseqElse &expr)
648 : {
649 273362 : visit (reinterpret_cast<AST::IfExpr &> (expr));
650 273362 : visit (expr.get_else_block ());
651 273362 : }
652 :
653 : void
654 14537 : DefaultASTVisitor::visit (AST::IfLetExpr &expr)
655 : {
656 14537 : visit_outer_attrs (expr);
657 14537 : visit (expr.get_pattern ());
658 14537 : visit (expr.get_value_expr ());
659 14537 : visit (expr.get_if_block ());
660 14537 : }
661 :
662 : void
663 4959 : DefaultASTVisitor::visit (AST::IfLetExprConseqElse &expr)
664 : {
665 4959 : visit (reinterpret_cast<AST::IfLetExpr &> (expr));
666 4959 : visit (expr.get_else_block ());
667 4959 : }
668 :
669 : void
670 7825865 : DefaultASTVisitor::visit (AST::MatchArm &arm)
671 : {
672 7825865 : visit_outer_attrs (arm);
673 7825865 : visit (arm.get_pattern ());
674 7825865 : if (arm.has_match_arm_guard ())
675 6108 : visit (arm.get_guard_expr ());
676 7825865 : }
677 :
678 : void
679 7876972 : DefaultASTVisitor::visit (AST::MatchCase &arm)
680 : {
681 7876972 : visit (arm.get_arm ());
682 7876972 : visit (arm.get_expr ());
683 7876971 : }
684 :
685 : void
686 787909 : DefaultASTVisitor::visit (AST::MatchExpr &expr)
687 : {
688 787909 : visit_outer_attrs (expr);
689 787909 : visit_inner_attrs (expr);
690 787909 : visit (expr.get_scrutinee_expr ());
691 8664879 : for (auto &arm : expr.get_match_cases ())
692 7876972 : visit (arm);
693 787907 : }
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 2219 : DefaultASTVisitor::visit (AST::LlvmInlineAsm &expr)
761 : {
762 2219 : visit_outer_attrs (expr);
763 :
764 5227 : for (auto &output : expr.get_outputs ())
765 3008 : visit (output.expr);
766 :
767 4616 : for (auto &input : expr.get_inputs ())
768 2397 : visit (input.expr);
769 2219 : }
770 :
771 : void
772 690257 : DefaultASTVisitor::visit (AST::TypeParam ¶m)
773 : {
774 690257 : visit_outer_attrs (param);
775 886086 : for (auto &bound : param.get_type_param_bounds ())
776 195829 : visit (bound);
777 690257 : if (param.has_type ())
778 6025 : visit (param.get_type ());
779 690257 : }
780 :
781 : void
782 256 : DefaultASTVisitor::visit (AST::LifetimeWhereClauseItem &item)
783 : {
784 256 : visit (item.get_lifetime ());
785 512 : for (auto &bound : item.get_lifetime_bounds ())
786 256 : visit (bound);
787 256 : }
788 :
789 : void
790 183963 : DefaultASTVisitor::visit (AST::TypeBoundWhereClauseItem &item)
791 : {
792 184289 : for (auto &lifetime : item.get_for_lifetimes ())
793 326 : visit (lifetime);
794 183963 : visit (item.get_type ());
795 376236 : for (auto ¶m : item.get_type_param_bounds ())
796 192273 : visit (param);
797 183963 : }
798 :
799 : void
800 5968879 : DefaultASTVisitor::visit (AST::Visibility &vis)
801 : {
802 5968879 : if (vis.has_path ())
803 67199 : visit (vis.get_path ());
804 5968879 : }
805 :
806 : void
807 2998535 : DefaultASTVisitor::visit (AST::FunctionQualifiers &qualifiers)
808 2998535 : {}
809 :
810 : void
811 164330 : DefaultASTVisitor::visit (AST::WhereClause &where)
812 : {
813 388357 : for (auto &item : where.get_items ())
814 224027 : visit (item);
815 164330 : }
816 : void
817 2590001 : DefaultASTVisitor::visit (AST::FunctionParam ¶m)
818 : {
819 2590001 : visit_outer_attrs (param);
820 2590001 : if (param.has_name ())
821 2590001 : visit (param.get_pattern ());
822 :
823 2590001 : visit (param.get_type ());
824 2590001 : }
825 :
826 : void
827 1584240 : DefaultASTVisitor::visit (AST::SelfParam ¶m)
828 : {
829 1584240 : visit_outer_attrs (param);
830 :
831 1584240 : if (param.has_lifetime ())
832 740163 : visit (param.get_lifetime ());
833 :
834 1584240 : if (param.has_type ())
835 2490 : visit (param.get_type ());
836 1584240 : }
837 :
838 : void
839 47916 : DefaultASTVisitor::visit (AST::Module &module)
840 : {
841 47916 : visit_outer_attrs (module);
842 47916 : visit (module.get_visibility ());
843 47916 : visit_inner_attrs (module);
844 1326587 : for (auto &item : module.get_items ())
845 1278671 : visit (item);
846 47916 : }
847 :
848 : void
849 554 : DefaultASTVisitor::visit (AST::ExternCrate &crate)
850 : {
851 554 : visit_outer_attrs (crate);
852 554 : visit (crate.get_visibility ());
853 554 : }
854 :
855 : void
856 7459 : DefaultASTVisitor::visit (AST::UseTreeGlob &use_tree)
857 : {
858 7459 : visit (use_tree.get_path ());
859 7459 : }
860 :
861 : void
862 25230 : DefaultASTVisitor::visit (AST::UseTreeList &use_tree)
863 : {
864 25230 : visit (use_tree.get_path ());
865 25230 : }
866 :
867 : void
868 54227 : DefaultASTVisitor::visit (AST::UseTreeRebind &use_tree)
869 : {
870 54227 : visit (use_tree.get_path ());
871 54227 : }
872 :
873 : void
874 87001 : DefaultASTVisitor::visit (AST::UseDeclaration &use_decl)
875 : {
876 87001 : visit (use_decl.get_visibility ());
877 87001 : visit (use_decl.get_tree ());
878 87001 : }
879 :
880 : void
881 2379401 : DefaultASTVisitor::visit_function_params (AST::Function &function)
882 : {
883 6525191 : for (auto ¶m : function.get_function_params ())
884 4145790 : visit (param);
885 2379401 : }
886 :
887 : void
888 2410970 : DefaultASTVisitor::visit (AST::Function &function)
889 : {
890 2410970 : visit_outer_attrs (function);
891 2410970 : visit (function.get_visibility ());
892 2410970 : visit (function.get_qualifiers ());
893 2702857 : for (auto &generic : function.get_generic_params ())
894 291887 : visit (generic);
895 :
896 2410970 : visit_function_params (function);
897 :
898 2410970 : if (function.has_return_type ())
899 2045226 : visit (function.get_return_type ());
900 2410970 : if (function.has_where_clause ())
901 79307 : visit (function.get_where_clause ());
902 2410970 : if (function.has_body ())
903 2179853 : visit (*function.get_definition ());
904 2410968 : }
905 :
906 : void
907 475641 : DefaultASTVisitor::visit (AST::TypeAlias &type_alias)
908 : {
909 475641 : visit_outer_attrs (type_alias);
910 475641 : visit (type_alias.get_visibility ());
911 476125 : for (auto &generic : type_alias.get_generic_params ())
912 484 : visit (generic);
913 475641 : if (type_alias.has_where_clause ())
914 0 : visit (type_alias.get_where_clause ());
915 475641 : visit (type_alias.get_type_aliased ());
916 475641 : }
917 :
918 : void
919 105053 : DefaultASTVisitor::visit (AST::StructField &field)
920 : {
921 105053 : visit_outer_attrs (field);
922 105053 : visit (field.get_visibility ());
923 105053 : visit (field.get_field_type ());
924 105053 : }
925 :
926 : void
927 253569 : DefaultASTVisitor::visit (AST::StructStruct &struct_item)
928 : {
929 253569 : visit_outer_attrs (struct_item);
930 253569 : visit (struct_item.get_visibility ());
931 327983 : for (auto &generic : struct_item.get_generic_params ())
932 74414 : visit (generic);
933 253569 : if (struct_item.has_where_clause ())
934 2442 : visit (struct_item.get_where_clause ());
935 387994 : for (auto &field : struct_item.get_fields ())
936 134425 : visit (field);
937 253569 : }
938 :
939 : void
940 107008 : DefaultASTVisitor::visit (AST::TupleField &field)
941 : {
942 107008 : visit_outer_attrs (field);
943 107008 : visit (field.get_visibility ());
944 107008 : visit (field.get_field_type ());
945 107008 : }
946 :
947 : void
948 43966 : DefaultASTVisitor::visit (AST::TupleStruct &tuple_struct)
949 : {
950 43966 : visit_outer_attrs (tuple_struct);
951 43966 : visit (tuple_struct.get_visibility ());
952 61025 : for (auto &generic : tuple_struct.get_generic_params ())
953 17059 : visit (generic);
954 43966 : if (tuple_struct.has_where_clause ())
955 218 : visit (tuple_struct.get_where_clause ());
956 180944 : for (auto &field : tuple_struct.get_fields ())
957 136978 : visit (field);
958 43966 : }
959 :
960 : void
961 41331 : DefaultASTVisitor::visit (AST::EnumItem &item)
962 : {
963 41331 : visit_outer_attrs (item);
964 41331 : visit (item.get_visibility ());
965 41331 : }
966 :
967 : void
968 14591 : DefaultASTVisitor::visit (AST::EnumItemTuple &item)
969 : {
970 14591 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
971 30733 : for (auto &field : item.get_tuple_fields ())
972 16142 : visit (field);
973 14591 : }
974 :
975 : void
976 1896 : DefaultASTVisitor::visit (AST::EnumItemStruct &item)
977 : {
978 1896 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
979 4978 : for (auto &field : item.get_struct_fields ())
980 3082 : visit (field);
981 1896 : }
982 :
983 : void
984 6349 : DefaultASTVisitor::visit (AST::EnumItemDiscriminant &item)
985 : {
986 6349 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
987 6349 : visit (item.get_expr ());
988 6349 : }
989 :
990 : void
991 19816 : DefaultASTVisitor::visit (AST::Enum &enum_item)
992 : {
993 19816 : visit_outer_attrs (enum_item);
994 19816 : visit (enum_item.get_visibility ());
995 29207 : for (auto &generic : enum_item.get_generic_params ())
996 9391 : visit (generic);
997 19816 : if (enum_item.has_where_clause ())
998 0 : visit (enum_item.get_where_clause ());
999 69769 : for (auto &item : enum_item.get_variants ())
1000 49953 : visit (item);
1001 19816 : }
1002 :
1003 : void
1004 2813 : DefaultASTVisitor::visit (AST::Union &union_item)
1005 : {
1006 2813 : visit_outer_attrs (union_item);
1007 2813 : visit (union_item.get_visibility ());
1008 4887 : for (auto &generic : union_item.get_generic_params ())
1009 2074 : visit (generic);
1010 2813 : if (union_item.has_where_clause ())
1011 0 : visit (union_item.get_where_clause ());
1012 10717 : for (auto &variant : union_item.get_variants ())
1013 7904 : visit (variant);
1014 2813 : }
1015 :
1016 : void
1017 120349 : DefaultASTVisitor::visit (AST::ConstantItem &const_item)
1018 : {
1019 120349 : visit_outer_attrs (const_item);
1020 120349 : visit (const_item.get_visibility ());
1021 120349 : visit (const_item.get_type ());
1022 120349 : if (const_item.has_expr ())
1023 116275 : visit (const_item.get_expr ());
1024 120349 : }
1025 :
1026 : void
1027 6256 : DefaultASTVisitor::visit (AST::StaticItem &static_item)
1028 : {
1029 6256 : visit_outer_attrs (static_item);
1030 6256 : visit (static_item.get_visibility ());
1031 6256 : visit (static_item.get_type ());
1032 6256 : visit (static_item.get_expr ());
1033 6256 : }
1034 :
1035 : void
1036 29012 : DefaultASTVisitor::visit (AST::TraitItemType &item)
1037 : {
1038 29012 : visit_outer_attrs (item);
1039 29426 : for (auto &generic : item.get_generic_params ())
1040 414 : visit (generic);
1041 35288 : for (auto &bound : item.get_type_param_bounds ())
1042 6276 : visit (bound);
1043 29012 : }
1044 :
1045 : void
1046 57021 : DefaultASTVisitor::visit (AST::Trait &trait)
1047 : {
1048 57021 : visit_outer_attrs (trait);
1049 57021 : visit (trait.get_visibility ());
1050 :
1051 57021 : visit_inner_attrs (trait);
1052 :
1053 57021 : visit (trait.get_implicit_self ());
1054 :
1055 69415 : for (auto &generic : trait.get_generic_params ())
1056 12394 : visit (generic);
1057 :
1058 57021 : if (trait.has_where_clause ())
1059 91 : visit (trait.get_where_clause ());
1060 :
1061 70028 : for (auto &bound : trait.get_type_param_bounds ())
1062 13007 : visit (bound);
1063 :
1064 126054 : for (auto &item : trait.get_trait_items ())
1065 69033 : visit (item);
1066 57021 : }
1067 :
1068 : void
1069 32853 : DefaultASTVisitor::visit (AST::InherentImpl &impl)
1070 : {
1071 32853 : visit_outer_attrs (impl);
1072 32853 : visit (impl.get_visibility ());
1073 :
1074 56561 : for (auto &generic : impl.get_generic_params ())
1075 23708 : visit (generic);
1076 32853 : if (impl.has_where_clause ())
1077 236 : visit (impl.get_where_clause ());
1078 32853 : visit (impl.get_type ());
1079 32853 : visit_inner_attrs (impl);
1080 224415 : for (auto &item : impl.get_impl_items ())
1081 191562 : visit (item);
1082 32853 : }
1083 :
1084 : void
1085 529950 : DefaultASTVisitor::visit (AST::TraitImpl &impl)
1086 : {
1087 529950 : visit_outer_attrs (impl);
1088 529950 : visit (impl.get_visibility ());
1089 :
1090 1014629 : for (auto &generic : impl.get_generic_params ())
1091 484679 : visit (generic);
1092 529950 : if (impl.has_where_clause ())
1093 27265 : visit (impl.get_where_clause ());
1094 529950 : visit (impl.get_type ());
1095 529950 : visit (impl.get_trait_path ());
1096 529950 : visit_inner_attrs (impl);
1097 1276970 : for (auto &item : impl.get_impl_items ())
1098 747020 : visit (item);
1099 529950 : }
1100 :
1101 : void
1102 179 : DefaultASTVisitor::visit (AST::ExternalTypeItem &item)
1103 : {
1104 179 : visit_outer_attrs (item);
1105 179 : visit (item.get_visibility ());
1106 179 : }
1107 :
1108 : void
1109 16 : DefaultASTVisitor::visit (AST::ExternalStaticItem &item)
1110 : {
1111 16 : visit_outer_attrs (item);
1112 16 : visit (item.get_visibility ());
1113 16 : visit (item.get_type ());
1114 16 : }
1115 :
1116 : void
1117 29654 : DefaultASTVisitor::visit (AST::ExternBlock &block)
1118 : {
1119 29654 : visit_outer_attrs (block);
1120 29654 : visit (block.get_visibility ());
1121 29654 : visit_inner_attrs (block);
1122 160083 : for (auto &item : block.get_extern_items ())
1123 130429 : visit (item);
1124 29654 : }
1125 :
1126 : void
1127 222635 : DefaultASTVisitor::visit (AST::MacroMatchFragment &match)
1128 222635 : {}
1129 :
1130 : void
1131 29289 : DefaultASTVisitor::visit (AST::MacroMatchRepetition &match)
1132 : {
1133 71954 : for (auto &m : match.get_matches ())
1134 42665 : visit (m);
1135 29289 : }
1136 :
1137 : void
1138 113214 : DefaultASTVisitor::visit (AST::MacroMatcher &matcher)
1139 : {
1140 468910 : for (auto &m : matcher.get_matches ())
1141 355696 : visit (m);
1142 113214 : }
1143 :
1144 : void
1145 107729 : DefaultASTVisitor::visit (AST::MacroTranscriber &transcriber)
1146 : {
1147 107729 : visit (transcriber.get_token_tree ());
1148 107729 : }
1149 :
1150 : void
1151 107729 : DefaultASTVisitor::visit (AST::MacroRule &rule)
1152 : {
1153 107729 : visit (rule.get_matcher ());
1154 107729 : visit (rule.get_transcriber ());
1155 107729 : }
1156 : void
1157 97821 : DefaultASTVisitor::visit (AST::MacroRulesDefinition &rules_def)
1158 : {
1159 97821 : visit_outer_attrs (rules_def);
1160 205550 : for (auto &rule : rules_def.get_macro_rules ())
1161 107729 : visit (rule);
1162 97821 : }
1163 :
1164 : void
1165 177713 : DefaultASTVisitor::visit (AST::MacroInvocData &data)
1166 : {
1167 177713 : visit (data.get_path ());
1168 177713 : visit (data.get_delim_tok_tree ());
1169 177713 : }
1170 : void
1171 177713 : DefaultASTVisitor::visit (AST::MacroInvocation ¯o_invoc)
1172 : {
1173 177713 : visit_outer_attrs (macro_invoc);
1174 177713 : visit (macro_invoc.get_invoc_data ());
1175 177713 : }
1176 :
1177 : void
1178 2146 : DefaultASTVisitor::visit (AST::MetaItemPath &meta_item)
1179 : {
1180 2146 : visit (meta_item.get_path ());
1181 2146 : }
1182 :
1183 : void
1184 15754 : DefaultASTVisitor::visit (AST::MetaItemSeq &meta_item)
1185 : {
1186 15754 : visit (meta_item.get_path ());
1187 36157 : for (auto &inner : meta_item.get_seq ())
1188 20403 : visit (inner);
1189 15754 : }
1190 :
1191 : void
1192 11527 : DefaultASTVisitor::visit (AST::MetaWord &meta_item)
1193 11527 : {}
1194 :
1195 : void
1196 27911 : DefaultASTVisitor::visit (AST::MetaNameValueStr &meta_item)
1197 27911 : {}
1198 :
1199 : void
1200 0 : DefaultASTVisitor::visit (AST::MetaListPaths &meta_item)
1201 : {
1202 0 : for (auto &path : meta_item.get_paths ())
1203 0 : visit (path);
1204 0 : }
1205 :
1206 : void
1207 0 : DefaultASTVisitor::visit (AST::MetaListNameValueStr &meta_item)
1208 : {
1209 0 : for (auto &str : meta_item.get_values ())
1210 0 : visit (str);
1211 0 : }
1212 :
1213 : void
1214 10470011 : DefaultASTVisitor::visit (AST::LiteralPattern &pattern)
1215 10470011 : {}
1216 :
1217 : void
1218 1807322 : DefaultASTVisitor::visit (AST::IdentifierPattern &pattern)
1219 : {
1220 1807322 : if (pattern.has_subpattern ())
1221 2691 : visit (pattern.get_subpattern ());
1222 1807322 : }
1223 :
1224 : void
1225 1040794 : DefaultASTVisitor::visit (AST::WildcardPattern &pattern)
1226 1040794 : {}
1227 :
1228 : void
1229 3673 : DefaultASTVisitor::visit (AST::RestPattern &pattern)
1230 3673 : {}
1231 :
1232 : void
1233 47312 : DefaultASTVisitor::visit (AST::RangePatternBoundLiteral &bound)
1234 47312 : {}
1235 :
1236 : void
1237 378 : DefaultASTVisitor::visit (AST::RangePatternBoundPath &bound)
1238 : {
1239 378 : visit (bound.get_path ());
1240 378 : }
1241 :
1242 : void
1243 0 : DefaultASTVisitor::visit (AST::RangePatternBoundQualPath &bound)
1244 : {
1245 0 : visit (bound.get_qualified_path ());
1246 0 : }
1247 :
1248 : void
1249 18458 : DefaultASTVisitor::visit (AST::RangePattern &pattern)
1250 : {
1251 18458 : if (pattern.get_has_lower_bound ())
1252 18458 : visit (pattern.get_lower_bound ());
1253 18458 : if (pattern.get_has_upper_bound ())
1254 18458 : visit (pattern.get_upper_bound ());
1255 18458 : }
1256 :
1257 : void
1258 45628 : DefaultASTVisitor::visit (AST::ReferencePattern &pattern)
1259 : {
1260 45628 : visit (pattern.get_referenced_pattern ());
1261 45628 : }
1262 :
1263 : void
1264 391 : DefaultASTVisitor::visit (AST::StructPatternFieldTuplePat &field)
1265 : {
1266 391 : visit_outer_attrs (field);
1267 391 : visit (field.get_index_pattern ());
1268 391 : }
1269 :
1270 : void
1271 10047 : DefaultASTVisitor::visit (AST::StructPatternFieldIdentPat &field)
1272 : {
1273 10047 : visit_outer_attrs (field);
1274 10047 : visit (field.get_ident_pattern ());
1275 10047 : }
1276 :
1277 : void
1278 3463 : DefaultASTVisitor::visit (AST::StructPatternFieldIdent &field)
1279 : {
1280 3463 : visit_outer_attrs (field);
1281 3463 : }
1282 :
1283 : void
1284 10673 : DefaultASTVisitor::visit (AST::StructPatternElements &spe)
1285 : {
1286 25636 : for (auto &field : spe.get_struct_pattern_fields ())
1287 14963 : visit (field);
1288 10673 : for (auto &attribute : spe.get_etc_outer_attrs ())
1289 0 : visit (attribute);
1290 10673 : }
1291 :
1292 : void
1293 10673 : DefaultASTVisitor::visit (AST::StructPattern &pattern)
1294 : {
1295 10673 : visit (pattern.get_path ());
1296 10673 : visit (pattern.get_struct_pattern_elems ());
1297 10673 : }
1298 :
1299 : void
1300 185733 : DefaultASTVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
1301 : {
1302 378603 : for (auto &pattern : tuple_items.get_patterns ())
1303 192870 : visit (pattern);
1304 185733 : }
1305 :
1306 : void
1307 2175 : DefaultASTVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
1308 : {
1309 2801 : for (auto &lower : tuple_items.get_lower_patterns ())
1310 626 : visit (lower);
1311 2558 : for (auto &upper : tuple_items.get_upper_patterns ())
1312 383 : visit (upper);
1313 2175 : }
1314 :
1315 : void
1316 247015 : DefaultASTVisitor::visit (AST::TupleStructPattern &pattern)
1317 : {
1318 247015 : visit (pattern.get_path ());
1319 247015 : visit (pattern.get_items ());
1320 247015 : }
1321 :
1322 : void
1323 494917 : DefaultASTVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
1324 : {
1325 1626898 : for (auto &pattern : tuple_items.get_patterns ())
1326 1131981 : visit (pattern);
1327 494917 : }
1328 :
1329 : void
1330 643 : DefaultASTVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
1331 : {
1332 1196 : for (auto &lower : tuple_items.get_lower_patterns ())
1333 553 : visit (lower);
1334 1241 : for (auto &upper : tuple_items.get_upper_patterns ())
1335 598 : visit (upper);
1336 643 : }
1337 :
1338 : void
1339 670810 : DefaultASTVisitor::visit (AST::TuplePattern &pattern)
1340 : {
1341 670810 : visit (pattern.get_items ());
1342 670810 : }
1343 :
1344 : void
1345 861 : DefaultASTVisitor::visit (AST::GroupedPattern &pattern)
1346 : {
1347 861 : visit (pattern.get_pattern_in_parens ());
1348 861 : }
1349 :
1350 : void
1351 4281 : DefaultASTVisitor::visit (AST::SlicePattern &pattern)
1352 : {
1353 13369 : for (auto &pat : pattern.get_patterns ())
1354 9088 : visit (pat);
1355 4281 : }
1356 :
1357 : void
1358 10595 : DefaultASTVisitor::visit (AST::AltPattern &pattern)
1359 : {
1360 36985 : for (auto &alt : pattern.get_alts ())
1361 26390 : visit (alt);
1362 10595 : }
1363 :
1364 : void
1365 1474 : DefaultASTVisitor::visit (AST::EmptyStmt &stmt)
1366 1474 : {}
1367 :
1368 : void
1369 1069804 : DefaultASTVisitor::visit (AST::LetStmt &stmt)
1370 : {
1371 1069804 : visit_outer_attrs (stmt);
1372 1069804 : visit (stmt.get_pattern ());
1373 1069804 : if (stmt.has_type ())
1374 126579 : visit (stmt.get_type ());
1375 1069804 : if (stmt.has_init_expr ())
1376 1025775 : visit (stmt.get_init_expr ());
1377 1069804 : }
1378 :
1379 : void
1380 1424453 : DefaultASTVisitor::visit (AST::ExprStmt &stmt)
1381 : {
1382 1424453 : visit (stmt.get_expr ());
1383 1424451 : }
1384 :
1385 : void
1386 692427 : DefaultASTVisitor::visit (AST::TraitBound &bound)
1387 : {
1388 692743 : for (auto &lifetime : bound.get_for_lifetimes ())
1389 316 : visit (lifetime);
1390 692427 : visit (bound.get_type_path ());
1391 692427 : }
1392 :
1393 : void
1394 646 : DefaultASTVisitor::visit (AST::ImplTraitType &type)
1395 : {
1396 1938 : for (auto &bound : type.get_type_param_bounds ())
1397 1292 : visit (bound);
1398 646 : }
1399 :
1400 : void
1401 29977 : DefaultASTVisitor::visit (AST::TraitObjectType &type)
1402 : {
1403 73431 : for (auto &bound : type.get_type_param_bounds ())
1404 43454 : visit (bound);
1405 29977 : }
1406 :
1407 : void
1408 1837 : DefaultASTVisitor::visit (AST::ParenthesisedType &type)
1409 : {
1410 1837 : visit (type.get_type_in_parens ());
1411 1837 : }
1412 :
1413 : void
1414 34897 : DefaultASTVisitor::visit (AST::ImplTraitTypeOneBound &type)
1415 : {
1416 34897 : visit (type.get_trait_bound ());
1417 34897 : }
1418 :
1419 : void
1420 8932 : DefaultASTVisitor::visit (AST::TraitObjectTypeOneBound &type)
1421 : {
1422 8932 : visit (type.get_trait_bound ());
1423 8932 : }
1424 :
1425 : void
1426 188187 : DefaultASTVisitor::visit (AST::TupleType &type)
1427 : {
1428 608524 : for (auto &elem : type.get_elems ())
1429 420337 : visit (elem);
1430 188187 : }
1431 :
1432 : void
1433 16486 : DefaultASTVisitor::visit (AST::NeverType &type)
1434 16486 : {}
1435 :
1436 : void
1437 399000 : DefaultASTVisitor::visit (AST::RawPointerType &type)
1438 : {
1439 399000 : visit (type.get_type_pointed_to ());
1440 399000 : }
1441 :
1442 : void
1443 1621646 : DefaultASTVisitor::visit (AST::ReferenceType &type)
1444 : {
1445 1621646 : visit (type.get_lifetime ());
1446 1621646 : visit (type.get_base_type ());
1447 1621646 : }
1448 :
1449 : void
1450 68887 : DefaultASTVisitor::visit (AST::ArrayType &type)
1451 : {
1452 68887 : visit (type.get_elem_type ());
1453 68887 : visit (type.get_size_expr ());
1454 68887 : }
1455 :
1456 : void
1457 131948 : DefaultASTVisitor::visit (AST::SliceType &type)
1458 : {
1459 131948 : visit (type.get_elem_type ());
1460 131948 : }
1461 :
1462 : void
1463 60770 : DefaultASTVisitor::visit (AST::InferredType &type)
1464 60770 : {}
1465 :
1466 : void
1467 459962 : DefaultASTVisitor::visit (AST::MaybeNamedParam ¶m)
1468 : {
1469 459962 : visit_outer_attrs (param);
1470 459962 : visit (param.get_type ());
1471 459962 : }
1472 :
1473 : void
1474 78143 : DefaultASTVisitor::visit (AST::BareFunctionType &type)
1475 : {
1476 78208 : for (auto &lifetime : type.get_for_lifetimes ())
1477 65 : visit (lifetime);
1478 78143 : visit (type.get_function_qualifiers ());
1479 538105 : for (auto ¶m : type.get_function_params ())
1480 459962 : visit (param);
1481 78143 : if (type.is_variadic ())
1482 23352 : for (auto attr : type.get_variadic_attr ())
1483 0 : visit (attr);
1484 78143 : if (type.has_return_type ())
1485 76125 : visit (type.get_return_type ());
1486 78143 : }
1487 :
1488 : void
1489 0 : DefaultASTVisitor::visit (AST::FormatArgs &)
1490 : {
1491 : // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1492 0 : }
1493 :
1494 : void
1495 170 : DefaultASTVisitor::visit (AST::OffsetOf &offset_of)
1496 : {
1497 170 : visit (offset_of.get_type ());
1498 170 : }
1499 :
1500 : void
1501 14589 : DefaultASTVisitor::visit (AST::VariadicParam ¶m)
1502 : {
1503 14589 : if (param.has_pattern ())
1504 176 : visit (param.get_pattern ());
1505 14589 : }
1506 :
1507 : void
1508 4911 : ContextualASTVisitor::visit (AST::Crate &crate)
1509 : {
1510 4911 : ctx.enter (Kind::CRATE);
1511 4911 : DefaultASTVisitor::visit (crate);
1512 4911 : ctx.exit ();
1513 4911 : }
1514 :
1515 : void
1516 1304 : ContextualASTVisitor::visit (AST::InherentImpl &impl)
1517 : {
1518 1304 : ctx.enter (Kind::INHERENT_IMPL);
1519 1304 : DefaultASTVisitor::visit (impl);
1520 1304 : ctx.exit ();
1521 1304 : }
1522 :
1523 : void
1524 11605 : ContextualASTVisitor::visit (AST::TraitImpl &impl)
1525 : {
1526 11605 : ctx.enter (Kind::TRAIT_IMPL);
1527 11605 : DefaultASTVisitor::visit (impl);
1528 11605 : ctx.exit ();
1529 11605 : }
1530 :
1531 : void
1532 4195 : ContextualASTVisitor::visit (AST::Trait &trait)
1533 : {
1534 4195 : ctx.enter (Kind::TRAIT);
1535 4195 : DefaultASTVisitor::visit (trait);
1536 4195 : ctx.exit ();
1537 4195 : }
1538 :
1539 : void
1540 31615 : ContextualASTVisitor::visit (AST::Function &function)
1541 : {
1542 31615 : ctx.enter (Kind::FUNCTION);
1543 31615 : DefaultASTVisitor::visit (function);
1544 31615 : ctx.exit ();
1545 31615 : }
1546 :
1547 : } // namespace AST
1548 : } // namespace Rust
|
