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 15472 : PointerVisitor::visit (AST::Crate &crate)
28 : {
29 15472 : visit_inner_attrs (crate);
30 81477 : for (auto &item : crate.items)
31 66005 : reseat (item);
32 15472 : }
33 :
34 : void
35 1536 : 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 3208 : for (auto &item : input.get_items ())
41 1672 : visit (item);
42 1536 : }
43 :
44 : void
45 78552 : PointerVisitor::visit (AST::IdentifierExpr &ident_expr)
46 : {
47 78552 : visit_outer_attrs (ident_expr);
48 78552 : }
49 :
50 : void
51 841 : PointerVisitor::visit (AST::LifetimeParam &lifetime_param)
52 : {
53 841 : visit_outer_attrs (lifetime_param);
54 :
55 : // Nothing to do for lifetimes right?
56 841 : }
57 :
58 : void
59 303 : PointerVisitor::visit (AST::ConstGenericParam &const_param)
60 : {
61 303 : visit_outer_attrs (const_param);
62 303 : if (const_param.has_type ())
63 303 : reseat (const_param.get_type_ptr ());
64 :
65 303 : if (const_param.has_default_value ())
66 54 : visit (const_param.get_default_value_unchecked ());
67 303 : }
68 :
69 : void
70 81918 : PointerVisitor::visit (AST::PathInExpression &path)
71 : {
72 81918 : visit_outer_attrs (path);
73 :
74 81918 : if (!path.is_lang_item ())
75 191104 : for (auto &segment : path.get_segments ())
76 109363 : visit (segment);
77 81918 : }
78 :
79 : void
80 267 : PointerVisitor::visit (GenericArgsBinding &binding)
81 : {
82 267 : reseat (binding.get_type_ptr ());
83 267 : }
84 :
85 : void
86 9742 : PointerVisitor::visit (AST::TypePathSegmentGeneric &segment)
87 : {
88 9742 : if (segment.has_generic_args ())
89 9739 : visit (segment.get_generic_args ());
90 9742 : }
91 :
92 : void
93 90 : PointerVisitor::visit (AST::TypePathFunction &tpf)
94 : {
95 186 : for (auto &input : tpf.get_params ())
96 96 : reseat (input);
97 90 : if (tpf.has_return_type ())
98 84 : reseat (tpf.get_return_type_ptr ());
99 90 : }
100 :
101 : void
102 90 : PointerVisitor::visit (AST::TypePathSegmentFunction &segment)
103 : {
104 : // FIXME: No reseating here correct? No macros possible or desugar?
105 90 : visit (segment.get_type_path_function ());
106 90 : visit (segment.get_ident_segment ());
107 90 : }
108 :
109 : void
110 12884 : 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 26357 : for (auto &generic : args.get_generic_args ())
119 13473 : visit (generic);
120 :
121 13151 : for (auto &binding : args.get_binding_args ())
122 267 : visit (binding);
123 12884 : }
124 :
125 : void
126 125053 : PointerVisitor::visit (AST::PathExprSegment &segment)
127 : {
128 125053 : visit (segment.get_ident_segment ());
129 125053 : if (segment.has_generic_args ())
130 3145 : visit (segment.get_generic_args ());
131 125053 : }
132 : void
133 308084 : PointerVisitor::visit (AST::TypePath &path)
134 : {
135 626893 : for (auto &segment : path.get_segments ())
136 318809 : visit (segment);
137 308084 : }
138 :
139 : void
140 372 : PointerVisitor::visit (AST::QualifiedPathInExpression &path)
141 : {
142 372 : visit_outer_attrs (path);
143 372 : visit (path.get_qualified_path_type ());
144 :
145 744 : for (auto &segment : path.get_segments ())
146 372 : visit (segment);
147 372 : }
148 :
149 : void
150 1410 : PointerVisitor::visit (AST::QualifiedPathType &path)
151 : {
152 1410 : reseat (path.get_type_ptr ());
153 1410 : if (path.has_as_clause ())
154 1281 : visit (path.get_as_type_path ());
155 1410 : }
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 11097 : PointerVisitor::visit (AST::BorrowExpr &expr)
166 : {
167 11097 : visit_outer_attrs (expr);
168 11097 : reseat (expr.get_borrowed_expr_ptr ());
169 11097 : }
170 :
171 : void
172 23861 : PointerVisitor::visit (AST::DereferenceExpr &expr)
173 : {
174 23861 : visit_outer_attrs (expr);
175 23861 : reseat (expr.get_dereferenced_expr_ptr ());
176 23861 : }
177 :
178 : void
179 4 : PointerVisitor::visit (AST::ErrorPropagationExpr &expr)
180 : {
181 4 : visit_outer_attrs (expr);
182 4 : reseat (expr.get_propagating_expr_ptr ());
183 4 : }
184 :
185 : void
186 3663 : PointerVisitor::visit (AST::NegationExpr &expr)
187 : {
188 3663 : visit_outer_attrs (expr);
189 3663 : reseat (expr.get_negated_expr_ptr ());
190 3663 : }
191 :
192 : void
193 1066751 : PointerVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
194 : {
195 1066751 : visit_outer_attrs (expr);
196 1066751 : reseat (expr.get_left_expr_ptr ());
197 1066751 : reseat (expr.get_right_expr_ptr ());
198 1066751 : }
199 :
200 : void
201 20123 : PointerVisitor::visit (AST::ComparisonExpr &expr)
202 : {
203 20123 : visit_outer_attrs (expr);
204 20123 : reseat (expr.get_left_expr_ptr ());
205 20123 : reseat (expr.get_right_expr_ptr ());
206 20123 : }
207 :
208 : void
209 2013 : PointerVisitor::visit (AST::LazyBooleanExpr &expr)
210 : {
211 2013 : visit_outer_attrs (expr);
212 2013 : reseat (expr.get_left_expr_ptr ());
213 2013 : reseat (expr.get_right_expr_ptr ());
214 2013 : }
215 :
216 : void
217 28742 : PointerVisitor::visit (AST::TypeCastExpr &expr)
218 : {
219 28742 : visit_outer_attrs (expr);
220 28742 : reseat (expr.get_casted_expr_ptr ());
221 28742 : reseat (expr.get_type_to_cast_to_ptr ());
222 28742 : }
223 :
224 : void
225 11599 : PointerVisitor::visit (AST::AssignmentExpr &expr)
226 : {
227 11599 : visit_outer_attrs (expr);
228 11599 : reseat (expr.get_left_expr_ptr ());
229 11599 : reseat (expr.get_right_expr_ptr ());
230 11599 : }
231 :
232 : void
233 3247 : PointerVisitor::visit (AST::CompoundAssignmentExpr &expr)
234 : {
235 3247 : visit_outer_attrs (expr);
236 3247 : reseat (expr.get_left_expr_ptr ());
237 3247 : reseat (expr.get_right_expr_ptr ());
238 3247 : }
239 :
240 : void
241 1832 : PointerVisitor::visit (AST::GroupedExpr &expr)
242 : {
243 1832 : visit_outer_attrs (expr);
244 1832 : visit_inner_attrs (expr);
245 1832 : reseat (expr.get_expr_in_parens_ptr ());
246 1832 : }
247 :
248 : void
249 1507 : PointerVisitor::visit (AST::ArrayElemsValues &elems)
250 : {
251 8609 : for (auto &value : elems.get_values ())
252 7102 : reseat (value);
253 1507 : }
254 :
255 : void
256 610 : PointerVisitor::visit (AST::ArrayElemsCopied &elems)
257 : {
258 610 : reseat (elems.get_elem_to_copy_ptr ());
259 610 : reseat (elems.get_num_copies_ptr ());
260 610 : }
261 :
262 : void
263 2117 : PointerVisitor::visit (AST::ArrayExpr &expr)
264 : {
265 2117 : visit_outer_attrs (expr);
266 2117 : visit_inner_attrs (expr);
267 2117 : visit (expr.get_array_elems ());
268 2117 : }
269 :
270 : void
271 1520 : PointerVisitor::visit (AST::ArrayIndexExpr &expr)
272 : {
273 1520 : visit_outer_attrs (expr);
274 1520 : reseat (expr.get_array_expr_ptr ());
275 1520 : reseat (expr.get_index_expr_ptr ());
276 1520 : }
277 :
278 : void
279 3108 : PointerVisitor::visit (AST::TupleExpr &expr)
280 : {
281 3108 : visit_outer_attrs (expr);
282 3108 : visit_inner_attrs (expr);
283 8550 : for (auto &elem : expr.get_tuple_elems ())
284 5442 : reseat (elem);
285 3108 : }
286 :
287 : void
288 4682 : PointerVisitor::visit (AST::TupleIndexExpr &expr)
289 : {
290 4682 : visit_outer_attrs (expr);
291 4682 : reseat (expr.get_tuple_expr_ptr ());
292 4682 : }
293 :
294 : void
295 11038 : PointerVisitor::visit (AST::StructExprFieldIdentifierValue &field)
296 : {
297 11038 : reseat (field.get_value_ptr ());
298 11038 : }
299 :
300 : void
301 220 : PointerVisitor::visit (AST::StructExprFieldIndexValue &field)
302 : {
303 220 : reseat (field.get_value_ptr ());
304 220 : }
305 :
306 : void
307 315 : PointerVisitor::visit (AST::StructBase &base)
308 : {
309 315 : reseat (base.get_base_struct_ptr ());
310 315 : }
311 :
312 : void
313 70866 : PointerVisitor::visit (AST::CallExpr &expr)
314 : {
315 70866 : visit_outer_attrs (expr);
316 70866 : reseat (expr.get_function_expr_ptr ());
317 151814 : for (auto ¶m : expr.get_params ())
318 80948 : reseat (param);
319 70866 : }
320 :
321 : void
322 15318 : PointerVisitor::visit (AST::MethodCallExpr &expr)
323 : {
324 15318 : visit_outer_attrs (expr);
325 15318 : reseat (expr.get_receiver_expr_ptr ());
326 15318 : visit (expr.get_method_name ());
327 25515 : for (auto ¶m : expr.get_params ())
328 10197 : reseat (param);
329 15318 : }
330 :
331 : void
332 22122 : PointerVisitor::visit (AST::FieldAccessExpr &expr)
333 : {
334 22122 : visit_outer_attrs (expr);
335 22122 : reseat (expr.get_receiver_expr_ptr ());
336 22122 : }
337 :
338 : void
339 111 : PointerVisitor::visit (AST::ClosureExprInner &expr)
340 : {
341 111 : 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 189 : for (auto ¶m : expr.get_params ())
346 78 : visit (param);
347 :
348 111 : reseat (expr.get_definition_expr_ptr ());
349 111 : }
350 :
351 : void
352 78033 : PointerVisitor::visit (AST::BlockExpr &expr)
353 : {
354 78033 : visit_outer_attrs (expr);
355 78033 : visit_inner_attrs (expr);
356 :
357 78033 : if (expr.has_label ())
358 6 : visit (expr.get_label ());
359 :
360 153690 : for (auto &stmt : expr.get_statements ())
361 75657 : reseat (stmt);
362 :
363 78033 : if (expr.has_tail_expr ())
364 56460 : reseat (expr.get_tail_expr_ptr ());
365 78033 : }
366 :
367 : void
368 3914 : PointerVisitor::visit (AST::AnonConst &expr)
369 : {
370 3914 : if (!expr.is_deferred ())
371 3873 : reseat (expr.get_inner_expr_ptr ());
372 3914 : }
373 :
374 : void
375 90 : PointerVisitor::visit (AST::ClosureExprInnerTyped &expr)
376 : {
377 90 : visit_outer_attrs (expr);
378 :
379 : // TODO: Same as ClosureExprInner
380 201 : for (auto ¶m : expr.get_params ())
381 111 : visit (param);
382 :
383 90 : reseat (expr.get_return_type_ptr ());
384 :
385 90 : reseat (expr.get_definition_expr_ptr ());
386 90 : }
387 :
388 : void
389 189 : PointerVisitor::visit (AST::ClosureParam ¶m)
390 : {
391 189 : visit_outer_attrs (param);
392 189 : reseat (param.get_pattern_ptr ());
393 189 : if (param.has_type_given ())
394 174 : reseat (param.get_type_ptr ());
395 189 : }
396 :
397 : void
398 85 : PointerVisitor::visit (AST::ContinueExpr &expr)
399 : {
400 85 : visit_outer_attrs (expr);
401 85 : if (expr.has_label ())
402 15 : visit (expr.get_label_unchecked ());
403 85 : }
404 :
405 : void
406 447 : PointerVisitor::visit (AST::BreakExpr &expr)
407 : {
408 447 : visit_outer_attrs (expr);
409 447 : if (expr.has_label ())
410 125 : visit (expr.get_label_unchecked ());
411 :
412 447 : if (expr.has_break_expr ())
413 120 : reseat (expr.get_break_expr_ptr_unchecked ());
414 447 : }
415 :
416 : void
417 426 : PointerVisitor::visit (AST::RangeFromToExpr &expr)
418 : {
419 426 : reseat (expr.get_from_expr_ptr ());
420 426 : reseat (expr.get_to_expr_ptr ());
421 426 : }
422 :
423 : void
424 35 : PointerVisitor::visit (AST::RangeFromExpr &expr)
425 : {
426 35 : reseat (expr.get_from_expr_ptr ());
427 35 : }
428 :
429 : void
430 35 : PointerVisitor::visit (AST::RangeToExpr &expr)
431 : {
432 35 : reseat (expr.get_to_expr_ptr ());
433 35 : }
434 :
435 : void
436 35 : PointerVisitor::visit (AST::RangeFromToInclExpr &expr)
437 : {
438 35 : reseat (expr.get_from_expr_ptr ());
439 35 : reseat (expr.get_to_expr_ptr ());
440 35 : }
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 2725 : PointerVisitor::visit (AST::ReturnExpr &expr)
450 : {
451 2725 : visit_outer_attrs (expr);
452 2725 : if (expr.has_returned_expr ())
453 2551 : reseat (expr.get_returned_expr_ptr ());
454 2725 : }
455 :
456 : void
457 4 : PointerVisitor::visit (AST::TryExpr &expr)
458 : {
459 4 : visit_outer_attrs (expr);
460 4 : reseat (expr.get_block_expr_ptr ());
461 4 : }
462 :
463 : void
464 5 : PointerVisitor::visit (AST::BoxExpr &expr)
465 : {
466 5 : visit_outer_attrs (expr);
467 5 : reseat (expr.get_boxed_expr_ptr ());
468 5 : }
469 :
470 : void
471 20004 : PointerVisitor::visit (AST::UnsafeBlockExpr &expr)
472 : {
473 20004 : visit_outer_attrs (expr);
474 20004 : reseat (expr.get_block_expr_ptr ());
475 20004 : }
476 :
477 : void
478 617 : PointerVisitor::visit (AST::LoopExpr &expr)
479 : {
480 617 : visit_outer_attrs (expr);
481 617 : if (expr.has_loop_label ())
482 190 : visit (expr.get_loop_label ());
483 617 : reseat (expr.get_loop_block_ptr ());
484 617 : }
485 :
486 : void
487 523 : PointerVisitor::visit (AST::WhileLoopExpr &expr)
488 : {
489 523 : visit_outer_attrs (expr);
490 523 : if (expr.has_loop_label ())
491 10 : visit (expr.get_loop_label ());
492 523 : reseat (expr.get_predicate_expr_ptr ());
493 523 : reseat (expr.get_loop_block_ptr ());
494 523 : }
495 :
496 : void
497 12 : PointerVisitor::visit (AST::WhileLetLoopExpr &expr)
498 : {
499 12 : visit_outer_attrs (expr);
500 12 : reseat (expr.get_pattern ());
501 :
502 12 : if (expr.has_loop_label ())
503 4 : visit (expr.get_loop_label ());
504 :
505 12 : reseat (expr.get_scrutinee_expr_ptr ());
506 12 : reseat (expr.get_loop_block_ptr ());
507 12 : }
508 :
509 : void
510 132 : PointerVisitor::visit (AST::ForLoopExpr &expr)
511 : {
512 132 : visit_outer_attrs (expr);
513 132 : reseat (expr.get_pattern_ptr ());
514 132 : reseat (expr.get_iterator_expr_ptr ());
515 132 : if (expr.has_loop_label ())
516 0 : visit (expr.get_loop_label ());
517 132 : reseat (expr.get_loop_block_ptr ());
518 132 : }
519 :
520 : void
521 8187 : PointerVisitor::visit (AST::IfExpr &expr)
522 : {
523 8187 : visit_outer_attrs (expr);
524 8187 : reseat (expr.get_condition_expr_ptr ());
525 8187 : visit (expr.get_if_block ());
526 8187 : }
527 :
528 : void
529 90 : PointerVisitor::visit (AST::IfLetExpr &expr)
530 : {
531 90 : visit_outer_attrs (expr);
532 90 : reseat (expr.get_pattern ());
533 90 : reseat (expr.get_value_expr_ptr ());
534 90 : visit (expr.get_if_block ());
535 90 : }
536 :
537 : void
538 14044 : PointerVisitor::visit (AST::MatchArm &arm)
539 : {
540 14044 : visit_outer_attrs (arm);
541 14044 : reseat (arm.get_pattern ());
542 14044 : if (arm.has_match_arm_guard ())
543 5 : reseat (arm.get_guard_expr_ptr ());
544 14044 : }
545 :
546 : void
547 14044 : PointerVisitor::visit (AST::MatchCase &arm)
548 : {
549 14044 : visit (arm.get_arm ());
550 14044 : reseat (arm.get_expr_ptr ());
551 14044 : }
552 :
553 : void
554 6050 : PointerVisitor::visit (AST::MatchExpr &expr)
555 : {
556 6050 : visit_outer_attrs (expr);
557 6050 : visit_inner_attrs (expr);
558 6050 : reseat (expr.get_scrutinee_expr_ptr ());
559 20094 : for (auto &arm : expr.get_match_cases ())
560 14044 : visit (arm);
561 6050 : }
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 6 : PointerVisitor::visit (AST::LlvmInlineAsm &expr)
629 : {
630 6 : for (auto &output : expr.get_outputs ())
631 0 : reseat (output.expr);
632 :
633 12 : for (auto &input : expr.get_inputs ())
634 6 : reseat (input.expr);
635 6 : }
636 :
637 : void
638 28434 : PointerVisitor::visit (AST::TypeParam ¶m)
639 : {
640 28434 : visit_outer_attrs (param);
641 : // FIXME: Can we do macro expansion here?
642 31055 : for (auto &bound : param.get_type_param_bounds ())
643 2621 : visit (bound);
644 28434 : if (param.has_type ())
645 1277 : reseat (param.get_type_ptr ());
646 28434 : }
647 :
648 : void
649 1073 : PointerVisitor::visit (AST::TypeBoundWhereClauseItem &item)
650 : {
651 1100 : for (auto &lifetime : item.get_for_lifetimes ())
652 27 : visit (lifetime);
653 1073 : reseat (item.get_type_ptr ());
654 : // FIXME: Likewise?
655 2146 : for (auto ¶m : item.get_type_param_bounds ())
656 1073 : visit (param);
657 1073 : }
658 :
659 : void
660 38445 : PointerVisitor::visit (AST::FunctionParam ¶m)
661 : {
662 38445 : visit_outer_attrs (param);
663 38445 : if (param.has_name ())
664 38445 : reseat (param.get_pattern_ptr ());
665 :
666 38445 : reseat (param.get_type_ptr ());
667 38445 : }
668 :
669 : void
670 27873 : PointerVisitor::visit (AST::SelfParam ¶m)
671 : {
672 27873 : visit_outer_attrs (param);
673 :
674 27873 : if (param.has_lifetime ())
675 15941 : visit (param.get_lifetime ());
676 :
677 27873 : if (param.has_type ())
678 3 : reseat (param.get_type_ptr ());
679 27873 : }
680 :
681 : void
682 4525 : PointerVisitor::visit (AST::Module &module)
683 : {
684 4525 : visit_outer_attrs (module);
685 4525 : visit (module.get_visibility ());
686 4525 : visit_inner_attrs (module);
687 20614 : for (auto &item : module.get_items ())
688 16089 : reseat (item);
689 4525 : }
690 :
691 : void
692 63566 : PointerVisitor::visit_function_params (AST::Function &function)
693 : {
694 132487 : for (auto ¶m : function.get_function_params ())
695 68921 : visit (param);
696 63566 : }
697 :
698 : void
699 63566 : PointerVisitor::visit (AST::Function &function)
700 : {
701 63566 : visit_outer_attrs (function);
702 63566 : visit (function.get_visibility ());
703 63566 : visit (function.get_qualifiers ());
704 69955 : for (auto &generic : function.get_generic_params ())
705 6389 : visit (generic);
706 :
707 63566 : visit_function_params (function);
708 :
709 63566 : if (function.has_return_type ())
710 46105 : reseat (function.get_return_type_ptr ());
711 63566 : if (function.has_where_clause ())
712 715 : visit (function.get_where_clause ());
713 63566 : if (function.has_body ())
714 49045 : reseat (*function.get_definition ());
715 63566 : }
716 :
717 : void
718 7647 : PointerVisitor::visit (AST::TypeAlias &type_alias)
719 : {
720 7647 : visit_outer_attrs (type_alias);
721 7647 : visit (type_alias.get_visibility ());
722 7737 : for (auto &generic : type_alias.get_generic_params ())
723 90 : visit (generic);
724 7647 : if (type_alias.has_where_clause ())
725 0 : visit (type_alias.get_where_clause ());
726 7647 : reseat (type_alias.get_type_aliased_ptr ());
727 7647 : }
728 :
729 : void
730 7329 : PointerVisitor::visit (AST::StructField &field)
731 : {
732 7329 : visit_outer_attrs (field);
733 7329 : visit (field.get_visibility ());
734 7329 : reseat (field.get_field_type_ptr ());
735 7329 : }
736 :
737 : void
738 7017 : PointerVisitor::visit (AST::TupleField &field)
739 : {
740 7017 : visit_outer_attrs (field);
741 7017 : visit (field.get_visibility ());
742 7017 : reseat (field.get_field_type_ptr ());
743 7017 : }
744 :
745 : void
746 968 : PointerVisitor::visit (AST::EnumItemDiscriminant &item)
747 : {
748 968 : PointerVisitor::visit (static_cast<EnumItem &> (item));
749 968 : reseat (item.get_expr_ptr ());
750 968 : }
751 :
752 : void
753 2939 : PointerVisitor::visit (AST::ConstantItem &const_item)
754 : {
755 2939 : visit_outer_attrs (const_item);
756 2939 : visit (const_item.get_visibility ());
757 2939 : reseat (const_item.get_type_ptr ());
758 2939 : if (const_item.has_expr ())
759 2770 : reseat (const_item.get_expr_ptr ());
760 2939 : }
761 :
762 : void
763 304 : PointerVisitor::visit (AST::StaticItem &static_item)
764 : {
765 304 : visit_outer_attrs (static_item);
766 304 : visit (static_item.get_visibility ());
767 304 : reseat (static_item.get_type_ptr ());
768 304 : reseat (static_item.get_expr_ptr ());
769 304 : }
770 :
771 : void
772 12901 : PointerVisitor::visit (AST::Trait &trait)
773 : {
774 12901 : visit_outer_attrs (trait);
775 12901 : visit (trait.get_visibility ());
776 :
777 12901 : visit_inner_attrs (trait);
778 :
779 12901 : visit (trait.get_implicit_self ());
780 :
781 15201 : for (auto &generic : trait.get_generic_params ())
782 2300 : visit (generic);
783 :
784 12901 : if (trait.has_where_clause ())
785 28 : visit (trait.get_where_clause ());
786 :
787 15186 : for (auto &bound : trait.get_type_param_bounds ())
788 2285 : visit (bound);
789 :
790 24724 : for (auto &item : trait.get_trait_items ())
791 11823 : reseat (item);
792 12901 : }
793 :
794 : void
795 3162 : PointerVisitor::visit (AST::InherentImpl &impl)
796 : {
797 3162 : visit_outer_attrs (impl);
798 3162 : visit (impl.get_visibility ());
799 :
800 4259 : for (auto &generic : impl.get_generic_params ())
801 1097 : visit (generic);
802 3162 : if (impl.has_where_clause ())
803 3 : visit (impl.get_where_clause ());
804 3162 : reseat (impl.get_type_ptr ());
805 3162 : visit_inner_attrs (impl);
806 12814 : for (auto &item : impl.get_impl_items ())
807 9652 : reseat (item);
808 3162 : }
809 :
810 : void
811 15902 : PointerVisitor::visit (AST::TraitImpl &impl)
812 : {
813 15902 : visit_outer_attrs (impl);
814 15902 : visit (impl.get_visibility ());
815 :
816 18618 : for (auto &generic : impl.get_generic_params ())
817 2716 : visit (generic);
818 15902 : if (impl.has_where_clause ())
819 297 : visit (impl.get_where_clause ());
820 15902 : reseat (impl.get_type_ptr ());
821 15902 : visit (impl.get_trait_path ());
822 15902 : visit_inner_attrs (impl);
823 34671 : for (auto &item : impl.get_impl_items ())
824 18769 : reseat (item);
825 15902 : }
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 5221 : PointerVisitor::visit (AST::ExternBlock &block)
837 : {
838 5221 : visit_outer_attrs (block);
839 5221 : visit (block.get_visibility ());
840 5221 : visit_inner_attrs (block);
841 13693 : for (auto &item : block.get_extern_items ())
842 8472 : reseat (item);
843 5221 : }
844 :
845 : void
846 81594 : PointerVisitor::visit (AST::IdentifierPattern &pattern)
847 : {
848 81594 : if (pattern.has_subpattern ())
849 54 : reseat (pattern.get_subpattern_ptr ());
850 81594 : }
851 :
852 : void
853 163 : 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 163 : if (pattern.get_has_lower_bound ())
858 163 : visit (pattern.get_lower_bound ());
859 163 : if (pattern.get_has_upper_bound ())
860 163 : visit (pattern.get_upper_bound ());
861 163 : }
862 :
863 : void
864 736 : PointerVisitor::visit (AST::ReferencePattern &pattern)
865 : {
866 736 : reseat (pattern.get_referenced_pattern_ptr ());
867 736 : }
868 :
869 : void
870 72 : PointerVisitor::visit (AST::StructPatternFieldTuplePat &field)
871 : {
872 72 : visit_outer_attrs (field);
873 72 : reseat (field.get_index_pattern_ptr ());
874 72 : }
875 :
876 : void
877 545 : PointerVisitor::visit (AST::StructPatternFieldIdentPat &field)
878 : {
879 545 : visit_outer_attrs (field);
880 545 : reseat (field.get_ident_pattern_ptr ());
881 545 : }
882 :
883 : void
884 3618 : PointerVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
885 : {
886 7679 : for (auto &pattern : tuple_items.get_patterns ())
887 4061 : reseat (pattern);
888 3618 : }
889 :
890 : void
891 117 : PointerVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
892 : {
893 210 : for (auto &lower : tuple_items.get_lower_patterns ())
894 93 : reseat (lower);
895 174 : for (auto &upper : tuple_items.get_upper_patterns ())
896 57 : reseat (upper);
897 117 : }
898 :
899 : void
900 1599 : PointerVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
901 : {
902 4851 : for (auto &pattern : tuple_items.get_patterns ())
903 3252 : reseat (pattern);
904 1599 : }
905 :
906 : void
907 84 : PointerVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
908 : {
909 171 : for (auto &lower : tuple_items.get_lower_patterns ())
910 87 : reseat (lower);
911 180 : for (auto &upper : tuple_items.get_upper_patterns ())
912 96 : reseat (upper);
913 84 : }
914 :
915 : void
916 132 : PointerVisitor::visit (AST::GroupedPattern &pattern)
917 : {
918 132 : reseat (pattern.get_pattern_in_parens_ptr ());
919 132 : }
920 :
921 : void
922 98 : PointerVisitor::visit (AST::SlicePatternItemsNoRest &items)
923 : {
924 292 : for (auto &item : items.get_patterns ())
925 194 : reseat (item);
926 98 : }
927 :
928 : void
929 132 : PointerVisitor::visit (AST::SlicePatternItemsHasRest &items)
930 : {
931 261 : for (auto &item : items.get_lower_patterns ())
932 129 : reseat (item);
933 261 : for (auto &item : items.get_upper_patterns ())
934 129 : reseat (item);
935 132 : }
936 :
937 : void
938 661 : PointerVisitor::visit (AST::AltPattern &pattern)
939 : {
940 2040 : for (auto &alt : pattern.get_alts ())
941 1379 : reseat (alt);
942 661 : }
943 :
944 : void
945 67782 : PointerVisitor::visit (AST::LetStmt &stmt)
946 : {
947 67782 : visit_outer_attrs (stmt);
948 67782 : reseat (stmt.get_pattern_ptr ());
949 67782 : if (stmt.has_type ())
950 11072 : reseat (stmt.get_type_ptr ());
951 67782 : if (stmt.has_init_expr ())
952 61867 : reseat (stmt.get_init_expr_ptr ());
953 67782 : }
954 :
955 : void
956 55517 : PointerVisitor::visit (AST::ExprStmt &stmt)
957 : {
958 55517 : reseat (stmt.get_expr_ptr ());
959 55517 : }
960 :
961 : void
962 38 : PointerVisitor::visit (AST::ParenthesisedType &type)
963 : {
964 38 : reseat (type.get_type_in_parens ());
965 38 : }
966 :
967 : void
968 652 : PointerVisitor::visit (AST::ImplTraitTypeOneBound &type)
969 : {
970 : // FIXME: Do we need to reseat here?
971 652 : visit (type.get_trait_bound ());
972 652 : }
973 :
974 : void
975 780 : PointerVisitor::visit (AST::TraitObjectTypeOneBound &type)
976 : {
977 : // FIXME: Do we need to reseat here?
978 780 : visit (type.get_trait_bound ());
979 780 : }
980 :
981 : void
982 2467 : PointerVisitor::visit (AST::TupleType &type)
983 : {
984 6308 : for (auto &elem : type.get_elems ())
985 3841 : reseat (elem);
986 2467 : }
987 :
988 : void
989 36239 : PointerVisitor::visit (AST::RawPointerType &type)
990 : {
991 36239 : reseat (type.get_type_pointed_to_ptr ());
992 36239 : }
993 :
994 : void
995 25767 : PointerVisitor::visit (AST::ReferenceType &type)
996 : {
997 25767 : visit (type.get_lifetime ());
998 25767 : reseat (type.get_type_ptr ());
999 25767 : }
1000 :
1001 : void
1002 3853 : PointerVisitor::visit (AST::ArrayType &type)
1003 : {
1004 3853 : reseat (type.get_elem_type_ptr ());
1005 3853 : visit (type.get_size_expr ());
1006 3853 : }
1007 :
1008 : void
1009 4344 : PointerVisitor::visit (AST::SliceType &type)
1010 : {
1011 4344 : reseat (type.get_elem_type_ptr ());
1012 4344 : }
1013 :
1014 : void
1015 152 : PointerVisitor::visit (AST::MaybeNamedParam ¶m)
1016 : {
1017 152 : visit_outer_attrs (param);
1018 152 : reseat (param.get_type_ptr ());
1019 152 : }
1020 :
1021 : void
1022 195 : PointerVisitor::visit (AST::BareFunctionType &type)
1023 : {
1024 204 : for (auto &lifetime : type.get_for_lifetimes ())
1025 9 : visit (lifetime);
1026 195 : visit (type.get_function_qualifiers ());
1027 347 : for (auto ¶m : type.get_function_params ())
1028 152 : visit (param);
1029 195 : if (type.is_variadic ())
1030 0 : for (auto attr : type.get_variadic_attr ())
1031 0 : visit (attr);
1032 195 : if (type.has_return_type ())
1033 145 : reseat (type.get_return_type_ptr ());
1034 195 : }
1035 :
1036 : void
1037 0 : PointerVisitor::visit (AST::FormatArgs &)
1038 : {
1039 : // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1040 0 : }
1041 :
1042 : void
1043 45 : PointerVisitor::visit (AST::OffsetOf &offset_of)
1044 : {
1045 45 : reseat (offset_of.get_type_ptr ());
1046 45 : }
1047 :
1048 : void
1049 2603 : PointerVisitor::visit (AST::VariadicParam ¶m)
1050 : {
1051 2603 : if (param.has_pattern ())
1052 33 : reseat (param.get_pattern_ptr ());
1053 2603 : }
1054 :
1055 : } // namespace AST
1056 : } // namespace Rust
|
