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 16355 : PointerVisitor::visit (AST::Crate &crate)
28 : {
29 16355 : visit_inner_attrs (crate);
30 91382 : for (auto &item : crate.items)
31 75027 : reseat (item);
32 16355 : }
33 :
34 : void
35 6957 : 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 14741 : for (auto &item : input.get_items ())
41 7784 : visit (item);
42 6957 : }
43 :
44 : void
45 4199154 : PointerVisitor::visit (AST::IdentifierExpr &ident_expr)
46 : {
47 4199154 : visit_outer_attrs (ident_expr);
48 4199154 : }
49 :
50 : void
51 43630 : PointerVisitor::visit (AST::LifetimeParam &lifetime_param)
52 : {
53 43630 : visit_outer_attrs (lifetime_param);
54 :
55 : // Nothing to do for lifetimes right?
56 43630 : }
57 :
58 : void
59 3099 : PointerVisitor::visit (AST::ConstGenericParam &const_param)
60 : {
61 3099 : visit_outer_attrs (const_param);
62 3099 : if (const_param.has_type ())
63 3099 : reseat (const_param.get_type_ptr ());
64 :
65 3099 : if (const_param.has_default_value ())
66 60 : visit (const_param.get_default_value_unchecked ());
67 3099 : }
68 :
69 : void
70 2634968 : PointerVisitor::visit (AST::PathInExpression &path)
71 : {
72 2634968 : visit_outer_attrs (path);
73 :
74 2634968 : if (!path.is_lang_item ())
75 5663589 : for (auto &segment : path.get_segments ())
76 3037244 : visit (segment);
77 2634968 : }
78 :
79 : void
80 12589 : PointerVisitor::visit (GenericArgsBinding &binding)
81 : {
82 12589 : reseat (binding.get_type_ptr ());
83 12589 : }
84 :
85 : void
86 511363 : PointerVisitor::visit (AST::TypePathSegmentGeneric &segment)
87 : {
88 511363 : if (segment.has_generic_args ())
89 511360 : visit (segment.get_generic_args ());
90 511363 : }
91 :
92 : void
93 18588 : PointerVisitor::visit (AST::TypePathFunction &tpf)
94 : {
95 44344 : for (auto &input : tpf.get_params ())
96 25756 : reseat (input);
97 18588 : if (tpf.has_return_type ())
98 17957 : reseat (tpf.get_return_type_ptr ());
99 18588 : }
100 :
101 : void
102 18588 : PointerVisitor::visit (AST::TypePathSegmentFunction &segment)
103 : {
104 : // FIXME: No reseating here correct? No macros possible or desugar?
105 18588 : visit (segment.get_type_path_function ());
106 18588 : visit (segment.get_ident_segment ());
107 18588 : }
108 :
109 : void
110 531884 : 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 1055614 : for (auto &generic : args.get_generic_args ())
119 523730 : visit (generic);
120 :
121 544473 : for (auto &binding : args.get_binding_args ())
122 12589 : visit (binding);
123 531884 : }
124 :
125 : void
126 4865901 : PointerVisitor::visit (AST::PathExprSegment &segment)
127 : {
128 4865901 : visit (segment.get_ident_segment ());
129 4865901 : if (segment.has_generic_args ())
130 20524 : visit (segment.get_generic_args ());
131 4865901 : }
132 : void
133 4872725 : PointerVisitor::visit (AST::TypePath &path)
134 : {
135 10091837 : for (auto &segment : path.get_segments ())
136 5219112 : visit (segment);
137 4872725 : }
138 :
139 : void
140 3957 : PointerVisitor::visit (AST::QualifiedPathInExpression &path)
141 : {
142 3957 : visit_outer_attrs (path);
143 3957 : visit (path.get_qualified_path_type ());
144 :
145 7919 : for (auto &segment : path.get_segments ())
146 3962 : visit (segment);
147 3957 : }
148 :
149 : void
150 110654 : PointerVisitor::visit (AST::QualifiedPathType &path)
151 : {
152 110654 : reseat (path.get_type_ptr ());
153 110654 : if (path.has_as_clause ())
154 107870 : visit (path.get_as_type_path ());
155 110654 : }
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 214783 : PointerVisitor::visit (AST::BorrowExpr &expr)
166 : {
167 214783 : visit_outer_attrs (expr);
168 214783 : reseat (expr.get_borrowed_expr_ptr ());
169 214783 : }
170 :
171 : void
172 381455 : PointerVisitor::visit (AST::DereferenceExpr &expr)
173 : {
174 381455 : visit_outer_attrs (expr);
175 381455 : reseat (expr.get_dereferenced_expr_ptr ());
176 381455 : }
177 :
178 : void
179 13858 : PointerVisitor::visit (AST::ErrorPropagationExpr &expr)
180 : {
181 13858 : visit_outer_attrs (expr);
182 13858 : reseat (expr.get_propagating_expr_ptr ());
183 13858 : }
184 :
185 : void
186 63503 : PointerVisitor::visit (AST::NegationExpr &expr)
187 : {
188 63503 : visit_outer_attrs (expr);
189 63503 : reseat (expr.get_negated_expr_ptr ());
190 63503 : }
191 :
192 : void
193 2415338 : PointerVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
194 : {
195 2415338 : visit_outer_attrs (expr);
196 2415338 : reseat (expr.get_left_expr_ptr ());
197 2415338 : reseat (expr.get_right_expr_ptr ());
198 2415338 : }
199 :
200 : void
201 196992 : PointerVisitor::visit (AST::ComparisonExpr &expr)
202 : {
203 196992 : visit_outer_attrs (expr);
204 196992 : reseat (expr.get_left_expr_ptr ());
205 196992 : reseat (expr.get_right_expr_ptr ());
206 196992 : }
207 :
208 : void
209 52062 : PointerVisitor::visit (AST::LazyBooleanExpr &expr)
210 : {
211 52062 : visit_outer_attrs (expr);
212 52062 : reseat (expr.get_left_expr_ptr ());
213 52062 : reseat (expr.get_right_expr_ptr ());
214 52062 : }
215 :
216 : void
217 269569 : PointerVisitor::visit (AST::TypeCastExpr &expr)
218 : {
219 269569 : visit_outer_attrs (expr);
220 269569 : reseat (expr.get_casted_expr_ptr ());
221 269569 : reseat (expr.get_type_to_cast_to_ptr ());
222 269569 : }
223 :
224 : void
225 85237 : PointerVisitor::visit (AST::AssignmentExpr &expr)
226 : {
227 85237 : visit_outer_attrs (expr);
228 85237 : reseat (expr.get_left_expr_ptr ());
229 85237 : reseat (expr.get_right_expr_ptr ());
230 85237 : }
231 :
232 : void
233 60457 : PointerVisitor::visit (AST::CompoundAssignmentExpr &expr)
234 : {
235 60457 : visit_outer_attrs (expr);
236 60457 : reseat (expr.get_left_expr_ptr ());
237 60457 : reseat (expr.get_right_expr_ptr ());
238 60457 : }
239 :
240 : void
241 432320 : PointerVisitor::visit (AST::GroupedExpr &expr)
242 : {
243 432320 : visit_outer_attrs (expr);
244 432320 : visit_inner_attrs (expr);
245 432320 : reseat (expr.get_expr_in_parens_ptr ());
246 432320 : }
247 :
248 : void
249 823342 : PointerVisitor::visit (AST::ArrayElemsValues &elems)
250 : {
251 8649938 : for (auto &value : elems.get_values ())
252 7826596 : reseat (value);
253 823342 : }
254 :
255 : void
256 3377 : PointerVisitor::visit (AST::ArrayElemsCopied &elems)
257 : {
258 3377 : reseat (elems.get_elem_to_copy_ptr ());
259 3377 : reseat (elems.get_num_copies_ptr ());
260 3377 : }
261 :
262 : void
263 826719 : PointerVisitor::visit (AST::ArrayExpr &expr)
264 : {
265 826719 : visit_outer_attrs (expr);
266 826719 : visit_inner_attrs (expr);
267 826719 : visit (expr.get_array_elems ());
268 826719 : }
269 :
270 : void
271 34183 : PointerVisitor::visit (AST::ArrayIndexExpr &expr)
272 : {
273 34183 : visit_outer_attrs (expr);
274 34183 : reseat (expr.get_array_expr_ptr ());
275 34183 : reseat (expr.get_index_expr_ptr ());
276 34183 : }
277 :
278 : void
279 284976 : PointerVisitor::visit (AST::TupleExpr &expr)
280 : {
281 284976 : visit_outer_attrs (expr);
282 284976 : visit_inner_attrs (expr);
283 814878 : for (auto &elem : expr.get_tuple_elems ())
284 529902 : reseat (elem);
285 284976 : }
286 :
287 : void
288 244009 : PointerVisitor::visit (AST::TupleIndexExpr &expr)
289 : {
290 244009 : visit_outer_attrs (expr);
291 244009 : reseat (expr.get_tuple_expr_ptr ());
292 244009 : }
293 :
294 : void
295 57909 : PointerVisitor::visit (AST::StructExprFieldIdentifierValue &field)
296 : {
297 57909 : reseat (field.get_value_ptr ());
298 57909 : }
299 :
300 : void
301 220 : PointerVisitor::visit (AST::StructExprFieldIndexValue &field)
302 : {
303 220 : reseat (field.get_value_ptr ());
304 220 : }
305 :
306 : void
307 542 : PointerVisitor::visit (AST::StructBase &base)
308 : {
309 542 : reseat (base.get_base_struct_ptr ());
310 542 : }
311 :
312 : void
313 4141868 : PointerVisitor::visit (AST::CallExpr &expr)
314 : {
315 4141868 : visit_outer_attrs (expr);
316 4141868 : reseat (expr.get_function_expr_ptr ());
317 14972299 : for (auto ¶m : expr.get_params ())
318 10830431 : reseat (param);
319 4141868 : }
320 :
321 : void
322 1824695 : PointerVisitor::visit (AST::MethodCallExpr &expr)
323 : {
324 1824695 : visit_outer_attrs (expr);
325 1824695 : reseat (expr.get_receiver_expr_ptr ());
326 1824695 : visit (expr.get_method_name ());
327 2119199 : for (auto ¶m : expr.get_params ())
328 294504 : reseat (param);
329 1824695 : }
330 :
331 : void
332 251699 : PointerVisitor::visit (AST::FieldAccessExpr &expr)
333 : {
334 251699 : visit_outer_attrs (expr);
335 251699 : reseat (expr.get_receiver_expr_ptr ());
336 251699 : }
337 :
338 : void
339 11466 : PointerVisitor::visit (AST::ClosureExprInner &expr)
340 : {
341 11466 : 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 25025 : for (auto ¶m : expr.get_params ())
346 13559 : visit (param);
347 :
348 11466 : reseat (expr.get_definition_expr_ptr ());
349 11466 : }
350 :
351 : void
352 674889 : PointerVisitor::visit (AST::BlockExpr &expr)
353 : {
354 674889 : visit_outer_attrs (expr);
355 674889 : visit_inner_attrs (expr);
356 :
357 674889 : if (expr.has_label ())
358 9 : visit (expr.get_label ());
359 :
360 1068932 : for (auto &stmt : expr.get_statements ())
361 394043 : reseat (stmt);
362 :
363 674889 : if (expr.has_tail_expr ())
364 582165 : reseat (expr.get_tail_expr_ptr ());
365 674889 : }
366 :
367 : void
368 24900 : PointerVisitor::visit (AST::AnonConst &expr)
369 : {
370 24900 : if (!expr.is_deferred ())
371 24849 : reseat (expr.get_inner_expr_ptr ());
372 24900 : }
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 13706 : PointerVisitor::visit (AST::ClosureParam ¶m)
390 : {
391 13706 : visit_outer_attrs (param);
392 13706 : reseat (param.get_pattern_ptr ());
393 13706 : if (param.has_type_given ())
394 814 : reseat (param.get_type_ptr ());
395 13706 : }
396 :
397 : void
398 1153 : PointerVisitor::visit (AST::ContinueExpr &expr)
399 : {
400 1153 : visit_outer_attrs (expr);
401 1153 : if (expr.has_label ())
402 461 : visit (expr.get_label_unchecked ());
403 1153 : }
404 :
405 : void
406 2818 : PointerVisitor::visit (AST::BreakExpr &expr)
407 : {
408 2818 : visit_outer_attrs (expr);
409 2818 : if (expr.has_label ())
410 190 : visit (expr.get_label_unchecked ());
411 :
412 2818 : if (expr.has_break_expr ())
413 140 : reseat (expr.get_break_expr_ptr_unchecked ());
414 2818 : }
415 :
416 : void
417 9351 : PointerVisitor::visit (AST::RangeFromToExpr &expr)
418 : {
419 9351 : reseat (expr.get_from_expr_ptr ());
420 9351 : reseat (expr.get_to_expr_ptr ());
421 9351 : }
422 :
423 : void
424 4042 : PointerVisitor::visit (AST::RangeFromExpr &expr)
425 : {
426 4042 : reseat (expr.get_from_expr_ptr ());
427 4042 : }
428 :
429 : void
430 7926 : PointerVisitor::visit (AST::RangeToExpr &expr)
431 : {
432 7926 : reseat (expr.get_to_expr_ptr ());
433 7926 : }
434 :
435 : void
436 506 : PointerVisitor::visit (AST::RangeFromToInclExpr &expr)
437 : {
438 506 : reseat (expr.get_from_expr_ptr ());
439 506 : reseat (expr.get_to_expr_ptr ());
440 506 : }
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 28857 : PointerVisitor::visit (AST::ReturnExpr &expr)
450 : {
451 28857 : visit_outer_attrs (expr);
452 28857 : if (expr.has_returned_expr ())
453 27564 : reseat (expr.get_returned_expr_ptr ());
454 28857 : }
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 143 : PointerVisitor::visit (AST::BoxExpr &expr)
465 : {
466 143 : visit_outer_attrs (expr);
467 143 : reseat (expr.get_boxed_expr_ptr ());
468 143 : }
469 :
470 : void
471 98864 : PointerVisitor::visit (AST::UnsafeBlockExpr &expr)
472 : {
473 98864 : visit_outer_attrs (expr);
474 98864 : reseat (expr.get_block_expr_ptr ());
475 98864 : }
476 :
477 : void
478 4809 : PointerVisitor::visit (AST::LoopExpr &expr)
479 : {
480 4809 : visit_outer_attrs (expr);
481 4809 : if (expr.has_loop_label ())
482 382 : visit (expr.get_loop_label ());
483 4809 : reseat (expr.get_loop_block_ptr ());
484 4809 : }
485 :
486 : void
487 7854 : PointerVisitor::visit (AST::WhileLoopExpr &expr)
488 : {
489 7854 : visit_outer_attrs (expr);
490 7854 : if (expr.has_loop_label ())
491 35 : visit (expr.get_loop_label ());
492 7854 : reseat (expr.get_predicate_expr_ptr ());
493 7854 : reseat (expr.get_loop_block_ptr ());
494 7854 : }
495 :
496 : void
497 1762 : PointerVisitor::visit (AST::WhileLetLoopExpr &expr)
498 : {
499 1762 : visit_outer_attrs (expr);
500 1762 : reseat (expr.get_pattern ());
501 :
502 1762 : if (expr.has_loop_label ())
503 4 : visit (expr.get_loop_label ());
504 :
505 1762 : reseat (expr.get_scrutinee_expr_ptr ());
506 1762 : reseat (expr.get_loop_block_ptr ());
507 1762 : }
508 :
509 : void
510 7588 : PointerVisitor::visit (AST::ForLoopExpr &expr)
511 : {
512 7588 : visit_outer_attrs (expr);
513 7588 : reseat (expr.get_pattern_ptr ());
514 7588 : reseat (expr.get_iterator_expr_ptr ());
515 7588 : if (expr.has_loop_label ())
516 0 : visit (expr.get_loop_label ());
517 7588 : reseat (expr.get_loop_block_ptr ());
518 7588 : }
519 :
520 : void
521 70011 : PointerVisitor::visit (AST::IfExpr &expr)
522 : {
523 70011 : visit_outer_attrs (expr);
524 70011 : reseat (expr.get_condition_expr_ptr ());
525 70011 : visit (expr.get_if_block ());
526 70011 : }
527 :
528 : void
529 3574 : PointerVisitor::visit (AST::IfLetExpr &expr)
530 : {
531 3574 : visit_outer_attrs (expr);
532 3574 : reseat (expr.get_pattern ());
533 3574 : reseat (expr.get_value_expr_ptr ());
534 3574 : visit (expr.get_if_block ());
535 3574 : }
536 :
537 : void
538 3266239 : PointerVisitor::visit (AST::MatchArm &arm)
539 : {
540 3266239 : visit_outer_attrs (arm);
541 3266239 : reseat (arm.get_pattern ());
542 3266239 : if (arm.has_match_arm_guard ())
543 2379 : reseat (arm.get_guard_expr_ptr ());
544 3266239 : }
545 :
546 : void
547 3266239 : PointerVisitor::visit (AST::MatchCase &arm)
548 : {
549 3266239 : visit (arm.get_arm ());
550 3266239 : reseat (arm.get_expr_ptr ());
551 3266239 : }
552 :
553 : void
554 314088 : PointerVisitor::visit (AST::MatchExpr &expr)
555 : {
556 314088 : visit_outer_attrs (expr);
557 314088 : visit_inner_attrs (expr);
558 314088 : reseat (expr.get_scrutinee_expr_ptr ());
559 3580327 : for (auto &arm : expr.get_match_cases ())
560 3266239 : visit (arm);
561 314088 : }
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 834 : visit_outer_attrs (expr);
631 :
632 2007 : for (auto &output : expr.get_outputs ())
633 1173 : reseat (output.expr);
634 :
635 1737 : for (auto &input : expr.get_inputs ())
636 903 : reseat (input.expr);
637 834 : }
638 :
639 : void
640 305067 : PointerVisitor::visit (AST::TypeParam ¶m)
641 : {
642 305067 : visit_outer_attrs (param);
643 : // FIXME: Can we do macro expansion here?
644 390089 : for (auto &bound : param.get_type_param_bounds ())
645 85022 : visit (bound);
646 305067 : if (param.has_type ())
647 2484 : reseat (param.get_type_ptr ());
648 305067 : }
649 :
650 : void
651 40539 : PointerVisitor::visit (AST::TypeBoundWhereClauseItem &item)
652 : {
653 40602 : for (auto &lifetime : item.get_for_lifetimes ())
654 63 : visit (lifetime);
655 40539 : reseat (item.get_type_ptr ());
656 : // FIXME: Likewise?
657 83014 : for (auto ¶m : item.get_type_param_bounds ())
658 42475 : visit (param);
659 40539 : }
660 :
661 : void
662 564086 : PointerVisitor::visit (AST::FunctionParam ¶m)
663 : {
664 564086 : visit_outer_attrs (param);
665 564086 : if (param.has_name ())
666 564086 : reseat (param.get_pattern_ptr ());
667 :
668 564086 : reseat (param.get_type_ptr ());
669 564086 : }
670 :
671 : void
672 319882 : PointerVisitor::visit (AST::SelfParam ¶m)
673 : {
674 319882 : visit_outer_attrs (param);
675 :
676 319882 : if (param.has_lifetime ())
677 150390 : visit (param.get_lifetime ());
678 :
679 319882 : if (param.has_type ())
680 537 : reseat (param.get_type_ptr ());
681 319882 : }
682 :
683 : void
684 13838 : PointerVisitor::visit (AST::Module &module)
685 : {
686 13838 : visit_outer_attrs (module);
687 13838 : visit (module.get_visibility ());
688 13838 : visit_inner_attrs (module);
689 429740 : for (auto &item : module.get_items ())
690 415902 : reseat (item);
691 13838 : }
692 :
693 : void
694 505162 : PointerVisitor::visit_function_params (AST::Function &function)
695 : {
696 1391928 : for (auto ¶m : function.get_function_params ())
697 886766 : visit (param);
698 505162 : }
699 :
700 : void
701 505162 : PointerVisitor::visit (AST::Function &function)
702 : {
703 505162 : visit_outer_attrs (function);
704 505162 : visit (function.get_visibility ());
705 505162 : visit (function.get_qualifiers ());
706 566817 : for (auto &generic : function.get_generic_params ())
707 61655 : visit (generic);
708 :
709 505162 : visit_function_params (function);
710 :
711 505162 : if (function.has_return_type ())
712 429887 : reseat (function.get_return_type_ptr ());
713 505162 : if (function.has_where_clause ())
714 16235 : visit (function.get_where_clause ());
715 505162 : if (function.has_body ())
716 453213 : reseat (*function.get_definition ());
717 505162 : }
718 :
719 : void
720 185590 : PointerVisitor::visit (AST::TypeAlias &type_alias)
721 : {
722 185590 : visit_outer_attrs (type_alias);
723 185590 : visit (type_alias.get_visibility ());
724 185730 : for (auto &generic : type_alias.get_generic_params ())
725 140 : visit (generic);
726 185590 : if (type_alias.has_where_clause ())
727 0 : visit (type_alias.get_where_clause ());
728 185590 : reseat (type_alias.get_type_aliased_ptr ());
729 185590 : }
730 :
731 : void
732 44018 : PointerVisitor::visit (AST::StructField &field)
733 : {
734 44018 : visit_outer_attrs (field);
735 44018 : visit (field.get_visibility ());
736 44018 : reseat (field.get_field_type_ptr ());
737 44018 : }
738 :
739 : void
740 47583 : PointerVisitor::visit (AST::TupleField &field)
741 : {
742 47583 : visit_outer_attrs (field);
743 47583 : visit (field.get_visibility ());
744 47583 : reseat (field.get_field_type_ptr ());
745 47583 : }
746 :
747 : void
748 1115 : PointerVisitor::visit (AST::EnumItemDiscriminant &item)
749 : {
750 1115 : PointerVisitor::visit (static_cast<EnumItem &> (item));
751 1115 : reseat (item.get_expr_ptr ());
752 1115 : }
753 :
754 : void
755 52786 : PointerVisitor::visit (AST::ConstantItem &const_item)
756 : {
757 52786 : visit_outer_attrs (const_item);
758 52786 : visit (const_item.get_visibility ());
759 52786 : reseat (const_item.get_type_ptr ());
760 52786 : if (const_item.has_expr ())
761 51258 : reseat (const_item.get_expr_ptr ());
762 52786 : }
763 :
764 : void
765 2824 : PointerVisitor::visit (AST::StaticItem &static_item)
766 : {
767 2824 : visit_outer_attrs (static_item);
768 2824 : visit (static_item.get_visibility ());
769 2824 : reseat (static_item.get_type_ptr ());
770 2824 : reseat (static_item.get_expr_ptr ());
771 2824 : }
772 :
773 : void
774 19343 : PointerVisitor::visit (AST::Trait &trait)
775 : {
776 19343 : visit_outer_attrs (trait);
777 19343 : visit (trait.get_visibility ());
778 :
779 19343 : visit_inner_attrs (trait);
780 :
781 19343 : visit (trait.get_implicit_self ());
782 :
783 24299 : for (auto &generic : trait.get_generic_params ())
784 4956 : visit (generic);
785 :
786 19343 : if (trait.has_where_clause ())
787 28 : visit (trait.get_where_clause ());
788 :
789 24548 : for (auto &bound : trait.get_type_param_bounds ())
790 5205 : visit (bound);
791 :
792 46697 : for (auto &item : trait.get_trait_items ())
793 27354 : reseat (item);
794 19343 : }
795 :
796 : void
797 14761 : PointerVisitor::visit (AST::InherentImpl &impl)
798 : {
799 14761 : visit_outer_attrs (impl);
800 14761 : visit (impl.get_visibility ());
801 :
802 27234 : for (auto &generic : impl.get_generic_params ())
803 12473 : visit (generic);
804 14761 : if (impl.has_where_clause ())
805 111 : visit (impl.get_where_clause ());
806 14761 : reseat (impl.get_type_ptr ());
807 14761 : visit_inner_attrs (impl);
808 106741 : for (auto &item : impl.get_impl_items ())
809 91980 : reseat (item);
810 14761 : }
811 :
812 : void
813 251980 : PointerVisitor::visit (AST::TraitImpl &impl)
814 : {
815 251980 : visit_outer_attrs (impl);
816 251980 : visit (impl.get_visibility ());
817 :
818 487818 : for (auto &generic : impl.get_generic_params ())
819 235838 : visit (generic);
820 251980 : if (impl.has_where_clause ())
821 13242 : visit (impl.get_where_clause ());
822 251980 : reseat (impl.get_type_ptr ());
823 251980 : visit (impl.get_trait_path ());
824 251980 : visit_inner_attrs (impl);
825 607103 : for (auto &item : impl.get_impl_items ())
826 355123 : reseat (item);
827 251980 : }
828 :
829 : void
830 5 : PointerVisitor::visit (AST::ExternalStaticItem &item)
831 : {
832 5 : visit_outer_attrs (item);
833 5 : visit (item.get_visibility ());
834 5 : reseat (item.get_type_ptr ());
835 5 : }
836 :
837 : void
838 7164 : PointerVisitor::visit (AST::ExternBlock &block)
839 : {
840 7164 : visit_outer_attrs (block);
841 7164 : visit (block.get_visibility ());
842 7164 : visit_inner_attrs (block);
843 45879 : for (auto &item : block.get_extern_items ())
844 38715 : reseat (item);
845 7164 : }
846 :
847 : void
848 1553726 : PointerVisitor::visit (AST::IdentifierPattern &pattern)
849 : {
850 1553726 : if (pattern.has_subpattern ())
851 1073 : reseat (pattern.get_subpattern_ptr ());
852 1553726 : }
853 :
854 : void
855 5417 : PointerVisitor::visit (AST::RangePattern &pattern)
856 : {
857 : // FIXME: So should this be reseat() instead? Can we have macro invocations as
858 : // patterns in range patterns?
859 5417 : if (pattern.get_has_lower_bound ())
860 5417 : visit (pattern.get_lower_bound ());
861 5417 : if (pattern.get_has_upper_bound ())
862 5417 : visit (pattern.get_upper_bound ());
863 5417 : }
864 :
865 : void
866 15674 : PointerVisitor::visit (AST::ReferencePattern &pattern)
867 : {
868 15674 : reseat (pattern.get_referenced_pattern_ptr ());
869 15674 : }
870 :
871 : void
872 160 : PointerVisitor::visit (AST::StructPatternFieldTuplePat &field)
873 : {
874 160 : visit_outer_attrs (field);
875 160 : reseat (field.get_index_pattern_ptr ());
876 160 : }
877 :
878 : void
879 3851 : PointerVisitor::visit (AST::StructPatternFieldIdentPat &field)
880 : {
881 3851 : visit_outer_attrs (field);
882 3851 : reseat (field.get_ident_pattern_ptr ());
883 3851 : }
884 :
885 : void
886 61893 : PointerVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
887 : {
888 126411 : for (auto &pattern : tuple_items.get_patterns ())
889 64518 : reseat (pattern);
890 61893 : }
891 :
892 : void
893 740 : PointerVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
894 : {
895 925 : for (auto &lower : tuple_items.get_lower_patterns ())
896 185 : reseat (lower);
897 855 : for (auto &upper : tuple_items.get_upper_patterns ())
898 115 : reseat (upper);
899 740 : }
900 :
901 : void
902 177960 : PointerVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
903 : {
904 590458 : for (auto &pattern : tuple_items.get_patterns ())
905 412498 : reseat (pattern);
906 177960 : }
907 :
908 : void
909 190 : PointerVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
910 : {
911 355 : for (auto &lower : tuple_items.get_lower_patterns ())
912 165 : reseat (lower);
913 370 : for (auto &upper : tuple_items.get_upper_patterns ())
914 180 : reseat (upper);
915 190 : }
916 :
917 : void
918 240 : PointerVisitor::visit (AST::GroupedPattern &pattern)
919 : {
920 240 : reseat (pattern.get_pattern_in_parens_ptr ());
921 240 : }
922 :
923 : void
924 1344 : PointerVisitor::visit (AST::SlicePattern &pattern)
925 : {
926 4236 : for (auto &pat : pattern.get_patterns ())
927 2892 : reseat (pat);
928 1344 : }
929 :
930 : void
931 3610 : PointerVisitor::visit (AST::AltPattern &pattern)
932 : {
933 12531 : for (auto &alt : pattern.get_alts ())
934 8921 : reseat (alt);
935 3610 : }
936 :
937 : void
938 333965 : PointerVisitor::visit (AST::LetStmt &stmt)
939 : {
940 333965 : visit_outer_attrs (stmt);
941 333965 : reseat (stmt.get_pattern_ptr ());
942 333965 : if (stmt.has_type ())
943 40530 : reseat (stmt.get_type_ptr ());
944 333965 : if (stmt.has_init_expr ())
945 320103 : reseat (stmt.get_init_expr_ptr ());
946 333965 : }
947 :
948 : void
949 336777 : PointerVisitor::visit (AST::ExprStmt &stmt)
950 : {
951 336777 : reseat (stmt.get_expr_ptr ());
952 336777 : }
953 :
954 : void
955 695 : PointerVisitor::visit (AST::ParenthesisedType &type)
956 : {
957 695 : reseat (type.get_type_in_parens ());
958 695 : }
959 :
960 : void
961 9299 : PointerVisitor::visit (AST::ImplTraitTypeOneBound &type)
962 : {
963 : // FIXME: Do we need to reseat here?
964 9299 : visit (type.get_trait_bound ());
965 9299 : }
966 :
967 : void
968 2758 : PointerVisitor::visit (AST::TraitObjectTypeOneBound &type)
969 : {
970 : // FIXME: Do we need to reseat here?
971 2758 : visit (type.get_trait_bound ());
972 2758 : }
973 :
974 : void
975 68504 : PointerVisitor::visit (AST::TupleType &type)
976 : {
977 224975 : for (auto &elem : type.get_elems ())
978 156471 : reseat (elem);
979 68504 : }
980 :
981 : void
982 122636 : PointerVisitor::visit (AST::RawPointerType &type)
983 : {
984 122636 : reseat (type.get_type_pointed_to_ptr ());
985 122636 : }
986 :
987 : void
988 550560 : PointerVisitor::visit (AST::ReferenceType &type)
989 : {
990 550560 : visit (type.get_lifetime ());
991 550560 : reseat (type.get_type_ptr ());
992 550560 : }
993 :
994 : void
995 24839 : PointerVisitor::visit (AST::ArrayType &type)
996 : {
997 24839 : reseat (type.get_elem_type_ptr ());
998 24839 : visit (type.get_size_expr ());
999 24839 : }
1000 :
1001 : void
1002 47894 : PointerVisitor::visit (AST::SliceType &type)
1003 : {
1004 47894 : reseat (type.get_elem_type_ptr ());
1005 47894 : }
1006 :
1007 : void
1008 112231 : PointerVisitor::visit (AST::MaybeNamedParam ¶m)
1009 : {
1010 112231 : visit_outer_attrs (param);
1011 112231 : reseat (param.get_type_ptr ());
1012 112231 : }
1013 :
1014 : void
1015 18865 : PointerVisitor::visit (AST::BareFunctionType &type)
1016 : {
1017 18877 : for (auto &lifetime : type.get_for_lifetimes ())
1018 12 : visit (lifetime);
1019 18865 : visit (type.get_function_qualifiers ());
1020 131096 : for (auto ¶m : type.get_function_params ())
1021 112231 : visit (param);
1022 18865 : if (type.is_variadic ())
1023 5712 : for (auto attr : type.get_variadic_attr ())
1024 0 : visit (attr);
1025 18865 : if (type.has_return_type ())
1026 18500 : reseat (type.get_return_type_ptr ());
1027 18865 : }
1028 :
1029 : void
1030 0 : PointerVisitor::visit (AST::FormatArgs &)
1031 : {
1032 : // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1033 0 : }
1034 :
1035 : void
1036 45 : PointerVisitor::visit (AST::OffsetOf &offset_of)
1037 : {
1038 45 : reseat (offset_of.get_type_ptr ());
1039 45 : }
1040 :
1041 : void
1042 2798 : PointerVisitor::visit (AST::VariadicParam ¶m)
1043 : {
1044 2798 : if (param.has_pattern ())
1045 33 : reseat (param.get_pattern_ptr ());
1046 2798 : }
1047 :
1048 : } // namespace AST
1049 : } // namespace Rust
|
