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 15947 : PointerVisitor::visit (AST::Crate &crate)
28 : {
29 15947 : visit_inner_attrs (crate);
30 86541 : for (auto &item : crate.items)
31 70594 : reseat (item);
32 15947 : }
33 :
34 : void
35 6415 : 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 13490 : for (auto &item : input.get_items ())
41 7075 : visit (item);
42 6415 : }
43 :
44 : void
45 4168887 : PointerVisitor::visit (AST::IdentifierExpr &ident_expr)
46 : {
47 4168887 : visit_outer_attrs (ident_expr);
48 4168887 : }
49 :
50 : void
51 41814 : PointerVisitor::visit (AST::LifetimeParam &lifetime_param)
52 : {
53 41814 : visit_outer_attrs (lifetime_param);
54 :
55 : // Nothing to do for lifetimes right?
56 41814 : }
57 :
58 : void
59 3014 : PointerVisitor::visit (AST::ConstGenericParam &const_param)
60 : {
61 3014 : visit_outer_attrs (const_param);
62 3014 : if (const_param.has_type ())
63 3014 : reseat (const_param.get_type_ptr ());
64 :
65 3014 : if (const_param.has_default_value ())
66 54 : visit (const_param.get_default_value_unchecked ());
67 3014 : }
68 :
69 : void
70 2602741 : PointerVisitor::visit (AST::PathInExpression &path)
71 : {
72 2602741 : visit_outer_attrs (path);
73 :
74 2602741 : if (!path.is_lang_item ())
75 5586669 : for (auto &segment : path.get_segments ())
76 2991900 : visit (segment);
77 2602741 : }
78 :
79 : void
80 9352 : PointerVisitor::visit (GenericArgsBinding &binding)
81 : {
82 9352 : reseat (binding.get_type_ptr ());
83 9352 : }
84 :
85 : void
86 495484 : PointerVisitor::visit (AST::TypePathSegmentGeneric &segment)
87 : {
88 495484 : if (segment.has_generic_args ())
89 495481 : visit (segment.get_generic_args ());
90 495484 : }
91 :
92 : void
93 18205 : PointerVisitor::visit (AST::TypePathFunction &tpf)
94 : {
95 43501 : for (auto &input : tpf.get_params ())
96 25296 : reseat (input);
97 18205 : if (tpf.has_return_type ())
98 17589 : reseat (tpf.get_return_type_ptr ());
99 18205 : }
100 :
101 : void
102 18205 : PointerVisitor::visit (AST::TypePathSegmentFunction &segment)
103 : {
104 : // FIXME: No reseating here correct? No macros possible or desugar?
105 18205 : visit (segment.get_type_path_function ());
106 18205 : visit (segment.get_ident_segment ());
107 18205 : }
108 :
109 : void
110 515053 : 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 1021088 : for (auto &generic : args.get_generic_args ())
119 506035 : visit (generic);
120 :
121 524405 : for (auto &binding : args.get_binding_args ())
122 9352 : visit (binding);
123 515053 : }
124 :
125 : void
126 4790595 : PointerVisitor::visit (AST::PathExprSegment &segment)
127 : {
128 4790595 : visit (segment.get_ident_segment ());
129 4790595 : if (segment.has_generic_args ())
130 19572 : visit (segment.get_generic_args ());
131 4790595 : }
132 : void
133 4757867 : PointerVisitor::visit (AST::TypePath &path)
134 : {
135 9847263 : for (auto &segment : path.get_segments ())
136 5089396 : visit (segment);
137 4757867 : }
138 :
139 : void
140 3833 : PointerVisitor::visit (AST::QualifiedPathInExpression &path)
141 : {
142 3833 : visit_outer_attrs (path);
143 3833 : visit (path.get_qualified_path_type ());
144 :
145 7666 : for (auto &segment : path.get_segments ())
146 3833 : visit (segment);
147 3833 : }
148 :
149 : void
150 110435 : PointerVisitor::visit (AST::QualifiedPathType &path)
151 : {
152 110435 : reseat (path.get_type_ptr ());
153 110435 : if (path.has_as_clause ())
154 107693 : visit (path.get_as_type_path ());
155 110435 : }
156 :
157 : void
158 0 : PointerVisitor::visit (AST::MetaItemPathExpr &meta_item)
159 : {
160 0 : visit (meta_item.get_path ());
161 0 : reseat (meta_item.get_expr_ptr ());
162 0 : }
163 :
164 : void
165 208505 : PointerVisitor::visit (AST::BorrowExpr &expr)
166 : {
167 208505 : visit_outer_attrs (expr);
168 208505 : reseat (expr.get_borrowed_expr_ptr ());
169 208505 : }
170 :
171 : void
172 375216 : PointerVisitor::visit (AST::DereferenceExpr &expr)
173 : {
174 375216 : visit_outer_attrs (expr);
175 375216 : reseat (expr.get_dereferenced_expr_ptr ());
176 375216 : }
177 :
178 : void
179 13482 : PointerVisitor::visit (AST::ErrorPropagationExpr &expr)
180 : {
181 13482 : visit_outer_attrs (expr);
182 13482 : reseat (expr.get_propagating_expr_ptr ());
183 13482 : }
184 :
185 : void
186 63039 : PointerVisitor::visit (AST::NegationExpr &expr)
187 : {
188 63039 : visit_outer_attrs (expr);
189 63039 : reseat (expr.get_negated_expr_ptr ());
190 63039 : }
191 :
192 : void
193 2410366 : PointerVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
194 : {
195 2410366 : visit_outer_attrs (expr);
196 2410366 : reseat (expr.get_left_expr_ptr ());
197 2410366 : reseat (expr.get_right_expr_ptr ());
198 2410366 : }
199 :
200 : void
201 192380 : PointerVisitor::visit (AST::ComparisonExpr &expr)
202 : {
203 192380 : visit_outer_attrs (expr);
204 192380 : reseat (expr.get_left_expr_ptr ());
205 192380 : reseat (expr.get_right_expr_ptr ());
206 192380 : }
207 :
208 : void
209 51295 : PointerVisitor::visit (AST::LazyBooleanExpr &expr)
210 : {
211 51295 : visit_outer_attrs (expr);
212 51295 : reseat (expr.get_left_expr_ptr ());
213 51295 : reseat (expr.get_right_expr_ptr ());
214 51295 : }
215 :
216 : void
217 265235 : PointerVisitor::visit (AST::TypeCastExpr &expr)
218 : {
219 265235 : visit_outer_attrs (expr);
220 265235 : reseat (expr.get_casted_expr_ptr ());
221 265235 : reseat (expr.get_type_to_cast_to_ptr ());
222 265235 : }
223 :
224 : void
225 82490 : PointerVisitor::visit (AST::AssignmentExpr &expr)
226 : {
227 82490 : visit_outer_attrs (expr);
228 82490 : reseat (expr.get_left_expr_ptr ());
229 82490 : reseat (expr.get_right_expr_ptr ());
230 82490 : }
231 :
232 : void
233 59620 : PointerVisitor::visit (AST::CompoundAssignmentExpr &expr)
234 : {
235 59620 : visit_outer_attrs (expr);
236 59620 : reseat (expr.get_left_expr_ptr ());
237 59620 : reseat (expr.get_right_expr_ptr ());
238 59620 : }
239 :
240 : void
241 430571 : PointerVisitor::visit (AST::GroupedExpr &expr)
242 : {
243 430571 : visit_outer_attrs (expr);
244 430571 : visit_inner_attrs (expr);
245 430571 : reseat (expr.get_expr_in_parens_ptr ());
246 430571 : }
247 :
248 : void
249 823244 : PointerVisitor::visit (AST::ArrayElemsValues &elems)
250 : {
251 8649663 : for (auto &value : elems.get_values ())
252 7826419 : reseat (value);
253 823244 : }
254 :
255 : void
256 3286 : PointerVisitor::visit (AST::ArrayElemsCopied &elems)
257 : {
258 3286 : reseat (elems.get_elem_to_copy_ptr ());
259 3286 : reseat (elems.get_num_copies_ptr ());
260 3286 : }
261 :
262 : void
263 826530 : PointerVisitor::visit (AST::ArrayExpr &expr)
264 : {
265 826530 : visit_outer_attrs (expr);
266 826530 : visit_inner_attrs (expr);
267 826530 : visit (expr.get_array_elems ());
268 826530 : }
269 :
270 : void
271 32664 : PointerVisitor::visit (AST::ArrayIndexExpr &expr)
272 : {
273 32664 : visit_outer_attrs (expr);
274 32664 : reseat (expr.get_array_expr_ptr ());
275 32664 : reseat (expr.get_index_expr_ptr ());
276 32664 : }
277 :
278 : void
279 282699 : PointerVisitor::visit (AST::TupleExpr &expr)
280 : {
281 282699 : visit_outer_attrs (expr);
282 282699 : visit_inner_attrs (expr);
283 809215 : for (auto &elem : expr.get_tuple_elems ())
284 526516 : reseat (elem);
285 282699 : }
286 :
287 : void
288 243052 : PointerVisitor::visit (AST::TupleIndexExpr &expr)
289 : {
290 243052 : visit_outer_attrs (expr);
291 243052 : reseat (expr.get_tuple_expr_ptr ());
292 243052 : }
293 :
294 : void
295 53507 : PointerVisitor::visit (AST::StructExprFieldIdentifierValue &field)
296 : {
297 53507 : reseat (field.get_value_ptr ());
298 53507 : }
299 :
300 : void
301 220 : PointerVisitor::visit (AST::StructExprFieldIndexValue &field)
302 : {
303 220 : reseat (field.get_value_ptr ());
304 220 : }
305 :
306 : void
307 524 : PointerVisitor::visit (AST::StructBase &base)
308 : {
309 524 : reseat (base.get_base_struct_ptr ());
310 524 : }
311 :
312 : void
313 4120386 : PointerVisitor::visit (AST::CallExpr &expr)
314 : {
315 4120386 : visit_outer_attrs (expr);
316 4120386 : reseat (expr.get_function_expr_ptr ());
317 14922100 : for (auto ¶m : expr.get_params ())
318 10801714 : reseat (param);
319 4120386 : }
320 :
321 : void
322 1794862 : PointerVisitor::visit (AST::MethodCallExpr &expr)
323 : {
324 1794862 : visit_outer_attrs (expr);
325 1794862 : reseat (expr.get_receiver_expr_ptr ());
326 1794862 : visit (expr.get_method_name ());
327 2076153 : for (auto ¶m : expr.get_params ())
328 281291 : reseat (param);
329 1794862 : }
330 :
331 : void
332 236791 : PointerVisitor::visit (AST::FieldAccessExpr &expr)
333 : {
334 236791 : visit_outer_attrs (expr);
335 236791 : reseat (expr.get_receiver_expr_ptr ());
336 236791 : }
337 :
338 : void
339 10701 : PointerVisitor::visit (AST::ClosureExprInner &expr)
340 : {
341 10701 : visit_outer_attrs (expr);
342 :
343 : // TODO: Actually we need to handle macro invocations as closure parameters so
344 : // this needs to be a reseat
345 23493 : for (auto ¶m : expr.get_params ())
346 12792 : visit (param);
347 :
348 10701 : reseat (expr.get_definition_expr_ptr ());
349 10701 : }
350 :
351 : void
352 652224 : PointerVisitor::visit (AST::BlockExpr &expr)
353 : {
354 652224 : visit_outer_attrs (expr);
355 652224 : visit_inner_attrs (expr);
356 :
357 652224 : if (expr.has_label ())
358 9 : visit (expr.get_label ());
359 :
360 1030177 : for (auto &stmt : expr.get_statements ())
361 377953 : reseat (stmt);
362 :
363 652224 : if (expr.has_tail_expr ())
364 564119 : reseat (expr.get_tail_expr_ptr ());
365 652224 : }
366 :
367 : void
368 23829 : PointerVisitor::visit (AST::AnonConst &expr)
369 : {
370 23829 : if (!expr.is_deferred ())
371 23778 : reseat (expr.get_inner_expr_ptr ());
372 23829 : }
373 :
374 : void
375 126 : PointerVisitor::visit (AST::ClosureExprInnerTyped &expr)
376 : {
377 126 : visit_outer_attrs (expr);
378 :
379 : // TODO: Same as ClosureExprInner
380 273 : for (auto ¶m : expr.get_params ())
381 147 : visit (param);
382 :
383 126 : reseat (expr.get_return_type_ptr ());
384 :
385 126 : reseat (expr.get_definition_expr_ptr ());
386 126 : }
387 :
388 : void
389 12939 : PointerVisitor::visit (AST::ClosureParam ¶m)
390 : {
391 12939 : visit_outer_attrs (param);
392 12939 : reseat (param.get_pattern_ptr ());
393 12939 : if (param.has_type_given ())
394 786 : reseat (param.get_type_ptr ());
395 12939 : }
396 :
397 : void
398 1120 : PointerVisitor::visit (AST::ContinueExpr &expr)
399 : {
400 1120 : visit_outer_attrs (expr);
401 1120 : if (expr.has_label ())
402 461 : visit (expr.get_label_unchecked ());
403 1120 : }
404 :
405 : void
406 2640 : PointerVisitor::visit (AST::BreakExpr &expr)
407 : {
408 2640 : visit_outer_attrs (expr);
409 2640 : if (expr.has_label ())
410 185 : visit (expr.get_label_unchecked ());
411 :
412 2640 : if (expr.has_break_expr ())
413 130 : reseat (expr.get_break_expr_ptr_unchecked ());
414 2640 : }
415 :
416 : void
417 8963 : PointerVisitor::visit (AST::RangeFromToExpr &expr)
418 : {
419 8963 : reseat (expr.get_from_expr_ptr ());
420 8963 : reseat (expr.get_to_expr_ptr ());
421 8963 : }
422 :
423 : void
424 3997 : PointerVisitor::visit (AST::RangeFromExpr &expr)
425 : {
426 3997 : reseat (expr.get_from_expr_ptr ());
427 3997 : }
428 :
429 : void
430 7872 : PointerVisitor::visit (AST::RangeToExpr &expr)
431 : {
432 7872 : reseat (expr.get_to_expr_ptr ());
433 7872 : }
434 :
435 : void
436 461 : PointerVisitor::visit (AST::RangeFromToInclExpr &expr)
437 : {
438 461 : reseat (expr.get_from_expr_ptr ());
439 461 : reseat (expr.get_to_expr_ptr ());
440 461 : }
441 :
442 : void
443 0 : PointerVisitor::visit (AST::RangeToInclExpr &expr)
444 : {
445 0 : reseat (expr.get_to_expr_ptr ());
446 0 : }
447 :
448 : void
449 27772 : PointerVisitor::visit (AST::ReturnExpr &expr)
450 : {
451 27772 : visit_outer_attrs (expr);
452 27772 : if (expr.has_returned_expr ())
453 26665 : reseat (expr.get_returned_expr_ptr ());
454 27772 : }
455 :
456 : void
457 2104 : PointerVisitor::visit (AST::TryExpr &expr)
458 : {
459 2104 : visit_outer_attrs (expr);
460 2104 : reseat (expr.get_block_expr_ptr ());
461 2104 : }
462 :
463 : void
464 20 : PointerVisitor::visit (AST::BoxExpr &expr)
465 : {
466 20 : visit_outer_attrs (expr);
467 20 : reseat (expr.get_boxed_expr_ptr ());
468 20 : }
469 :
470 : void
471 91973 : PointerVisitor::visit (AST::UnsafeBlockExpr &expr)
472 : {
473 91973 : visit_outer_attrs (expr);
474 91973 : reseat (expr.get_block_expr_ptr ());
475 91973 : }
476 :
477 : void
478 3434 : PointerVisitor::visit (AST::LoopExpr &expr)
479 : {
480 3434 : visit_outer_attrs (expr);
481 3434 : if (expr.has_loop_label ())
482 377 : visit (expr.get_loop_label ());
483 3434 : reseat (expr.get_loop_block_ptr ());
484 3434 : }
485 :
486 : void
487 7573 : PointerVisitor::visit (AST::WhileLoopExpr &expr)
488 : {
489 7573 : visit_outer_attrs (expr);
490 7573 : if (expr.has_loop_label ())
491 35 : visit (expr.get_loop_label ());
492 7573 : reseat (expr.get_predicate_expr_ptr ());
493 7573 : reseat (expr.get_loop_block_ptr ());
494 7573 : }
495 :
496 : void
497 1594 : PointerVisitor::visit (AST::WhileLetLoopExpr &expr)
498 : {
499 1594 : visit_outer_attrs (expr);
500 1594 : reseat (expr.get_pattern ());
501 :
502 1594 : if (expr.has_loop_label ())
503 4 : visit (expr.get_loop_label ());
504 :
505 1594 : reseat (expr.get_scrutinee_expr_ptr ());
506 1594 : reseat (expr.get_loop_block_ptr ());
507 1594 : }
508 :
509 : void
510 7208 : PointerVisitor::visit (AST::ForLoopExpr &expr)
511 : {
512 7208 : visit_outer_attrs (expr);
513 7208 : reseat (expr.get_pattern_ptr ());
514 7208 : reseat (expr.get_iterator_expr_ptr ());
515 7208 : if (expr.has_loop_label ())
516 0 : visit (expr.get_loop_label ());
517 7208 : reseat (expr.get_loop_block_ptr ());
518 7208 : }
519 :
520 : void
521 68259 : PointerVisitor::visit (AST::IfExpr &expr)
522 : {
523 68259 : visit_outer_attrs (expr);
524 68259 : reseat (expr.get_condition_expr_ptr ());
525 68259 : visit (expr.get_if_block ());
526 68259 : }
527 :
528 : void
529 3364 : PointerVisitor::visit (AST::IfLetExpr &expr)
530 : {
531 3364 : visit_outer_attrs (expr);
532 3364 : reseat (expr.get_pattern ());
533 3364 : reseat (expr.get_value_expr_ptr ());
534 3364 : visit (expr.get_if_block ());
535 3364 : }
536 :
537 : void
538 3261585 : PointerVisitor::visit (AST::MatchArm &arm)
539 : {
540 3261585 : visit_outer_attrs (arm);
541 3261585 : reseat (arm.get_pattern ());
542 3261585 : if (arm.has_match_arm_guard ())
543 2298 : reseat (arm.get_guard_expr_ptr ());
544 3261585 : }
545 :
546 : void
547 3261585 : PointerVisitor::visit (AST::MatchCase &arm)
548 : {
549 3261585 : visit (arm.get_arm ());
550 3261585 : reseat (arm.get_expr_ptr ());
551 3261585 : }
552 :
553 : void
554 312099 : PointerVisitor::visit (AST::MatchExpr &expr)
555 : {
556 312099 : visit_outer_attrs (expr);
557 312099 : visit_inner_attrs (expr);
558 312099 : reseat (expr.get_scrutinee_expr_ptr ());
559 3573684 : for (auto &arm : expr.get_match_cases ())
560 3261585 : visit (arm);
561 312099 : }
562 :
563 : void
564 0 : PointerVisitor::visit (AST::AwaitExpr &expr)
565 : {
566 0 : visit_outer_attrs (expr);
567 0 : reseat (expr.get_awaited_expr ());
568 0 : }
569 :
570 : void
571 0 : PointerVisitor::visit (AST::AsyncBlockExpr &expr)
572 : {
573 0 : visit_outer_attrs (expr);
574 0 : reseat (expr.get_block_expr ());
575 0 : }
576 :
577 : void
578 81 : PointerVisitor::visit (AST::InlineAsm &expr)
579 : {
580 81 : visit_outer_attrs (expr);
581 81 : using RegisterType = AST::InlineAsmOperand::RegisterType;
582 168 : for (auto &operand : expr.get_operands ())
583 : {
584 87 : switch (operand.get_register_type ())
585 : {
586 30 : case RegisterType::In:
587 30 : {
588 30 : reseat (operand.get_in ().expr);
589 30 : break;
590 : }
591 51 : case RegisterType::Out:
592 51 : {
593 51 : reseat (operand.get_out ().expr);
594 51 : break;
595 : }
596 0 : case RegisterType::InOut:
597 0 : {
598 0 : reseat (operand.get_in_out ().expr);
599 0 : break;
600 : }
601 6 : case RegisterType::SplitInOut:
602 6 : {
603 6 : auto split = operand.get_split_in_out ();
604 6 : reseat (split.in_expr);
605 6 : reseat (split.out_expr);
606 6 : break;
607 6 : }
608 0 : case RegisterType::Const:
609 0 : {
610 0 : reseat (operand.get_const ().anon_const.get_inner_expr_ptr ());
611 0 : break;
612 : }
613 0 : case RegisterType::Sym:
614 0 : {
615 0 : reseat (operand.get_sym ().expr);
616 0 : break;
617 : }
618 0 : case RegisterType::Label:
619 0 : {
620 0 : reseat (operand.get_label ().expr);
621 0 : break;
622 : }
623 : }
624 81 : }
625 81 : }
626 :
627 : void
628 834 : PointerVisitor::visit (AST::LlvmInlineAsm &expr)
629 : {
630 2007 : for (auto &output : expr.get_outputs ())
631 1173 : reseat (output.expr);
632 :
633 1737 : for (auto &input : expr.get_inputs ())
634 903 : reseat (input.expr);
635 834 : }
636 :
637 : void
638 293197 : PointerVisitor::visit (AST::TypeParam ¶m)
639 : {
640 293197 : visit_outer_attrs (param);
641 : // FIXME: Can we do macro expansion here?
642 372850 : for (auto &bound : param.get_type_param_bounds ())
643 79653 : visit (bound);
644 293197 : if (param.has_type ())
645 2435 : reseat (param.get_type_ptr ());
646 293197 : }
647 :
648 : void
649 39265 : PointerVisitor::visit (AST::TypeBoundWhereClauseItem &item)
650 : {
651 39328 : for (auto &lifetime : item.get_for_lifetimes ())
652 63 : visit (lifetime);
653 39265 : reseat (item.get_type_ptr ());
654 : // FIXME: Likewise?
655 80326 : for (auto ¶m : item.get_type_param_bounds ())
656 41061 : visit (param);
657 39265 : }
658 :
659 : void
660 553027 : PointerVisitor::visit (AST::FunctionParam ¶m)
661 : {
662 553027 : visit_outer_attrs (param);
663 553027 : if (param.has_name ())
664 553027 : reseat (param.get_pattern_ptr ());
665 :
666 553027 : reseat (param.get_type_ptr ());
667 553027 : }
668 :
669 : void
670 309016 : PointerVisitor::visit (AST::SelfParam ¶m)
671 : {
672 309016 : visit_outer_attrs (param);
673 :
674 309016 : if (param.has_lifetime ())
675 143706 : visit (param.get_lifetime ());
676 :
677 309016 : if (param.has_type ())
678 471 : reseat (param.get_type_ptr ());
679 309016 : }
680 :
681 : void
682 12929 : PointerVisitor::visit (AST::Module &module)
683 : {
684 12929 : visit_outer_attrs (module);
685 12929 : visit (module.get_visibility ());
686 12929 : visit_inner_attrs (module);
687 416620 : for (auto &item : module.get_items ())
688 403691 : reseat (item);
689 12929 : }
690 :
691 : void
692 490167 : PointerVisitor::visit_function_params (AST::Function &function)
693 : {
694 1354953 : for (auto ¶m : function.get_function_params ())
695 864786 : visit (param);
696 490167 : }
697 :
698 : void
699 490167 : PointerVisitor::visit (AST::Function &function)
700 : {
701 490167 : visit_outer_attrs (function);
702 490167 : visit (function.get_visibility ());
703 490167 : visit (function.get_qualifiers ());
704 549524 : for (auto &generic : function.get_generic_params ())
705 59357 : visit (generic);
706 :
707 490167 : visit_function_params (function);
708 :
709 490167 : if (function.has_return_type ())
710 417496 : reseat (function.get_return_type_ptr ());
711 490167 : if (function.has_where_clause ())
712 15739 : visit (function.get_where_clause ());
713 490167 : if (function.has_body ())
714 440039 : reseat (*function.get_definition ());
715 490167 : }
716 :
717 : void
718 182958 : PointerVisitor::visit (AST::TypeAlias &type_alias)
719 : {
720 182958 : visit_outer_attrs (type_alias);
721 182958 : visit (type_alias.get_visibility ());
722 183098 : for (auto &generic : type_alias.get_generic_params ())
723 140 : visit (generic);
724 182958 : if (type_alias.has_where_clause ())
725 0 : visit (type_alias.get_where_clause ());
726 182958 : reseat (type_alias.get_type_aliased_ptr ());
727 182958 : }
728 :
729 : void
730 21404 : PointerVisitor::visit (AST::StructField &field)
731 : {
732 21404 : visit_outer_attrs (field);
733 21404 : visit (field.get_visibility ());
734 21404 : reseat (field.get_field_type_ptr ());
735 21404 : }
736 :
737 : void
738 24174 : PointerVisitor::visit (AST::TupleField &field)
739 : {
740 24174 : visit_outer_attrs (field);
741 24174 : visit (field.get_visibility ());
742 24174 : reseat (field.get_field_type_ptr ());
743 24174 : }
744 :
745 : void
746 1079 : PointerVisitor::visit (AST::EnumItemDiscriminant &item)
747 : {
748 1079 : PointerVisitor::visit (static_cast<EnumItem &> (item));
749 1079 : reseat (item.get_expr_ptr ());
750 1079 : }
751 :
752 : void
753 52533 : PointerVisitor::visit (AST::ConstantItem &const_item)
754 : {
755 52533 : visit_outer_attrs (const_item);
756 52533 : visit (const_item.get_visibility ());
757 52533 : reseat (const_item.get_type_ptr ());
758 52533 : if (const_item.has_expr ())
759 51010 : reseat (const_item.get_expr_ptr ());
760 52533 : }
761 :
762 : void
763 2809 : PointerVisitor::visit (AST::StaticItem &static_item)
764 : {
765 2809 : visit_outer_attrs (static_item);
766 2809 : visit (static_item.get_visibility ());
767 2809 : reseat (static_item.get_type_ptr ());
768 2809 : reseat (static_item.get_expr_ptr ());
769 2809 : }
770 :
771 : void
772 17978 : PointerVisitor::visit (AST::Trait &trait)
773 : {
774 17978 : visit_outer_attrs (trait);
775 17978 : visit (trait.get_visibility ());
776 :
777 17978 : visit_inner_attrs (trait);
778 :
779 17978 : visit (trait.get_implicit_self ());
780 :
781 22401 : for (auto &generic : trait.get_generic_params ())
782 4423 : visit (generic);
783 :
784 17978 : if (trait.has_where_clause ())
785 28 : visit (trait.get_where_clause ());
786 :
787 22834 : for (auto &bound : trait.get_type_param_bounds ())
788 4856 : visit (bound);
789 :
790 43354 : for (auto &item : trait.get_trait_items ())
791 25376 : reseat (item);
792 17978 : }
793 :
794 : void
795 13642 : PointerVisitor::visit (AST::InherentImpl &impl)
796 : {
797 13642 : visit_outer_attrs (impl);
798 13642 : visit (impl.get_visibility ());
799 :
800 24225 : for (auto &generic : impl.get_generic_params ())
801 10583 : visit (generic);
802 13642 : if (impl.has_where_clause ())
803 111 : visit (impl.get_where_clause ());
804 13642 : reseat (impl.get_type_ptr ());
805 13642 : visit_inner_attrs (impl);
806 100654 : for (auto &item : impl.get_impl_items ())
807 87012 : reseat (item);
808 13642 : }
809 :
810 : void
811 245173 : PointerVisitor::visit (AST::TraitImpl &impl)
812 : {
813 245173 : visit_outer_attrs (impl);
814 245173 : visit (impl.get_visibility ());
815 :
816 475415 : for (auto &generic : impl.get_generic_params ())
817 230242 : visit (generic);
818 245173 : if (impl.has_where_clause ())
819 12866 : visit (impl.get_where_clause ());
820 245173 : reseat (impl.get_type_ptr ());
821 245173 : visit (impl.get_trait_path ());
822 245173 : visit_inner_attrs (impl);
823 592350 : for (auto &item : impl.get_impl_items ())
824 347177 : reseat (item);
825 245173 : }
826 :
827 : void
828 3 : PointerVisitor::visit (AST::ExternalStaticItem &item)
829 : {
830 3 : visit_outer_attrs (item);
831 3 : visit (item.get_visibility ());
832 3 : reseat (item.get_type_ptr ());
833 3 : }
834 :
835 : void
836 6973 : PointerVisitor::visit (AST::ExternBlock &block)
837 : {
838 6973 : visit_outer_attrs (block);
839 6973 : visit (block.get_visibility ());
840 6973 : visit_inner_attrs (block);
841 45025 : for (auto &item : block.get_extern_items ())
842 38052 : reseat (item);
843 6973 : }
844 :
845 : void
846 1515027 : PointerVisitor::visit (AST::IdentifierPattern &pattern)
847 : {
848 1515027 : if (pattern.has_subpattern ())
849 1033 : reseat (pattern.get_subpattern_ptr ());
850 1515027 : }
851 :
852 : void
853 5408 : PointerVisitor::visit (AST::RangePattern &pattern)
854 : {
855 : // FIXME: So should this be reseat() instead? Can we have macro invocations as
856 : // patterns in range patterns?
857 5408 : if (pattern.get_has_lower_bound ())
858 5408 : visit (pattern.get_lower_bound ());
859 5408 : if (pattern.get_has_upper_bound ())
860 5408 : visit (pattern.get_upper_bound ());
861 5408 : }
862 :
863 : void
864 14857 : PointerVisitor::visit (AST::ReferencePattern &pattern)
865 : {
866 14857 : reseat (pattern.get_referenced_pattern_ptr ());
867 14857 : }
868 :
869 : void
870 120 : PointerVisitor::visit (AST::StructPatternFieldTuplePat &field)
871 : {
872 120 : visit_outer_attrs (field);
873 120 : reseat (field.get_index_pattern_ptr ());
874 120 : }
875 :
876 : void
877 3707 : PointerVisitor::visit (AST::StructPatternFieldIdentPat &field)
878 : {
879 3707 : visit_outer_attrs (field);
880 3707 : reseat (field.get_ident_pattern_ptr ());
881 3707 : }
882 :
883 : void
884 58385 : PointerVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
885 : {
886 119329 : for (auto &pattern : tuple_items.get_patterns ())
887 60944 : reseat (pattern);
888 58385 : }
889 :
890 : void
891 722 : PointerVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
892 : {
893 907 : for (auto &lower : tuple_items.get_lower_patterns ())
894 185 : reseat (lower);
895 837 : for (auto &upper : tuple_items.get_upper_patterns ())
896 115 : reseat (upper);
897 722 : }
898 :
899 : void
900 175060 : PointerVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
901 : {
902 581479 : for (auto &pattern : tuple_items.get_patterns ())
903 406419 : reseat (pattern);
904 175060 : }
905 :
906 : void
907 190 : PointerVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
908 : {
909 355 : for (auto &lower : tuple_items.get_lower_patterns ())
910 165 : reseat (lower);
911 370 : for (auto &upper : tuple_items.get_upper_patterns ())
912 180 : reseat (upper);
913 190 : }
914 :
915 : void
916 240 : PointerVisitor::visit (AST::GroupedPattern &pattern)
917 : {
918 240 : reseat (pattern.get_pattern_in_parens_ptr ());
919 240 : }
920 :
921 : void
922 1275 : PointerVisitor::visit (AST::SlicePattern &pattern)
923 : {
924 3985 : for (auto &pat : pattern.get_patterns ())
925 2710 : reseat (pat);
926 1275 : }
927 :
928 : void
929 3569 : PointerVisitor::visit (AST::AltPattern &pattern)
930 : {
931 12408 : for (auto &alt : pattern.get_alts ())
932 8839 : reseat (alt);
933 3569 : }
934 :
935 : void
936 321275 : PointerVisitor::visit (AST::LetStmt &stmt)
937 : {
938 321275 : visit_outer_attrs (stmt);
939 321275 : reseat (stmt.get_pattern_ptr ());
940 321275 : if (stmt.has_type ())
941 39481 : reseat (stmt.get_type_ptr ());
942 321275 : if (stmt.has_init_expr ())
943 307881 : reseat (stmt.get_init_expr_ptr ());
944 321275 : }
945 :
946 : void
947 322079 : PointerVisitor::visit (AST::ExprStmt &stmt)
948 : {
949 322079 : reseat (stmt.get_expr_ptr ());
950 322079 : }
951 :
952 : void
953 677 : PointerVisitor::visit (AST::ParenthesisedType &type)
954 : {
955 677 : reseat (type.get_type_in_parens ());
956 677 : }
957 :
958 : void
959 9172 : PointerVisitor::visit (AST::ImplTraitTypeOneBound &type)
960 : {
961 : // FIXME: Do we need to reseat here?
962 9172 : visit (type.get_trait_bound ());
963 9172 : }
964 :
965 : void
966 2663 : PointerVisitor::visit (AST::TraitObjectTypeOneBound &type)
967 : {
968 : // FIXME: Do we need to reseat here?
969 2663 : visit (type.get_trait_bound ());
970 2663 : }
971 :
972 : void
973 66411 : PointerVisitor::visit (AST::TupleType &type)
974 : {
975 218994 : for (auto &elem : type.get_elems ())
976 152583 : reseat (elem);
977 66411 : }
978 :
979 : void
980 117656 : PointerVisitor::visit (AST::RawPointerType &type)
981 : {
982 117656 : reseat (type.get_type_pointed_to_ptr ());
983 117656 : }
984 :
985 : void
986 538996 : PointerVisitor::visit (AST::ReferenceType &type)
987 : {
988 538996 : visit (type.get_lifetime ());
989 538996 : reseat (type.get_type_ptr ());
990 538996 : }
991 :
992 : void
993 23768 : PointerVisitor::visit (AST::ArrayType &type)
994 : {
995 23768 : reseat (type.get_elem_type_ptr ());
996 23768 : visit (type.get_size_expr ());
997 23768 : }
998 :
999 : void
1000 45113 : PointerVisitor::visit (AST::SliceType &type)
1001 : {
1002 45113 : reseat (type.get_elem_type_ptr ());
1003 45113 : }
1004 :
1005 : void
1006 112190 : PointerVisitor::visit (AST::MaybeNamedParam ¶m)
1007 : {
1008 112190 : visit_outer_attrs (param);
1009 112190 : reseat (param.get_type_ptr ());
1010 112190 : }
1011 :
1012 : void
1013 18829 : PointerVisitor::visit (AST::BareFunctionType &type)
1014 : {
1015 37670 : for (auto &lifetime : type.get_for_lifetimes ())
1016 12 : visit (lifetime);
1017 18829 : visit (type.get_function_qualifiers ());
1018 131019 : for (auto ¶m : type.get_function_params ())
1019 112190 : visit (param);
1020 18829 : if (type.is_variadic ())
1021 5712 : for (auto attr : type.get_variadic_attr ())
1022 0 : visit (attr);
1023 18829 : if (type.has_return_type ())
1024 18485 : reseat (type.get_return_type_ptr ());
1025 18829 : }
1026 :
1027 : void
1028 0 : PointerVisitor::visit (AST::FormatArgs &)
1029 : {
1030 : // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1031 0 : }
1032 :
1033 : void
1034 45 : PointerVisitor::visit (AST::OffsetOf &offset_of)
1035 : {
1036 45 : reseat (offset_of.get_type_ptr ());
1037 45 : }
1038 :
1039 : void
1040 2743 : PointerVisitor::visit (AST::VariadicParam ¶m)
1041 : {
1042 2743 : if (param.has_pattern ())
1043 33 : reseat (param.get_pattern_ptr ());
1044 2743 : }
1045 :
1046 : } // namespace AST
1047 : } // namespace Rust
|
