Branch data Line data Source code
1 : : // Copyright (C) 2025 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 : 4354 : PointerVisitor::visit (AST::Crate &crate)
28 : : {
29 : 4354 : visit_inner_attrs (crate);
30 : 23283 : for (auto &item : crate.items)
31 : 18929 : reseat (item);
32 : 4354 : }
33 : :
34 : : void
35 : 0 : 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 : 0 : for (auto &item : input.get_items ())
41 : 0 : visit (item);
42 : 0 : }
43 : :
44 : : void
45 : 146174 : PointerVisitor::visit (AST::IdentifierExpr &ident_expr)
46 : : {
47 : 146174 : visit_outer_attrs (ident_expr);
48 : 146174 : }
49 : :
50 : : void
51 : 1469 : PointerVisitor::visit (AST::LifetimeParam &lifetime_param)
52 : : {
53 : 1469 : visit_outer_attrs (lifetime_param);
54 : :
55 : : // Nothing to do for lifetimes right?
56 : 1469 : }
57 : :
58 : : void
59 : 172 : PointerVisitor::visit (AST::ConstGenericParam &const_param)
60 : : {
61 : 172 : visit_outer_attrs (const_param);
62 : 172 : if (const_param.has_type ())
63 : 172 : reseat (const_param.get_type_ptr ());
64 : :
65 : 172 : if (const_param.has_default_value ())
66 : 18 : visit (const_param.get_default_value_unchecked ());
67 : 172 : }
68 : :
69 : : void
70 : 99545 : PointerVisitor::visit (AST::PathInExpression &path)
71 : : {
72 : 99545 : visit_outer_attrs (path);
73 : :
74 : 99545 : if (!path.is_lang_item ())
75 : 214363 : for (auto &segment : path.get_segments ())
76 : 116546 : visit (segment);
77 : 99545 : }
78 : :
79 : : void
80 : 331 : PointerVisitor::visit (GenericArgsBinding &binding)
81 : : {
82 : 331 : reseat (binding.get_type_ptr ());
83 : 331 : }
84 : :
85 : : void
86 : 17173 : PointerVisitor::visit (AST::TypePathSegmentGeneric &segment)
87 : : {
88 : 17173 : if (segment.has_generic_args ())
89 : 17172 : visit (segment.get_generic_args ());
90 : 17173 : }
91 : :
92 : : void
93 : 534 : PointerVisitor::visit (AST::TypePathFunction &tpf)
94 : : {
95 : 1267 : for (auto &input : tpf.get_params ())
96 : 733 : reseat (input);
97 : 534 : if (tpf.has_return_type ())
98 : 515 : reseat (tpf.get_return_type_ptr ());
99 : 534 : }
100 : :
101 : : void
102 : 534 : PointerVisitor::visit (AST::TypePathSegmentFunction &segment)
103 : : {
104 : : // FIXME: No reseating here correct? No macros possible or desugar?
105 : 534 : visit (segment.get_type_path_function ());
106 : 534 : visit (segment.get_ident_segment ());
107 : 534 : }
108 : :
109 : : void
110 : 19335 : 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 : 38570 : for (auto &generic : args.get_generic_args ())
119 : 19235 : visit (generic);
120 : :
121 : 19666 : for (auto &binding : args.get_binding_args ())
122 : 331 : visit (binding);
123 : 19335 : }
124 : :
125 : : void
126 : 1028616 : PointerVisitor::visit (AST::PathExprSegment &segment)
127 : : {
128 : 1028616 : visit (segment.get_ident_segment ());
129 : 1028616 : if (segment.has_generic_args ())
130 : 2163 : visit (segment.get_generic_args ());
131 : 1028616 : }
132 : : void
133 : 2434416 : PointerVisitor::visit (AST::TypePath &path)
134 : : {
135 : 5039032 : for (auto &segment : path.get_segments ())
136 : 2604616 : visit (segment);
137 : 2434416 : }
138 : :
139 : : void
140 : 214 : PointerVisitor::visit (AST::QualifiedPathInExpression &path)
141 : : {
142 : 214 : visit_outer_attrs (path);
143 : 214 : visit (path.get_qualified_path_type ());
144 : :
145 : 428 : for (auto &segment : path.get_segments ())
146 : 214 : visit (segment);
147 : 214 : }
148 : :
149 : : void
150 : 3765 : PointerVisitor::visit (AST::QualifiedPathType &path)
151 : : {
152 : 3765 : reseat (path.get_type_ptr ());
153 : 3765 : if (path.has_as_clause ())
154 : 3654 : visit (path.get_as_type_path ());
155 : 3765 : }
156 : :
157 : : void
158 : 3551 : PointerVisitor::visit (AST::QualifiedPathInType &path)
159 : : {
160 : 3551 : visit (path.get_qualified_path_type ());
161 : 3551 : visit (path.get_associated_segment ());
162 : :
163 : 3551 : for (auto &segment : path.get_segments ())
164 : 0 : visit (segment);
165 : 3551 : }
166 : :
167 : : void
168 : 199327 : PointerVisitor::visit (AST::LiteralExpr &expr)
169 : : {
170 : 199327 : visit_outer_attrs (expr);
171 : 199327 : }
172 : :
173 : : void
174 : 0 : PointerVisitor::visit (AST::AttrInputLiteral &attr_input)
175 : : {
176 : 0 : visit (attr_input.get_literal ());
177 : 0 : }
178 : :
179 : : void
180 : 0 : PointerVisitor::visit (AST::AttrInputMacro &attr_input)
181 : : {
182 : 0 : visit (attr_input.get_macro ());
183 : 0 : }
184 : :
185 : : void
186 : 0 : PointerVisitor::visit (AST::MetaItemLitExpr &meta_item)
187 : : {
188 : 0 : visit (meta_item.get_literal ());
189 : 0 : }
190 : :
191 : : void
192 : 1865 : PointerVisitor::visit (AST::SimplePath &path)
193 : : {
194 : 5646 : for (auto &segment : path.get_segments ())
195 : 3781 : visit (segment);
196 : 1865 : }
197 : :
198 : : void
199 : 0 : PointerVisitor::visit (AST::MetaItemPathExpr &meta_item)
200 : : {
201 : 0 : visit (meta_item.get_path ());
202 : 0 : reseat (meta_item.get_expr_ptr ());
203 : 0 : }
204 : :
205 : : void
206 : 107167 : PointerVisitor::visit (AST::BorrowExpr &expr)
207 : : {
208 : 107167 : visit_outer_attrs (expr);
209 : 107167 : reseat (expr.get_borrowed_expr_ptr ());
210 : 107167 : }
211 : :
212 : : void
213 : 192194 : PointerVisitor::visit (AST::DereferenceExpr &expr)
214 : : {
215 : 192194 : visit_outer_attrs (expr);
216 : 192194 : reseat (expr.get_dereferenced_expr_ptr ());
217 : 192194 : }
218 : :
219 : : void
220 : 6741 : PointerVisitor::visit (AST::ErrorPropagationExpr &expr)
221 : : {
222 : 6741 : visit_outer_attrs (expr);
223 : 6741 : reseat (expr.get_propagating_expr_ptr ());
224 : 6741 : }
225 : :
226 : : void
227 : 31813 : PointerVisitor::visit (AST::NegationExpr &expr)
228 : : {
229 : 31813 : visit_outer_attrs (expr);
230 : 31813 : reseat (expr.get_negated_expr_ptr ());
231 : 31813 : }
232 : :
233 : : void
234 : 24679 : PointerVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
235 : : {
236 : 24679 : visit_outer_attrs (expr);
237 : 24679 : reseat (expr.get_left_expr_ptr ());
238 : 24679 : reseat (expr.get_right_expr_ptr ());
239 : 24679 : }
240 : :
241 : : void
242 : 5244 : PointerVisitor::visit (AST::ComparisonExpr &expr)
243 : : {
244 : 5244 : visit_outer_attrs (expr);
245 : 5244 : reseat (expr.get_left_expr_ptr ());
246 : 5244 : reseat (expr.get_right_expr_ptr ());
247 : 5244 : }
248 : :
249 : : void
250 : 1102 : PointerVisitor::visit (AST::LazyBooleanExpr &expr)
251 : : {
252 : 1102 : visit_outer_attrs (expr);
253 : 1102 : reseat (expr.get_left_expr_ptr ());
254 : 1102 : reseat (expr.get_right_expr_ptr ());
255 : 1102 : }
256 : :
257 : : void
258 : 8556 : PointerVisitor::visit (AST::TypeCastExpr &expr)
259 : : {
260 : 8556 : visit_outer_attrs (expr);
261 : 8556 : reseat (expr.get_casted_expr_ptr ());
262 : 8556 : reseat (expr.get_type_to_cast_to_ptr ());
263 : 8556 : }
264 : :
265 : : void
266 : 3608 : PointerVisitor::visit (AST::AssignmentExpr &expr)
267 : : {
268 : 3608 : visit_outer_attrs (expr);
269 : 3608 : reseat (expr.get_left_expr_ptr ());
270 : 3608 : reseat (expr.get_right_expr_ptr ());
271 : 3608 : }
272 : :
273 : : void
274 : 1496 : PointerVisitor::visit (AST::CompoundAssignmentExpr &expr)
275 : : {
276 : 1496 : visit_outer_attrs (expr);
277 : 1496 : reseat (expr.get_left_expr_ptr ());
278 : 1496 : reseat (expr.get_right_expr_ptr ());
279 : 1496 : }
280 : :
281 : : void
282 : 7516 : PointerVisitor::visit (AST::GroupedExpr &expr)
283 : : {
284 : 7516 : visit_outer_attrs (expr);
285 : 7516 : visit_inner_attrs (expr);
286 : 7516 : reseat (expr.get_expr_in_parens_ptr ());
287 : 7516 : }
288 : :
289 : : void
290 : 418123 : PointerVisitor::visit (AST::ArrayElemsValues &elems)
291 : : {
292 : 4393046 : for (auto &value : elems.get_values ())
293 : 3974923 : reseat (value);
294 : 418123 : }
295 : :
296 : : void
297 : 1723 : PointerVisitor::visit (AST::ArrayElemsCopied &elems)
298 : : {
299 : 1723 : reseat (elems.get_elem_to_copy_ptr ());
300 : 1723 : reseat (elems.get_num_copies_ptr ());
301 : 1723 : }
302 : :
303 : : void
304 : 419846 : PointerVisitor::visit (AST::ArrayExpr &expr)
305 : : {
306 : 419846 : visit_outer_attrs (expr);
307 : 419846 : visit_inner_attrs (expr);
308 : 419846 : visit (expr.get_array_elems ());
309 : 419846 : }
310 : :
311 : : void
312 : 16558 : PointerVisitor::visit (AST::ArrayIndexExpr &expr)
313 : : {
314 : 16558 : visit_outer_attrs (expr);
315 : 16558 : reseat (expr.get_array_expr_ptr ());
316 : 16558 : reseat (expr.get_index_expr_ptr ());
317 : 16558 : }
318 : :
319 : : void
320 : 4519 : PointerVisitor::visit (AST::TupleExpr &expr)
321 : : {
322 : 4519 : visit_outer_attrs (expr);
323 : 4519 : visit_inner_attrs (expr);
324 : 12860 : for (auto &elem : expr.get_tuple_elems ())
325 : 8341 : reseat (elem);
326 : 4519 : }
327 : :
328 : : void
329 : 124421 : PointerVisitor::visit (AST::TupleIndexExpr &expr)
330 : : {
331 : 124421 : visit_outer_attrs (expr);
332 : 124421 : reseat (expr.get_tuple_expr_ptr ());
333 : 124421 : }
334 : :
335 : : void
336 : 102 : PointerVisitor::visit (AST::StructExprStruct &expr)
337 : : {
338 : 102 : visit_outer_attrs (expr);
339 : 102 : visit_inner_attrs (expr);
340 : 102 : visit (expr.get_struct_name ());
341 : 102 : }
342 : :
343 : : void
344 : 6800 : PointerVisitor::visit (AST::StructExprFieldIdentifier &field)
345 : 6800 : {}
346 : :
347 : : void
348 : 28011 : PointerVisitor::visit (AST::StructExprFieldIdentifierValue &field)
349 : : {
350 : 28011 : reseat (field.get_value_ptr ());
351 : 28011 : }
352 : :
353 : : void
354 : 132 : PointerVisitor::visit (AST::StructExprFieldIndexValue &field)
355 : : {
356 : 132 : reseat (field.get_value_ptr ());
357 : 132 : }
358 : :
359 : : void
360 : 295 : PointerVisitor::visit (AST::StructBase &base)
361 : : {
362 : 295 : reseat (base.get_base_struct_ptr ());
363 : 295 : }
364 : :
365 : : void
366 : 18186 : PointerVisitor::visit (AST::StructExprStructFields &expr)
367 : : {
368 : 18186 : visit_outer_attrs (expr);
369 : 18186 : visit_inner_attrs (expr);
370 : 18186 : visit (expr.get_struct_name ());
371 : 18186 : if (expr.has_struct_base ())
372 : 295 : visit (expr.get_struct_base ());
373 : 53129 : for (auto &field : expr.get_fields ())
374 : 34943 : visit (field);
375 : 18186 : }
376 : :
377 : : void
378 : 0 : PointerVisitor::visit (AST::StructExprStructBase &expr)
379 : : {
380 : 0 : visit_outer_attrs (expr);
381 : 0 : visit_inner_attrs (expr);
382 : 0 : visit (expr.get_struct_name ());
383 : 0 : visit (expr.get_struct_base ());
384 : 0 : }
385 : :
386 : : void
387 : 72845 : PointerVisitor::visit (AST::CallExpr &expr)
388 : : {
389 : 72845 : visit_outer_attrs (expr);
390 : 72845 : reseat (expr.get_function_expr_ptr ());
391 : 248317 : for (auto ¶m : expr.get_params ())
392 : 175472 : reseat (param);
393 : 72845 : }
394 : :
395 : : void
396 : 911856 : PointerVisitor::visit (AST::MethodCallExpr &expr)
397 : : {
398 : 911856 : visit_outer_attrs (expr);
399 : 911856 : reseat (expr.get_receiver_expr_ptr ());
400 : 911856 : visit (expr.get_method_name ());
401 : 1055451 : for (auto ¶m : expr.get_params ())
402 : 143595 : reseat (param);
403 : 911856 : }
404 : :
405 : : void
406 : 122435 : PointerVisitor::visit (AST::FieldAccessExpr &expr)
407 : : {
408 : 122435 : visit_outer_attrs (expr);
409 : 122435 : reseat (expr.get_receiver_expr_ptr ());
410 : 122435 : }
411 : :
412 : : void
413 : 337 : PointerVisitor::visit (AST::ClosureExprInner &expr)
414 : : {
415 : 337 : visit_outer_attrs (expr);
416 : :
417 : : // TODO: Actually we need to handle macro invocations as closure parameters so
418 : : // this needs to be a reseat
419 : 722 : for (auto ¶m : expr.get_params ())
420 : 385 : visit (param);
421 : :
422 : 337 : reseat (expr.get_definition_expr_ptr ());
423 : 337 : }
424 : :
425 : : void
426 : 38758 : PointerVisitor::visit (AST::BlockExpr &expr)
427 : : {
428 : 38758 : visit_outer_attrs (expr);
429 : 38758 : visit_inner_attrs (expr);
430 : :
431 : 38758 : if (expr.has_label ())
432 : 0 : visit (expr.get_label ());
433 : :
434 : 70370 : for (auto &stmt : expr.get_statements ())
435 : 31612 : reseat (stmt);
436 : :
437 : 38758 : if (expr.has_tail_expr ())
438 : 30713 : reseat (expr.get_tail_expr_ptr ());
439 : 38758 : }
440 : :
441 : : void
442 : 38 : PointerVisitor::visit (AST::ConstBlock &expr)
443 : : {
444 : 38 : visit (expr.get_const_expr ());
445 : 38 : }
446 : :
447 : : void
448 : 12360 : PointerVisitor::visit (AST::AnonConst &expr)
449 : : {
450 : 12360 : if (!expr.is_deferred ())
451 : 12334 : reseat (expr.get_inner_expr_ptr ());
452 : 12360 : }
453 : :
454 : : void
455 : 31 : PointerVisitor::visit (AST::ClosureExprInnerTyped &expr)
456 : : {
457 : 31 : visit_outer_attrs (expr);
458 : :
459 : : // TODO: Same as ClosureExprInner
460 : 69 : for (auto ¶m : expr.get_params ())
461 : 38 : visit (param);
462 : :
463 : 31 : reseat (expr.get_return_type_ptr ());
464 : :
465 : 31 : reseat (expr.get_definition_expr_ptr ());
466 : 31 : }
467 : :
468 : : void
469 : 423 : PointerVisitor::visit (AST::ClosureParam ¶m)
470 : : {
471 : 423 : visit_outer_attrs (param);
472 : 423 : reseat (param.get_pattern_ptr ());
473 : 423 : if (param.has_type_given ())
474 : 75 : reseat (param.get_type_ptr ());
475 : 423 : }
476 : :
477 : : void
478 : 26 : PointerVisitor::visit (AST::ContinueExpr &expr)
479 : : {
480 : 26 : visit_outer_attrs (expr);
481 : 26 : if (expr.has_label ())
482 : 7 : visit (expr.get_label_unchecked ());
483 : 26 : }
484 : :
485 : : void
486 : 1380 : PointerVisitor::visit (AST::BreakExpr &expr)
487 : : {
488 : 1380 : visit_outer_attrs (expr);
489 : 1380 : if (expr.has_label ())
490 : 63 : visit (expr.get_label_unchecked ());
491 : :
492 : 1380 : if (expr.has_break_expr ())
493 : 66 : reseat (expr.get_break_expr_ptr ());
494 : 1380 : }
495 : :
496 : : void
497 : 4575 : PointerVisitor::visit (AST::RangeFromToExpr &expr)
498 : : {
499 : 4575 : reseat (expr.get_from_expr_ptr ());
500 : 4575 : reseat (expr.get_to_expr_ptr ());
501 : 4575 : }
502 : :
503 : : void
504 : 2030 : PointerVisitor::visit (AST::RangeFromExpr &expr)
505 : : {
506 : 2030 : reseat (expr.get_from_expr_ptr ());
507 : 2030 : }
508 : :
509 : : void
510 : 3995 : PointerVisitor::visit (AST::RangeToExpr &expr)
511 : : {
512 : 3995 : reseat (expr.get_to_expr_ptr ());
513 : 3995 : }
514 : :
515 : : void
516 : 1900 : PointerVisitor::visit (AST::RangeFullExpr &expr)
517 : 1900 : {}
518 : :
519 : : void
520 : 237 : PointerVisitor::visit (AST::RangeFromToInclExpr &expr)
521 : : {
522 : 237 : reseat (expr.get_from_expr_ptr ());
523 : 237 : reseat (expr.get_to_expr_ptr ());
524 : 237 : }
525 : :
526 : : void
527 : 0 : PointerVisitor::visit (AST::RangeToInclExpr &expr)
528 : : {
529 : 0 : reseat (expr.get_to_expr_ptr ());
530 : 0 : }
531 : :
532 : : void
533 : 14351 : PointerVisitor::visit (AST::ReturnExpr &expr)
534 : : {
535 : 14351 : visit_outer_attrs (expr);
536 : 14351 : if (expr.has_returned_expr ())
537 : 13783 : reseat (expr.get_returned_expr_ptr ());
538 : 14351 : }
539 : :
540 : : void
541 : 1052 : PointerVisitor::visit (AST::TryExpr &expr)
542 : : {
543 : 1052 : visit_outer_attrs (expr);
544 : 1052 : reseat (expr.get_block_expr_ptr ());
545 : 1052 : }
546 : :
547 : : void
548 : 3 : PointerVisitor::visit (AST::BoxExpr &expr)
549 : : {
550 : 3 : visit_outer_attrs (expr);
551 : 3 : reseat (expr.get_boxed_expr_ptr ());
552 : 3 : }
553 : :
554 : : void
555 : 47767 : PointerVisitor::visit (AST::UnsafeBlockExpr &expr)
556 : : {
557 : 47767 : visit_outer_attrs (expr);
558 : 47767 : reseat (expr.get_block_expr_ptr ());
559 : 47767 : }
560 : :
561 : : void
562 : 237 : PointerVisitor::visit (AST::LoopLabel &label)
563 : : {
564 : 237 : visit (label.get_lifetime ());
565 : 237 : }
566 : :
567 : : void
568 : 1791 : PointerVisitor::visit (AST::LoopExpr &expr)
569 : : {
570 : 1791 : visit_outer_attrs (expr);
571 : 1791 : if (expr.has_loop_label ())
572 : 168 : visit (expr.get_loop_label ());
573 : 1791 : reseat (expr.get_loop_block_ptr ());
574 : 1791 : }
575 : :
576 : : void
577 : 3838 : PointerVisitor::visit (AST::WhileLoopExpr &expr)
578 : : {
579 : 3838 : visit_outer_attrs (expr);
580 : 3838 : if (expr.has_loop_label ())
581 : 6 : visit (expr.get_loop_label ());
582 : 3838 : reseat (expr.get_predicate_expr_ptr ());
583 : 3838 : reseat (expr.get_loop_block_ptr ());
584 : 3838 : }
585 : :
586 : : void
587 : 795 : PointerVisitor::visit (AST::WhileLetLoopExpr &expr)
588 : : {
589 : 795 : visit_outer_attrs (expr);
590 : 1590 : for (auto &pattern : expr.get_patterns ())
591 : 795 : reseat (pattern);
592 : :
593 : 795 : if (expr.has_loop_label ())
594 : 0 : visit (expr.get_loop_label ());
595 : :
596 : 795 : reseat (expr.get_scrutinee_expr_ptr ());
597 : 795 : reseat (expr.get_loop_block_ptr ());
598 : 795 : }
599 : :
600 : : void
601 : 3602 : PointerVisitor::visit (AST::ForLoopExpr &expr)
602 : : {
603 : 3602 : visit_outer_attrs (expr);
604 : 3602 : reseat (expr.get_pattern_ptr ());
605 : 3602 : reseat (expr.get_iterator_expr_ptr ());
606 : 3602 : if (expr.has_loop_label ())
607 : 0 : visit (expr.get_loop_label ());
608 : 3602 : reseat (expr.get_loop_block_ptr ());
609 : 3602 : }
610 : :
611 : : void
612 : 3417 : PointerVisitor::visit (AST::IfExpr &expr)
613 : : {
614 : 3417 : visit_outer_attrs (expr);
615 : 3417 : reseat (expr.get_condition_expr_ptr ());
616 : 3417 : visit (expr.get_if_block ());
617 : 3417 : }
618 : :
619 : : void
620 : 2306 : PointerVisitor::visit (AST::IfExprConseqElse &expr)
621 : : {
622 : 2306 : visit (reinterpret_cast<AST::IfExpr &> (expr));
623 : 2306 : visit (expr.get_else_block ());
624 : 2306 : }
625 : :
626 : : void
627 : 121 : PointerVisitor::visit (AST::IfLetExpr &expr)
628 : : {
629 : 121 : visit_outer_attrs (expr);
630 : 242 : for (auto &pattern : expr.get_patterns ())
631 : 121 : reseat (pattern);
632 : 121 : reseat (expr.get_value_expr_ptr ());
633 : 121 : visit (expr.get_if_block ());
634 : 121 : }
635 : :
636 : : void
637 : 42 : PointerVisitor::visit (AST::IfLetExprConseqElse &expr)
638 : : {
639 : 42 : visit (reinterpret_cast<AST::IfLetExpr &> (expr));
640 : 42 : visit (expr.get_else_block ());
641 : 42 : }
642 : :
643 : : void
644 : 1656389 : PointerVisitor::visit (AST::MatchArm &arm)
645 : : {
646 : 1656389 : visit_outer_attrs (arm);
647 : 3312778 : for (auto &pattern : arm.get_patterns ())
648 : 1656389 : reseat (pattern);
649 : 1656389 : if (arm.has_match_arm_guard ())
650 : 1166 : reseat (arm.get_guard_expr_ptr ());
651 : 1656389 : }
652 : :
653 : : void
654 : 1656389 : PointerVisitor::visit (AST::MatchCase &arm)
655 : : {
656 : 1656389 : visit (arm.get_arm ());
657 : 1656389 : reseat (arm.get_expr_ptr ());
658 : 1656389 : }
659 : :
660 : : void
661 : 159159 : PointerVisitor::visit (AST::MatchExpr &expr)
662 : : {
663 : 159159 : visit_outer_attrs (expr);
664 : 159159 : visit_inner_attrs (expr);
665 : 159159 : reseat (expr.get_scrutinee_expr_ptr ());
666 : 1815548 : for (auto &arm : expr.get_match_cases ())
667 : 1656389 : visit (arm);
668 : 159159 : }
669 : :
670 : : void
671 : 0 : PointerVisitor::visit (AST::AwaitExpr &expr)
672 : : {
673 : 0 : visit_outer_attrs (expr);
674 : 0 : reseat (expr.get_awaited_expr ());
675 : 0 : }
676 : :
677 : : void
678 : 0 : PointerVisitor::visit (AST::AsyncBlockExpr &expr)
679 : : {
680 : 0 : visit_outer_attrs (expr);
681 : 0 : reseat (expr.get_block_expr ());
682 : 0 : }
683 : :
684 : : void
685 : 54 : PointerVisitor::visit (AST::InlineAsm &expr)
686 : : {
687 : 54 : visit_outer_attrs (expr);
688 : 54 : using RegisterType = AST::InlineAsmOperand::RegisterType;
689 : 112 : for (auto &operand : expr.get_operands ())
690 : : {
691 : 58 : switch (operand.get_register_type ())
692 : : {
693 : 20 : case RegisterType::In:
694 : 20 : {
695 : 20 : reseat (operand.get_in ().expr);
696 : 20 : break;
697 : : }
698 : 34 : case RegisterType::Out:
699 : 34 : {
700 : 34 : reseat (operand.get_out ().expr);
701 : 34 : break;
702 : : }
703 : 0 : case RegisterType::InOut:
704 : 0 : {
705 : 0 : reseat (operand.get_in_out ().expr);
706 : 0 : break;
707 : : }
708 : 4 : case RegisterType::SplitInOut:
709 : 4 : {
710 : 4 : auto split = operand.get_split_in_out ();
711 : 4 : reseat (split.in_expr);
712 : 4 : reseat (split.out_expr);
713 : 4 : break;
714 : 4 : }
715 : 0 : case RegisterType::Const:
716 : 0 : {
717 : 0 : reseat (operand.get_const ().anon_const.get_inner_expr_ptr ());
718 : 0 : break;
719 : : }
720 : 0 : case RegisterType::Sym:
721 : 0 : {
722 : 0 : reseat (operand.get_sym ().expr);
723 : 0 : break;
724 : : }
725 : 0 : case RegisterType::Label:
726 : 0 : {
727 : 0 : reseat (operand.get_label ().expr);
728 : 0 : break;
729 : : }
730 : : }
731 : 54 : }
732 : 54 : }
733 : :
734 : : void
735 : 424 : PointerVisitor::visit (AST::LlvmInlineAsm &expr)
736 : : {
737 : 1019 : for (auto &output : expr.get_outputs ())
738 : 595 : reseat (output.expr);
739 : :
740 : 883 : for (auto &input : expr.get_inputs ())
741 : 459 : reseat (input.expr);
742 : 424 : }
743 : :
744 : : void
745 : 15591 : PointerVisitor::visit (AST::TypeParam ¶m)
746 : : {
747 : 15591 : visit_outer_attrs (param);
748 : : // FIXME: Can we do macro expansion here?
749 : 18538 : for (auto &bound : param.get_type_param_bounds ())
750 : 2947 : visit (bound);
751 : 15591 : if (param.has_type ())
752 : 386 : reseat (param.get_type_ptr ());
753 : 15591 : }
754 : :
755 : : void
756 : 3 : PointerVisitor::visit (AST::LifetimeWhereClauseItem &item)
757 : : {
758 : 3 : visit (item.get_lifetime ());
759 : 6 : for (auto &bound : item.get_lifetime_bounds ())
760 : 3 : visit (bound);
761 : 3 : }
762 : :
763 : : void
764 : 1380 : PointerVisitor::visit (AST::TypeBoundWhereClauseItem &item)
765 : : {
766 : 1390 : for (auto &lifetime : item.get_for_lifetimes ())
767 : 10 : visit (lifetime);
768 : 1380 : reseat (item.get_type_ptr ());
769 : : // FIXME: Likewise?
770 : 2810 : for (auto ¶m : item.get_type_param_bounds ())
771 : 1430 : visit (param);
772 : 1380 : }
773 : :
774 : : void
775 : 158570 : PointerVisitor::visit (AST::Visibility &vis)
776 : : {
777 : 158570 : if (vis.has_path ())
778 : 379 : visit (vis.get_path ());
779 : 158570 : }
780 : :
781 : : void
782 : 1092 : PointerVisitor::visit (AST::WhereClause &where)
783 : : {
784 : 2475 : for (auto &item : where.get_items ())
785 : 1383 : visit (item);
786 : 1092 : }
787 : :
788 : : void
789 : 25387 : PointerVisitor::visit (AST::FunctionParam ¶m)
790 : : {
791 : 25387 : visit_outer_attrs (param);
792 : 25387 : if (param.has_name ())
793 : 25387 : reseat (param.get_pattern_ptr ());
794 : :
795 : 25387 : reseat (param.get_type_ptr ());
796 : 25387 : }
797 : :
798 : : void
799 : 16210 : PointerVisitor::visit (AST::SelfParam ¶m)
800 : : {
801 : 16210 : visit_outer_attrs (param);
802 : :
803 : 16210 : if (param.has_lifetime ())
804 : 8294 : visit (param.get_lifetime ());
805 : :
806 : 16210 : if (param.has_type ())
807 : 14 : reseat (param.get_type_ptr ());
808 : 16210 : }
809 : :
810 : : void
811 : 1447 : PointerVisitor::visit (AST::Module &module)
812 : : {
813 : 1447 : visit_outer_attrs (module);
814 : 1447 : visit (module.get_visibility ());
815 : 1447 : visit_inner_attrs (module);
816 : 16896 : for (auto &item : module.get_items ())
817 : 15449 : reseat (item);
818 : 1447 : }
819 : :
820 : : void
821 : 24 : PointerVisitor::visit (AST::ExternCrate &crate)
822 : : {
823 : 24 : visit_outer_attrs (crate);
824 : 24 : visit (crate.get_visibility ());
825 : 24 : }
826 : :
827 : : void
828 : 73 : PointerVisitor::visit (AST::UseTreeGlob &use_tree)
829 : : {
830 : 73 : visit (use_tree.get_path ());
831 : 73 : }
832 : :
833 : : void
834 : 351 : PointerVisitor::visit (AST::UseTreeList &use_tree)
835 : : {
836 : 351 : visit (use_tree.get_path ());
837 : 351 : }
838 : :
839 : : void
840 : 890 : PointerVisitor::visit (AST::UseTreeRebind &use_tree)
841 : : {
842 : 890 : visit (use_tree.get_path ());
843 : 890 : }
844 : :
845 : : void
846 : 1314 : PointerVisitor::visit (AST::UseDeclaration &use_decl)
847 : : {
848 : 1314 : visit (use_decl.get_visibility ());
849 : 1314 : visit (use_decl.get_tree ());
850 : 1314 : }
851 : :
852 : : void
853 : 30319 : PointerVisitor::visit_function_params (AST::Function &function)
854 : : {
855 : 72752 : for (auto ¶m : function.get_function_params ())
856 : 42433 : visit (param);
857 : 30319 : }
858 : :
859 : : void
860 : 30319 : PointerVisitor::visit (AST::Function &function)
861 : : {
862 : 30319 : visit_outer_attrs (function);
863 : 30319 : visit (function.get_visibility ());
864 : 30319 : visit (function.get_qualifiers ());
865 : 33377 : for (auto &generic : function.get_generic_params ())
866 : 3058 : visit (generic);
867 : :
868 : 30319 : visit_function_params (function);
869 : :
870 : 30319 : if (function.has_return_type ())
871 : 23364 : reseat (function.get_return_type_ptr ());
872 : 30319 : if (function.has_where_clause ())
873 : 613 : visit (function.get_where_clause ());
874 : 30319 : if (function.has_body ())
875 : 25427 : reseat (*function.get_definition ());
876 : 30319 : }
877 : :
878 : : void
879 : 93331 : PointerVisitor::visit (AST::TypeAlias &type_alias)
880 : : {
881 : 93331 : visit_outer_attrs (type_alias);
882 : 93331 : visit (type_alias.get_visibility ());
883 : 93364 : for (auto &generic : type_alias.get_generic_params ())
884 : 33 : visit (generic);
885 : 93331 : if (type_alias.has_where_clause ())
886 : 0 : visit (type_alias.get_where_clause ());
887 : 93331 : reseat (type_alias.get_type_aliased_ptr ());
888 : 93331 : }
889 : :
890 : : void
891 : 2667 : PointerVisitor::visit (AST::StructField &field)
892 : : {
893 : 2667 : visit_outer_attrs (field);
894 : 2667 : visit (field.get_visibility ());
895 : 2667 : reseat (field.get_field_type_ptr ());
896 : 2667 : }
897 : :
898 : : void
899 : 2107 : PointerVisitor::visit (AST::StructStruct &struct_item)
900 : : {
901 : 2107 : visit_outer_attrs (struct_item);
902 : 2107 : visit (struct_item.get_visibility ());
903 : 2874 : for (auto &generic : struct_item.get_generic_params ())
904 : 767 : visit (generic);
905 : 2107 : if (struct_item.has_where_clause ())
906 : 13 : visit (struct_item.get_where_clause ());
907 : 4318 : for (auto &field : struct_item.get_fields ())
908 : 2211 : visit (field);
909 : 2107 : }
910 : :
911 : : void
912 : 2557 : PointerVisitor::visit (AST::TupleField &field)
913 : : {
914 : 2557 : visit_outer_attrs (field);
915 : 2557 : visit (field.get_visibility ());
916 : 2557 : reseat (field.get_field_type_ptr ());
917 : 2557 : }
918 : :
919 : : void
920 : 1056 : PointerVisitor::visit (AST::TupleStruct &tuple_struct)
921 : : {
922 : 1056 : visit_outer_attrs (tuple_struct);
923 : 1056 : visit (tuple_struct.get_visibility ());
924 : 1467 : for (auto &generic : tuple_struct.get_generic_params ())
925 : 411 : visit (generic);
926 : 1056 : if (tuple_struct.has_where_clause ())
927 : 1 : visit (tuple_struct.get_where_clause ());
928 : 3121 : for (auto &field : tuple_struct.get_fields ())
929 : 2065 : visit (field);
930 : 1056 : }
931 : :
932 : : void
933 : 1325 : PointerVisitor::visit (AST::EnumItem &item)
934 : : {
935 : 1325 : visit_outer_attrs (item);
936 : 1325 : visit (item.get_visibility ());
937 : 1325 : }
938 : :
939 : : void
940 : 461 : PointerVisitor::visit (AST::EnumItemTuple &item)
941 : : {
942 : 461 : PointerVisitor::visit (static_cast<EnumItem &> (item));
943 : 953 : for (auto &field : item.get_tuple_fields ())
944 : 492 : visit (field);
945 : 461 : }
946 : :
947 : : void
948 : 88 : PointerVisitor::visit (AST::EnumItemStruct &item)
949 : : {
950 : 88 : PointerVisitor::visit (static_cast<EnumItem &> (item));
951 : 235 : for (auto &field : item.get_struct_fields ())
952 : 147 : visit (field);
953 : 88 : }
954 : :
955 : : void
956 : 276 : PointerVisitor::visit (AST::EnumItemDiscriminant &item)
957 : : {
958 : 276 : PointerVisitor::visit (static_cast<EnumItem &> (item));
959 : 276 : reseat (item.get_expr_ptr ());
960 : 276 : }
961 : :
962 : : void
963 : 2897 : PointerVisitor::visit (AST::Enum &enum_item)
964 : : {
965 : 2897 : visit_outer_attrs (enum_item);
966 : 2897 : visit (enum_item.get_visibility ());
967 : 4313 : for (auto &generic : enum_item.get_generic_params ())
968 : 1416 : visit (generic);
969 : 2897 : if (enum_item.has_where_clause ())
970 : 0 : visit (enum_item.get_where_clause ());
971 : 10342 : for (auto &item : enum_item.get_variants ())
972 : 7445 : visit (item);
973 : 2897 : }
974 : :
975 : : void
976 : 106 : PointerVisitor::visit (AST::Union &union_item)
977 : : {
978 : 106 : visit_outer_attrs (union_item);
979 : 106 : visit (union_item.get_visibility ());
980 : 183 : for (auto &generic : union_item.get_generic_params ())
981 : 77 : visit (generic);
982 : 106 : if (union_item.has_where_clause ())
983 : 0 : visit (union_item.get_where_clause ());
984 : 415 : for (auto &variant : union_item.get_variants ())
985 : 309 : visit (variant);
986 : 106 : }
987 : :
988 : : void
989 : 1274 : PointerVisitor::visit (AST::ConstantItem &const_item)
990 : : {
991 : 1274 : visit_outer_attrs (const_item);
992 : 1274 : visit (const_item.get_visibility ());
993 : 1274 : reseat (const_item.get_type_ptr ());
994 : 1274 : if (const_item.has_expr ())
995 : 1224 : reseat (const_item.get_expr_ptr ());
996 : 1274 : }
997 : :
998 : : void
999 : 87 : PointerVisitor::visit (AST::StaticItem &static_item)
1000 : : {
1001 : 87 : visit_outer_attrs (static_item);
1002 : 87 : visit (static_item.get_visibility ());
1003 : 87 : reseat (static_item.get_type_ptr ());
1004 : 87 : reseat (static_item.get_expr_ptr ());
1005 : 87 : }
1006 : :
1007 : : void
1008 : 3875 : PointerVisitor::visit (AST::TraitItemType &item)
1009 : : {
1010 : 3875 : visit_outer_attrs (item);
1011 : 4755 : for (auto &bound : item.get_type_param_bounds ())
1012 : 880 : visit (bound);
1013 : 3875 : }
1014 : :
1015 : : void
1016 : 3833 : PointerVisitor::visit (AST::Trait &trait)
1017 : : {
1018 : 3833 : visit_outer_attrs (trait);
1019 : 3833 : visit (trait.get_visibility ());
1020 : :
1021 : 3833 : visit_inner_attrs (trait);
1022 : :
1023 : 3833 : visit (trait.get_implicit_self ());
1024 : :
1025 : 4551 : for (auto &generic : trait.get_generic_params ())
1026 : 718 : visit (generic);
1027 : :
1028 : 3833 : if (trait.has_where_clause ())
1029 : 7 : visit (trait.get_where_clause ());
1030 : :
1031 : 4512 : for (auto &bound : trait.get_type_param_bounds ())
1032 : 679 : visit (bound);
1033 : :
1034 : 7530 : for (auto &item : trait.get_trait_items ())
1035 : 3697 : reseat (item);
1036 : 3833 : }
1037 : :
1038 : : void
1039 : 1245 : PointerVisitor::visit (AST::InherentImpl &impl)
1040 : : {
1041 : 1245 : visit_outer_attrs (impl);
1042 : 1245 : visit (impl.get_visibility ());
1043 : :
1044 : 1828 : for (auto &generic : impl.get_generic_params ())
1045 : 583 : visit (generic);
1046 : 1245 : if (impl.has_where_clause ())
1047 : 4 : visit (impl.get_where_clause ());
1048 : 1245 : reseat (impl.get_type_ptr ());
1049 : 1245 : visit_inner_attrs (impl);
1050 : 6167 : for (auto &item : impl.get_impl_items ())
1051 : 4922 : reseat (item);
1052 : 1245 : }
1053 : :
1054 : : void
1055 : 11469 : PointerVisitor::visit (AST::TraitImpl &impl)
1056 : : {
1057 : 11469 : visit_outer_attrs (impl);
1058 : 11469 : visit (impl.get_visibility ());
1059 : :
1060 : 18933 : for (auto &generic : impl.get_generic_params ())
1061 : 7464 : visit (generic);
1062 : 11469 : if (impl.has_where_clause ())
1063 : 454 : visit (impl.get_where_clause ());
1064 : 11469 : reseat (impl.get_type_ptr ());
1065 : 11469 : visit (impl.get_trait_path ());
1066 : 11469 : visit_inner_attrs (impl);
1067 : 26621 : for (auto &item : impl.get_impl_items ())
1068 : 15152 : reseat (item);
1069 : 11469 : }
1070 : :
1071 : : void
1072 : 2 : PointerVisitor::visit (AST::ExternalTypeItem &item)
1073 : : {
1074 : 2 : visit_outer_attrs (item);
1075 : 2 : visit (item.get_visibility ());
1076 : 2 : }
1077 : :
1078 : : void
1079 : 1 : PointerVisitor::visit (AST::ExternalStaticItem &item)
1080 : : {
1081 : 1 : visit_outer_attrs (item);
1082 : 1 : visit (item.get_visibility ());
1083 : 1 : reseat (item.get_type_ptr ());
1084 : 1 : }
1085 : :
1086 : : void
1087 : 1509 : PointerVisitor::visit (AST::ExternBlock &block)
1088 : : {
1089 : 1509 : visit_outer_attrs (block);
1090 : 1509 : visit (block.get_visibility ());
1091 : 1509 : visit_inner_attrs (block);
1092 : 4537 : for (auto &item : block.get_extern_items ())
1093 : 3028 : reseat (item);
1094 : 1509 : }
1095 : :
1096 : : void
1097 : 2697 : PointerVisitor::visit (AST::MacroMatchFragment &match)
1098 : 2697 : {}
1099 : :
1100 : : void
1101 : 650 : PointerVisitor::visit (AST::MacroMatchRepetition &match)
1102 : : {
1103 : 1507 : for (auto &m : match.get_matches ())
1104 : 857 : visit (m);
1105 : 650 : }
1106 : :
1107 : : void
1108 : 1909 : PointerVisitor::visit (AST::MacroMatcher &matcher)
1109 : : {
1110 : 6168 : for (auto &m : matcher.get_matches ())
1111 : 4259 : visit (m);
1112 : 1909 : }
1113 : :
1114 : : void
1115 : 1806 : PointerVisitor::visit (AST::MacroTranscriber &transcriber)
1116 : : {
1117 : 1806 : visit (transcriber.get_token_tree ());
1118 : 1806 : }
1119 : :
1120 : : void
1121 : 1806 : PointerVisitor::visit (AST::MacroRule &rule)
1122 : : {
1123 : 1806 : visit (rule.get_matcher ());
1124 : 1806 : visit (rule.get_transcriber ());
1125 : 1806 : }
1126 : :
1127 : : void
1128 : 1630 : PointerVisitor::visit (AST::MacroRulesDefinition &rules_def)
1129 : : {
1130 : 1630 : visit_outer_attrs (rules_def);
1131 : 3436 : for (auto &rule : rules_def.get_macro_rules ())
1132 : 1806 : visit (rule);
1133 : 1630 : }
1134 : :
1135 : : void
1136 : 172 : PointerVisitor::visit (AST::MacroInvocData &data)
1137 : : {
1138 : 172 : visit (data.get_path ());
1139 : 172 : visit (data.get_delim_tok_tree ());
1140 : 172 : }
1141 : :
1142 : : void
1143 : 172 : PointerVisitor::visit (AST::MacroInvocation ¯o_invoc)
1144 : : {
1145 : 172 : visit_outer_attrs (macro_invoc);
1146 : 172 : visit (macro_invoc.get_invoc_data ());
1147 : 172 : }
1148 : :
1149 : : void
1150 : 0 : PointerVisitor::visit (AST::MetaItemPath &meta_item)
1151 : : {
1152 : 0 : visit (meta_item.get_path ());
1153 : 0 : }
1154 : :
1155 : : void
1156 : 0 : PointerVisitor::visit (AST::MetaItemSeq &meta_item)
1157 : : {
1158 : 0 : visit (meta_item.get_path ());
1159 : 0 : for (auto &inner : meta_item.get_seq ())
1160 : 0 : visit (inner);
1161 : 0 : }
1162 : :
1163 : : void
1164 : 0 : PointerVisitor::visit (AST::MetaListPaths &meta_item)
1165 : : {
1166 : 0 : for (auto &path : meta_item.get_paths ())
1167 : 0 : visit (path);
1168 : 0 : }
1169 : :
1170 : : void
1171 : 0 : PointerVisitor::visit (AST::MetaListNameValueStr &meta_item)
1172 : : {
1173 : 0 : for (auto &str : meta_item.get_values ())
1174 : 0 : visit (str);
1175 : 0 : }
1176 : :
1177 : : void
1178 : 793228 : PointerVisitor::visit (AST::IdentifierPattern &pattern)
1179 : : {
1180 : 793228 : if (pattern.has_subpattern ())
1181 : 448 : reseat (pattern.get_subpattern_ptr ());
1182 : 793228 : }
1183 : :
1184 : : void
1185 : 63 : PointerVisitor::visit (AST::RangePatternBoundPath &bound)
1186 : : {
1187 : 63 : visit (bound.get_path ());
1188 : 63 : }
1189 : :
1190 : : void
1191 : 0 : PointerVisitor::visit (AST::RangePatternBoundQualPath &bound)
1192 : : {
1193 : 0 : visit (bound.get_qualified_path ());
1194 : 0 : }
1195 : :
1196 : : void
1197 : 2745 : PointerVisitor::visit (AST::RangePattern &pattern)
1198 : : {
1199 : : // FIXME: So should this be reseat() instead? Can we have macro invocations as
1200 : : // patterns in range patterns?
1201 : 2745 : if (pattern.get_has_lower_bound ())
1202 : 2745 : visit (pattern.get_lower_bound ());
1203 : 2745 : if (pattern.get_has_upper_bound ())
1204 : 2745 : visit (pattern.get_upper_bound ());
1205 : 2745 : }
1206 : :
1207 : : void
1208 : 7741 : PointerVisitor::visit (AST::ReferencePattern &pattern)
1209 : : {
1210 : 7741 : reseat (pattern.get_referenced_pattern_ptr ());
1211 : 7741 : }
1212 : :
1213 : : void
1214 : 3 : PointerVisitor::visit (AST::StructPatternFieldTuplePat &field)
1215 : : {
1216 : 3 : visit_outer_attrs (field);
1217 : 3 : reseat (field.get_index_pattern_ptr ());
1218 : 3 : }
1219 : :
1220 : : void
1221 : 1952 : PointerVisitor::visit (AST::StructPatternFieldIdentPat &field)
1222 : : {
1223 : 1952 : visit_outer_attrs (field);
1224 : 1952 : reseat (field.get_ident_pattern_ptr ());
1225 : 1952 : }
1226 : :
1227 : : void
1228 : 110 : PointerVisitor::visit (AST::StructPatternFieldIdent &field)
1229 : : {
1230 : 110 : visit_outer_attrs (field);
1231 : 110 : }
1232 : :
1233 : : void
1234 : 1959 : PointerVisitor::visit (AST::StructPatternElements &spe)
1235 : : {
1236 : 4659 : for (auto &field : spe.get_struct_pattern_fields ())
1237 : 2700 : visit (field);
1238 : 1959 : for (auto &attribute : spe.get_etc_outer_attrs ())
1239 : : visit (attribute);
1240 : 1959 : }
1241 : :
1242 : : void
1243 : 1959 : PointerVisitor::visit (AST::StructPattern &pattern)
1244 : : {
1245 : 1959 : visit (pattern.get_path ());
1246 : 1959 : visit (pattern.get_struct_pattern_elems ());
1247 : 1959 : }
1248 : :
1249 : : void
1250 : 2328 : PointerVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
1251 : : {
1252 : 4803 : for (auto &pattern : tuple_items.get_patterns ())
1253 : 2475 : reseat (pattern);
1254 : 2328 : }
1255 : :
1256 : : void
1257 : 46 : PointerVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
1258 : : {
1259 : 77 : for (auto &lower : tuple_items.get_lower_patterns ())
1260 : 31 : reseat (lower);
1261 : 65 : for (auto &upper : tuple_items.get_upper_patterns ())
1262 : 19 : reseat (upper);
1263 : 46 : }
1264 : :
1265 : : void
1266 : 29352 : PointerVisitor::visit (AST::TupleStructPattern &pattern)
1267 : : {
1268 : 29352 : visit (pattern.get_path ());
1269 : 29352 : visit (pattern.get_items ());
1270 : 29352 : }
1271 : :
1272 : : void
1273 : 2921 : PointerVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
1274 : : {
1275 : 9610 : for (auto &pattern : tuple_items.get_patterns ())
1276 : 6689 : reseat (pattern);
1277 : 2921 : }
1278 : :
1279 : : void
1280 : 27 : PointerVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
1281 : : {
1282 : 55 : for (auto &lower : tuple_items.get_lower_patterns ())
1283 : 28 : reseat (lower);
1284 : 59 : for (auto &upper : tuple_items.get_upper_patterns ())
1285 : 32 : reseat (upper);
1286 : 27 : }
1287 : :
1288 : : void
1289 : 88901 : PointerVisitor::visit (AST::TuplePattern &pattern)
1290 : : {
1291 : 88901 : visit (pattern.get_items ());
1292 : 88901 : }
1293 : :
1294 : : void
1295 : 44 : PointerVisitor::visit (AST::GroupedPattern &pattern)
1296 : : {
1297 : 44 : reseat (pattern.get_pattern_in_parens_ptr ());
1298 : 44 : }
1299 : :
1300 : : void
1301 : 40 : PointerVisitor::visit (AST::SlicePatternItemsNoRest &items)
1302 : : {
1303 : 113 : for (auto &item : items.get_patterns ())
1304 : 73 : reseat (item);
1305 : 40 : }
1306 : :
1307 : : void
1308 : 52 : PointerVisitor::visit (AST::SlicePatternItemsHasRest &items)
1309 : : {
1310 : 107 : for (auto &item : items.get_lower_patterns ())
1311 : 55 : reseat (item);
1312 : 97 : for (auto &item : items.get_upper_patterns ())
1313 : 45 : reseat (item);
1314 : 52 : }
1315 : :
1316 : : void
1317 : 524 : PointerVisitor::visit (AST::SlicePattern &pattern)
1318 : : {
1319 : 524 : visit (pattern.get_items ());
1320 : 524 : }
1321 : :
1322 : : void
1323 : 226 : PointerVisitor::visit (AST::AltPattern &pattern)
1324 : : {
1325 : 719 : for (auto &alt : pattern.get_alts ())
1326 : 493 : reseat (alt);
1327 : 226 : }
1328 : :
1329 : : void
1330 : 205 : PointerVisitor::visit (AST::EmptyStmt &stmt)
1331 : 205 : {}
1332 : :
1333 : : void
1334 : 16539 : PointerVisitor::visit (AST::LetStmt &stmt)
1335 : : {
1336 : 16539 : visit_outer_attrs (stmt);
1337 : 16539 : reseat (stmt.get_pattern_ptr ());
1338 : 16539 : if (stmt.has_type ())
1339 : 2489 : reseat (stmt.get_type_ptr ());
1340 : 16539 : if (stmt.has_init_expr ())
1341 : 15187 : reseat (stmt.get_init_expr_ptr ());
1342 : 16539 : }
1343 : :
1344 : : void
1345 : 13354 : PointerVisitor::visit (AST::ExprStmt &stmt)
1346 : : {
1347 : 13354 : reseat (stmt.get_expr_ptr ());
1348 : 13354 : }
1349 : :
1350 : : void
1351 : 134623 : PointerVisitor::visit (AST::TraitBound &bound)
1352 : : {
1353 : 134701 : for (auto &lifetime : bound.get_for_lifetimes ())
1354 : 78 : visit (lifetime);
1355 : 134623 : visit (bound.get_type_path ());
1356 : 134623 : }
1357 : :
1358 : : void
1359 : 72 : PointerVisitor::visit (AST::ImplTraitType &type)
1360 : : {
1361 : 216 : for (auto &bound : type.get_type_param_bounds ())
1362 : 144 : visit (bound);
1363 : 72 : }
1364 : :
1365 : : void
1366 : 4309 : PointerVisitor::visit (AST::TraitObjectType &type)
1367 : : {
1368 : 10262 : for (auto &bound : type.get_type_param_bounds ())
1369 : 5953 : visit (bound);
1370 : 4309 : }
1371 : :
1372 : : void
1373 : 338 : PointerVisitor::visit (AST::ParenthesisedType &type)
1374 : : {
1375 : 338 : reseat (type.get_type_in_parens ());
1376 : 338 : }
1377 : :
1378 : : void
1379 : 4713 : PointerVisitor::visit (AST::ImplTraitTypeOneBound &type)
1380 : : {
1381 : : // FIXME: Do we need to reseat here?
1382 : 4713 : visit (type.get_trait_bound ());
1383 : 4713 : }
1384 : :
1385 : : void
1386 : 1305 : PointerVisitor::visit (AST::TraitObjectTypeOneBound &type)
1387 : : {
1388 : : // FIXME: Do we need to reseat here?
1389 : 1305 : visit (type.get_trait_bound ());
1390 : 1305 : }
1391 : :
1392 : : void
1393 : 33771 : PointerVisitor::visit (AST::TupleType &type)
1394 : : {
1395 : 111330 : for (auto &elem : type.get_elems ())
1396 : 77559 : reseat (elem);
1397 : 33771 : }
1398 : :
1399 : : void
1400 : 1915 : PointerVisitor::visit (AST::NeverType &type)
1401 : 1915 : {}
1402 : :
1403 : : void
1404 : 61845 : PointerVisitor::visit (AST::RawPointerType &type)
1405 : : {
1406 : 61845 : reseat (type.get_type_pointed_to_ptr ());
1407 : 61845 : }
1408 : :
1409 : : void
1410 : 275683 : PointerVisitor::visit (AST::ReferenceType &type)
1411 : : {
1412 : 275683 : visit (type.get_lifetime ());
1413 : 275683 : reseat (type.get_type_ptr ());
1414 : 275683 : }
1415 : :
1416 : : void
1417 : 12322 : PointerVisitor::visit (AST::ArrayType &type)
1418 : : {
1419 : 12322 : reseat (type.get_elem_type_ptr ());
1420 : 12322 : visit (type.get_size_expr ());
1421 : 12322 : }
1422 : :
1423 : : void
1424 : 23143 : PointerVisitor::visit (AST::SliceType &type)
1425 : : {
1426 : 23143 : reseat (type.get_elem_type_ptr ());
1427 : 23143 : }
1428 : :
1429 : : void
1430 : 8711 : PointerVisitor::visit (AST::InferredType &type)
1431 : 8711 : {}
1432 : :
1433 : : void
1434 : 3342 : PointerVisitor::visit (AST::MaybeNamedParam ¶m)
1435 : : {
1436 : 3342 : visit_outer_attrs (param);
1437 : 3342 : reseat (param.get_type_ptr ());
1438 : 3342 : }
1439 : :
1440 : : void
1441 : 610 : PointerVisitor::visit (AST::BareFunctionType &type)
1442 : : {
1443 : 613 : for (auto &lifetime : type.get_for_lifetimes ())
1444 : 3 : visit (lifetime);
1445 : 610 : visit (type.get_function_qualifiers ());
1446 : 3952 : for (auto ¶m : type.get_function_params ())
1447 : 3342 : visit (param);
1448 : 610 : if (type.is_variadic ())
1449 : 168 : for (auto attr : type.get_variadic_attr ())
1450 : 0 : visit (attr);
1451 : 610 : if (type.has_return_type ())
1452 : 587 : reseat (type.get_return_type_ptr ());
1453 : 610 : }
1454 : :
1455 : : void
1456 : 0 : PointerVisitor::visit (AST::FormatArgs &)
1457 : : {
1458 : : // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
1459 : 0 : }
1460 : :
1461 : : void
1462 : 30 : PointerVisitor::visit (AST::OffsetOf &offset_of)
1463 : : {
1464 : 30 : reseat (offset_of.get_type_ptr ());
1465 : 30 : }
1466 : :
1467 : : void
1468 : 836 : PointerVisitor::visit (AST::VariadicParam ¶m)
1469 : : {
1470 : 836 : if (param.has_pattern ())
1471 : 11 : reseat (param.get_pattern_ptr ());
1472 : 836 : }
1473 : :
1474 : : } // namespace AST
1475 : : } // namespace Rust
|
