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 15370 : PointerVisitor::visit (AST::Crate &crate)
28 : {
29 15370 : visit_inner_attrs (crate);
30 81123 : for (auto &item : crate.items)
31 65753 : reseat (item);
32 15370 : }
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 78445 : PointerVisitor::visit (AST::IdentifierExpr &ident_expr)
46 : {
47 78445 : visit_outer_attrs (ident_expr);
48 78445 : }
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 300 : PointerVisitor::visit (AST::ConstGenericParam &const_param)
60 : {
61 300 : visit_outer_attrs (const_param);
62 300 : if (const_param.has_type ())
63 300 : reseat (const_param.get_type_ptr ());
64 :
65 300 : if (const_param.has_default_value ())
66 54 : visit (const_param.get_default_value_unchecked ());
67 300 : }
68 :
69 : void
70 81835 : PointerVisitor::visit (AST::PathInExpression &path)
71 : {
72 81835 : visit_outer_attrs (path);
73 :
74 81835 : if (!path.is_lang_item ())
75 190934 : for (auto &segment : path.get_segments ())
76 109272 : visit (segment);
77 81835 : }
78 :
79 : void
80 267 : PointerVisitor::visit (GenericArgsBinding &binding)
81 : {
82 267 : reseat (binding.get_type_ptr ());
83 267 : }
84 :
85 : void
86 9739 : PointerVisitor::visit (AST::TypePathSegmentGeneric &segment)
87 : {
88 9739 : if (segment.has_generic_args ())
89 9736 : visit (segment.get_generic_args ());
90 9739 : }
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 12875 : 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 26339 : for (auto &generic : args.get_generic_args ())
119 13464 : visit (generic);
120 :
121 13142 : for (auto &binding : args.get_binding_args ())
122 267 : visit (binding);
123 12875 : }
124 :
125 : void
126 124962 : PointerVisitor::visit (AST::PathExprSegment &segment)
127 : {
128 124962 : visit (segment.get_ident_segment ());
129 124962 : if (segment.has_generic_args ())
130 3139 : visit (segment.get_generic_args ());
131 124962 : }
132 : void
133 307666 : PointerVisitor::visit (AST::TypePath &path)
134 : {
135 626057 : for (auto &segment : path.get_segments ())
136 318391 : visit (segment);
137 307666 : }
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 11086 : PointerVisitor::visit (AST::BorrowExpr &expr)
166 : {
167 11086 : visit_outer_attrs (expr);
168 11086 : reseat (expr.get_borrowed_expr_ptr ());
169 11086 : }
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 3661 : PointerVisitor::visit (AST::NegationExpr &expr)
187 : {
188 3661 : visit_outer_attrs (expr);
189 3661 : reseat (expr.get_negated_expr_ptr ());
190 3661 : }
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 20108 : PointerVisitor::visit (AST::ComparisonExpr &expr)
202 : {
203 20108 : visit_outer_attrs (expr);
204 20108 : reseat (expr.get_left_expr_ptr ());
205 20108 : reseat (expr.get_right_expr_ptr ());
206 20108 : }
207 :
208 : void
209 2008 : PointerVisitor::visit (AST::LazyBooleanExpr &expr)
210 : {
211 2008 : visit_outer_attrs (expr);
212 2008 : reseat (expr.get_left_expr_ptr ());
213 2008 : reseat (expr.get_right_expr_ptr ());
214 2008 : }
215 :
216 : void
217 28667 : PointerVisitor::visit (AST::TypeCastExpr &expr)
218 : {
219 28667 : visit_outer_attrs (expr);
220 28667 : reseat (expr.get_casted_expr_ptr ());
221 28667 : reseat (expr.get_type_to_cast_to_ptr ());
222 28667 : }
223 :
224 : void
225 11598 : PointerVisitor::visit (AST::AssignmentExpr &expr)
226 : {
227 11598 : visit_outer_attrs (expr);
228 11598 : reseat (expr.get_left_expr_ptr ());
229 11598 : reseat (expr.get_right_expr_ptr ());
230 11598 : }
231 :
232 : void
233 3232 : PointerVisitor::visit (AST::CompoundAssignmentExpr &expr)
234 : {
235 3232 : visit_outer_attrs (expr);
236 3232 : reseat (expr.get_left_expr_ptr ());
237 3232 : reseat (expr.get_right_expr_ptr ());
238 3232 : }
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 1505 : PointerVisitor::visit (AST::ArrayElemsValues &elems)
250 : {
251 8601 : for (auto &value : elems.get_values ())
252 7096 : reseat (value);
253 1505 : }
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 2115 : PointerVisitor::visit (AST::ArrayExpr &expr)
264 : {
265 2115 : visit_outer_attrs (expr);
266 2115 : visit_inner_attrs (expr);
267 2115 : visit (expr.get_array_elems ());
268 2115 : }
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 3093 : PointerVisitor::visit (AST::TupleExpr &expr)
280 : {
281 3093 : visit_outer_attrs (expr);
282 3093 : visit_inner_attrs (expr);
283 8525 : for (auto &elem : expr.get_tuple_elems ())
284 5432 : reseat (elem);
285 3093 : }
286 :
287 : void
288 4667 : PointerVisitor::visit (AST::TupleIndexExpr &expr)
289 : {
290 4667 : visit_outer_attrs (expr);
291 4667 : reseat (expr.get_tuple_expr_ptr ());
292 4667 : }
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 70754 : PointerVisitor::visit (AST::CallExpr &expr)
314 : {
315 70754 : visit_outer_attrs (expr);
316 70754 : reseat (expr.get_function_expr_ptr ());
317 151610 : for (auto ¶m : expr.get_params ())
318 80856 : reseat (param);
319 70754 : }
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 77832 : PointerVisitor::visit (AST::BlockExpr &expr)
353 : {
354 77832 : visit_outer_attrs (expr);
355 77832 : visit_inner_attrs (expr);
356 :
357 77832 : if (expr.has_label ())
358 0 : visit (expr.get_label ());
359 :
360 153262 : for (auto &stmt : expr.get_statements ())
361 75430 : reseat (stmt);
362 :
363 77832 : if (expr.has_tail_expr ())
364 56365 : reseat (expr.get_tail_expr_ptr ());
365 77832 : }
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 435 : PointerVisitor::visit (AST::BreakExpr &expr)
407 : {
408 435 : visit_outer_attrs (expr);
409 435 : if (expr.has_label ())
410 115 : visit (expr.get_label_unchecked ());
411 :
412 435 : if (expr.has_break_expr ())
413 110 : reseat (expr.get_break_expr_ptr_unchecked ());
414 435 : }
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 19969 : PointerVisitor::visit (AST::UnsafeBlockExpr &expr)
472 : {
473 19969 : visit_outer_attrs (expr);
474 19969 : reseat (expr.get_block_expr_ptr ());
475 19969 : }
476 :
477 : void
478 615 : PointerVisitor::visit (AST::LoopExpr &expr)
479 : {
480 615 : visit_outer_attrs (expr);
481 615 : if (expr.has_loop_label ())
482 190 : visit (expr.get_loop_label ());
483 615 : reseat (expr.get_loop_block_ptr ());
484 615 : }
485 :
486 : void
487 518 : PointerVisitor::visit (AST::WhileLoopExpr &expr)
488 : {
489 518 : visit_outer_attrs (expr);
490 518 : if (expr.has_loop_label ())
491 10 : visit (expr.get_loop_label ());
492 518 : reseat (expr.get_predicate_expr_ptr ());
493 518 : reseat (expr.get_loop_block_ptr ());
494 518 : }
495 :
496 : void
497 8 : PointerVisitor::visit (AST::WhileLetLoopExpr &expr)
498 : {
499 8 : visit_outer_attrs (expr);
500 8 : reseat (expr.get_pattern ());
501 :
502 8 : if (expr.has_loop_label ())
503 0 : visit (expr.get_loop_label ());
504 :
505 8 : reseat (expr.get_scrutinee_expr_ptr ());
506 8 : reseat (expr.get_loop_block_ptr ());
507 8 : }
508 :
509 : void
510 128 : PointerVisitor::visit (AST::ForLoopExpr &expr)
511 : {
512 128 : visit_outer_attrs (expr);
513 128 : reseat (expr.get_pattern_ptr ());
514 128 : reseat (expr.get_iterator_expr_ptr ());
515 128 : if (expr.has_loop_label ())
516 0 : visit (expr.get_loop_label ());
517 128 : reseat (expr.get_loop_block_ptr ());
518 128 : }
519 :
520 : void
521 8177 : PointerVisitor::visit (AST::IfExpr &expr)
522 : {
523 8177 : visit_outer_attrs (expr);
524 8177 : reseat (expr.get_condition_expr_ptr ());
525 8177 : visit (expr.get_if_block ());
526 8177 : }
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 14035 : PointerVisitor::visit (AST::MatchArm &arm)
539 : {
540 14035 : visit_outer_attrs (arm);
541 14035 : reseat (arm.get_pattern ());
542 14035 : if (arm.has_match_arm_guard ())
543 5 : reseat (arm.get_guard_expr_ptr ());
544 14035 : }
545 :
546 : void
547 14035 : PointerVisitor::visit (AST::MatchCase &arm)
548 : {
549 14035 : visit (arm.get_arm ());
550 14035 : reseat (arm.get_expr_ptr ());
551 14035 : }
552 :
553 : void
554 6045 : PointerVisitor::visit (AST::MatchExpr &expr)
555 : {
556 6045 : visit_outer_attrs (expr);
557 6045 : visit_inner_attrs (expr);
558 6045 : reseat (expr.get_scrutinee_expr_ptr ());
559 20080 : for (auto &arm : expr.get_match_cases ())
560 14035 : visit (arm);
561 6045 : }
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 28365 : PointerVisitor::visit (AST::TypeParam ¶m)
639 : {
640 28365 : visit_outer_attrs (param);
641 : // FIXME: Can we do macro expansion here?
642 30986 : for (auto &bound : param.get_type_param_bounds ())
643 2621 : visit (bound);
644 28365 : if (param.has_type ())
645 1277 : reseat (param.get_type_ptr ());
646 28365 : }
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 38382 : PointerVisitor::visit (AST::FunctionParam ¶m)
661 : {
662 38382 : visit_outer_attrs (param);
663 38382 : if (param.has_name ())
664 38382 : reseat (param.get_pattern_ptr ());
665 :
666 38382 : reseat (param.get_type_ptr ());
667 38382 : }
668 :
669 : void
670 27846 : PointerVisitor::visit (AST::SelfParam ¶m)
671 : {
672 27846 : visit_outer_attrs (param);
673 :
674 27846 : if (param.has_lifetime ())
675 15914 : visit (param.get_lifetime ());
676 :
677 27846 : if (param.has_type ())
678 3 : reseat (param.get_type_ptr ());
679 27846 : }
680 :
681 : void
682 4479 : PointerVisitor::visit (AST::Module &module)
683 : {
684 4479 : visit_outer_attrs (module);
685 4479 : visit (module.get_visibility ());
686 4479 : visit_inner_attrs (module);
687 20512 : for (auto &item : module.get_items ())
688 16033 : reseat (item);
689 4479 : }
690 :
691 : void
692 63368 : PointerVisitor::visit_function_params (AST::Function &function)
693 : {
694 132184 : for (auto ¶m : function.get_function_params ())
695 68816 : visit (param);
696 63368 : }
697 :
698 : void
699 63368 : PointerVisitor::visit (AST::Function &function)
700 : {
701 63368 : visit_outer_attrs (function);
702 63368 : visit (function.get_visibility ());
703 63368 : visit (function.get_qualifiers ());
704 69733 : for (auto &generic : function.get_generic_params ())
705 6365 : visit (generic);
706 :
707 63368 : visit_function_params (function);
708 :
709 63368 : if (function.has_return_type ())
710 46033 : reseat (function.get_return_type_ptr ());
711 63368 : if (function.has_where_clause ())
712 715 : visit (function.get_where_clause ());
713 63368 : if (function.has_body ())
714 48913 : reseat (*function.get_definition ());
715 63368 : }
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 7011 : PointerVisitor::visit (AST::TupleField &field)
739 : {
740 7011 : visit_outer_attrs (field);
741 7011 : visit (field.get_visibility ());
742 7011 : reseat (field.get_field_type_ptr ());
743 7011 : }
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 2915 : PointerVisitor::visit (AST::ConstantItem &const_item)
754 : {
755 2915 : visit_outer_attrs (const_item);
756 2915 : visit (const_item.get_visibility ());
757 2915 : reseat (const_item.get_type_ptr ());
758 2915 : if (const_item.has_expr ())
759 2746 : reseat (const_item.get_expr_ptr ());
760 2915 : }
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 12856 : PointerVisitor::visit (AST::Trait &trait)
773 : {
774 12856 : visit_outer_attrs (trait);
775 12856 : visit (trait.get_visibility ());
776 :
777 12856 : visit_inner_attrs (trait);
778 :
779 12856 : visit (trait.get_implicit_self ());
780 :
781 15156 : for (auto &generic : trait.get_generic_params ())
782 2300 : visit (generic);
783 :
784 12856 : if (trait.has_where_clause ())
785 28 : visit (trait.get_where_clause ());
786 :
787 15141 : for (auto &bound : trait.get_type_param_bounds ())
788 2285 : visit (bound);
789 :
790 24655 : for (auto &item : trait.get_trait_items ())
791 11799 : reseat (item);
792 12856 : }
793 :
794 : void
795 3159 : PointerVisitor::visit (AST::InherentImpl &impl)
796 : {
797 3159 : visit_outer_attrs (impl);
798 3159 : visit (impl.get_visibility ());
799 :
800 4256 : for (auto &generic : impl.get_generic_params ())
801 1097 : visit (generic);
802 3159 : if (impl.has_where_clause ())
803 3 : visit (impl.get_where_clause ());
804 3159 : reseat (impl.get_type_ptr ());
805 3159 : visit_inner_attrs (impl);
806 12808 : for (auto &item : impl.get_impl_items ())
807 9649 : reseat (item);
808 3159 : }
809 :
810 : void
811 15887 : PointerVisitor::visit (AST::TraitImpl &impl)
812 : {
813 15887 : visit_outer_attrs (impl);
814 15887 : visit (impl.get_visibility ());
815 :
816 18603 : for (auto &generic : impl.get_generic_params ())
817 2716 : visit (generic);
818 15887 : if (impl.has_where_clause ())
819 297 : visit (impl.get_where_clause ());
820 15887 : reseat (impl.get_type_ptr ());
821 15887 : visit (impl.get_trait_path ());
822 15887 : visit_inner_attrs (impl);
823 34641 : for (auto &item : impl.get_impl_items ())
824 18754 : reseat (item);
825 15887 : }
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 5197 : PointerVisitor::visit (AST::ExternBlock &block)
837 : {
838 5197 : visit_outer_attrs (block);
839 5197 : visit (block.get_visibility ());
840 5197 : visit_inner_attrs (block);
841 13627 : for (auto &item : block.get_extern_items ())
842 8430 : reseat (item);
843 5197 : }
844 :
845 : void
846 81433 : PointerVisitor::visit (AST::IdentifierPattern &pattern)
847 : {
848 81433 : if (pattern.has_subpattern ())
849 54 : reseat (pattern.get_subpattern_ptr ());
850 81433 : }
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 3614 : PointerVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
885 : {
886 7671 : for (auto &pattern : tuple_items.get_patterns ())
887 4057 : reseat (pattern);
888 3614 : }
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 96 : PointerVisitor::visit (AST::SlicePatternItemsNoRest &items)
923 : {
924 288 : for (auto &item : items.get_patterns ())
925 192 : reseat (item);
926 96 : }
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 67554 : PointerVisitor::visit (AST::LetStmt &stmt)
946 : {
947 67554 : visit_outer_attrs (stmt);
948 67554 : reseat (stmt.get_pattern_ptr ());
949 67554 : if (stmt.has_type ())
950 11047 : reseat (stmt.get_type_ptr ());
951 67554 : if (stmt.has_init_expr ())
952 61640 : reseat (stmt.get_init_expr_ptr ());
953 67554 : }
954 :
955 : void
956 55402 : PointerVisitor::visit (AST::ExprStmt &stmt)
957 : {
958 55402 : reseat (stmt.get_expr_ptr ());
959 55402 : }
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 2458 : PointerVisitor::visit (AST::TupleType &type)
983 : {
984 6289 : for (auto &elem : type.get_elems ())
985 3831 : reseat (elem);
986 2458 : }
987 :
988 : void
989 36104 : PointerVisitor::visit (AST::RawPointerType &type)
990 : {
991 36104 : reseat (type.get_type_pointed_to_ptr ());
992 36104 : }
993 :
994 : void
995 25777 : PointerVisitor::visit (AST::ReferenceType &type)
996 : {
997 25777 : visit (type.get_lifetime ());
998 25777 : reseat (type.get_type_ptr ());
999 25777 : }
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 146 : PointerVisitor::visit (AST::MaybeNamedParam ¶m)
1016 : {
1017 146 : visit_outer_attrs (param);
1018 146 : reseat (param.get_type_ptr ());
1019 146 : }
1020 :
1021 : void
1022 192 : PointerVisitor::visit (AST::BareFunctionType &type)
1023 : {
1024 201 : for (auto &lifetime : type.get_for_lifetimes ())
1025 9 : visit (lifetime);
1026 192 : visit (type.get_function_qualifiers ());
1027 338 : for (auto ¶m : type.get_function_params ())
1028 146 : visit (param);
1029 192 : if (type.is_variadic ())
1030 0 : for (auto attr : type.get_variadic_attr ())
1031 0 : visit (attr);
1032 192 : if (type.has_return_type ())
1033 145 : reseat (type.get_return_type_ptr ());
1034 192 : }
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 2588 : PointerVisitor::visit (AST::VariadicParam ¶m)
1050 : {
1051 2588 : if (param.has_pattern ())
1052 33 : reseat (param.get_pattern_ptr ());
1053 2588 : }
1054 :
1055 : } // namespace AST
1056 : } // namespace Rust
|
