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 58207 : DefaultASTVisitor::visit (AST::Crate &crate)
36 : {
37 58207 : visit_inner_attrs (crate);
38 309222 : for (auto &item : crate.items)
39 251016 : visit (item);
40 58206 : }
41 :
42 : void
43 344582 : DefaultASTVisitor::visit (AST::Token &tok)
44 344582 : {}
45 :
46 : void
47 61616 : DefaultASTVisitor::visit (AST::DelimTokenTree &delim_tok_tree)
48 : {
49 463467 : for (auto &token : delim_tok_tree.get_token_trees ())
50 401851 : visit (token);
51 61616 : }
52 :
53 : void
54 8036 : DefaultASTVisitor::visit (AST::AttrInputMetaItemContainer &input)
55 : {
56 16848 : for (auto &item : input.get_items ())
57 8812 : visit (item);
58 8036 : }
59 :
60 : void
61 411886 : DefaultASTVisitor::visit (AST::IdentifierExpr &ident_expr)
62 : {
63 411886 : visit_outer_attrs (ident_expr);
64 411886 : }
65 :
66 : void
67 169649 : DefaultASTVisitor::visit (AST::Lifetime &lifetime)
68 169649 : {}
69 :
70 : void
71 3243 : DefaultASTVisitor::visit (AST::LifetimeParam &lifetime_param)
72 : {
73 3243 : visit_outer_attrs (lifetime_param);
74 3243 : visit (lifetime_param.get_lifetime ());
75 3255 : for (auto &lifetime_bound : lifetime_param.get_lifetime_bounds ())
76 12 : visit (lifetime_bound);
77 3243 : }
78 :
79 : void
80 1155 : DefaultASTVisitor::visit (AST::ConstGenericParam &const_param)
81 : {
82 1155 : visit_outer_attrs (const_param);
83 1155 : if (const_param.has_type ())
84 1155 : visit (const_param.get_type ());
85 1155 : if (const_param.has_default_value ())
86 215 : visit (const_param.get_default_value_unchecked ());
87 1155 : }
88 :
89 : void
90 238617 : DefaultASTVisitor::visit (AST::PathInExpression &path)
91 : {
92 238617 : visit_outer_attrs (path);
93 :
94 238617 : if (!path.is_lang_item ())
95 568706 : for (auto &segment : path.get_segments ())
96 331087 : visit (segment);
97 238617 : }
98 :
99 : void
100 1000763 : DefaultASTVisitor::visit (AST::TypePathSegment &segment)
101 1000763 : {}
102 :
103 : void
104 778 : DefaultASTVisitor::visit (GenericArgsBinding &binding)
105 : {
106 778 : visit (binding.get_type ());
107 778 : }
108 :
109 : void
110 29548 : DefaultASTVisitor::visit (AST::TypePathSegmentGeneric &segment)
111 : {
112 29548 : if (segment.has_generic_args ())
113 29538 : visit (segment.get_generic_args ());
114 29548 : }
115 :
116 : void
117 349 : DefaultASTVisitor::visit (AST::TypePathFunction &tpf)
118 : {
119 720 : for (auto &input : tpf.get_params ())
120 371 : visit (input);
121 349 : if (tpf.has_return_type ())
122 327 : visit (tpf.get_return_type ());
123 349 : }
124 :
125 : void
126 423008 : DefaultASTVisitor::visit (AST::PathIdentSegment &segment)
127 423008 : {}
128 :
129 : void
130 349 : DefaultASTVisitor::visit (AST::TypePathSegmentFunction &segment)
131 : {
132 349 : visit (segment.get_type_path_function ());
133 349 : visit (segment.get_ident_segment ());
134 349 : }
135 :
136 : void
137 34869 : DefaultASTVisitor::visit (AST::GenericArgs &args)
138 : {
139 35231 : for (auto &lifetime : args.get_lifetime_args ())
140 362 : visit (lifetime);
141 :
142 71324 : for (auto &generic : args.get_generic_args ())
143 36455 : visit (generic);
144 :
145 35575 : for (auto &binding : args.get_binding_args ())
146 706 : visit (binding);
147 34869 : }
148 :
149 : void
150 379936 : DefaultASTVisitor::visit (AST::PathExprSegment &segment)
151 : {
152 379936 : visit (segment.get_ident_segment ());
153 379936 : if (segment.has_generic_args ())
154 9003 : visit (segment.get_generic_args ());
155 379936 : }
156 : void
157 836271 : DefaultASTVisitor::visit (AST::TypePath &path)
158 : {
159 1699711 : for (auto &segment : path.get_segments ())
160 863440 : visit (segment);
161 836271 : }
162 :
163 : void
164 1601 : DefaultASTVisitor::visit (AST::QualifiedPathInExpression &path)
165 : {
166 1601 : visit_outer_attrs (path);
167 1601 : visit (path.get_qualified_path_type ());
168 :
169 3202 : for (auto &segment : path.get_segments ())
170 1601 : visit (segment);
171 1601 : }
172 :
173 : void
174 5928 : DefaultASTVisitor::visit (AST::QualifiedPathType &path)
175 : {
176 5928 : visit (path.get_type ());
177 5928 : if (path.has_as_clause ())
178 5374 : visit (path.get_as_type_path ());
179 5928 : }
180 :
181 : void
182 4327 : DefaultASTVisitor::visit (AST::QualifiedPathInType &path)
183 : {
184 4327 : visit (path.get_qualified_path_type ());
185 4327 : visit (path.get_associated_segment ());
186 :
187 4327 : for (auto &segment : path.get_segments ())
188 0 : visit (segment);
189 4327 : }
190 :
191 : void
192 1222824 : DefaultASTVisitor::visit (AST::LiteralExpr &expr)
193 : {
194 1222824 : visit_outer_attrs (expr);
195 1222824 : }
196 :
197 : void
198 0 : DefaultASTVisitor::visit (AST::AttrInputLiteral &attr_input)
199 : {
200 0 : visit (attr_input.get_literal ());
201 0 : }
202 :
203 : void
204 0 : DefaultASTVisitor::visit (AST::AttrInputMacro &attr_input)
205 : {
206 0 : visit (attr_input.get_macro ());
207 0 : }
208 :
209 : void
210 0 : DefaultASTVisitor::visit (AST::MetaItemLitExpr &meta_item)
211 : {
212 0 : visit (meta_item.get_literal ());
213 0 : }
214 :
215 : void
216 18517 : DefaultASTVisitor::visit (AST::SimplePathSegment &segment)
217 18517 : {}
218 :
219 : void
220 9015 : DefaultASTVisitor::visit (AST::SimplePath &path)
221 : {
222 25830 : for (auto &segment : path.get_segments ())
223 16815 : visit (segment);
224 9015 : }
225 :
226 : void
227 0 : DefaultASTVisitor::visit (AST::MetaItemPathExpr &meta_item)
228 : {
229 0 : visit (meta_item.get_path ());
230 0 : visit (meta_item.get_expr ());
231 0 : }
232 :
233 : void
234 33977 : DefaultASTVisitor::visit (AST::BorrowExpr &expr)
235 : {
236 33977 : visit_outer_attrs (expr);
237 33977 : visit (expr.get_borrowed_expr ());
238 33977 : }
239 :
240 : void
241 39497 : DefaultASTVisitor::visit (AST::DereferenceExpr &expr)
242 : {
243 39497 : visit_outer_attrs (expr);
244 39497 : visit (expr.get_dereferenced_expr ());
245 39497 : }
246 :
247 : void
248 8 : DefaultASTVisitor::visit (AST::ErrorPropagationExpr &expr)
249 : {
250 8 : visit_outer_attrs (expr);
251 8 : visit (expr.get_propagating_expr ());
252 8 : }
253 :
254 : void
255 7535 : DefaultASTVisitor::visit (AST::NegationExpr &expr)
256 : {
257 7535 : visit_outer_attrs (expr);
258 7535 : visit (expr.get_negated_expr ());
259 7535 : }
260 :
261 : void
262 1624965 : DefaultASTVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
263 : {
264 1624965 : visit_outer_attrs (expr);
265 1624965 : visit (expr.get_left_expr ());
266 1624965 : visit (expr.get_right_expr ());
267 1624965 : }
268 :
269 : void
270 40242 : DefaultASTVisitor::visit (AST::ComparisonExpr &expr)
271 : {
272 40242 : visit_outer_attrs (expr);
273 40242 : visit (expr.get_left_expr ());
274 40242 : visit (expr.get_right_expr ());
275 40242 : }
276 :
277 : void
278 5060 : DefaultASTVisitor::visit (AST::LazyBooleanExpr &expr)
279 : {
280 5060 : visit_outer_attrs (expr);
281 5060 : visit (expr.get_left_expr ());
282 5060 : visit (expr.get_right_expr ());
283 5060 : }
284 :
285 : void
286 101380 : DefaultASTVisitor::visit (AST::TypeCastExpr &expr)
287 : {
288 101380 : visit_outer_attrs (expr);
289 101380 : visit (expr.get_casted_expr ());
290 101380 : visit (expr.get_type_to_cast_to ());
291 101380 : }
292 :
293 : void
294 37389 : DefaultASTVisitor::visit (AST::AssignmentExpr &expr)
295 : {
296 37389 : visit_outer_attrs (expr);
297 37389 : visit (expr.get_left_expr ());
298 37389 : visit (expr.get_right_expr ());
299 37389 : }
300 :
301 : void
302 12254 : DefaultASTVisitor::visit (AST::CompoundAssignmentExpr &expr)
303 : {
304 12254 : visit_outer_attrs (expr);
305 12254 : visit (expr.get_left_expr ());
306 12254 : visit (expr.get_right_expr ());
307 12254 : }
308 :
309 : void
310 5199 : DefaultASTVisitor::visit (AST::GroupedExpr &expr)
311 : {
312 5199 : visit_outer_attrs (expr);
313 5199 : visit_inner_attrs (expr);
314 5199 : visit (expr.get_expr_in_parens ());
315 5199 : }
316 :
317 : void
318 2690 : DefaultASTVisitor::visit (AST::ArrayElemsValues &elems)
319 : {
320 15232 : for (auto &value : elems.get_values ())
321 12542 : visit (value);
322 2690 : }
323 :
324 : void
325 1573 : DefaultASTVisitor::visit (AST::ArrayElemsCopied &elems)
326 : {
327 1573 : visit (elems.get_elem_to_copy ());
328 1573 : visit (elems.get_num_copies ());
329 1573 : }
330 :
331 : void
332 5411 : DefaultASTVisitor::visit (AST::ArrayExpr &expr)
333 : {
334 5411 : visit_outer_attrs (expr);
335 5411 : visit_inner_attrs (expr);
336 5411 : visit (expr.get_array_elems ());
337 5411 : }
338 :
339 : void
340 3462 : DefaultASTVisitor::visit (AST::ArrayIndexExpr &expr)
341 : {
342 3462 : visit_outer_attrs (expr);
343 3462 : visit (expr.get_array_expr ());
344 3462 : visit (expr.get_index_expr ());
345 3462 : }
346 :
347 : void
348 5307 : DefaultASTVisitor::visit (AST::TupleExpr &expr)
349 : {
350 5307 : visit_outer_attrs (expr);
351 5307 : visit_inner_attrs (expr);
352 14566 : for (auto &elem : expr.get_tuple_elems ())
353 9259 : visit (elem);
354 5307 : }
355 :
356 : void
357 13795 : DefaultASTVisitor::visit (AST::TupleIndexExpr &expr)
358 : {
359 13795 : visit_outer_attrs (expr);
360 13795 : visit (expr.get_tuple_expr ());
361 13795 : }
362 :
363 : void
364 648 : DefaultASTVisitor::visit (AST::StructExprStruct &expr)
365 : {
366 648 : visit_outer_attrs (expr);
367 648 : visit_inner_attrs (expr);
368 648 : visit (expr.get_struct_name ());
369 648 : }
370 :
371 : void
372 2393 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifier &field)
373 2393 : {}
374 :
375 : void
376 28467 : DefaultASTVisitor::visit (AST::StructExprFieldIdentifierValue &field)
377 : {
378 28467 : visit (field.get_value ());
379 28467 : }
380 :
381 : void
382 572 : DefaultASTVisitor::visit (AST::StructExprFieldIndexValue &field)
383 : {
384 572 : visit (field.get_value ());
385 572 : }
386 :
387 : void
388 819 : DefaultASTVisitor::visit (AST::StructBase &base)
389 : {
390 819 : visit (base.get_base_struct ());
391 819 : }
392 :
393 : void
394 16783 : DefaultASTVisitor::visit (AST::StructExprStructFields &expr)
395 : {
396 16783 : visit_outer_attrs (expr);
397 16783 : visit_inner_attrs (expr);
398 16783 : visit (expr.get_struct_name ());
399 16783 : if (expr.has_struct_base ())
400 756 : visit (expr.get_struct_base ());
401 46145 : for (auto &field : expr.get_fields ())
402 29362 : visit (field);
403 16783 : }
404 :
405 : void
406 0 : DefaultASTVisitor::visit (AST::StructExprStructBase &expr)
407 : {
408 0 : visit_outer_attrs (expr);
409 0 : visit_inner_attrs (expr);
410 0 : visit (expr.get_struct_name ());
411 0 : visit (expr.get_struct_base ());
412 0 : }
413 :
414 : void
415 175588 : DefaultASTVisitor::visit (AST::CallExpr &expr)
416 : {
417 175588 : visit_outer_attrs (expr);
418 175588 : visit (expr.get_function_expr ());
419 387945 : for (auto ¶m : expr.get_params ())
420 212357 : visit (param);
421 175588 : }
422 :
423 : void
424 47248 : DefaultASTVisitor::visit (AST::MethodCallExpr &expr)
425 : {
426 47248 : visit_outer_attrs (expr);
427 47248 : visit (expr.get_receiver_expr ());
428 47248 : visit (expr.get_method_name ());
429 80188 : for (auto ¶m : expr.get_params ())
430 32940 : visit (param);
431 47248 : }
432 :
433 : void
434 80465 : DefaultASTVisitor::visit (AST::FieldAccessExpr &expr)
435 : {
436 80465 : visit_outer_attrs (expr);
437 80465 : visit (expr.get_receiver_expr ());
438 80465 : }
439 :
440 : void
441 242 : DefaultASTVisitor::visit (AST::ClosureExprInner &expr)
442 : {
443 242 : visit_outer_attrs (expr);
444 422 : for (auto ¶m : expr.get_params ())
445 180 : visit (param);
446 242 : visit (expr.get_definition_expr ());
447 242 : }
448 :
449 : void
450 317941 : DefaultASTVisitor::visit (AST::BlockExpr &expr)
451 : {
452 317941 : visit_outer_attrs (expr);
453 317941 : visit_inner_attrs (expr);
454 :
455 317941 : if (expr.has_label ())
456 0 : visit (expr.get_label ());
457 :
458 612677 : for (auto &stmt : expr.get_statements ())
459 294737 : visit (stmt);
460 :
461 317940 : if (expr.has_tail_expr ())
462 238159 : visit (expr.get_tail_expr ());
463 317940 : }
464 :
465 : void
466 173 : DefaultASTVisitor::visit (AST::ConstBlock &expr)
467 : {
468 173 : visit (expr.get_const_expr ());
469 173 : }
470 :
471 : void
472 11608 : DefaultASTVisitor::visit (AST::AnonConst &expr)
473 : {
474 11608 : if (!expr.is_deferred ())
475 11451 : visit (expr.get_inner_expr ());
476 11608 : }
477 :
478 : void
479 210 : DefaultASTVisitor::visit (AST::ClosureExprInnerTyped &expr)
480 : {
481 210 : visit_outer_attrs (expr);
482 469 : for (auto ¶m : expr.get_params ())
483 259 : visit (param);
484 210 : visit (expr.get_return_type ());
485 210 : visit (expr.get_definition_expr ());
486 210 : }
487 :
488 : void
489 817 : DefaultASTVisitor::visit (AST::ClosureParam ¶m)
490 : {
491 817 : visit_outer_attrs (param);
492 817 : visit (param.get_pattern ());
493 817 : if (param.has_type_given ())
494 754 : visit (param.get_type ());
495 817 : }
496 :
497 : void
498 153 : DefaultASTVisitor::visit (AST::ContinueExpr &expr)
499 : {
500 153 : visit_outer_attrs (expr);
501 153 : if (expr.has_label ())
502 27 : visit (expr.get_label_unchecked ());
503 153 : }
504 :
505 : void
506 1443 : DefaultASTVisitor::visit (AST::BreakExpr &expr)
507 : {
508 1443 : visit_outer_attrs (expr);
509 1443 : if (expr.has_label ())
510 307 : visit (expr.get_label_unchecked ());
511 :
512 1443 : if (expr.has_break_expr ())
513 446 : visit (expr.get_break_expr_unchecked ());
514 1442 : }
515 :
516 : void
517 1011 : DefaultASTVisitor::visit (AST::RangeFromToExpr &expr)
518 : {
519 1011 : visit (expr.get_from_expr ());
520 1011 : visit (expr.get_to_expr ());
521 1011 : }
522 :
523 : void
524 91 : DefaultASTVisitor::visit (AST::RangeFromExpr &expr)
525 : {
526 91 : visit (expr.get_from_expr ());
527 91 : }
528 :
529 : void
530 91 : DefaultASTVisitor::visit (AST::RangeToExpr &expr)
531 : {
532 91 : visit (expr.get_to_expr ());
533 91 : }
534 :
535 : void
536 0 : DefaultASTVisitor::visit (AST::RangeFullExpr &expr)
537 0 : {}
538 :
539 : void
540 91 : DefaultASTVisitor::visit (AST::RangeFromToInclExpr &expr)
541 : {
542 91 : visit (expr.get_from_expr ());
543 91 : visit (expr.get_to_expr ());
544 91 : }
545 :
546 : void
547 0 : DefaultASTVisitor::visit (AST::RangeToInclExpr &expr)
548 : {
549 0 : visit (expr.get_to_expr ());
550 0 : }
551 :
552 : void
553 7992 : DefaultASTVisitor::visit (AST::ReturnExpr &expr)
554 : {
555 7992 : visit_outer_attrs (expr);
556 7992 : if (expr.has_returned_expr ())
557 7331 : visit (expr.get_returned_expr ());
558 7992 : }
559 :
560 : void
561 8 : DefaultASTVisitor::visit (AST::TryExpr &expr)
562 : {
563 8 : visit_outer_attrs (expr);
564 8 : visit (expr.get_block_expr ());
565 8 : }
566 :
567 : void
568 13 : DefaultASTVisitor::visit (AST::BoxExpr &expr)
569 : {
570 13 : visit_outer_attrs (expr);
571 13 : visit (expr.get_boxed_expr ());
572 13 : }
573 :
574 : void
575 51257 : DefaultASTVisitor::visit (AST::UnsafeBlockExpr &expr)
576 : {
577 51257 : visit_outer_attrs (expr);
578 51257 : visit (expr.get_block_expr ());
579 51257 : }
580 :
581 : void
582 629 : DefaultASTVisitor::visit (AST::LoopLabel &label)
583 : {
584 629 : visit (label.get_lifetime ());
585 629 : }
586 :
587 : void
588 1472 : DefaultASTVisitor::visit (AST::LoopExpr &expr)
589 : {
590 1472 : visit_outer_attrs (expr);
591 1472 : if (expr.has_loop_label ())
592 424 : visit (expr.get_loop_label ());
593 1472 : visit (expr.get_loop_block ());
594 1472 : }
595 :
596 : void
597 1300 : DefaultASTVisitor::visit (AST::WhileLoopExpr &expr)
598 : {
599 1300 : visit_outer_attrs (expr);
600 1300 : if (expr.has_loop_label ())
601 24 : visit (expr.get_loop_label ());
602 1300 : visit (expr.get_predicate_expr ());
603 1300 : visit (expr.get_loop_block ());
604 1300 : }
605 :
606 : void
607 12 : DefaultASTVisitor::visit (AST::WhileLetLoopExpr &expr)
608 : {
609 12 : visit_outer_attrs (expr);
610 12 : visit (expr.get_pattern ());
611 :
612 12 : if (expr.has_loop_label ())
613 0 : visit (expr.get_loop_label ());
614 :
615 12 : visit (expr.get_scrutinee_expr ());
616 12 : visit (expr.get_loop_block ());
617 12 : }
618 :
619 : void
620 248 : DefaultASTVisitor::visit (AST::ForLoopExpr &expr)
621 : {
622 248 : visit_outer_attrs (expr);
623 248 : visit (expr.get_pattern ());
624 248 : visit (expr.get_iterator_expr ());
625 248 : if (expr.has_loop_label ())
626 0 : visit (expr.get_loop_label ());
627 248 : visit (expr.get_loop_block ());
628 248 : }
629 :
630 : void
631 25001 : DefaultASTVisitor::visit (AST::IfExpr &expr)
632 : {
633 25001 : visit_outer_attrs (expr);
634 25001 : visit (expr.get_condition_expr ());
635 25001 : visit (expr.get_if_block ());
636 25001 : }
637 :
638 : void
639 18308 : DefaultASTVisitor::visit (AST::IfExprConseqElse &expr)
640 : {
641 18308 : visit (reinterpret_cast<AST::IfExpr &> (expr));
642 18308 : visit (expr.get_else_block ());
643 18308 : }
644 :
645 : void
646 192 : DefaultASTVisitor::visit (AST::IfLetExpr &expr)
647 : {
648 192 : visit_outer_attrs (expr);
649 192 : visit (expr.get_pattern ());
650 192 : visit (expr.get_value_expr ());
651 192 : visit (expr.get_if_block ());
652 192 : }
653 :
654 : void
655 66 : DefaultASTVisitor::visit (AST::IfLetExprConseqElse &expr)
656 : {
657 66 : visit (reinterpret_cast<AST::IfLetExpr &> (expr));
658 66 : visit (expr.get_else_block ());
659 66 : }
660 :
661 : void
662 31310 : DefaultASTVisitor::visit (AST::MatchArm &arm)
663 : {
664 31310 : visit_outer_attrs (arm);
665 31310 : visit (arm.get_pattern ());
666 31310 : if (arm.has_match_arm_guard ())
667 10 : visit (arm.get_guard_expr ());
668 31310 : }
669 :
670 : void
671 33802 : DefaultASTVisitor::visit (AST::MatchCase &arm)
672 : {
673 33802 : visit (arm.get_arm ());
674 33802 : visit (arm.get_expr ());
675 33802 : }
676 :
677 : void
678 14579 : DefaultASTVisitor::visit (AST::MatchExpr &expr)
679 : {
680 14579 : visit_outer_attrs (expr);
681 14579 : visit_inner_attrs (expr);
682 14579 : visit (expr.get_scrutinee_expr ());
683 48381 : for (auto &arm : expr.get_match_cases ())
684 33802 : visit (arm);
685 14579 : }
686 :
687 : void
688 0 : DefaultASTVisitor::visit (AST::AwaitExpr &expr)
689 : {
690 0 : visit_outer_attrs (expr);
691 0 : visit (expr.get_awaited_expr ());
692 0 : }
693 :
694 : void
695 0 : DefaultASTVisitor::visit (AST::AsyncBlockExpr &expr)
696 : {
697 0 : visit_outer_attrs (expr);
698 0 : visit (expr.get_block_expr ());
699 0 : }
700 :
701 : void
702 289 : DefaultASTVisitor::visit (AST::InlineAsm &expr)
703 : {
704 289 : visit_outer_attrs (expr);
705 289 : using RegisterType = AST::InlineAsmOperand::RegisterType;
706 604 : for (auto &operand : expr.get_operands ())
707 : {
708 315 : switch (operand.get_register_type ())
709 : {
710 110 : case RegisterType::In:
711 110 : {
712 110 : visit (operand.get_in ().expr);
713 110 : break;
714 : }
715 183 : case RegisterType::Out:
716 183 : {
717 183 : visit (operand.get_out ().expr);
718 183 : break;
719 : }
720 0 : case RegisterType::InOut:
721 0 : {
722 0 : visit (operand.get_in_out ().expr);
723 0 : break;
724 : }
725 22 : case RegisterType::SplitInOut:
726 22 : {
727 22 : auto split = operand.get_split_in_out ();
728 22 : visit (split.in_expr);
729 22 : visit (split.out_expr);
730 22 : break;
731 22 : }
732 0 : case RegisterType::Const:
733 0 : {
734 0 : visit (operand.get_const ().anon_const.get_inner_expr ());
735 0 : break;
736 : }
737 0 : case RegisterType::Sym:
738 0 : {
739 0 : visit (operand.get_sym ().expr);
740 0 : break;
741 : }
742 0 : case RegisterType::Label:
743 0 : {
744 0 : visit (operand.get_label ().expr);
745 0 : break;
746 : }
747 : }
748 289 : }
749 289 : }
750 :
751 : void
752 22 : DefaultASTVisitor::visit (AST::LlvmInlineAsm &expr)
753 : {
754 22 : for (auto &output : expr.get_outputs ())
755 0 : visit (output.expr);
756 :
757 44 : for (auto &input : expr.get_inputs ())
758 22 : visit (input.expr);
759 22 : }
760 :
761 : void
762 106208 : DefaultASTVisitor::visit (AST::TypeParam ¶m)
763 : {
764 106208 : visit_outer_attrs (param);
765 116995 : for (auto &bound : param.get_type_param_bounds ())
766 10787 : visit (bound);
767 106208 : if (param.has_type ())
768 4940 : visit (param.get_type ());
769 106208 : }
770 :
771 : void
772 22 : DefaultASTVisitor::visit (AST::LifetimeWhereClauseItem &item)
773 : {
774 22 : visit (item.get_lifetime ());
775 44 : for (auto &bound : item.get_lifetime_bounds ())
776 22 : visit (bound);
777 22 : }
778 :
779 : void
780 4495 : DefaultASTVisitor::visit (AST::TypeBoundWhereClauseItem &item)
781 : {
782 4594 : for (auto &lifetime : item.get_for_lifetimes ())
783 99 : visit (lifetime);
784 4495 : visit (item.get_type ());
785 8990 : for (auto ¶m : item.get_type_param_bounds ())
786 4495 : visit (param);
787 4495 : }
788 :
789 : void
790 506661 : DefaultASTVisitor::visit (AST::Visibility &vis)
791 : {
792 506661 : if (vis.has_path ())
793 862 : visit (vis.get_path ());
794 506661 : }
795 :
796 : void
797 265610 : DefaultASTVisitor::visit (AST::FunctionQualifiers &qualifiers)
798 265610 : {}
799 :
800 : void
801 4434 : DefaultASTVisitor::visit (AST::WhereClause &where)
802 : {
803 9036 : for (auto &item : where.get_items ())
804 4602 : visit (item);
805 4434 : }
806 : void
807 151254 : DefaultASTVisitor::visit (AST::FunctionParam ¶m)
808 : {
809 151254 : visit_outer_attrs (param);
810 151254 : if (param.has_name ())
811 151254 : visit (param.get_pattern ());
812 :
813 151254 : visit (param.get_type ());
814 151254 : }
815 :
816 : void
817 119440 : DefaultASTVisitor::visit (AST::SelfParam ¶m)
818 : {
819 119440 : visit_outer_attrs (param);
820 :
821 119440 : if (param.has_lifetime ())
822 68280 : visit (param.get_lifetime ());
823 :
824 119440 : if (param.has_type ())
825 13 : visit (param.get_type ());
826 119440 : }
827 :
828 : void
829 15471 : DefaultASTVisitor::visit (AST::Module &module)
830 : {
831 15471 : visit_outer_attrs (module);
832 15471 : visit (module.get_visibility ());
833 15471 : visit_inner_attrs (module);
834 68181 : for (auto &item : module.get_items ())
835 52710 : visit (item);
836 15471 : }
837 :
838 : void
839 105 : DefaultASTVisitor::visit (AST::ExternCrate &crate)
840 : {
841 105 : visit_outer_attrs (crate);
842 105 : visit (crate.get_visibility ());
843 105 : }
844 :
845 : void
846 55 : DefaultASTVisitor::visit (AST::UseTreeGlob &use_tree)
847 : {
848 55 : visit (use_tree.get_path ());
849 55 : }
850 :
851 : void
852 1229 : DefaultASTVisitor::visit (AST::UseTreeList &use_tree)
853 : {
854 1229 : visit (use_tree.get_path ());
855 1229 : }
856 :
857 : void
858 3904 : DefaultASTVisitor::visit (AST::UseTreeRebind &use_tree)
859 : {
860 3904 : visit (use_tree.get_path ());
861 3904 : }
862 :
863 : void
864 5198 : DefaultASTVisitor::visit (AST::UseDeclaration &use_decl)
865 : {
866 5198 : visit (use_decl.get_visibility ());
867 5198 : visit (use_decl.get_tree ());
868 5198 : }
869 :
870 : void
871 228312 : DefaultASTVisitor::visit_function_params (AST::Function &function)
872 : {
873 488924 : for (auto ¶m : function.get_function_params ())
874 260612 : visit (param);
875 228312 : }
876 :
877 : void
878 246551 : DefaultASTVisitor::visit (AST::Function &function)
879 : {
880 246551 : visit_outer_attrs (function);
881 246551 : visit (function.get_visibility ());
882 246551 : visit (function.get_qualifiers ());
883 268317 : for (auto &generic : function.get_generic_params ())
884 21766 : visit (generic);
885 :
886 246551 : visit_function_params (function);
887 :
888 246551 : if (function.has_return_type ())
889 181546 : visit (function.get_return_type ());
890 246551 : if (function.has_where_clause ())
891 3070 : visit (function.get_where_clause ());
892 246551 : if (function.has_body ())
893 193504 : visit (*function.get_definition ());
894 246550 : }
895 :
896 : void
897 20320 : DefaultASTVisitor::visit (AST::TypeAlias &type_alias)
898 : {
899 20320 : visit_outer_attrs (type_alias);
900 20320 : visit (type_alias.get_visibility ());
901 20552 : for (auto &generic : type_alias.get_generic_params ())
902 232 : visit (generic);
903 20320 : if (type_alias.has_where_clause ())
904 0 : visit (type_alias.get_where_clause ());
905 20320 : visit (type_alias.get_type_aliased ());
906 20320 : }
907 :
908 : void
909 28803 : DefaultASTVisitor::visit (AST::StructField &field)
910 : {
911 28803 : visit_outer_attrs (field);
912 28803 : visit (field.get_visibility ());
913 28803 : visit (field.get_field_type ());
914 28803 : }
915 :
916 : void
917 20371 : DefaultASTVisitor::visit (AST::StructStruct &struct_item)
918 : {
919 20371 : visit_outer_attrs (struct_item);
920 20371 : visit (struct_item.get_visibility ());
921 27095 : for (auto &generic : struct_item.get_generic_params ())
922 6724 : visit (generic);
923 20371 : if (struct_item.has_where_clause ())
924 24 : visit (struct_item.get_where_clause ());
925 43809 : for (auto &field : struct_item.get_fields ())
926 23438 : visit (field);
927 20371 : }
928 :
929 : void
930 27042 : DefaultASTVisitor::visit (AST::TupleField &field)
931 : {
932 27042 : visit_outer_attrs (field);
933 27042 : visit (field.get_visibility ());
934 27042 : visit (field.get_field_type ());
935 27042 : }
936 :
937 : void
938 12324 : DefaultASTVisitor::visit (AST::TupleStruct &tuple_struct)
939 : {
940 12324 : visit_outer_attrs (tuple_struct);
941 12324 : visit (tuple_struct.get_visibility ());
942 16766 : for (auto &generic : tuple_struct.get_generic_params ())
943 4442 : visit (generic);
944 12324 : if (tuple_struct.has_where_clause ())
945 0 : visit (tuple_struct.get_where_clause ());
946 34209 : for (auto &field : tuple_struct.get_fields ())
947 21885 : visit (field);
948 12324 : }
949 :
950 : void
951 15008 : DefaultASTVisitor::visit (AST::EnumItem &item)
952 : {
953 15008 : visit_outer_attrs (item);
954 15008 : visit (item.get_visibility ());
955 15008 : }
956 :
957 : void
958 4859 : DefaultASTVisitor::visit (AST::EnumItemTuple &item)
959 : {
960 4859 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
961 10016 : for (auto &field : item.get_tuple_fields ())
962 5157 : visit (field);
963 4859 : }
964 :
965 : void
966 983 : DefaultASTVisitor::visit (AST::EnumItemStruct &item)
967 : {
968 983 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
969 2579 : for (auto &field : item.get_struct_fields ())
970 1596 : visit (field);
971 983 : }
972 :
973 : void
974 4393 : DefaultASTVisitor::visit (AST::EnumItemDiscriminant &item)
975 : {
976 4393 : DefaultASTVisitor::visit (static_cast<EnumItem &> (item));
977 4393 : visit (item.get_expr ());
978 4393 : }
979 :
980 : void
981 7166 : DefaultASTVisitor::visit (AST::Enum &enum_item)
982 : {
983 7166 : visit_outer_attrs (enum_item);
984 7166 : visit (enum_item.get_visibility ());
985 11051 : for (auto &generic : enum_item.get_generic_params ())
986 3885 : visit (generic);
987 7166 : if (enum_item.has_where_clause ())
988 0 : visit (enum_item.get_where_clause ());
989 23886 : for (auto &item : enum_item.get_variants ())
990 16720 : visit (item);
991 7166 : }
992 :
993 : void
994 1297 : DefaultASTVisitor::visit (AST::Union &union_item)
995 : {
996 1297 : visit_outer_attrs (union_item);
997 1297 : visit (union_item.get_visibility ());
998 2218 : for (auto &generic : union_item.get_generic_params ())
999 921 : visit (generic);
1000 1297 : if (union_item.has_where_clause ())
1001 0 : visit (union_item.get_where_clause ());
1002 5066 : for (auto &variant : union_item.get_variants ())
1003 3769 : visit (variant);
1004 1297 : }
1005 :
1006 : void
1007 7226 : DefaultASTVisitor::visit (AST::ConstantItem &const_item)
1008 : {
1009 7226 : visit_outer_attrs (const_item);
1010 7226 : visit (const_item.get_visibility ());
1011 7226 : visit (const_item.get_type ());
1012 7226 : if (const_item.has_expr ())
1013 6760 : visit (const_item.get_expr ());
1014 7226 : }
1015 :
1016 : void
1017 722 : DefaultASTVisitor::visit (AST::StaticItem &static_item)
1018 : {
1019 722 : visit_outer_attrs (static_item);
1020 722 : visit (static_item.get_visibility ());
1021 722 : visit (static_item.get_type ());
1022 722 : visit (static_item.get_expr ());
1023 722 : }
1024 :
1025 : void
1026 11825 : DefaultASTVisitor::visit (AST::TraitItemType &item)
1027 : {
1028 11825 : visit_outer_attrs (item);
1029 11951 : for (auto &generic : item.get_generic_params ())
1030 126 : visit (generic);
1031 12636 : for (auto &bound : item.get_type_param_bounds ())
1032 811 : visit (bound);
1033 11825 : }
1034 :
1035 : void
1036 23597 : DefaultASTVisitor::visit (AST::Trait &trait)
1037 : {
1038 23597 : visit_outer_attrs (trait);
1039 23597 : visit (trait.get_visibility ());
1040 :
1041 23597 : visit_inner_attrs (trait);
1042 :
1043 23597 : visit (trait.get_implicit_self ());
1044 :
1045 27874 : for (auto &generic : trait.get_generic_params ())
1046 4277 : visit (generic);
1047 :
1048 23597 : if (trait.has_where_clause ())
1049 49 : visit (trait.get_where_clause ());
1050 :
1051 27707 : for (auto &bound : trait.get_type_param_bounds ())
1052 4110 : visit (bound);
1053 :
1054 45421 : for (auto &item : trait.get_trait_items ())
1055 21824 : visit (item);
1056 23597 : }
1057 :
1058 : void
1059 6827 : DefaultASTVisitor::visit (AST::InherentImpl &impl)
1060 : {
1061 6827 : visit_outer_attrs (impl);
1062 6827 : visit (impl.get_visibility ());
1063 :
1064 9210 : for (auto &generic : impl.get_generic_params ())
1065 2383 : visit (generic);
1066 6827 : if (impl.has_where_clause ())
1067 7 : visit (impl.get_where_clause ());
1068 6827 : visit (impl.get_type ());
1069 6827 : visit_inner_attrs (impl);
1070 25948 : for (auto &item : impl.get_impl_items ())
1071 19121 : visit (item);
1072 6827 : }
1073 :
1074 : void
1075 32118 : DefaultASTVisitor::visit (AST::TraitImpl &impl)
1076 : {
1077 32118 : visit_outer_attrs (impl);
1078 32118 : visit (impl.get_visibility ());
1079 :
1080 37992 : for (auto &generic : impl.get_generic_params ())
1081 5874 : visit (generic);
1082 32118 : if (impl.has_where_clause ())
1083 629 : visit (impl.get_where_clause ());
1084 32118 : visit (impl.get_type ());
1085 32118 : visit (impl.get_trait_path ());
1086 32118 : visit_inner_attrs (impl);
1087 70433 : for (auto &item : impl.get_impl_items ())
1088 38315 : visit (item);
1089 32118 : }
1090 :
1091 : void
1092 9 : DefaultASTVisitor::visit (AST::ExternalTypeItem &item)
1093 : {
1094 9 : visit_outer_attrs (item);
1095 9 : visit (item.get_visibility ());
1096 9 : }
1097 :
1098 : void
1099 12 : DefaultASTVisitor::visit (AST::ExternalStaticItem &item)
1100 : {
1101 12 : visit_outer_attrs (item);
1102 12 : visit (item.get_visibility ());
1103 12 : visit (item.get_type ());
1104 12 : }
1105 :
1106 : void
1107 15434 : DefaultASTVisitor::visit (AST::ExternBlock &block)
1108 : {
1109 15434 : visit_outer_attrs (block);
1110 15434 : visit (block.get_visibility ());
1111 15434 : visit_inner_attrs (block);
1112 39460 : for (auto &item : block.get_extern_items ())
1113 24026 : visit (item);
1114 15434 : }
1115 :
1116 : void
1117 10101 : DefaultASTVisitor::visit (AST::MacroMatchFragment &match)
1118 10101 : {}
1119 :
1120 : void
1121 4751 : DefaultASTVisitor::visit (AST::MacroMatchRepetition &match)
1122 : {
1123 11558 : for (auto &m : match.get_matches ())
1124 6807 : visit (m);
1125 4751 : }
1126 :
1127 : void
1128 10112 : DefaultASTVisitor::visit (AST::MacroMatcher &matcher)
1129 : {
1130 23086 : for (auto &m : matcher.get_matches ())
1131 12974 : visit (m);
1132 10112 : }
1133 :
1134 : void
1135 9663 : DefaultASTVisitor::visit (AST::MacroTranscriber &transcriber)
1136 : {
1137 9663 : visit (transcriber.get_token_tree ());
1138 9663 : }
1139 :
1140 : void
1141 9663 : DefaultASTVisitor::visit (AST::MacroRule &rule)
1142 : {
1143 9663 : visit (rule.get_matcher ());
1144 9663 : visit (rule.get_transcriber ());
1145 9663 : }
1146 : void
1147 7579 : DefaultASTVisitor::visit (AST::MacroRulesDefinition &rules_def)
1148 : {
1149 7579 : visit_outer_attrs (rules_def);
1150 17242 : for (auto &rule : rules_def.get_macro_rules ())
1151 9663 : visit (rule);
1152 7579 : }
1153 :
1154 : void
1155 2936 : DefaultASTVisitor::visit (AST::MacroInvocData &data)
1156 : {
1157 2936 : visit (data.get_path ());
1158 2936 : visit (data.get_delim_tok_tree ());
1159 2936 : }
1160 : void
1161 2936 : DefaultASTVisitor::visit (AST::MacroInvocation ¯o_invoc)
1162 : {
1163 2936 : visit_outer_attrs (macro_invoc);
1164 2936 : visit (macro_invoc.get_invoc_data ());
1165 2936 : }
1166 :
1167 : void
1168 0 : DefaultASTVisitor::visit (AST::MetaItemPath &meta_item)
1169 : {
1170 0 : visit (meta_item.get_path ());
1171 0 : }
1172 :
1173 : void
1174 29 : DefaultASTVisitor::visit (AST::MetaItemSeq &meta_item)
1175 : {
1176 29 : visit (meta_item.get_path ());
1177 67 : for (auto &inner : meta_item.get_seq ())
1178 38 : visit (inner);
1179 29 : }
1180 :
1181 : void
1182 0 : DefaultASTVisitor::visit (AST::MetaWord &meta_item)
1183 0 : {}
1184 :
1185 : void
1186 0 : DefaultASTVisitor::visit (AST::MetaNameValueStr &meta_item)
1187 0 : {}
1188 :
1189 : void
1190 0 : DefaultASTVisitor::visit (AST::MetaListPaths &meta_item)
1191 : {
1192 0 : for (auto &path : meta_item.get_paths ())
1193 0 : visit (path);
1194 0 : }
1195 :
1196 : void
1197 0 : DefaultASTVisitor::visit (AST::MetaListNameValueStr &meta_item)
1198 : {
1199 0 : for (auto &str : meta_item.get_values ())
1200 0 : visit (str);
1201 0 : }
1202 :
1203 : void
1204 6808 : DefaultASTVisitor::visit (AST::LiteralPattern &pattern)
1205 6808 : {}
1206 :
1207 : void
1208 233727 : DefaultASTVisitor::visit (AST::IdentifierPattern &pattern)
1209 : {
1210 233727 : if (pattern.has_subpattern ())
1211 232 : visit (pattern.get_subpattern ());
1212 233727 : }
1213 :
1214 : void
1215 21438 : DefaultASTVisitor::visit (AST::WildcardPattern &pattern)
1216 21438 : {}
1217 :
1218 : void
1219 0 : DefaultASTVisitor::visit (AST::RestPattern &pattern)
1220 0 : {}
1221 :
1222 : void
1223 1573 : DefaultASTVisitor::visit (AST::RangePatternBoundLiteral &bound)
1224 1573 : {}
1225 :
1226 : void
1227 168 : DefaultASTVisitor::visit (AST::RangePatternBoundPath &bound)
1228 : {
1229 168 : visit (bound.get_path ());
1230 168 : }
1231 :
1232 : void
1233 0 : DefaultASTVisitor::visit (AST::RangePatternBoundQualPath &bound)
1234 : {
1235 0 : visit (bound.get_qualified_path ());
1236 0 : }
1237 :
1238 : void
1239 760 : DefaultASTVisitor::visit (AST::RangePattern &pattern)
1240 : {
1241 760 : if (pattern.get_has_lower_bound ())
1242 760 : visit (pattern.get_lower_bound ());
1243 760 : if (pattern.get_has_upper_bound ())
1244 760 : visit (pattern.get_upper_bound ());
1245 760 : }
1246 :
1247 : void
1248 2539 : DefaultASTVisitor::visit (AST::ReferencePattern &pattern)
1249 : {
1250 2539 : visit (pattern.get_referenced_pattern ());
1251 2539 : }
1252 :
1253 : void
1254 294 : DefaultASTVisitor::visit (AST::StructPatternFieldTuplePat &field)
1255 : {
1256 294 : visit_outer_attrs (field);
1257 294 : visit (field.get_index_pattern ());
1258 294 : }
1259 :
1260 : void
1261 1875 : DefaultASTVisitor::visit (AST::StructPatternFieldIdentPat &field)
1262 : {
1263 1875 : visit_outer_attrs (field);
1264 1875 : visit (field.get_ident_pattern ());
1265 1875 : }
1266 :
1267 : void
1268 814 : DefaultASTVisitor::visit (AST::StructPatternFieldIdent &field)
1269 : {
1270 814 : visit_outer_attrs (field);
1271 814 : }
1272 :
1273 : void
1274 1499 : DefaultASTVisitor::visit (AST::StructPatternElements &spe)
1275 : {
1276 3988 : for (auto &field : spe.get_struct_pattern_fields ())
1277 2489 : visit (field);
1278 1499 : for (auto &attribute : spe.get_etc_outer_attrs ())
1279 : visit (attribute);
1280 1499 : }
1281 :
1282 : void
1283 1499 : DefaultASTVisitor::visit (AST::StructPattern &pattern)
1284 : {
1285 1499 : visit (pattern.get_path ());
1286 1499 : visit (pattern.get_struct_pattern_elems ());
1287 1499 : }
1288 :
1289 : void
1290 14966 : DefaultASTVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
1291 : {
1292 31550 : for (auto &pattern : tuple_items.get_patterns ())
1293 16584 : visit (pattern);
1294 14966 : }
1295 :
1296 : void
1297 499 : DefaultASTVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
1298 : {
1299 896 : for (auto &lower : tuple_items.get_lower_patterns ())
1300 397 : visit (lower);
1301 736 : for (auto &upper : tuple_items.get_upper_patterns ())
1302 237 : visit (upper);
1303 499 : }
1304 :
1305 : void
1306 15465 : DefaultASTVisitor::visit (AST::TupleStructPattern &pattern)
1307 : {
1308 15465 : visit (pattern.get_path ());
1309 15465 : visit (pattern.get_items ());
1310 15465 : }
1311 :
1312 : void
1313 8283 : DefaultASTVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
1314 : {
1315 25029 : for (auto &pattern : tuple_items.get_patterns ())
1316 16746 : visit (pattern);
1317 8283 : }
1318 :
1319 : void
1320 345 : DefaultASTVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
1321 : {
1322 701 : for (auto &lower : tuple_items.get_lower_patterns ())
1323 356 : visit (lower);
1324 745 : for (auto &upper : tuple_items.get_upper_patterns ())
1325 400 : visit (upper);
1326 345 : }
1327 :
1328 : void
1329 8628 : DefaultASTVisitor::visit (AST::TuplePattern &pattern)
1330 : {
1331 8628 : visit (pattern.get_items ());
1332 8628 : }
1333 :
1334 : void
1335 572 : DefaultASTVisitor::visit (AST::GroupedPattern &pattern)
1336 : {
1337 572 : visit (pattern.get_pattern_in_parens ());
1338 572 : }
1339 :
1340 : void
1341 408 : DefaultASTVisitor::visit (AST::SlicePatternItemsNoRest &items)
1342 : {
1343 1224 : for (auto &item : items.get_patterns ())
1344 816 : visit (item);
1345 408 : }
1346 :
1347 : void
1348 568 : DefaultASTVisitor::visit (AST::SlicePatternItemsHasRest &items)
1349 : {
1350 1125 : for (auto &item : items.get_lower_patterns ())
1351 557 : visit (item);
1352 1125 : for (auto &item : items.get_upper_patterns ())
1353 557 : visit (item);
1354 568 : }
1355 :
1356 : void
1357 976 : DefaultASTVisitor::visit (AST::SlicePattern &pattern)
1358 : {
1359 976 : visit (pattern.get_items ());
1360 976 : }
1361 :
1362 : void
1363 2674 : DefaultASTVisitor::visit (AST::AltPattern &pattern)
1364 : {
1365 8302 : for (auto &alt : pattern.get_alts ())
1366 5628 : visit (alt);
1367 2674 : }
1368 :
1369 : void
1370 878 : DefaultASTVisitor::visit (AST::EmptyStmt &stmt)
1371 878 : {}
1372 :
1373 : void
1374 179290 : DefaultASTVisitor::visit (AST::LetStmt &stmt)
1375 : {
1376 179290 : visit_outer_attrs (stmt);
1377 179290 : visit (stmt.get_pattern ());
1378 179290 : if (stmt.has_type ())
1379 27250 : visit (stmt.get_type ());
1380 179290 : if (stmt.has_init_expr ())
1381 164886 : visit (stmt.get_init_expr ());
1382 179290 : }
1383 :
1384 : void
1385 146997 : DefaultASTVisitor::visit (AST::ExprStmt &stmt)
1386 : {
1387 146997 : visit (stmt.get_expr ());
1388 146996 : }
1389 :
1390 : void
1391 21419 : DefaultASTVisitor::visit (AST::TraitBound &bound)
1392 : {
1393 21559 : for (auto &lifetime : bound.get_for_lifetimes ())
1394 140 : visit (lifetime);
1395 21419 : visit (bound.get_type_path ());
1396 21419 : }
1397 :
1398 : void
1399 0 : DefaultASTVisitor::visit (AST::ImplTraitType &type)
1400 : {
1401 0 : for (auto &bound : type.get_type_param_bounds ())
1402 0 : visit (bound);
1403 0 : }
1404 :
1405 : void
1406 160 : DefaultASTVisitor::visit (AST::TraitObjectType &type)
1407 : {
1408 568 : for (auto &bound : type.get_type_param_bounds ())
1409 408 : visit (bound);
1410 160 : }
1411 :
1412 : void
1413 94 : DefaultASTVisitor::visit (AST::ParenthesisedType &type)
1414 : {
1415 94 : visit (type.get_type_in_parens ());
1416 94 : }
1417 :
1418 : void
1419 1199 : DefaultASTVisitor::visit (AST::ImplTraitTypeOneBound &type)
1420 : {
1421 1199 : visit (type.get_trait_bound ());
1422 1199 : }
1423 :
1424 : void
1425 2060 : DefaultASTVisitor::visit (AST::TraitObjectTypeOneBound &type)
1426 : {
1427 2060 : visit (type.get_trait_bound ());
1428 2060 : }
1429 :
1430 : void
1431 5896 : DefaultASTVisitor::visit (AST::TupleType &type)
1432 : {
1433 15178 : for (auto &elem : type.get_elems ())
1434 9282 : visit (elem);
1435 5896 : }
1436 :
1437 : void
1438 792 : DefaultASTVisitor::visit (AST::NeverType &type)
1439 792 : {}
1440 :
1441 : void
1442 110981 : DefaultASTVisitor::visit (AST::RawPointerType &type)
1443 : {
1444 110981 : visit (type.get_type_pointed_to ());
1445 110981 : }
1446 :
1447 : void
1448 76794 : DefaultASTVisitor::visit (AST::ReferenceType &type)
1449 : {
1450 76794 : visit (type.get_lifetime ());
1451 76794 : visit (type.get_base_type ());
1452 76794 : }
1453 :
1454 : void
1455 11435 : DefaultASTVisitor::visit (AST::ArrayType &type)
1456 : {
1457 11435 : visit (type.get_elem_type ());
1458 11435 : visit (type.get_size_expr ());
1459 11435 : }
1460 :
1461 : void
1462 12145 : DefaultASTVisitor::visit (AST::SliceType &type)
1463 : {
1464 12145 : visit (type.get_elem_type ());
1465 12145 : }
1466 :
1467 : void
1468 4242 : DefaultASTVisitor::visit (AST::InferredType &type)
1469 4242 : {}
1470 :
1471 : void
1472 680 : DefaultASTVisitor::visit (AST::MaybeNamedParam ¶m)
1473 : {
1474 680 : visit_outer_attrs (param);
1475 680 : visit (param.get_type ());
1476 680 : }
1477 :
1478 : void
1479 865 : DefaultASTVisitor::visit (AST::BareFunctionType &type)
1480 : {
1481 902 : for (auto &lifetime : type.get_for_lifetimes ())
1482 37 : visit (lifetime);
1483 865 : visit (type.get_function_qualifiers ());
1484 1545 : for (auto ¶m : type.get_function_params ())
1485 680 : visit (param);
1486 865 : if (type.is_variadic ())
1487 0 : for (auto attr : type.get_variadic_attr ())
1488 0 : visit (attr);
1489 865 : if (type.has_return_type ())
1490 641 : visit (type.get_return_type ());
1491 865 : }
1492 :
1493 : void
1494 0 : DefaultASTVisitor::visit (AST::FormatArgs &)
1495 : {
1496 : // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1497 0 : }
1498 :
1499 : void
1500 139 : DefaultASTVisitor::visit (AST::OffsetOf &offset_of)
1501 : {
1502 139 : visit (offset_of.get_type ());
1503 139 : }
1504 :
1505 : void
1506 9456 : DefaultASTVisitor::visit (AST::VariadicParam ¶m)
1507 : {
1508 9456 : if (param.has_pattern ())
1509 121 : visit (param.get_pattern ());
1510 9456 : }
1511 :
1512 : void
1513 4509 : ContextualASTVisitor::visit (AST::Crate &crate)
1514 : {
1515 4509 : ctx.enter (Kind::CRATE);
1516 4509 : DefaultASTVisitor::visit (crate);
1517 4509 : ctx.exit ();
1518 4509 : }
1519 :
1520 : void
1521 971 : ContextualASTVisitor::visit (AST::InherentImpl &impl)
1522 : {
1523 971 : ctx.enter (Kind::INHERENT_IMPL);
1524 971 : DefaultASTVisitor::visit (impl);
1525 971 : ctx.exit ();
1526 971 : }
1527 :
1528 : void
1529 4739 : ContextualASTVisitor::visit (AST::TraitImpl &impl)
1530 : {
1531 4739 : ctx.enter (Kind::TRAIT_IMPL);
1532 4739 : DefaultASTVisitor::visit (impl);
1533 4739 : ctx.exit ();
1534 4739 : }
1535 :
1536 : void
1537 3736 : ContextualASTVisitor::visit (AST::Trait &trait)
1538 : {
1539 3736 : ctx.enter (Kind::TRAIT);
1540 3736 : DefaultASTVisitor::visit (trait);
1541 3736 : ctx.exit ();
1542 3736 : }
1543 :
1544 : } // namespace AST
1545 : } // namespace Rust
|
