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 16571 : PointerVisitor::visit (AST::Crate &crate)
28 : {
29 16571 : visit_inner_attrs (crate);
30 92680 : for (auto &item : crate.items)
31 76109 : reseat (item);
32 16571 : }
33 :
34 : void
35 6961 : 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 14749 : for (auto &item : input.get_items ())
41 7788 : visit (item);
42 6961 : }
43 :
44 : void
45 4199916 : PointerVisitor::visit (AST::IdentifierExpr &ident_expr)
46 : {
47 4199916 : visit_outer_attrs (ident_expr);
48 4199916 : }
49 :
50 : void
51 43690 : PointerVisitor::visit (AST::LifetimeParam &lifetime_param)
52 : {
53 43690 : visit_outer_attrs (lifetime_param);
54 :
55 : // Nothing to do for lifetimes right?
56 43690 : }
57 :
58 : void
59 3105 : PointerVisitor::visit (AST::ConstGenericParam &const_param)
60 : {
61 3105 : visit_outer_attrs (const_param);
62 3105 : if (const_param.has_type ())
63 3105 : reseat (const_param.get_type_ptr ());
64 :
65 3105 : if (const_param.has_default_value ())
66 60 : visit (const_param.get_default_value_unchecked ());
67 3105 : }
68 :
69 : void
70 2636081 : PointerVisitor::visit (AST::PathInExpression &path)
71 : {
72 2636081 : visit_outer_attrs (path);
73 :
74 2636081 : if (!path.is_lang_item ())
75 5666205 : for (auto &segment : path.get_segments ())
76 3038747 : visit (segment);
77 2636081 : }
78 :
79 : void
80 12604 : PointerVisitor::visit (GenericArgsBinding &binding)
81 : {
82 12604 : reseat (binding.get_type_ptr ());
83 12604 : }
84 :
85 : void
86 511512 : PointerVisitor::visit (AST::TypePathSegmentGeneric &segment)
87 : {
88 511512 : if (segment.has_generic_args ())
89 511509 : visit (segment.get_generic_args ());
90 511512 : }
91 :
92 : void
93 18613 : PointerVisitor::visit (AST::TypePathFunction &tpf)
94 : {
95 44394 : for (auto &input : tpf.get_params ())
96 25781 : reseat (input);
97 18613 : if (tpf.has_return_type ())
98 17982 : reseat (tpf.get_return_type_ptr ());
99 18613 : }
100 :
101 : void
102 18613 : PointerVisitor::visit (AST::TypePathSegmentFunction &segment)
103 : {
104 : // FIXME: No reseating here correct? No macros possible or desugar?
105 18613 : visit (segment.get_type_path_function ());
106 18613 : visit (segment.get_ident_segment ());
107 18613 : }
108 :
109 : void
110 532039 : 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 1055909 : for (auto &generic : args.get_generic_args ())
119 523870 : visit (generic);
120 :
121 544643 : for (auto &binding : args.get_binding_args ())
122 12604 : visit (binding);
123 532039 : }
124 :
125 : void
126 4867464 : PointerVisitor::visit (AST::PathExprSegment &segment)
127 : {
128 4867464 : visit (segment.get_ident_segment ());
129 4867464 : if (segment.has_generic_args ())
130 20530 : visit (segment.get_generic_args ());
131 4867464 : }
132 : void
133 4876028 : PointerVisitor::visit (AST::TypePath &path)
134 : {
135 10098604 : for (auto &segment : path.get_segments ())
136 5222576 : visit (segment);
137 4876028 : }
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 110660 : PointerVisitor::visit (AST::QualifiedPathType &path)
151 : {
152 110660 : reseat (path.get_type_ptr ());
153 110660 : if (path.has_as_clause ())
154 107876 : visit (path.get_as_type_path ());
155 110660 : }
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 214813 : PointerVisitor::visit (AST::BorrowExpr &expr)
166 : {
167 214813 : visit_outer_attrs (expr);
168 214813 : reseat (expr.get_borrowed_expr_ptr ());
169 214813 : }
170 :
171 : void
172 381480 : PointerVisitor::visit (AST::DereferenceExpr &expr)
173 : {
174 381480 : visit_outer_attrs (expr);
175 381480 : reseat (expr.get_dereferenced_expr_ptr ());
176 381480 : }
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 63543 : PointerVisitor::visit (AST::NegationExpr &expr)
187 : {
188 63543 : visit_outer_attrs (expr);
189 63543 : reseat (expr.get_negated_expr_ptr ());
190 63543 : }
191 :
192 : void
193 2415803 : PointerVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
194 : {
195 2415803 : visit_outer_attrs (expr);
196 2415803 : reseat (expr.get_left_expr_ptr ());
197 2415803 : reseat (expr.get_right_expr_ptr ());
198 2415803 : }
199 :
200 : void
201 197797 : PointerVisitor::visit (AST::ComparisonExpr &expr)
202 : {
203 197797 : visit_outer_attrs (expr);
204 197797 : reseat (expr.get_left_expr_ptr ());
205 197797 : reseat (expr.get_right_expr_ptr ());
206 197797 : }
207 :
208 : void
209 52342 : PointerVisitor::visit (AST::LazyBooleanExpr &expr)
210 : {
211 52342 : visit_outer_attrs (expr);
212 52342 : reseat (expr.get_left_expr_ptr ());
213 52342 : reseat (expr.get_right_expr_ptr ());
214 52342 : }
215 :
216 : void
217 269624 : PointerVisitor::visit (AST::TypeCastExpr &expr)
218 : {
219 269624 : visit_outer_attrs (expr);
220 269624 : reseat (expr.get_casted_expr_ptr ());
221 269624 : reseat (expr.get_type_to_cast_to_ptr ());
222 269624 : }
223 :
224 : void
225 85397 : PointerVisitor::visit (AST::AssignmentExpr &expr)
226 : {
227 85397 : visit_outer_attrs (expr);
228 85397 : reseat (expr.get_left_expr_ptr ());
229 85397 : reseat (expr.get_right_expr_ptr ());
230 85397 : }
231 :
232 : void
233 60532 : PointerVisitor::visit (AST::CompoundAssignmentExpr &expr)
234 : {
235 60532 : visit_outer_attrs (expr);
236 60532 : reseat (expr.get_left_expr_ptr ());
237 60532 : reseat (expr.get_right_expr_ptr ());
238 60532 : }
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 3382 : PointerVisitor::visit (AST::ArrayElemsCopied &elems)
257 : {
258 3382 : reseat (elems.get_elem_to_copy_ptr ());
259 3382 : reseat (elems.get_num_copies_ptr ());
260 3382 : }
261 :
262 : void
263 826724 : PointerVisitor::visit (AST::ArrayExpr &expr)
264 : {
265 826724 : visit_outer_attrs (expr);
266 826724 : visit_inner_attrs (expr);
267 826724 : visit (expr.get_array_elems ());
268 826724 : }
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 285081 : PointerVisitor::visit (AST::TupleExpr &expr)
280 : {
281 285081 : visit_outer_attrs (expr);
282 285081 : visit_inner_attrs (expr);
283 815193 : for (auto &elem : expr.get_tuple_elems ())
284 530112 : reseat (elem);
285 285081 : }
286 :
287 : void
288 244079 : PointerVisitor::visit (AST::TupleIndexExpr &expr)
289 : {
290 244079 : visit_outer_attrs (expr);
291 244079 : reseat (expr.get_tuple_expr_ptr ());
292 244079 : }
293 :
294 : void
295 57964 : PointerVisitor::visit (AST::StructExprFieldIdentifierValue &field)
296 : {
297 57964 : reseat (field.get_value_ptr ());
298 57964 : }
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 4143058 : PointerVisitor::visit (AST::CallExpr &expr)
314 : {
315 4143058 : visit_outer_attrs (expr);
316 4143058 : reseat (expr.get_function_expr_ptr ());
317 14974494 : for (auto ¶m : expr.get_params ())
318 10831436 : reseat (param);
319 4143058 : }
320 :
321 : void
322 1824755 : PointerVisitor::visit (AST::MethodCallExpr &expr)
323 : {
324 1824755 : visit_outer_attrs (expr);
325 1824755 : reseat (expr.get_receiver_expr_ptr ());
326 1824755 : visit (expr.get_method_name ());
327 2119334 : for (auto ¶m : expr.get_params ())
328 294579 : reseat (param);
329 1824755 : }
330 :
331 : void
332 251769 : PointerVisitor::visit (AST::FieldAccessExpr &expr)
333 : {
334 251769 : visit_outer_attrs (expr);
335 251769 : reseat (expr.get_receiver_expr_ptr ());
336 251769 : }
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 675733 : PointerVisitor::visit (AST::BlockExpr &expr)
353 : {
354 675733 : visit_outer_attrs (expr);
355 675733 : visit_inner_attrs (expr);
356 :
357 675733 : if (expr.has_label ())
358 9 : visit (expr.get_label ());
359 :
360 1070493 : for (auto &stmt : expr.get_statements ())
361 394760 : reseat (stmt);
362 :
363 675733 : if (expr.has_tail_expr ())
364 582705 : reseat (expr.get_tail_expr_ptr ());
365 675733 : }
366 :
367 : void
368 24920 : PointerVisitor::visit (AST::AnonConst &expr)
369 : {
370 24920 : if (!expr.is_deferred ())
371 24869 : reseat (expr.get_inner_expr_ptr ());
372 24920 : }
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 29207 : PointerVisitor::visit (AST::ReturnExpr &expr)
450 : {
451 29207 : visit_outer_attrs (expr);
452 29207 : if (expr.has_returned_expr ())
453 27914 : reseat (expr.get_returned_expr_ptr ());
454 29207 : }
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 99079 : PointerVisitor::visit (AST::UnsafeBlockExpr &expr)
472 : {
473 99079 : visit_outer_attrs (expr);
474 99079 : reseat (expr.get_block_expr_ptr ());
475 99079 : }
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 70200 : PointerVisitor::visit (AST::IfExpr &expr)
522 : {
523 70200 : visit_outer_attrs (expr);
524 70200 : reseat (expr.get_condition_expr_ptr ());
525 70200 : visit (expr.get_if_block ());
526 70200 : }
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 3266934 : PointerVisitor::visit (AST::MatchArm &arm)
539 : {
540 3266934 : visit_outer_attrs (arm);
541 3266934 : reseat (arm.get_pattern ());
542 3266934 : if (arm.has_match_arm_guard ())
543 2684 : reseat (arm.get_guard_expr_ptr ());
544 3266934 : }
545 :
546 : void
547 3266934 : PointerVisitor::visit (AST::MatchCase &arm)
548 : {
549 3266934 : visit (arm.get_arm ());
550 3266934 : reseat (arm.get_expr_ptr ());
551 3266934 : }
552 :
553 : void
554 314318 : PointerVisitor::visit (AST::MatchExpr &expr)
555 : {
556 314318 : visit_outer_attrs (expr);
557 314318 : visit_inner_attrs (expr);
558 314318 : reseat (expr.get_scrutinee_expr_ptr ());
559 3581252 : for (auto &arm : expr.get_match_cases ())
560 3266934 : visit (arm);
561 314318 : }
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 305580 : PointerVisitor::visit (AST::TypeParam ¶m)
641 : {
642 305580 : visit_outer_attrs (param);
643 : // FIXME: Can we do macro expansion here?
644 390666 : for (auto &bound : param.get_type_param_bounds ())
645 85086 : visit (bound);
646 305580 : if (param.has_type ())
647 2520 : reseat (param.get_type_ptr ());
648 305580 : }
649 :
650 : void
651 40572 : PointerVisitor::visit (AST::TypeBoundWhereClauseItem &item)
652 : {
653 40635 : for (auto &lifetime : item.get_for_lifetimes ())
654 63 : visit (lifetime);
655 40572 : reseat (item.get_type_ptr ());
656 : // FIXME: Likewise?
657 83080 : for (auto ¶m : item.get_type_param_bounds ())
658 42508 : visit (param);
659 40572 : }
660 :
661 : void
662 564542 : PointerVisitor::visit (AST::FunctionParam ¶m)
663 : {
664 564542 : visit_outer_attrs (param);
665 564542 : if (param.has_name ())
666 564542 : reseat (param.get_pattern_ptr ());
667 :
668 564542 : reseat (param.get_type_ptr ());
669 564542 : }
670 :
671 : void
672 320023 : PointerVisitor::visit (AST::SelfParam ¶m)
673 : {
674 320023 : visit_outer_attrs (param);
675 :
676 320023 : if (param.has_lifetime ())
677 150476 : visit (param.get_lifetime ());
678 :
679 320023 : if (param.has_type ())
680 537 : reseat (param.get_type_ptr ());
681 320023 : }
682 :
683 : void
684 13844 : PointerVisitor::visit (AST::Module &module)
685 : {
686 13844 : visit_outer_attrs (module);
687 13844 : visit (module.get_visibility ());
688 13844 : visit_inner_attrs (module);
689 429755 : for (auto &item : module.get_items ())
690 415911 : reseat (item);
691 13844 : }
692 :
693 : void
694 505760 : PointerVisitor::visit_function_params (AST::Function &function)
695 : {
696 1393123 : for (auto ¶m : function.get_function_params ())
697 887363 : visit (param);
698 505760 : }
699 :
700 : void
701 505760 : PointerVisitor::visit (AST::Function &function)
702 : {
703 505760 : visit_outer_attrs (function);
704 505760 : visit (function.get_visibility ());
705 505760 : visit (function.get_qualifiers ());
706 567502 : for (auto &generic : function.get_generic_params ())
707 61742 : visit (generic);
708 :
709 505760 : visit_function_params (function);
710 :
711 505760 : if (function.has_return_type ())
712 430382 : reseat (function.get_return_type_ptr ());
713 505760 : if (function.has_where_clause ())
714 16244 : visit (function.get_where_clause ());
715 505760 : if (function.has_body ())
716 453664 : reseat (*function.get_definition ());
717 505760 : }
718 :
719 : void
720 185675 : PointerVisitor::visit (AST::TypeAlias &type_alias)
721 : {
722 185675 : visit_outer_attrs (type_alias);
723 185675 : visit (type_alias.get_visibility ());
724 185820 : for (auto &generic : type_alias.get_generic_params ())
725 145 : visit (generic);
726 185675 : if (type_alias.has_where_clause ())
727 0 : visit (type_alias.get_where_clause ());
728 185675 : reseat (type_alias.get_type_aliased_ptr ());
729 185675 : }
730 :
731 : void
732 44248 : PointerVisitor::visit (AST::StructField &field)
733 : {
734 44248 : visit_outer_attrs (field);
735 44248 : visit (field.get_visibility ());
736 44248 : reseat (field.get_field_type_ptr ());
737 44248 : }
738 :
739 : void
740 47849 : PointerVisitor::visit (AST::TupleField &field)
741 : {
742 47849 : visit_outer_attrs (field);
743 47849 : visit (field.get_visibility ());
744 47849 : reseat (field.get_field_type_ptr ());
745 47849 : }
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 52866 : PointerVisitor::visit (AST::ConstantItem &const_item)
756 : {
757 52866 : visit_outer_attrs (const_item);
758 52866 : visit (const_item.get_visibility ());
759 52866 : reseat (const_item.get_type_ptr ());
760 52866 : if (const_item.has_expr ())
761 51338 : reseat (const_item.get_expr_ptr ());
762 52866 : }
763 :
764 : void
765 2954 : PointerVisitor::visit (AST::StaticItem &static_item)
766 : {
767 2954 : visit_outer_attrs (static_item);
768 2954 : visit (static_item.get_visibility ());
769 2954 : reseat (static_item.get_type_ptr ());
770 2954 : reseat (static_item.get_expr_ptr ());
771 2954 : }
772 :
773 : void
774 19586 : PointerVisitor::visit (AST::Trait &trait)
775 : {
776 19586 : visit_outer_attrs (trait);
777 19586 : visit (trait.get_visibility ());
778 :
779 19586 : visit_inner_attrs (trait);
780 :
781 19586 : visit (trait.get_implicit_self ());
782 :
783 24605 : for (auto &generic : trait.get_generic_params ())
784 5019 : visit (generic);
785 :
786 19586 : if (trait.has_where_clause ())
787 28 : visit (trait.get_where_clause ());
788 :
789 24814 : for (auto &bound : trait.get_type_param_bounds ())
790 5228 : visit (bound);
791 :
792 47094 : for (auto &item : trait.get_trait_items ())
793 27508 : reseat (item);
794 19586 : }
795 :
796 : void
797 14788 : PointerVisitor::visit (AST::InherentImpl &impl)
798 : {
799 14788 : visit_outer_attrs (impl);
800 14788 : visit (impl.get_visibility ());
801 :
802 27267 : for (auto &generic : impl.get_generic_params ())
803 12479 : visit (generic);
804 14788 : if (impl.has_where_clause ())
805 111 : visit (impl.get_where_clause ());
806 14788 : reseat (impl.get_type_ptr ());
807 14788 : visit_inner_attrs (impl);
808 106792 : for (auto &item : impl.get_impl_items ())
809 92004 : reseat (item);
810 14788 : }
811 :
812 : void
813 252046 : PointerVisitor::visit (AST::TraitImpl &impl)
814 : {
815 252046 : visit_outer_attrs (impl);
816 252046 : visit (impl.get_visibility ());
817 :
818 487959 : for (auto &generic : impl.get_generic_params ())
819 235913 : visit (generic);
820 252046 : if (impl.has_where_clause ())
821 13257 : visit (impl.get_where_clause ());
822 252046 : reseat (impl.get_type_ptr ());
823 252046 : visit (impl.get_trait_path ());
824 252046 : visit_inner_attrs (impl);
825 607265 : for (auto &item : impl.get_impl_items ())
826 355219 : reseat (item);
827 252046 : }
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 7194 : PointerVisitor::visit (AST::ExternBlock &block)
839 : {
840 7194 : visit_outer_attrs (block);
841 7194 : visit (block.get_visibility ());
842 7194 : visit_inner_attrs (block);
843 45966 : for (auto &item : block.get_extern_items ())
844 38772 : reseat (item);
845 7194 : }
846 :
847 : void
848 1554997 : PointerVisitor::visit (AST::IdentifierPattern &pattern)
849 : {
850 1554997 : if (pattern.has_subpattern ())
851 1083 : reseat (pattern.get_subpattern_ptr ());
852 1554997 : }
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 62168 : PointerVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
887 : {
888 127056 : for (auto &pattern : tuple_items.get_patterns ())
889 64888 : reseat (pattern);
890 62168 : }
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 178115 : PointerVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
903 : {
904 590918 : for (auto &pattern : tuple_items.get_patterns ())
905 412803 : reseat (pattern);
906 178115 : }
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 250 : PointerVisitor::visit (AST::GroupedPattern &pattern)
919 : {
920 250 : reseat (pattern.get_pattern_in_parens_ptr ());
921 250 : }
922 :
923 : void
924 1349 : PointerVisitor::visit (AST::SlicePattern &pattern)
925 : {
926 4251 : for (auto &pat : pattern.get_patterns ())
927 2902 : reseat (pat);
928 1349 : }
929 :
930 : void
931 3645 : PointerVisitor::visit (AST::AltPattern &pattern)
932 : {
933 12636 : for (auto &alt : pattern.get_alts ())
934 8991 : reseat (alt);
935 3645 : }
936 :
937 : void
938 334235 : PointerVisitor::visit (AST::LetStmt &stmt)
939 : {
940 334235 : visit_outer_attrs (stmt);
941 334235 : reseat (stmt.get_pattern_ptr ());
942 334235 : if (stmt.has_type ())
943 40585 : reseat (stmt.get_type_ptr ());
944 334235 : if (stmt.has_init_expr ())
945 320368 : reseat (stmt.get_init_expr_ptr ());
946 334235 : }
947 :
948 : void
949 337697 : PointerVisitor::visit (AST::ExprStmt &stmt)
950 : {
951 337697 : reseat (stmt.get_expr_ptr ());
952 337697 : }
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 68574 : PointerVisitor::visit (AST::TupleType &type)
976 : {
977 225140 : for (auto &elem : type.get_elems ())
978 156566 : reseat (elem);
979 68574 : }
980 :
981 : void
982 122733 : PointerVisitor::visit (AST::RawPointerType &type)
983 : {
984 122733 : reseat (type.get_type_pointed_to_ptr ());
985 122733 : }
986 :
987 : void
988 550790 : PointerVisitor::visit (AST::ReferenceType &type)
989 : {
990 550790 : visit (type.get_lifetime ());
991 550790 : reseat (type.get_type_ptr ());
992 550790 : }
993 :
994 : void
995 24859 : PointerVisitor::visit (AST::ArrayType &type)
996 : {
997 24859 : reseat (type.get_elem_type_ptr ());
998 24859 : visit (type.get_size_expr ());
999 24859 : }
1000 :
1001 : void
1002 47939 : PointerVisitor::visit (AST::SliceType &type)
1003 : {
1004 47939 : reseat (type.get_elem_type_ptr ());
1005 47939 : }
1006 :
1007 : void
1008 112234 : PointerVisitor::visit (AST::MaybeNamedParam ¶m)
1009 : {
1010 112234 : visit_outer_attrs (param);
1011 112234 : reseat (param.get_type_ptr ());
1012 112234 : }
1013 :
1014 : void
1015 18868 : PointerVisitor::visit (AST::BareFunctionType &type)
1016 : {
1017 18880 : for (auto &lifetime : type.get_for_lifetimes ())
1018 12 : visit (lifetime);
1019 18868 : visit (type.get_function_qualifiers ());
1020 131102 : for (auto ¶m : type.get_function_params ())
1021 112234 : visit (param);
1022 18868 : if (type.is_variadic ())
1023 5712 : for (auto attr : type.get_variadic_attr ())
1024 0 : visit (attr);
1025 18868 : if (type.has_return_type ())
1026 18503 : reseat (type.get_return_type_ptr ());
1027 18868 : }
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
|
