Line data Source code
1 : // Copyright (C) 2025-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-pointer-visitor.h"
20 : #include "rust-ast-visitor.h"
21 : #include "rust-ast-full.h"
22 :
23 : namespace Rust {
24 : namespace AST {
25 :
26 : void
27 4398 : PointerVisitor::visit (AST::Crate &crate)
28 : {
29 4398 : visit_inner_attrs (crate);
30 23389 : for (auto &item : crate.items)
31 18991 : reseat (item);
32 4398 : }
33 :
34 : void
35 0 : PointerVisitor::visit (AST::AttrInputMetaItemContainer &input)
36 : {
37 : // FIXME: I think we might actually have to reseat sub-items for macro
38 : // invocations within attributes correct?
39 :
40 0 : for (auto &item : input.get_items ())
41 0 : visit (item);
42 0 : }
43 :
44 : void
45 24322 : PointerVisitor::visit (AST::IdentifierExpr &ident_expr)
46 : {
47 24322 : visit_outer_attrs (ident_expr);
48 24322 : }
49 :
50 : void
51 274 : PointerVisitor::visit (AST::LifetimeParam &lifetime_param)
52 : {
53 274 : visit_outer_attrs (lifetime_param);
54 :
55 : // Nothing to do for lifetimes right?
56 274 : }
57 :
58 : void
59 97 : PointerVisitor::visit (AST::ConstGenericParam &const_param)
60 : {
61 97 : visit_outer_attrs (const_param);
62 97 : if (const_param.has_type ())
63 97 : reseat (const_param.get_type_ptr ());
64 :
65 97 : if (const_param.has_default_value ())
66 18 : visit (const_param.get_default_value_unchecked ());
67 97 : }
68 :
69 : void
70 24391 : PointerVisitor::visit (AST::PathInExpression &path)
71 : {
72 24391 : visit_outer_attrs (path);
73 :
74 24391 : if (!path.is_lang_item ())
75 57679 : for (auto &segment : path.get_segments ())
76 33432 : visit (segment);
77 24391 : }
78 :
79 : void
80 73 : PointerVisitor::visit (GenericArgsBinding &binding)
81 : {
82 73 : reseat (binding.get_type_ptr ());
83 73 : }
84 :
85 : void
86 2889 : PointerVisitor::visit (AST::TypePathSegmentGeneric &segment)
87 : {
88 2889 : if (segment.has_generic_args ())
89 2888 : visit (segment.get_generic_args ());
90 2889 : }
91 :
92 : void
93 30 : PointerVisitor::visit (AST::TypePathFunction &tpf)
94 : {
95 62 : for (auto &input : tpf.get_params ())
96 32 : reseat (input);
97 30 : if (tpf.has_return_type ())
98 28 : reseat (tpf.get_return_type_ptr ());
99 30 : }
100 :
101 : void
102 30 : PointerVisitor::visit (AST::TypePathSegmentFunction &segment)
103 : {
104 : // FIXME: No reseating here correct? No macros possible or desugar?
105 30 : visit (segment.get_type_path_function ());
106 30 : visit (segment.get_ident_segment ());
107 30 : }
108 :
109 : void
110 3837 : PointerVisitor::visit (AST::GenericArgs &args)
111 : {
112 : // Nothing to do for lifetimes?
113 : // for (auto &lifetime : args.get_lifetime_args ())
114 : // reseat (lifetime);
115 :
116 : // FIXME: Actually this can probably be a macro invocation, so we need to
117 : // reseat them?
118 7855 : for (auto &generic : args.get_generic_args ())
119 4018 : visit (generic);
120 :
121 3910 : for (auto &binding : args.get_binding_args ())
122 73 : visit (binding);
123 3837 : }
124 :
125 : void
126 42693 : PointerVisitor::visit (AST::PathExprSegment &segment)
127 : {
128 42693 : visit (segment.get_ident_segment ());
129 42693 : if (segment.has_generic_args ())
130 949 : visit (segment.get_generic_args ());
131 42693 : }
132 : void
133 179382 : PointerVisitor::visit (AST::TypePath &path)
134 : {
135 365372 : for (auto &segment : path.get_segments ())
136 185990 : visit (segment);
137 179382 : }
138 :
139 : void
140 114 : PointerVisitor::visit (AST::QualifiedPathInExpression &path)
141 : {
142 114 : visit_outer_attrs (path);
143 114 : visit (path.get_qualified_path_type ());
144 :
145 228 : for (auto &segment : path.get_segments ())
146 114 : visit (segment);
147 114 : }
148 :
149 : void
150 443 : PointerVisitor::visit (AST::QualifiedPathType &path)
151 : {
152 443 : reseat (path.get_type_ptr ());
153 443 : if (path.has_as_clause ())
154 408 : visit (path.get_as_type_path ());
155 443 : }
156 :
157 : void
158 329 : PointerVisitor::visit (AST::QualifiedPathInType &path)
159 : {
160 329 : visit (path.get_qualified_path_type ());
161 329 : visit (path.get_associated_segment ());
162 :
163 329 : for (auto &segment : path.get_segments ())
164 0 : visit (segment);
165 329 : }
166 :
167 : void
168 18588 : PointerVisitor::visit (AST::LiteralExpr &expr)
169 : {
170 18588 : visit_outer_attrs (expr);
171 18588 : }
172 :
173 : void
174 0 : PointerVisitor::visit (AST::AttrInputLiteral &attr_input)
175 : {
176 0 : visit (attr_input.get_literal ());
177 0 : }
178 :
179 : void
180 0 : PointerVisitor::visit (AST::AttrInputMacro &attr_input)
181 : {
182 0 : visit (attr_input.get_macro ());
183 0 : }
184 :
185 : void
186 0 : PointerVisitor::visit (AST::MetaItemLitExpr &meta_item)
187 : {
188 0 : visit (meta_item.get_literal ());
189 0 : }
190 :
191 : void
192 720 : PointerVisitor::visit (AST::SimplePath &path)
193 : {
194 2422 : for (auto &segment : path.get_segments ())
195 1702 : visit (segment);
196 720 : }
197 :
198 : void
199 0 : PointerVisitor::visit (AST::MetaItemPathExpr &meta_item)
200 : {
201 0 : visit (meta_item.get_path ());
202 0 : reseat (meta_item.get_expr_ptr ());
203 0 : }
204 :
205 : void
206 6739 : PointerVisitor::visit (AST::BorrowExpr &expr)
207 : {
208 6739 : visit_outer_attrs (expr);
209 6739 : reseat (expr.get_borrowed_expr_ptr ());
210 6739 : }
211 :
212 : void
213 13913 : PointerVisitor::visit (AST::DereferenceExpr &expr)
214 : {
215 13913 : visit_outer_attrs (expr);
216 13913 : reseat (expr.get_dereferenced_expr_ptr ());
217 13913 : }
218 :
219 : void
220 2 : PointerVisitor::visit (AST::ErrorPropagationExpr &expr)
221 : {
222 2 : visit_outer_attrs (expr);
223 2 : reseat (expr.get_propagating_expr_ptr ());
224 2 : }
225 :
226 : void
227 1710 : PointerVisitor::visit (AST::NegationExpr &expr)
228 : {
229 1710 : visit_outer_attrs (expr);
230 1710 : reseat (expr.get_negated_expr_ptr ());
231 1710 : }
232 :
233 : void
234 3383 : PointerVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
235 : {
236 3383 : visit_outer_attrs (expr);
237 3383 : reseat (expr.get_left_expr_ptr ());
238 3383 : reseat (expr.get_right_expr_ptr ());
239 3383 : }
240 :
241 : void
242 2719 : PointerVisitor::visit (AST::ComparisonExpr &expr)
243 : {
244 2719 : visit_outer_attrs (expr);
245 2719 : reseat (expr.get_left_expr_ptr ());
246 2719 : reseat (expr.get_right_expr_ptr ());
247 2719 : }
248 :
249 : void
250 385 : PointerVisitor::visit (AST::LazyBooleanExpr &expr)
251 : {
252 385 : visit_outer_attrs (expr);
253 385 : reseat (expr.get_left_expr_ptr ());
254 385 : reseat (expr.get_right_expr_ptr ());
255 385 : }
256 :
257 : void
258 5114 : PointerVisitor::visit (AST::TypeCastExpr &expr)
259 : {
260 5114 : visit_outer_attrs (expr);
261 5114 : reseat (expr.get_casted_expr_ptr ());
262 5114 : reseat (expr.get_type_to_cast_to_ptr ());
263 5114 : }
264 :
265 : void
266 2497 : PointerVisitor::visit (AST::AssignmentExpr &expr)
267 : {
268 2497 : visit_outer_attrs (expr);
269 2497 : reseat (expr.get_left_expr_ptr ());
270 2497 : reseat (expr.get_right_expr_ptr ());
271 2497 : }
272 :
273 : void
274 682 : PointerVisitor::visit (AST::CompoundAssignmentExpr &expr)
275 : {
276 682 : visit_outer_attrs (expr);
277 682 : reseat (expr.get_left_expr_ptr ());
278 682 : reseat (expr.get_right_expr_ptr ());
279 682 : }
280 :
281 : void
282 311 : PointerVisitor::visit (AST::GroupedExpr &expr)
283 : {
284 311 : visit_outer_attrs (expr);
285 311 : visit_inner_attrs (expr);
286 311 : reseat (expr.get_expr_in_parens_ptr ());
287 311 : }
288 :
289 : void
290 895 : PointerVisitor::visit (AST::ArrayElemsValues &elems)
291 : {
292 5055 : for (auto &value : elems.get_values ())
293 4160 : reseat (value);
294 895 : }
295 :
296 : void
297 366 : PointerVisitor::visit (AST::ArrayElemsCopied &elems)
298 : {
299 366 : reseat (elems.get_elem_to_copy_ptr ());
300 366 : reseat (elems.get_num_copies_ptr ());
301 366 : }
302 :
303 : void
304 1261 : PointerVisitor::visit (AST::ArrayExpr &expr)
305 : {
306 1261 : visit_outer_attrs (expr);
307 1261 : visit_inner_attrs (expr);
308 1261 : visit (expr.get_array_elems ());
309 1261 : }
310 :
311 : void
312 765 : PointerVisitor::visit (AST::ArrayIndexExpr &expr)
313 : {
314 765 : visit_outer_attrs (expr);
315 765 : reseat (expr.get_array_expr_ptr ());
316 765 : reseat (expr.get_index_expr_ptr ());
317 765 : }
318 :
319 : void
320 565 : PointerVisitor::visit (AST::TupleExpr &expr)
321 : {
322 565 : visit_outer_attrs (expr);
323 565 : visit_inner_attrs (expr);
324 1548 : for (auto &elem : expr.get_tuple_elems ())
325 983 : reseat (elem);
326 565 : }
327 :
328 : void
329 2801 : PointerVisitor::visit (AST::TupleIndexExpr &expr)
330 : {
331 2801 : visit_outer_attrs (expr);
332 2801 : reseat (expr.get_tuple_expr_ptr ());
333 2801 : }
334 :
335 : void
336 81 : PointerVisitor::visit (AST::StructExprStruct &expr)
337 : {
338 81 : visit_outer_attrs (expr);
339 81 : visit_inner_attrs (expr);
340 81 : visit (expr.get_struct_name ());
341 81 : }
342 :
343 : void
344 648 : PointerVisitor::visit (AST::StructExprFieldIdentifier &field)
345 648 : {}
346 :
347 : void
348 6535 : PointerVisitor::visit (AST::StructExprFieldIdentifierValue &field)
349 : {
350 6535 : reseat (field.get_value_ptr ());
351 6535 : }
352 :
353 : void
354 132 : PointerVisitor::visit (AST::StructExprFieldIndexValue &field)
355 : {
356 132 : reseat (field.get_value_ptr ());
357 132 : }
358 :
359 : void
360 189 : PointerVisitor::visit (AST::StructBase &base)
361 : {
362 189 : reseat (base.get_base_struct_ptr ());
363 189 : }
364 :
365 : void
366 4235 : PointerVisitor::visit (AST::StructExprStructFields &expr)
367 : {
368 4235 : visit_outer_attrs (expr);
369 4235 : visit_inner_attrs (expr);
370 4235 : visit (expr.get_struct_name ());
371 4235 : if (expr.has_struct_base ())
372 189 : visit (expr.get_struct_base ());
373 11550 : for (auto &field : expr.get_fields ())
374 7315 : visit (field);
375 4235 : }
376 :
377 : void
378 0 : PointerVisitor::visit (AST::StructExprStructBase &expr)
379 : {
380 0 : visit_outer_attrs (expr);
381 0 : visit_inner_attrs (expr);
382 0 : visit (expr.get_struct_name ());
383 0 : visit (expr.get_struct_base ());
384 0 : }
385 :
386 : void
387 11118 : PointerVisitor::visit (AST::CallExpr &expr)
388 : {
389 11118 : visit_outer_attrs (expr);
390 11118 : reseat (expr.get_function_expr_ptr ());
391 24320 : for (auto ¶m : expr.get_params ())
392 13202 : reseat (param);
393 11118 : }
394 :
395 : void
396 9147 : PointerVisitor::visit (AST::MethodCallExpr &expr)
397 : {
398 9147 : visit_outer_attrs (expr);
399 9147 : reseat (expr.get_receiver_expr_ptr ());
400 9147 : visit (expr.get_method_name ());
401 15264 : for (auto ¶m : expr.get_params ())
402 6117 : reseat (param);
403 9147 : }
404 :
405 : void
406 13613 : PointerVisitor::visit (AST::FieldAccessExpr &expr)
407 : {
408 13613 : visit_outer_attrs (expr);
409 13613 : reseat (expr.get_receiver_expr_ptr ());
410 13613 : }
411 :
412 : void
413 37 : PointerVisitor::visit (AST::ClosureExprInner &expr)
414 : {
415 37 : visit_outer_attrs (expr);
416 :
417 : // TODO: Actually we need to handle macro invocations as closure parameters so
418 : // this needs to be a reseat
419 63 : for (auto ¶m : expr.get_params ())
420 26 : visit (param);
421 :
422 37 : reseat (expr.get_definition_expr_ptr ());
423 37 : }
424 :
425 : void
426 22122 : PointerVisitor::visit (AST::BlockExpr &expr)
427 : {
428 22122 : visit_outer_attrs (expr);
429 22122 : visit_inner_attrs (expr);
430 :
431 22122 : if (expr.has_label ())
432 0 : visit (expr.get_label ());
433 :
434 44603 : for (auto &stmt : expr.get_statements ())
435 22481 : reseat (stmt);
436 :
437 22122 : if (expr.has_tail_expr ())
438 16052 : reseat (expr.get_tail_expr_ptr ());
439 22122 : }
440 :
441 : void
442 38 : PointerVisitor::visit (AST::ConstBlock &expr)
443 : {
444 38 : visit (expr.get_const_expr ());
445 38 : }
446 :
447 : void
448 2278 : PointerVisitor::visit (AST::AnonConst &expr)
449 : {
450 2278 : if (!expr.is_deferred ())
451 2252 : reseat (expr.get_inner_expr_ptr ());
452 2278 : }
453 :
454 : void
455 30 : PointerVisitor::visit (AST::ClosureExprInnerTyped &expr)
456 : {
457 30 : visit_outer_attrs (expr);
458 :
459 : // TODO: Same as ClosureExprInner
460 67 : for (auto ¶m : expr.get_params ())
461 37 : visit (param);
462 :
463 30 : reseat (expr.get_return_type_ptr ());
464 :
465 30 : reseat (expr.get_definition_expr_ptr ());
466 30 : }
467 :
468 : void
469 63 : PointerVisitor::visit (AST::ClosureParam ¶m)
470 : {
471 63 : visit_outer_attrs (param);
472 63 : reseat (param.get_pattern_ptr ());
473 63 : if (param.has_type_given ())
474 58 : reseat (param.get_type_ptr ());
475 63 : }
476 :
477 : void
478 17 : PointerVisitor::visit (AST::ContinueExpr &expr)
479 : {
480 17 : visit_outer_attrs (expr);
481 17 : if (expr.has_label ())
482 3 : visit (expr.get_label_unchecked ());
483 17 : }
484 :
485 : void
486 265 : PointerVisitor::visit (AST::BreakExpr &expr)
487 : {
488 265 : visit_outer_attrs (expr);
489 265 : if (expr.has_label ())
490 69 : visit (expr.get_label_unchecked ());
491 :
492 265 : if (expr.has_break_expr ())
493 66 : reseat (expr.get_break_expr_ptr_unchecked ());
494 265 : }
495 :
496 : void
497 246 : PointerVisitor::visit (AST::RangeFromToExpr &expr)
498 : {
499 246 : reseat (expr.get_from_expr_ptr ());
500 246 : reseat (expr.get_to_expr_ptr ());
501 246 : }
502 :
503 : void
504 21 : PointerVisitor::visit (AST::RangeFromExpr &expr)
505 : {
506 21 : reseat (expr.get_from_expr_ptr ());
507 21 : }
508 :
509 : void
510 21 : PointerVisitor::visit (AST::RangeToExpr &expr)
511 : {
512 21 : reseat (expr.get_to_expr_ptr ());
513 21 : }
514 :
515 : void
516 0 : PointerVisitor::visit (AST::RangeFullExpr &expr)
517 0 : {}
518 :
519 : void
520 21 : PointerVisitor::visit (AST::RangeFromToInclExpr &expr)
521 : {
522 21 : reseat (expr.get_from_expr_ptr ());
523 21 : reseat (expr.get_to_expr_ptr ());
524 21 : }
525 :
526 : void
527 0 : PointerVisitor::visit (AST::RangeToInclExpr &expr)
528 : {
529 0 : reseat (expr.get_to_expr_ptr ());
530 0 : }
531 :
532 : void
533 1626 : PointerVisitor::visit (AST::ReturnExpr &expr)
534 : {
535 1626 : visit_outer_attrs (expr);
536 1626 : if (expr.has_returned_expr ())
537 1523 : reseat (expr.get_returned_expr_ptr ());
538 1626 : }
539 :
540 : void
541 2 : PointerVisitor::visit (AST::TryExpr &expr)
542 : {
543 2 : visit_outer_attrs (expr);
544 2 : reseat (expr.get_block_expr_ptr ());
545 2 : }
546 :
547 : void
548 3 : PointerVisitor::visit (AST::BoxExpr &expr)
549 : {
550 3 : visit_outer_attrs (expr);
551 3 : reseat (expr.get_boxed_expr_ptr ());
552 3 : }
553 :
554 : void
555 11553 : PointerVisitor::visit (AST::UnsafeBlockExpr &expr)
556 : {
557 11553 : visit_outer_attrs (expr);
558 11553 : reseat (expr.get_block_expr_ptr ());
559 11553 : }
560 :
561 : void
562 189 : PointerVisitor::visit (AST::LoopLabel &label)
563 : {
564 189 : visit (label.get_lifetime ());
565 189 : }
566 :
567 : void
568 373 : PointerVisitor::visit (AST::LoopExpr &expr)
569 : {
570 373 : visit_outer_attrs (expr);
571 373 : if (expr.has_loop_label ())
572 114 : visit (expr.get_loop_label ());
573 373 : reseat (expr.get_loop_block_ptr ());
574 373 : }
575 :
576 : void
577 298 : PointerVisitor::visit (AST::WhileLoopExpr &expr)
578 : {
579 298 : visit_outer_attrs (expr);
580 298 : if (expr.has_loop_label ())
581 6 : visit (expr.get_loop_label ());
582 298 : reseat (expr.get_predicate_expr_ptr ());
583 298 : reseat (expr.get_loop_block_ptr ());
584 298 : }
585 :
586 : void
587 4 : PointerVisitor::visit (AST::WhileLetLoopExpr &expr)
588 : {
589 4 : visit_outer_attrs (expr);
590 4 : reseat (expr.get_pattern ());
591 :
592 4 : if (expr.has_loop_label ())
593 0 : visit (expr.get_loop_label ());
594 :
595 4 : reseat (expr.get_scrutinee_expr_ptr ());
596 4 : reseat (expr.get_loop_block_ptr ());
597 4 : }
598 :
599 : void
600 64 : PointerVisitor::visit (AST::ForLoopExpr &expr)
601 : {
602 64 : visit_outer_attrs (expr);
603 64 : reseat (expr.get_pattern_ptr ());
604 64 : reseat (expr.get_iterator_expr_ptr ());
605 64 : if (expr.has_loop_label ())
606 0 : visit (expr.get_loop_label ());
607 64 : reseat (expr.get_loop_block_ptr ());
608 64 : }
609 :
610 : void
611 1687 : PointerVisitor::visit (AST::IfExpr &expr)
612 : {
613 1687 : visit_outer_attrs (expr);
614 1687 : reseat (expr.get_condition_expr_ptr ());
615 1687 : visit (expr.get_if_block ());
616 1687 : }
617 :
618 : void
619 1207 : PointerVisitor::visit (AST::IfExprConseqElse &expr)
620 : {
621 1207 : visit (reinterpret_cast<AST::IfExpr &> (expr));
622 1207 : visit (expr.get_else_block ());
623 1207 : }
624 :
625 : void
626 30 : PointerVisitor::visit (AST::IfLetExpr &expr)
627 : {
628 30 : visit_outer_attrs (expr);
629 30 : reseat (expr.get_pattern ());
630 30 : reseat (expr.get_value_expr_ptr ());
631 30 : visit (expr.get_if_block ());
632 30 : }
633 :
634 : void
635 12 : PointerVisitor::visit (AST::IfLetExprConseqElse &expr)
636 : {
637 12 : visit (reinterpret_cast<AST::IfLetExpr &> (expr));
638 12 : visit (expr.get_else_block ());
639 12 : }
640 :
641 : void
642 8384 : PointerVisitor::visit (AST::MatchArm &arm)
643 : {
644 8384 : visit_outer_attrs (arm);
645 8384 : reseat (arm.get_pattern ());
646 8384 : if (arm.has_match_arm_guard ())
647 3 : reseat (arm.get_guard_expr_ptr ());
648 8384 : }
649 :
650 : void
651 8384 : PointerVisitor::visit (AST::MatchCase &arm)
652 : {
653 8384 : visit (arm.get_arm ());
654 8384 : reseat (arm.get_expr_ptr ());
655 8384 : }
656 :
657 : void
658 3609 : PointerVisitor::visit (AST::MatchExpr &expr)
659 : {
660 3609 : visit_outer_attrs (expr);
661 3609 : visit_inner_attrs (expr);
662 3609 : reseat (expr.get_scrutinee_expr_ptr ());
663 11993 : for (auto &arm : expr.get_match_cases ())
664 8384 : visit (arm);
665 3609 : }
666 :
667 : void
668 0 : PointerVisitor::visit (AST::AwaitExpr &expr)
669 : {
670 0 : visit_outer_attrs (expr);
671 0 : reseat (expr.get_awaited_expr ());
672 0 : }
673 :
674 : void
675 0 : PointerVisitor::visit (AST::AsyncBlockExpr &expr)
676 : {
677 0 : visit_outer_attrs (expr);
678 0 : reseat (expr.get_block_expr ());
679 0 : }
680 :
681 : void
682 54 : PointerVisitor::visit (AST::InlineAsm &expr)
683 : {
684 54 : visit_outer_attrs (expr);
685 54 : using RegisterType = AST::InlineAsmOperand::RegisterType;
686 112 : for (auto &operand : expr.get_operands ())
687 : {
688 58 : switch (operand.get_register_type ())
689 : {
690 20 : case RegisterType::In:
691 20 : {
692 20 : reseat (operand.get_in ().expr);
693 20 : break;
694 : }
695 34 : case RegisterType::Out:
696 34 : {
697 34 : reseat (operand.get_out ().expr);
698 34 : break;
699 : }
700 0 : case RegisterType::InOut:
701 0 : {
702 0 : reseat (operand.get_in_out ().expr);
703 0 : break;
704 : }
705 4 : case RegisterType::SplitInOut:
706 4 : {
707 4 : auto split = operand.get_split_in_out ();
708 4 : reseat (split.in_expr);
709 4 : reseat (split.out_expr);
710 4 : break;
711 4 : }
712 0 : case RegisterType::Const:
713 0 : {
714 0 : reseat (operand.get_const ().anon_const.get_inner_expr_ptr ());
715 0 : break;
716 : }
717 0 : case RegisterType::Sym:
718 0 : {
719 0 : reseat (operand.get_sym ().expr);
720 0 : break;
721 : }
722 0 : case RegisterType::Label:
723 0 : {
724 0 : reseat (operand.get_label ().expr);
725 0 : break;
726 : }
727 : }
728 54 : }
729 54 : }
730 :
731 : void
732 4 : PointerVisitor::visit (AST::LlvmInlineAsm &expr)
733 : {
734 4 : for (auto &output : expr.get_outputs ())
735 0 : reseat (output.expr);
736 :
737 8 : for (auto &input : expr.get_inputs ())
738 4 : reseat (input.expr);
739 4 : }
740 :
741 : void
742 8001 : PointerVisitor::visit (AST::TypeParam ¶m)
743 : {
744 8001 : visit_outer_attrs (param);
745 : // FIXME: Can we do macro expansion here?
746 8751 : for (auto &bound : param.get_type_param_bounds ())
747 750 : visit (bound);
748 8001 : if (param.has_type ())
749 354 : reseat (param.get_type_ptr ());
750 8001 : }
751 :
752 : void
753 2 : PointerVisitor::visit (AST::LifetimeWhereClauseItem &item)
754 : {
755 2 : visit (item.get_lifetime ());
756 4 : for (auto &bound : item.get_lifetime_bounds ())
757 2 : visit (bound);
758 2 : }
759 :
760 : void
761 296 : PointerVisitor::visit (AST::TypeBoundWhereClauseItem &item)
762 : {
763 305 : for (auto &lifetime : item.get_for_lifetimes ())
764 9 : visit (lifetime);
765 296 : reseat (item.get_type_ptr ());
766 : // FIXME: Likewise?
767 592 : for (auto ¶m : item.get_type_param_bounds ())
768 296 : visit (param);
769 296 : }
770 :
771 : void
772 46050 : PointerVisitor::visit (AST::Visibility &vis)
773 : {
774 46050 : if (vis.has_path ())
775 65 : visit (vis.get_path ());
776 46050 : }
777 :
778 : void
779 288 : PointerVisitor::visit (AST::WhereClause &where)
780 : {
781 586 : for (auto &item : where.get_items ())
782 298 : visit (item);
783 288 : }
784 :
785 : void
786 10733 : PointerVisitor::visit (AST::FunctionParam ¶m)
787 : {
788 10733 : visit_outer_attrs (param);
789 10733 : if (param.has_name ())
790 10733 : reseat (param.get_pattern_ptr ());
791 :
792 10733 : reseat (param.get_type_ptr ());
793 10733 : }
794 :
795 : void
796 8031 : PointerVisitor::visit (AST::SelfParam ¶m)
797 : {
798 8031 : visit_outer_attrs (param);
799 :
800 8031 : if (param.has_lifetime ())
801 4625 : visit (param.get_lifetime ());
802 :
803 8031 : if (param.has_type ())
804 1 : reseat (param.get_type_ptr ());
805 8031 : }
806 :
807 : void
808 1216 : PointerVisitor::visit (AST::Module &module)
809 : {
810 1216 : visit_outer_attrs (module);
811 1216 : visit (module.get_visibility ());
812 1216 : visit_inner_attrs (module);
813 5614 : for (auto &item : module.get_items ())
814 4398 : reseat (item);
815 1216 : }
816 :
817 : void
818 24 : PointerVisitor::visit (AST::ExternCrate &crate)
819 : {
820 24 : visit_outer_attrs (crate);
821 24 : visit (crate.get_visibility ());
822 24 : }
823 :
824 : void
825 8 : PointerVisitor::visit (AST::UseTreeGlob &use_tree)
826 : {
827 8 : visit (use_tree.get_path ());
828 8 : }
829 :
830 : void
831 150 : PointerVisitor::visit (AST::UseTreeList &use_tree)
832 : {
833 150 : visit (use_tree.get_path ());
834 150 : }
835 :
836 : void
837 497 : PointerVisitor::visit (AST::UseTreeRebind &use_tree)
838 : {
839 497 : visit (use_tree.get_path ());
840 497 : }
841 :
842 : void
843 655 : PointerVisitor::visit (AST::UseDeclaration &use_decl)
844 : {
845 655 : visit (use_decl.get_visibility ());
846 655 : visit (use_decl.get_tree ());
847 655 : }
848 :
849 : void
850 18131 : PointerVisitor::visit_function_params (AST::Function &function)
851 : {
852 37732 : for (auto ¶m : function.get_function_params ())
853 19601 : visit (param);
854 18131 : }
855 :
856 : void
857 18131 : PointerVisitor::visit (AST::Function &function)
858 : {
859 18131 : visit_outer_attrs (function);
860 18131 : visit (function.get_visibility ());
861 18131 : visit (function.get_qualifiers ());
862 19711 : for (auto &generic : function.get_generic_params ())
863 1580 : visit (generic);
864 :
865 18131 : visit_function_params (function);
866 :
867 18131 : if (function.has_return_type ())
868 12744 : reseat (function.get_return_type_ptr ());
869 18131 : if (function.has_where_clause ())
870 195 : visit (function.get_where_clause ());
871 18131 : if (function.has_body ())
872 14216 : reseat (*function.get_definition ());
873 18131 : }
874 :
875 : void
876 4469 : PointerVisitor::visit (AST::TypeAlias &type_alias)
877 : {
878 4469 : visit_outer_attrs (type_alias);
879 4469 : visit (type_alias.get_visibility ());
880 4523 : for (auto &generic : type_alias.get_generic_params ())
881 54 : visit (generic);
882 4469 : if (type_alias.has_where_clause ())
883 0 : visit (type_alias.get_where_clause ());
884 4469 : reseat (type_alias.get_type_aliased_ptr ());
885 4469 : }
886 :
887 : void
888 2285 : PointerVisitor::visit (AST::StructField &field)
889 : {
890 2285 : visit_outer_attrs (field);
891 2285 : visit (field.get_visibility ());
892 2285 : reseat (field.get_field_type_ptr ());
893 2285 : }
894 :
895 : void
896 1535 : PointerVisitor::visit (AST::StructStruct &struct_item)
897 : {
898 1535 : visit_outer_attrs (struct_item);
899 1535 : visit (struct_item.get_visibility ());
900 2046 : for (auto &generic : struct_item.get_generic_params ())
901 511 : visit (generic);
902 1535 : if (struct_item.has_where_clause ())
903 2 : visit (struct_item.get_where_clause ());
904 3367 : for (auto &field : struct_item.get_fields ())
905 1832 : visit (field);
906 1535 : }
907 :
908 : void
909 2089 : PointerVisitor::visit (AST::TupleField &field)
910 : {
911 2089 : visit_outer_attrs (field);
912 2089 : visit (field.get_visibility ());
913 2089 : reseat (field.get_field_type_ptr ());
914 2089 : }
915 :
916 : void
917 963 : PointerVisitor::visit (AST::TupleStruct &tuple_struct)
918 : {
919 963 : visit_outer_attrs (tuple_struct);
920 963 : visit (tuple_struct.get_visibility ());
921 1332 : for (auto &generic : tuple_struct.get_generic_params ())
922 369 : visit (generic);
923 963 : if (tuple_struct.has_where_clause ())
924 0 : visit (tuple_struct.get_where_clause ());
925 2591 : for (auto &field : tuple_struct.get_fields ())
926 1628 : visit (field);
927 963 : }
928 :
929 : void
930 1244 : PointerVisitor::visit (AST::EnumItem &item)
931 : {
932 1244 : visit_outer_attrs (item);
933 1244 : visit (item.get_visibility ());
934 1244 : }
935 :
936 : void
937 436 : PointerVisitor::visit (AST::EnumItemTuple &item)
938 : {
939 436 : PointerVisitor::visit (static_cast<EnumItem &> (item));
940 897 : for (auto &field : item.get_tuple_fields ())
941 461 : visit (field);
942 436 : }
943 :
944 : void
945 91 : PointerVisitor::visit (AST::EnumItemStruct &item)
946 : {
947 91 : PointerVisitor::visit (static_cast<EnumItem &> (item));
948 240 : for (auto &field : item.get_struct_fields ())
949 149 : visit (field);
950 91 : }
951 :
952 : void
953 273 : PointerVisitor::visit (AST::EnumItemDiscriminant &item)
954 : {
955 273 : PointerVisitor::visit (static_cast<EnumItem &> (item));
956 273 : reseat (item.get_expr_ptr ());
957 273 : }
958 :
959 : void
960 1827 : PointerVisitor::visit (AST::Enum &enum_item)
961 : {
962 1827 : visit_outer_attrs (enum_item);
963 1827 : visit (enum_item.get_visibility ());
964 2847 : for (auto &generic : enum_item.get_generic_params ())
965 1020 : visit (generic);
966 1827 : if (enum_item.has_where_clause ())
967 0 : visit (enum_item.get_where_clause ());
968 6094 : for (auto &item : enum_item.get_variants ())
969 4267 : visit (item);
970 1827 : }
971 :
972 : void
973 104 : PointerVisitor::visit (AST::Union &union_item)
974 : {
975 104 : visit_outer_attrs (union_item);
976 104 : visit (union_item.get_visibility ());
977 179 : for (auto &generic : union_item.get_generic_params ())
978 75 : visit (generic);
979 104 : if (union_item.has_where_clause ())
980 0 : visit (union_item.get_where_clause ());
981 408 : for (auto &variant : union_item.get_variants ())
982 304 : visit (variant);
983 104 : }
984 :
985 : void
986 571 : PointerVisitor::visit (AST::ConstantItem &const_item)
987 : {
988 571 : visit_outer_attrs (const_item);
989 571 : visit (const_item.get_visibility ());
990 571 : reseat (const_item.get_type_ptr ());
991 571 : if (const_item.has_expr ())
992 540 : reseat (const_item.get_expr_ptr ());
993 571 : }
994 :
995 : void
996 54 : PointerVisitor::visit (AST::StaticItem &static_item)
997 : {
998 54 : visit_outer_attrs (static_item);
999 54 : visit (static_item.get_visibility ());
1000 54 : reseat (static_item.get_type_ptr ());
1001 54 : reseat (static_item.get_expr_ptr ());
1002 54 : }
1003 :
1004 : void
1005 2573 : PointerVisitor::visit (AST::TraitItemType &item)
1006 : {
1007 2573 : visit_outer_attrs (item);
1008 2754 : for (auto &bound : item.get_type_param_bounds ())
1009 181 : visit (bound);
1010 2573 : }
1011 :
1012 : void
1013 3722 : PointerVisitor::visit (AST::Trait &trait)
1014 : {
1015 3722 : visit_outer_attrs (trait);
1016 3722 : visit (trait.get_visibility ());
1017 :
1018 3722 : visit_inner_attrs (trait);
1019 :
1020 3722 : visit (trait.get_implicit_self ());
1021 :
1022 4381 : for (auto &generic : trait.get_generic_params ())
1023 659 : visit (generic);
1024 :
1025 3722 : if (trait.has_where_clause ())
1026 7 : visit (trait.get_where_clause ());
1027 :
1028 4331 : for (auto &bound : trait.get_type_param_bounds ())
1029 609 : visit (bound);
1030 :
1031 7058 : for (auto &item : trait.get_trait_items ())
1032 3336 : reseat (item);
1033 3722 : }
1034 :
1035 : void
1036 955 : PointerVisitor::visit (AST::InherentImpl &impl)
1037 : {
1038 955 : visit_outer_attrs (impl);
1039 955 : visit (impl.get_visibility ());
1040 :
1041 1276 : for (auto &generic : impl.get_generic_params ())
1042 321 : visit (generic);
1043 955 : if (impl.has_where_clause ())
1044 1 : visit (impl.get_where_clause ());
1045 955 : reseat (impl.get_type_ptr ());
1046 955 : visit_inner_attrs (impl);
1047 3696 : for (auto &item : impl.get_impl_items ())
1048 2741 : reseat (item);
1049 955 : }
1050 :
1051 : void
1052 4736 : PointerVisitor::visit (AST::TraitImpl &impl)
1053 : {
1054 4736 : visit_outer_attrs (impl);
1055 4736 : visit (impl.get_visibility ());
1056 :
1057 5556 : for (auto &generic : impl.get_generic_params ())
1058 820 : visit (generic);
1059 4736 : if (impl.has_where_clause ())
1060 83 : visit (impl.get_where_clause ());
1061 4736 : reseat (impl.get_type_ptr ());
1062 4736 : visit (impl.get_trait_path ());
1063 4736 : visit_inner_attrs (impl);
1064 10224 : for (auto &item : impl.get_impl_items ())
1065 5488 : reseat (item);
1066 4736 : }
1067 :
1068 : void
1069 1 : PointerVisitor::visit (AST::ExternalTypeItem &item)
1070 : {
1071 1 : visit_outer_attrs (item);
1072 1 : visit (item.get_visibility ());
1073 1 : }
1074 :
1075 : void
1076 1 : PointerVisitor::visit (AST::ExternalStaticItem &item)
1077 : {
1078 1 : visit_outer_attrs (item);
1079 1 : visit (item.get_visibility ());
1080 1 : reseat (item.get_type_ptr ());
1081 1 : }
1082 :
1083 : void
1084 1468 : PointerVisitor::visit (AST::ExternBlock &block)
1085 : {
1086 1468 : visit_outer_attrs (block);
1087 1468 : visit (block.get_visibility ());
1088 1468 : visit_inner_attrs (block);
1089 3682 : for (auto &item : block.get_extern_items ())
1090 2214 : reseat (item);
1091 1468 : }
1092 :
1093 : void
1094 924 : PointerVisitor::visit (AST::MacroMatchFragment &match)
1095 924 : {}
1096 :
1097 : void
1098 493 : PointerVisitor::visit (AST::MacroMatchRepetition &match)
1099 : {
1100 1122 : for (auto &m : match.get_matches ())
1101 629 : visit (m);
1102 493 : }
1103 :
1104 : void
1105 1113 : PointerVisitor::visit (AST::MacroMatcher &matcher)
1106 : {
1107 2460 : for (auto &m : matcher.get_matches ())
1108 1347 : visit (m);
1109 1113 : }
1110 :
1111 : void
1112 1050 : PointerVisitor::visit (AST::MacroTranscriber &transcriber)
1113 : {
1114 1050 : visit (transcriber.get_token_tree ());
1115 1050 : }
1116 :
1117 : void
1118 1050 : PointerVisitor::visit (AST::MacroRule &rule)
1119 : {
1120 1050 : visit (rule.get_matcher ());
1121 1050 : visit (rule.get_transcriber ());
1122 1050 : }
1123 :
1124 : void
1125 913 : PointerVisitor::visit (AST::MacroRulesDefinition &rules_def)
1126 : {
1127 913 : visit_outer_attrs (rules_def);
1128 1963 : for (auto &rule : rules_def.get_macro_rules ())
1129 1050 : visit (rule);
1130 913 : }
1131 :
1132 : void
1133 0 : PointerVisitor::visit (AST::MacroInvocData &data)
1134 : {
1135 0 : visit (data.get_path ());
1136 0 : visit (data.get_delim_tok_tree ());
1137 0 : }
1138 :
1139 : void
1140 0 : PointerVisitor::visit (AST::MacroInvocation ¯o_invoc)
1141 : {
1142 0 : visit_outer_attrs (macro_invoc);
1143 0 : visit (macro_invoc.get_invoc_data ());
1144 0 : }
1145 :
1146 : void
1147 0 : PointerVisitor::visit (AST::MetaItemPath &meta_item)
1148 : {
1149 0 : visit (meta_item.get_path ());
1150 0 : }
1151 :
1152 : void
1153 0 : PointerVisitor::visit (AST::MetaItemSeq &meta_item)
1154 : {
1155 0 : visit (meta_item.get_path ());
1156 0 : for (auto &inner : meta_item.get_seq ())
1157 0 : visit (inner);
1158 0 : }
1159 :
1160 : void
1161 0 : PointerVisitor::visit (AST::MetaListPaths &meta_item)
1162 : {
1163 0 : for (auto &path : meta_item.get_paths ())
1164 0 : visit (path);
1165 0 : }
1166 :
1167 : void
1168 0 : PointerVisitor::visit (AST::MetaListNameValueStr &meta_item)
1169 : {
1170 0 : for (auto &str : meta_item.get_values ())
1171 0 : visit (str);
1172 0 : }
1173 :
1174 : void
1175 80959 : PointerVisitor::visit (AST::IdentifierPattern &pattern)
1176 : {
1177 80959 : if (pattern.has_subpattern ())
1178 54 : reseat (pattern.get_subpattern_ptr ());
1179 80959 : }
1180 :
1181 : void
1182 63 : PointerVisitor::visit (AST::RangePatternBoundPath &bound)
1183 : {
1184 63 : visit (bound.get_path ());
1185 63 : }
1186 :
1187 : void
1188 0 : PointerVisitor::visit (AST::RangePatternBoundQualPath &bound)
1189 : {
1190 0 : visit (bound.get_qualified_path ());
1191 0 : }
1192 :
1193 : void
1194 163 : PointerVisitor::visit (AST::RangePattern &pattern)
1195 : {
1196 : // FIXME: So should this be reseat() instead? Can we have macro invocations as
1197 : // patterns in range patterns?
1198 163 : if (pattern.get_has_lower_bound ())
1199 163 : visit (pattern.get_lower_bound ());
1200 163 : if (pattern.get_has_upper_bound ())
1201 163 : visit (pattern.get_upper_bound ());
1202 163 : }
1203 :
1204 : void
1205 736 : PointerVisitor::visit (AST::ReferencePattern &pattern)
1206 : {
1207 736 : reseat (pattern.get_referenced_pattern_ptr ());
1208 736 : }
1209 :
1210 : void
1211 72 : PointerVisitor::visit (AST::StructPatternFieldTuplePat &field)
1212 : {
1213 72 : visit_outer_attrs (field);
1214 72 : reseat (field.get_index_pattern_ptr ());
1215 72 : }
1216 :
1217 : void
1218 545 : PointerVisitor::visit (AST::StructPatternFieldIdentPat &field)
1219 : {
1220 545 : visit_outer_attrs (field);
1221 545 : reseat (field.get_ident_pattern_ptr ());
1222 545 : }
1223 :
1224 : void
1225 100 : PointerVisitor::visit (AST::StructPatternFieldIdent &field)
1226 : {
1227 100 : visit_outer_attrs (field);
1228 100 : }
1229 :
1230 : void
1231 558 : PointerVisitor::visit (AST::StructPatternElements &spe)
1232 : {
1233 1494 : for (auto &field : spe.get_struct_pattern_fields ())
1234 936 : visit (field);
1235 558 : for (auto &attribute : spe.get_etc_outer_attrs ())
1236 : visit (attribute);
1237 558 : }
1238 :
1239 : void
1240 558 : PointerVisitor::visit (AST::StructPattern &pattern)
1241 : {
1242 558 : visit (pattern.get_path ());
1243 558 : visit (pattern.get_struct_pattern_elems ());
1244 558 : }
1245 :
1246 : void
1247 1052 : PointerVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
1248 : {
1249 2224 : for (auto &pattern : tuple_items.get_patterns ())
1250 1172 : reseat (pattern);
1251 1052 : }
1252 :
1253 : void
1254 39 : PointerVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
1255 : {
1256 70 : for (auto &lower : tuple_items.get_lower_patterns ())
1257 31 : reseat (lower);
1258 58 : for (auto &upper : tuple_items.get_upper_patterns ())
1259 19 : reseat (upper);
1260 39 : }
1261 :
1262 : void
1263 3725 : PointerVisitor::visit (AST::TupleStructPattern &pattern)
1264 : {
1265 3725 : visit (pattern.get_path ());
1266 3725 : visit (pattern.get_items ());
1267 3725 : }
1268 :
1269 : void
1270 427 : PointerVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
1271 : {
1272 1301 : for (auto &pattern : tuple_items.get_patterns ())
1273 874 : reseat (pattern);
1274 427 : }
1275 :
1276 : void
1277 27 : PointerVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
1278 : {
1279 55 : for (auto &lower : tuple_items.get_lower_patterns ())
1280 28 : reseat (lower);
1281 59 : for (auto &upper : tuple_items.get_upper_patterns ())
1282 32 : reseat (upper);
1283 27 : }
1284 :
1285 : void
1286 1680 : PointerVisitor::visit (AST::TuplePattern &pattern)
1287 : {
1288 1680 : visit (pattern.get_items ());
1289 1680 : }
1290 :
1291 : void
1292 44 : PointerVisitor::visit (AST::GroupedPattern &pattern)
1293 : {
1294 44 : reseat (pattern.get_pattern_in_parens_ptr ());
1295 44 : }
1296 :
1297 : void
1298 32 : PointerVisitor::visit (AST::SlicePatternItemsNoRest &items)
1299 : {
1300 96 : for (auto &item : items.get_patterns ())
1301 64 : reseat (item);
1302 32 : }
1303 :
1304 : void
1305 44 : PointerVisitor::visit (AST::SlicePatternItemsHasRest &items)
1306 : {
1307 87 : for (auto &item : items.get_lower_patterns ())
1308 43 : reseat (item);
1309 87 : for (auto &item : items.get_upper_patterns ())
1310 43 : reseat (item);
1311 44 : }
1312 :
1313 : void
1314 228 : PointerVisitor::visit (AST::SlicePattern &pattern)
1315 : {
1316 228 : visit (pattern.get_items ());
1317 228 : }
1318 :
1319 : void
1320 191 : PointerVisitor::visit (AST::AltPattern &pattern)
1321 : {
1322 591 : for (auto &alt : pattern.get_alts ())
1323 400 : reseat (alt);
1324 191 : }
1325 :
1326 : void
1327 208 : PointerVisitor::visit (AST::EmptyStmt &stmt)
1328 208 : {}
1329 :
1330 : void
1331 12686 : PointerVisitor::visit (AST::LetStmt &stmt)
1332 : {
1333 12686 : visit_outer_attrs (stmt);
1334 12686 : reseat (stmt.get_pattern_ptr ());
1335 12686 : if (stmt.has_type ())
1336 2096 : reseat (stmt.get_type_ptr ());
1337 12686 : if (stmt.has_init_expr ())
1338 11540 : reseat (stmt.get_init_expr_ptr ());
1339 12686 : }
1340 :
1341 : void
1342 9305 : PointerVisitor::visit (AST::ExprStmt &stmt)
1343 : {
1344 9305 : reseat (stmt.get_expr_ptr ());
1345 9305 : }
1346 :
1347 : void
1348 7187 : PointerVisitor::visit (AST::TraitBound &bound)
1349 : {
1350 7229 : for (auto &lifetime : bound.get_for_lifetimes ())
1351 42 : visit (lifetime);
1352 7187 : visit (bound.get_type_path ());
1353 7187 : }
1354 :
1355 : void
1356 0 : PointerVisitor::visit (AST::ImplTraitType &type)
1357 : {
1358 0 : for (auto &bound : type.get_type_param_bounds ())
1359 0 : visit (bound);
1360 0 : }
1361 :
1362 : void
1363 39 : PointerVisitor::visit (AST::TraitObjectType &type)
1364 : {
1365 138 : for (auto &bound : type.get_type_param_bounds ())
1366 99 : visit (bound);
1367 39 : }
1368 :
1369 : void
1370 23 : PointerVisitor::visit (AST::ParenthesisedType &type)
1371 : {
1372 23 : reseat (type.get_type_in_parens ());
1373 23 : }
1374 :
1375 : void
1376 393 : PointerVisitor::visit (AST::ImplTraitTypeOneBound &type)
1377 : {
1378 : // FIXME: Do we need to reseat here?
1379 393 : visit (type.get_trait_bound ());
1380 393 : }
1381 :
1382 : void
1383 468 : PointerVisitor::visit (AST::TraitObjectTypeOneBound &type)
1384 : {
1385 : // FIXME: Do we need to reseat here?
1386 468 : visit (type.get_trait_bound ());
1387 468 : }
1388 :
1389 : void
1390 1409 : PointerVisitor::visit (AST::TupleType &type)
1391 : {
1392 3640 : for (auto &elem : type.get_elems ())
1393 2231 : reseat (elem);
1394 1409 : }
1395 :
1396 : void
1397 190 : PointerVisitor::visit (AST::NeverType &type)
1398 190 : {}
1399 :
1400 : void
1401 21298 : PointerVisitor::visit (AST::RawPointerType &type)
1402 : {
1403 21298 : reseat (type.get_type_pointed_to_ptr ());
1404 21298 : }
1405 :
1406 : void
1407 15216 : PointerVisitor::visit (AST::ReferenceType &type)
1408 : {
1409 15216 : visit (type.get_lifetime ());
1410 15216 : reseat (type.get_type_ptr ());
1411 15216 : }
1412 :
1413 : void
1414 2240 : PointerVisitor::visit (AST::ArrayType &type)
1415 : {
1416 2240 : reseat (type.get_elem_type_ptr ());
1417 2240 : visit (type.get_size_expr ());
1418 2240 : }
1419 :
1420 : void
1421 2593 : PointerVisitor::visit (AST::SliceType &type)
1422 : {
1423 2593 : reseat (type.get_elem_type_ptr ());
1424 2593 : }
1425 :
1426 : void
1427 726 : PointerVisitor::visit (AST::InferredType &type)
1428 726 : {}
1429 :
1430 : void
1431 48 : PointerVisitor::visit (AST::MaybeNamedParam ¶m)
1432 : {
1433 48 : visit_outer_attrs (param);
1434 48 : reseat (param.get_type_ptr ());
1435 48 : }
1436 :
1437 : void
1438 63 : PointerVisitor::visit (AST::BareFunctionType &type)
1439 : {
1440 66 : for (auto &lifetime : type.get_for_lifetimes ())
1441 3 : visit (lifetime);
1442 63 : visit (type.get_function_qualifiers ());
1443 111 : for (auto ¶m : type.get_function_params ())
1444 48 : visit (param);
1445 63 : if (type.is_variadic ())
1446 0 : for (auto attr : type.get_variadic_attr ())
1447 0 : visit (attr);
1448 63 : if (type.has_return_type ())
1449 48 : reseat (type.get_return_type_ptr ());
1450 63 : }
1451 :
1452 : void
1453 0 : PointerVisitor::visit (AST::FormatArgs &)
1454 : {
1455 : // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1456 0 : }
1457 :
1458 : void
1459 30 : PointerVisitor::visit (AST::OffsetOf &offset_of)
1460 : {
1461 30 : reseat (offset_of.get_type_ptr ());
1462 30 : }
1463 :
1464 : void
1465 837 : PointerVisitor::visit (AST::VariadicParam ¶m)
1466 : {
1467 837 : if (param.has_pattern ())
1468 11 : reseat (param.get_pattern_ptr ());
1469 837 : }
1470 :
1471 : } // namespace AST
1472 : } // namespace Rust
|
