1pub use rustc_ast_ir::visit::VisitorResult;
17pub use rustc_ast_ir::{try_visit, visit_opt, walk_list, walk_visitable_list};
18use rustc_span::{Ident, Span};
19use thin_vec::ThinVec;
20
21use crate::ast::*;
22use crate::ptr::P;
23
24#[derive(Copy, Clone, Debug, PartialEq)]
25pub enum AssocCtxt {
26 Trait,
27 Impl { of_trait: bool },
28}
29
30#[derive(Copy, Clone, Debug, PartialEq)]
31pub enum FnCtxt {
32 Free,
33 Foreign,
34 Assoc(AssocCtxt),
35}
36
37#[derive(Copy, Clone, Debug)]
38pub enum BoundKind {
39 Bound,
42
43 Impl,
46
47 TraitObject,
50
51 SuperTraits,
54}
55impl BoundKind {
56 pub fn descr(self) -> &'static str {
57 match self {
58 BoundKind::Bound => "bounds",
59 BoundKind::Impl => "`impl Trait`",
60 BoundKind::TraitObject => "`dyn` trait object bounds",
61 BoundKind::SuperTraits => "supertrait bounds",
62 }
63 }
64}
65
66#[derive(Copy, Clone, Debug)]
67pub enum FnKind<'a> {
68 Fn(FnCtxt, &'a Visibility, &'a Fn),
70
71 Closure(&'a ClosureBinder, &'a Option<CoroutineKind>, &'a FnDecl, &'a Expr),
73}
74
75impl<'a> FnKind<'a> {
76 pub fn header(&self) -> Option<&'a FnHeader> {
77 match *self {
78 FnKind::Fn(_, _, Fn { sig, .. }) => Some(&sig.header),
79 FnKind::Closure(..) => None,
80 }
81 }
82
83 pub fn ident(&self) -> Option<&Ident> {
84 match self {
85 FnKind::Fn(_, _, Fn { ident, .. }) => Some(ident),
86 _ => None,
87 }
88 }
89
90 pub fn decl(&self) -> &'a FnDecl {
91 match self {
92 FnKind::Fn(_, _, Fn { sig, .. }) => &sig.decl,
93 FnKind::Closure(_, _, decl, _) => decl,
94 }
95 }
96
97 pub fn ctxt(&self) -> Option<FnCtxt> {
98 match self {
99 FnKind::Fn(ctxt, ..) => Some(*ctxt),
100 FnKind::Closure(..) => None,
101 }
102 }
103}
104
105#[derive(Copy, Clone, Debug)]
106pub enum LifetimeCtxt {
107 Ref,
109 Bound,
111 GenericArg,
113}
114
115pub trait Visitor<'ast>: Sized {
125 type Result: VisitorResult = ();
128
129 fn visit_ident(&mut self, _ident: &'ast Ident) -> Self::Result {
130 Self::Result::output()
131 }
132 fn visit_foreign_mod(&mut self, nm: &'ast ForeignMod) -> Self::Result {
133 walk_foreign_mod(self, nm)
134 }
135 fn visit_foreign_item(&mut self, i: &'ast ForeignItem) -> Self::Result {
136 walk_item(self, i)
137 }
138 fn visit_item(&mut self, i: &'ast Item) -> Self::Result {
139 walk_item(self, i)
140 }
141 fn visit_local(&mut self, l: &'ast Local) -> Self::Result {
142 walk_local(self, l)
143 }
144 fn visit_block(&mut self, b: &'ast Block) -> Self::Result {
145 walk_block(self, b)
146 }
147 fn visit_stmt(&mut self, s: &'ast Stmt) -> Self::Result {
148 walk_stmt(self, s)
149 }
150 fn visit_param(&mut self, param: &'ast Param) -> Self::Result {
151 walk_param(self, param)
152 }
153 fn visit_arm(&mut self, a: &'ast Arm) -> Self::Result {
154 walk_arm(self, a)
155 }
156 fn visit_pat(&mut self, p: &'ast Pat) -> Self::Result {
157 walk_pat(self, p)
158 }
159 fn visit_anon_const(&mut self, c: &'ast AnonConst) -> Self::Result {
160 walk_anon_const(self, c)
161 }
162 fn visit_expr(&mut self, ex: &'ast Expr) -> Self::Result {
163 walk_expr(self, ex)
164 }
165 fn visit_method_receiver_expr(&mut self, ex: &'ast Expr) -> Self::Result {
168 self.visit_expr(ex)
169 }
170 fn visit_ty(&mut self, t: &'ast Ty) -> Self::Result {
171 walk_ty(self, t)
172 }
173 fn visit_ty_pat(&mut self, t: &'ast TyPat) -> Self::Result {
174 walk_ty_pat(self, t)
175 }
176 fn visit_generic_param(&mut self, param: &'ast GenericParam) -> Self::Result {
177 walk_generic_param(self, param)
178 }
179 fn visit_generics(&mut self, g: &'ast Generics) -> Self::Result {
180 walk_generics(self, g)
181 }
182 fn visit_closure_binder(&mut self, b: &'ast ClosureBinder) -> Self::Result {
183 walk_closure_binder(self, b)
184 }
185 fn visit_contract(&mut self, c: &'ast FnContract) -> Self::Result {
186 walk_contract(self, c)
187 }
188 fn visit_where_predicate(&mut self, p: &'ast WherePredicate) -> Self::Result {
189 walk_where_predicate(self, p)
190 }
191 fn visit_where_predicate_kind(&mut self, k: &'ast WherePredicateKind) -> Self::Result {
192 walk_where_predicate_kind(self, k)
193 }
194 fn visit_fn(&mut self, fk: FnKind<'ast>, _: Span, _: NodeId) -> Self::Result {
195 walk_fn(self, fk)
196 }
197 fn visit_assoc_item(&mut self, i: &'ast AssocItem, ctxt: AssocCtxt) -> Self::Result {
198 walk_assoc_item(self, i, ctxt)
199 }
200 fn visit_trait_ref(&mut self, t: &'ast TraitRef) -> Self::Result {
201 walk_trait_ref(self, t)
202 }
203 fn visit_param_bound(&mut self, bounds: &'ast GenericBound, _ctxt: BoundKind) -> Self::Result {
204 walk_param_bound(self, bounds)
205 }
206 fn visit_precise_capturing_arg(&mut self, arg: &'ast PreciseCapturingArg) -> Self::Result {
207 walk_precise_capturing_arg(self, arg)
208 }
209 fn visit_poly_trait_ref(&mut self, t: &'ast PolyTraitRef) -> Self::Result {
210 walk_poly_trait_ref(self, t)
211 }
212 fn visit_variant_data(&mut self, s: &'ast VariantData) -> Self::Result {
213 walk_struct_def(self, s)
214 }
215 fn visit_field_def(&mut self, s: &'ast FieldDef) -> Self::Result {
216 walk_field_def(self, s)
217 }
218 fn visit_enum_def(&mut self, enum_definition: &'ast EnumDef) -> Self::Result {
219 walk_enum_def(self, enum_definition)
220 }
221 fn visit_variant(&mut self, v: &'ast Variant) -> Self::Result {
222 walk_variant(self, v)
223 }
224 fn visit_variant_discr(&mut self, discr: &'ast AnonConst) -> Self::Result {
225 self.visit_anon_const(discr)
226 }
227 fn visit_label(&mut self, label: &'ast Label) -> Self::Result {
228 walk_label(self, label)
229 }
230 fn visit_lifetime(&mut self, lifetime: &'ast Lifetime, _: LifetimeCtxt) -> Self::Result {
231 walk_lifetime(self, lifetime)
232 }
233 fn visit_mac_call(&mut self, mac: &'ast MacCall) -> Self::Result {
234 walk_mac(self, mac)
235 }
236 fn visit_macro_def(&mut self, _mac: &'ast MacroDef, _id: NodeId) -> Self::Result {
237 Self::Result::output()
238 }
239 fn visit_path(&mut self, path: &'ast Path, _id: NodeId) -> Self::Result {
240 walk_path(self, path)
241 }
242 fn visit_use_tree(
243 &mut self,
244 use_tree: &'ast UseTree,
245 id: NodeId,
246 _nested: bool,
247 ) -> Self::Result {
248 walk_use_tree(self, use_tree, id)
249 }
250 fn visit_path_segment(&mut self, path_segment: &'ast PathSegment) -> Self::Result {
251 walk_path_segment(self, path_segment)
252 }
253 fn visit_generic_args(&mut self, generic_args: &'ast GenericArgs) -> Self::Result {
254 walk_generic_args(self, generic_args)
255 }
256 fn visit_generic_arg(&mut self, generic_arg: &'ast GenericArg) -> Self::Result {
257 walk_generic_arg(self, generic_arg)
258 }
259 fn visit_assoc_item_constraint(
260 &mut self,
261 constraint: &'ast AssocItemConstraint,
262 ) -> Self::Result {
263 walk_assoc_item_constraint(self, constraint)
264 }
265 fn visit_attribute(&mut self, attr: &'ast Attribute) -> Self::Result {
266 walk_attribute(self, attr)
267 }
268 fn visit_vis(&mut self, vis: &'ast Visibility) -> Self::Result {
269 walk_vis(self, vis)
270 }
271 fn visit_fn_ret_ty(&mut self, ret_ty: &'ast FnRetTy) -> Self::Result {
272 walk_fn_ret_ty(self, ret_ty)
273 }
274 fn visit_fn_header(&mut self, header: &'ast FnHeader) -> Self::Result {
275 walk_fn_header(self, header)
276 }
277 fn visit_expr_field(&mut self, f: &'ast ExprField) -> Self::Result {
278 walk_expr_field(self, f)
279 }
280 fn visit_pat_field(&mut self, fp: &'ast PatField) -> Self::Result {
281 walk_pat_field(self, fp)
282 }
283 fn visit_crate(&mut self, krate: &'ast Crate) -> Self::Result {
284 walk_crate(self, krate)
285 }
286 fn visit_inline_asm(&mut self, asm: &'ast InlineAsm) -> Self::Result {
287 walk_inline_asm(self, asm)
288 }
289 fn visit_format_args(&mut self, fmt: &'ast FormatArgs) -> Self::Result {
290 walk_format_args(self, fmt)
291 }
292 fn visit_inline_asm_sym(&mut self, sym: &'ast InlineAsmSym) -> Self::Result {
293 walk_inline_asm_sym(self, sym)
294 }
295 fn visit_capture_by(&mut self, _capture_by: &'ast CaptureBy) -> Self::Result {
296 Self::Result::output()
297 }
298 fn visit_coroutine_kind(&mut self, _coroutine_kind: &'ast CoroutineKind) -> Self::Result {
299 Self::Result::output()
300 }
301 fn visit_fn_decl(&mut self, fn_decl: &'ast FnDecl) -> Self::Result {
302 walk_fn_decl(self, fn_decl)
303 }
304 fn visit_qself(&mut self, qs: &'ast Option<P<QSelf>>) -> Self::Result {
305 walk_qself(self, qs)
306 }
307}
308
309#[macro_export]
310macro_rules! common_visitor_and_walkers {
311 ($(($mut: ident))? $Visitor:ident$(<$lt:lifetime>)?) => {
312 pub trait WalkItemKind {
313 type Ctxt;
314 fn walk<$($lt,)? V: $Visitor$(<$lt>)?>(
315 &$($lt)? $($mut)? self,
316 span: Span,
317 id: NodeId,
318 visibility: &$($lt)? $($mut)? Visibility,
319 ctxt: Self::Ctxt,
320 visitor: &mut V,
321 ) $(-> <V as Visitor<$lt>>::Result)?;
322 }
323
324 $(${ignore($lt)}
326 #[expect(unused, rustc::pass_by_value)]
327 #[inline]
328 )?
329 fn visit_span<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, span: &$($lt)? $($mut)? Span) $(-> <V as Visitor<$lt>>::Result)? {
330 $(
331 ${ignore($mut)}
332 visitor.visit_span(span);
333 )?
334 $(${ignore($lt)}V::Result::output())?
335 }
336
337 $(${ignore($lt)}
339 #[expect(unused, rustc::pass_by_value)]
340 #[inline]
341 )?
342 fn visit_id<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, id: &$($lt)? $($mut)? NodeId) $(-> <V as Visitor<$lt>>::Result)? {
343 $(
344 ${ignore($mut)}
345 visitor.visit_id(id);
346 )?
347 $(${ignore($lt)}V::Result::output())?
348 }
349
350 fn visit_safety<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, safety: &$($lt)? $($mut)? Safety) $(-> <V as Visitor<$lt>>::Result)? {
352 match safety {
353 Safety::Unsafe(span) => visit_span(vis, span),
354 Safety::Safe(span) => visit_span(vis, span),
355 Safety::Default => { $(${ignore($lt)}V::Result::output())? }
356 }
357 }
358
359 fn visit_constness<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, constness: &$($lt)? $($mut)? Const) $(-> <V as Visitor<$lt>>::Result)? {
360 match constness {
361 Const::Yes(span) => visit_span(vis, span),
362 Const::No => {
363 $(<V as Visitor<$lt>>::Result::output())?
364 }
365 }
366 }
367
368 fn visit_defaultness<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, defaultness: &$($lt)? $($mut)? Defaultness) $(-> <V as Visitor<$lt>>::Result)? {
369 match defaultness {
370 Defaultness::Default(span) => visit_span(vis, span),
371 Defaultness::Final => {
372 $(<V as Visitor<$lt>>::Result::output())?
373 }
374 }
375 }
376
377 fn visit_polarity<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, polarity: &$($lt)? $($mut)? ImplPolarity) $(-> <V as Visitor<$lt>>::Result)? {
378 match polarity {
379 ImplPolarity::Positive => { $(<V as Visitor<$lt>>::Result::output())? }
380 ImplPolarity::Negative(span) => visit_span(vis, span),
381 }
382 }
383
384 fn visit_bounds<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, bounds: &$($lt)? $($mut)? GenericBounds, ctxt: BoundKind) $(-> <V as Visitor<$lt>>::Result)? {
385 walk_list!(visitor, visit_param_bound, bounds, ctxt);
386 $(<V as Visitor<$lt>>::Result::output())?
387 }
388
389 pub fn walk_label<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, Label { ident }: &$($lt)? $($mut)? Label) $(-> <V as Visitor<$lt>>::Result)? {
390 visitor.visit_ident(ident)
391 }
392
393 pub fn walk_fn_header<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, header: &$($lt)? $($mut)? FnHeader) $(-> <V as Visitor<$lt>>::Result)? {
394 let FnHeader { safety, coroutine_kind, constness, ext: _ } = header;
395 try_visit!(visit_constness(visitor, constness));
396 visit_opt!(visitor, visit_coroutine_kind, coroutine_kind);
397 visit_safety(visitor, safety)
398 }
399
400 pub fn walk_lifetime<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, Lifetime { id, ident }: &$($lt)? $($mut)? Lifetime) $(-> <V as Visitor<$lt>>::Result)? {
401 try_visit!(visit_id(visitor, id));
402 visitor.visit_ident(ident)
403 }
404
405 fn walk_item_ctxt<$($lt,)? V: $Visitor$(<$lt>)?, K: WalkItemKind>(
406 visitor: &mut V,
407 item: &$($mut)? $($lt)? Item<K>,
408 ctxt: K::Ctxt,
409 ) $(-> <V as Visitor<$lt>>::Result)? {
410 let Item { attrs, id, kind, vis, span, tokens: _ } = item;
411 try_visit!(visit_id(visitor, id));
412 walk_list!(visitor, visit_attribute, attrs);
413 try_visit!(visitor.visit_vis(vis));
414 try_visit!(kind.walk(*span, *id, vis, ctxt, visitor));
415 visit_span(visitor, span)
416 }
417
418 pub fn walk_item<$($lt,)? V: $Visitor$(<$lt>)?, K: WalkItemKind<Ctxt = ()>>(
419 visitor: &mut V,
420 item: &$($mut)? $($lt)? Item<K>,
421 ) $(-> <V as Visitor<$lt>>::Result)? {
422 walk_item_ctxt(visitor, item, ())
423 }
424
425 pub fn walk_assoc_item<$($lt,)? V: $Visitor$(<$lt>)?>(
426 visitor: &mut V,
427 item: &$($mut)? $($lt)? AssocItem,
428 ctxt: AssocCtxt,
429 ) $(-> <V as Visitor<$lt>>::Result)? {
430 walk_item_ctxt(visitor, item, ctxt)
431 }
432
433 impl WalkItemKind for ItemKind {
434 type Ctxt = ();
435 fn walk<$($lt,)? V: $Visitor$(<$lt>)?>(
436 &$($lt)? $($mut)? self,
437 span: Span,
438 id: NodeId,
439 visibility: &$($lt)? $($mut)? Visibility,
440 _ctxt: Self::Ctxt,
441 vis: &mut V,
442 ) $(-> <V as Visitor<$lt>>::Result)? {
443 match self {
444 ItemKind::ExternCrate(_orig_name, ident) => vis.visit_ident(ident),
445 ItemKind::Use(use_tree) => vis.visit_use_tree(use_tree$(${ignore($lt)}, id, false)?),
447 ItemKind::Static(box StaticItem {
448 ident,
449 ty,
450 safety: _,
451 mutability: _,
452 expr,
453 define_opaque,
454 }) => {
455 try_visit!(vis.visit_ident(ident));
456 try_visit!(vis.visit_ty(ty));
457 visit_opt!(vis, visit_expr, expr);
458 walk_define_opaques(vis, define_opaque)
459 }
460 ItemKind::Const(item) => {
461 walk_const_item(vis, item)
462 }
463 ItemKind::Fn(func) => {
464 let kind = FnKind::Fn(FnCtxt::Free, visibility, &$($mut)? *func);
465 vis.visit_fn(kind, span, id)
466 }
467 ItemKind::Mod(safety, ident, mod_kind) => {
468 try_visit!(visit_safety(vis, safety));
469 try_visit!(vis.visit_ident(ident));
470 match mod_kind {
471 ModKind::Loaded(
472 items,
473 _inline,
474 ModSpans { inner_span, inject_use_span },
475 _,
476 ) => {
477 $(${ignore($mut)}
478 items.flat_map_in_place(|item| vis.flat_map_item(item));
479 )?
480 $(${ignore($lt)}
481 walk_list!(vis, visit_item, items);
482 )?
483 try_visit!(visit_span(vis, inner_span));
484 try_visit!(visit_span(vis, inject_use_span));
485 }
486 ModKind::Unloaded => {}
487 }
488 $(<V as Visitor<$lt>>::Result::output())?
489 }
490 ItemKind::ForeignMod(nm) => vis.visit_foreign_mod(nm),
491 ItemKind::GlobalAsm(asm) => vis.visit_inline_asm(asm),
492 ItemKind::TyAlias(box TyAlias {
493 defaultness,
494 ident,
495 generics,
496 $(${ignore($lt)} #[expect(unused)])?
497 where_clauses,
498 bounds,
499 ty,
500 }) => {
501 try_visit!(visit_defaultness(vis, defaultness));
502 try_visit!(vis.visit_ident(ident));
503 try_visit!(vis.visit_generics(generics));
504 try_visit!(visit_bounds(vis, bounds, BoundKind::Bound));
505 visit_opt!(vis, visit_ty, ty);
506 $(${ignore($mut)}
507 walk_ty_alias_where_clauses(vis, where_clauses);
508 )?
509 $(<V as Visitor<$lt>>::Result::output())?
510 }
511 ItemKind::Enum(ident, generics, enum_definition) => {
512 try_visit!(vis.visit_ident(ident));
513 try_visit!(vis.visit_generics(generics));
514 $(${ignore($mut)}
515 enum_definition.variants.flat_map_in_place(|variant| vis.flat_map_variant(variant));
516 )?
517 $(${ignore($lt)}vis.visit_enum_def(enum_definition))?
518 }
519 ItemKind::Struct(ident, generics, variant_data)
520 | ItemKind::Union(ident, generics, variant_data) => {
521 try_visit!(vis.visit_ident(ident));
522 try_visit!(vis.visit_generics(generics));
523 vis.visit_variant_data(variant_data)
524 }
525 ItemKind::Impl(box Impl {
526 defaultness,
527 safety,
528 generics,
529 constness,
530 polarity,
531 of_trait,
532 self_ty,
533 items,
534 }) => {
535 try_visit!(visit_defaultness(vis, defaultness));
536 try_visit!(visit_safety(vis, safety));
537 try_visit!(vis.visit_generics(generics));
538 try_visit!(visit_constness(vis, constness));
539 try_visit!(visit_polarity(vis, polarity));
540 visit_opt!(vis, visit_trait_ref, of_trait);
541 try_visit!(vis.visit_ty(self_ty));
542 $(${ignore($mut)}
543 items.flat_map_in_place(|item| {
544 vis.flat_map_assoc_item(item, AssocCtxt::Impl { of_trait: of_trait.is_some() })
545 });
546 )?
547 $(${ignore($lt)}
548 walk_list!(
549 vis,
550 visit_assoc_item,
551 items,
552 AssocCtxt::Impl { of_trait: of_trait.is_some() }
553 );
554 <V as Visitor<$lt>>::Result::output()
555 )?
556 }
557 ItemKind::Trait(box Trait { safety, is_auto: _, ident, generics, bounds, items }) => {
558 try_visit!(visit_safety(vis, safety));
559 try_visit!(vis.visit_ident(ident));
560 try_visit!(vis.visit_generics(generics));
561 try_visit!(visit_bounds(vis, bounds, BoundKind::Bound));
562 $(${ignore($mut)}
563 items.flat_map_in_place(|item| {
564 vis.flat_map_assoc_item(item, AssocCtxt::Trait)
565 });
566 )?
567 $(${ignore($lt)}
568 walk_list!(vis, visit_assoc_item, items, AssocCtxt::Trait);
569 <V as Visitor<$lt>>::Result::output()
570 )?
571 }
572 ItemKind::TraitAlias(ident, generics, bounds) => {
573 try_visit!(vis.visit_ident(ident));
574 try_visit!(vis.visit_generics(generics));
575 visit_bounds(vis, bounds, BoundKind::Bound)
576 }
577 ItemKind::MacCall(m) => vis.visit_mac_call(m),
578 ItemKind::MacroDef(ident, def) => {
579 try_visit!(vis.visit_ident(ident));
580 vis.visit_macro_def(def$(${ignore($lt)}, id)?)
582 }
583 ItemKind::Delegation(box Delegation {
584 id,
585 qself,
586 path,
587 ident,
588 rename,
589 body,
590 from_glob: _,
591 }) => {
592 try_visit!(visit_id(vis, id));
593 try_visit!(vis.visit_qself(qself));
594 try_visit!(vis.visit_path(path$(${ignore($lt)}, *id)?));
595 try_visit!(vis.visit_ident(ident));
596 visit_opt!(vis, visit_ident, rename);
597 visit_opt!(vis, visit_block, body);
598 $(<V as Visitor<$lt>>::Result::output())?
599 }
600 ItemKind::DelegationMac(box DelegationMac { qself, prefix, suffixes, body }) => {
601 try_visit!(vis.visit_qself(qself));
602 try_visit!(vis.visit_path(prefix$(${ignore($lt)}, id)?));
603 if let Some(suffixes) = suffixes {
604 for (ident, rename) in suffixes {
605 try_visit!(vis.visit_ident(ident));
606 visit_opt!(vis, visit_ident, rename);
607 }
608 }
609 visit_opt!(vis, visit_block, body);
610 $(<V as Visitor<$lt>>::Result::output())?
611 }
612 }
613 }
614 }
615
616 fn walk_const_item<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, item: &$($lt)? $($mut)? ConstItem) $(-> <V as Visitor<$lt>>::Result)? {
617 let ConstItem { defaultness, ident, generics, ty, expr, define_opaque } = item;
618 try_visit!(visit_defaultness(vis, defaultness));
619 try_visit!(vis.visit_ident(ident));
620 try_visit!(vis.visit_generics(generics));
621 try_visit!(vis.visit_ty(ty));
622 visit_opt!(vis, visit_expr, expr);
623 walk_define_opaques(vis, define_opaque)
624 }
625
626 fn walk_foreign_mod<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, foreign_mod: &$($lt)? $($mut)? ForeignMod) $(-> <V as Visitor<$lt>>::Result)? {
627 let ForeignMod { extern_span: _, safety, abi: _, items } = foreign_mod;
628 try_visit!(visit_safety(vis, safety));
629 $(${ignore($mut)}
630 items.flat_map_in_place(|item| vis.flat_map_foreign_item(item));
631 )?
632 $(
633 walk_list!(vis, visit_foreign_item, items);
634 <V as Visitor<$lt>>::Result::output()
635 )?
636 }
637
638 fn walk_define_opaques<$($lt,)? V: $Visitor$(<$lt>)?>(
639 visitor: &mut V,
640 define_opaque: &$($lt)? $($mut)? Option<ThinVec<(NodeId, Path)>>,
641 ) $(-> <V as Visitor<$lt>>::Result)? {
642 if let Some(define_opaque) = define_opaque {
643 for (id, path) in define_opaque {
644 try_visit!(visit_id(visitor, id));
645 try_visit!(visitor.visit_path(path$(${ignore($lt)}, *id)?));
647 }
648 }
649 $(<V as Visitor<$lt>>::Result::output())?
650 }
651
652 impl WalkItemKind for AssocItemKind {
653 type Ctxt = AssocCtxt;
654 fn walk<$($lt,)? V: $Visitor$(<$lt>)?>(
655 &$($lt)? $($mut)? self,
656 span: Span,
657 id: NodeId,
658 visibility: &$($lt)? $($mut)? Visibility,
659 ctxt: Self::Ctxt,
660 vis: &mut V,
661 ) $(-> <V as Visitor<$lt>>::Result)? {
662 match self {
663 AssocItemKind::Const(item) => {
664 walk_const_item(vis, item)
665 }
666 AssocItemKind::Fn(func) => {
667 vis.visit_fn(FnKind::Fn(FnCtxt::Assoc(ctxt), visibility, &$($mut)? *func), span, id)
668 }
669 AssocItemKind::Type(box TyAlias {
670 generics,
671 ident,
672 bounds,
673 ty,
674 defaultness,
675 $(${ignore($lt)} #[expect(unused)])?
676 where_clauses,
677 }) => {
678 try_visit!(visit_defaultness(vis, defaultness));
679 try_visit!(vis.visit_ident(ident));
680 try_visit!(vis.visit_generics(generics));
681 try_visit!(visit_bounds(vis, bounds, BoundKind::Bound));
682 visit_opt!(vis, visit_ty, ty);
683 $(${ignore($mut)}
684 walk_ty_alias_where_clauses(vis, where_clauses);
685 )?
686 $(<V as Visitor<$lt>>::Result::output())?
687 }
688 AssocItemKind::MacCall(mac) => {
689 vis.visit_mac_call(mac)
690 }
691 AssocItemKind::Delegation(box Delegation {
692 id,
693 qself,
694 path,
695 ident,
696 rename,
697 body,
698 from_glob: _,
699 }) => {
700 try_visit!(visit_id(vis, id));
701 try_visit!(vis.visit_qself(qself));
702 try_visit!(vis.visit_path(path $(${ignore($lt)}, *id)?));
703 try_visit!(vis.visit_ident(ident));
704 visit_opt!(vis, visit_ident, rename);
705 visit_opt!(vis, visit_block, body);
706 $(<V as Visitor<$lt>>::Result::output())?
707 }
708 AssocItemKind::DelegationMac(box DelegationMac { qself, prefix, suffixes, body }) => {
709 try_visit!(vis.visit_qself(qself));
710 try_visit!(vis.visit_path(prefix$(${ignore($lt)}, id)?));
711 if let Some(suffixes) = suffixes {
712 for (ident, rename) in suffixes {
713 try_visit!(vis.visit_ident(ident));
714 visit_opt!(vis, visit_ident, rename);
715 }
716 }
717 visit_opt!(vis, visit_block, body);
718 $(<V as Visitor<$lt>>::Result::output())?
719 }
720 }
721 }
722 }
723
724 impl WalkItemKind for ForeignItemKind {
725 type Ctxt = ();
726 fn walk<$($lt,)? V: $Visitor$(<$lt>)?>(
727 &$($lt)? $($mut)? self,
728 span: Span,
729 id: NodeId,
730 visibility: &$($lt)? $($mut)? Visibility,
731 _ctxt: Self::Ctxt,
732 vis: &mut V,
733 ) $(-> <V as Visitor<$lt>>::Result)? {
734 match self {
735 ForeignItemKind::Static(box StaticItem {
736 ident,
737 ty,
738 mutability: _,
739 expr,
740 safety: _,
741 define_opaque,
742 }) => {
743 try_visit!(vis.visit_ident(ident));
744 try_visit!(vis.visit_ty(ty));
745 visit_opt!(vis, visit_expr, expr);
746 walk_define_opaques(vis, define_opaque)
747 }
748 ForeignItemKind::Fn(func) => {
749 vis.visit_fn(FnKind::Fn(FnCtxt::Foreign, visibility, &$($mut)?*func), span, id)
750 }
751 ForeignItemKind::TyAlias(box TyAlias {
752 defaultness,
753 ident,
754 generics,
755 bounds,
756 ty,
757 $(${ignore($lt)} #[expect(unused)])?
758 where_clauses,
759 }) => {
760 try_visit!(visit_defaultness(vis, defaultness));
761 try_visit!(vis.visit_ident(ident));
762 try_visit!(vis.visit_generics(generics));
763 try_visit!(visit_bounds(vis, bounds, BoundKind::Bound));
764 visit_opt!(vis, visit_ty, ty);
765 $(${ignore($mut)}
766 walk_ty_alias_where_clauses(vis, where_clauses);
767 )?
768 $(<V as Visitor<$lt>>::Result::output())?
769 }
770 ForeignItemKind::MacCall(mac) => {
771 vis.visit_mac_call(mac)
772 }
773 }
774 }
775 }
776 };
777}
778
779common_visitor_and_walkers!(Visitor<'a>);
780
781pub fn walk_crate<'a, V: Visitor<'a>>(visitor: &mut V, krate: &'a Crate) -> V::Result {
782 let Crate { attrs, items, spans: _, id: _, is_placeholder: _ } = krate;
783 walk_list!(visitor, visit_attribute, attrs);
784 walk_list!(visitor, visit_item, items);
785 V::Result::output()
786}
787
788pub fn walk_local<'a, V: Visitor<'a>>(visitor: &mut V, local: &'a Local) -> V::Result {
789 let Local { id: _, super_: _, pat, ty, kind, span: _, colon_sp: _, attrs, tokens: _ } = local;
790 walk_list!(visitor, visit_attribute, attrs);
791 try_visit!(visitor.visit_pat(pat));
792 visit_opt!(visitor, visit_ty, ty);
793 if let Some((init, els)) = kind.init_else_opt() {
794 try_visit!(visitor.visit_expr(init));
795 visit_opt!(visitor, visit_block, els);
796 }
797 V::Result::output()
798}
799
800pub fn walk_poly_trait_ref<'a, V>(visitor: &mut V, trait_ref: &'a PolyTraitRef) -> V::Result
801where
802 V: Visitor<'a>,
803{
804 let PolyTraitRef { bound_generic_params, modifiers: _, trait_ref, span: _ } = trait_ref;
805 walk_list!(visitor, visit_generic_param, bound_generic_params);
806 visitor.visit_trait_ref(trait_ref)
807}
808
809pub fn walk_trait_ref<'a, V: Visitor<'a>>(visitor: &mut V, trait_ref: &'a TraitRef) -> V::Result {
810 let TraitRef { path, ref_id } = trait_ref;
811 visitor.visit_path(path, *ref_id)
812}
813
814pub fn walk_enum_def<'a, V: Visitor<'a>>(
815 visitor: &mut V,
816 EnumDef { variants }: &'a EnumDef,
817) -> V::Result {
818 walk_list!(visitor, visit_variant, variants);
819 V::Result::output()
820}
821
822pub fn walk_variant<'a, V: Visitor<'a>>(visitor: &mut V, variant: &'a Variant) -> V::Result
823where
824 V: Visitor<'a>,
825{
826 let Variant { attrs, id: _, span: _, vis, ident, data, disr_expr, is_placeholder: _ } = variant;
827 walk_list!(visitor, visit_attribute, attrs);
828 try_visit!(visitor.visit_vis(vis));
829 try_visit!(visitor.visit_ident(ident));
830 try_visit!(visitor.visit_variant_data(data));
831 visit_opt!(visitor, visit_variant_discr, disr_expr);
832 V::Result::output()
833}
834
835pub fn walk_expr_field<'a, V: Visitor<'a>>(visitor: &mut V, f: &'a ExprField) -> V::Result {
836 let ExprField { attrs, id: _, span: _, ident, expr, is_shorthand: _, is_placeholder: _ } = f;
837 walk_list!(visitor, visit_attribute, attrs);
838 try_visit!(visitor.visit_ident(ident));
839 try_visit!(visitor.visit_expr(expr));
840 V::Result::output()
841}
842
843pub fn walk_pat_field<'a, V: Visitor<'a>>(visitor: &mut V, fp: &'a PatField) -> V::Result {
844 let PatField { ident, pat, is_shorthand: _, attrs, id: _, span: _, is_placeholder: _ } = fp;
845 walk_list!(visitor, visit_attribute, attrs);
846 try_visit!(visitor.visit_ident(ident));
847 try_visit!(visitor.visit_pat(pat));
848 V::Result::output()
849}
850
851pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) -> V::Result {
852 let Ty { id, kind, span: _, tokens: _ } = typ;
853 match kind {
854 TyKind::Slice(ty) | TyKind::Paren(ty) => try_visit!(visitor.visit_ty(ty)),
855 TyKind::Ptr(MutTy { ty, mutbl: _ }) => try_visit!(visitor.visit_ty(ty)),
856 TyKind::Ref(opt_lifetime, MutTy { ty, mutbl: _ })
857 | TyKind::PinnedRef(opt_lifetime, MutTy { ty, mutbl: _ }) => {
858 visit_opt!(visitor, visit_lifetime, opt_lifetime, LifetimeCtxt::Ref);
859 try_visit!(visitor.visit_ty(ty));
860 }
861 TyKind::Tup(tuple_element_types) => {
862 walk_list!(visitor, visit_ty, tuple_element_types);
863 }
864 TyKind::BareFn(function_declaration) => {
865 let BareFnTy { safety: _, ext: _, generic_params, decl, decl_span: _ } =
866 &**function_declaration;
867 walk_list!(visitor, visit_generic_param, generic_params);
868 try_visit!(visitor.visit_fn_decl(decl));
869 }
870 TyKind::UnsafeBinder(binder) => {
871 walk_list!(visitor, visit_generic_param, &binder.generic_params);
872 try_visit!(visitor.visit_ty(&binder.inner_ty));
873 }
874 TyKind::Path(maybe_qself, path) => {
875 try_visit!(visitor.visit_qself(maybe_qself));
876 try_visit!(visitor.visit_path(path, *id));
877 }
878 TyKind::Pat(ty, pat) => {
879 try_visit!(visitor.visit_ty(ty));
880 try_visit!(visitor.visit_ty_pat(pat));
881 }
882 TyKind::Array(ty, length) => {
883 try_visit!(visitor.visit_ty(ty));
884 try_visit!(visitor.visit_anon_const(length));
885 }
886 TyKind::TraitObject(bounds, _syntax) => {
887 walk_list!(visitor, visit_param_bound, bounds, BoundKind::TraitObject);
888 }
889 TyKind::ImplTrait(_id, bounds) => {
890 walk_list!(visitor, visit_param_bound, bounds, BoundKind::Impl);
891 }
892 TyKind::Typeof(expression) => try_visit!(visitor.visit_anon_const(expression)),
893 TyKind::Infer | TyKind::ImplicitSelf | TyKind::Dummy => {}
894 TyKind::Err(_guar) => {}
895 TyKind::MacCall(mac) => try_visit!(visitor.visit_mac_call(mac)),
896 TyKind::Never | TyKind::CVarArgs => {}
897 }
898 V::Result::output()
899}
900
901pub fn walk_ty_pat<'a, V: Visitor<'a>>(visitor: &mut V, tp: &'a TyPat) -> V::Result {
902 let TyPat { id: _, kind, span: _, tokens: _ } = tp;
903 match kind {
904 TyPatKind::Range(start, end, _include_end) => {
905 visit_opt!(visitor, visit_anon_const, start);
906 visit_opt!(visitor, visit_anon_const, end);
907 }
908 TyPatKind::Or(variants) => walk_list!(visitor, visit_ty_pat, variants),
909 TyPatKind::Err(_) => {}
910 }
911 V::Result::output()
912}
913
914fn walk_qself<'a, V: Visitor<'a>>(visitor: &mut V, qself: &'a Option<P<QSelf>>) -> V::Result {
915 if let Some(qself) = qself {
916 let QSelf { ty, path_span: _, position: _ } = &**qself;
917 try_visit!(visitor.visit_ty(ty));
918 }
919 V::Result::output()
920}
921
922pub fn walk_path<'a, V: Visitor<'a>>(visitor: &mut V, path: &'a Path) -> V::Result {
923 let Path { span: _, segments, tokens: _ } = path;
924 walk_list!(visitor, visit_path_segment, segments);
925 V::Result::output()
926}
927
928pub fn walk_use_tree<'a, V: Visitor<'a>>(
929 visitor: &mut V,
930 use_tree: &'a UseTree,
931 id: NodeId,
932) -> V::Result {
933 let UseTree { prefix, kind, span: _ } = use_tree;
934 try_visit!(visitor.visit_path(prefix, id));
935 match kind {
936 UseTreeKind::Simple(rename) => {
937 visit_opt!(visitor, visit_ident, rename);
939 }
940 UseTreeKind::Glob => {}
941 UseTreeKind::Nested { items, span: _ } => {
942 for &(ref nested_tree, nested_id) in items {
943 try_visit!(visitor.visit_use_tree(nested_tree, nested_id, true));
944 }
945 }
946 }
947 V::Result::output()
948}
949
950pub fn walk_path_segment<'a, V: Visitor<'a>>(
951 visitor: &mut V,
952 segment: &'a PathSegment,
953) -> V::Result {
954 let PathSegment { ident, id: _, args } = segment;
955 try_visit!(visitor.visit_ident(ident));
956 visit_opt!(visitor, visit_generic_args, args);
957 V::Result::output()
958}
959
960pub fn walk_generic_args<'a, V>(visitor: &mut V, generic_args: &'a GenericArgs) -> V::Result
961where
962 V: Visitor<'a>,
963{
964 match generic_args {
965 GenericArgs::AngleBracketed(AngleBracketedArgs { span: _, args }) => {
966 for arg in args {
967 match arg {
968 AngleBracketedArg::Arg(a) => try_visit!(visitor.visit_generic_arg(a)),
969 AngleBracketedArg::Constraint(c) => {
970 try_visit!(visitor.visit_assoc_item_constraint(c))
971 }
972 }
973 }
974 }
975 GenericArgs::Parenthesized(data) => {
976 let ParenthesizedArgs { span: _, inputs, inputs_span: _, output } = data;
977 walk_list!(visitor, visit_ty, inputs);
978 try_visit!(visitor.visit_fn_ret_ty(output));
979 }
980 GenericArgs::ParenthesizedElided(_span) => {}
981 }
982 V::Result::output()
983}
984
985pub fn walk_generic_arg<'a, V>(visitor: &mut V, generic_arg: &'a GenericArg) -> V::Result
986where
987 V: Visitor<'a>,
988{
989 match generic_arg {
990 GenericArg::Lifetime(lt) => visitor.visit_lifetime(lt, LifetimeCtxt::GenericArg),
991 GenericArg::Type(ty) => visitor.visit_ty(ty),
992 GenericArg::Const(ct) => visitor.visit_anon_const(ct),
993 }
994}
995
996pub fn walk_assoc_item_constraint<'a, V: Visitor<'a>>(
997 visitor: &mut V,
998 constraint: &'a AssocItemConstraint,
999) -> V::Result {
1000 let AssocItemConstraint { id: _, ident, gen_args, kind, span: _ } = constraint;
1001 try_visit!(visitor.visit_ident(ident));
1002 visit_opt!(visitor, visit_generic_args, gen_args);
1003 match kind {
1004 AssocItemConstraintKind::Equality { term } => match term {
1005 Term::Ty(ty) => try_visit!(visitor.visit_ty(ty)),
1006 Term::Const(c) => try_visit!(visitor.visit_anon_const(c)),
1007 },
1008 AssocItemConstraintKind::Bound { bounds } => {
1009 walk_list!(visitor, visit_param_bound, bounds, BoundKind::Bound);
1010 }
1011 }
1012 V::Result::output()
1013}
1014
1015pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) -> V::Result {
1016 let Pat { id, kind, span: _, tokens: _ } = pattern;
1017 match kind {
1018 PatKind::TupleStruct(opt_qself, path, elems) => {
1019 try_visit!(visitor.visit_qself(opt_qself));
1020 try_visit!(visitor.visit_path(path, *id));
1021 walk_list!(visitor, visit_pat, elems);
1022 }
1023 PatKind::Path(opt_qself, path) => {
1024 try_visit!(visitor.visit_qself(opt_qself));
1025 try_visit!(visitor.visit_path(path, *id))
1026 }
1027 PatKind::Struct(opt_qself, path, fields, _rest) => {
1028 try_visit!(visitor.visit_qself(opt_qself));
1029 try_visit!(visitor.visit_path(path, *id));
1030 walk_list!(visitor, visit_pat_field, fields);
1031 }
1032 PatKind::Box(subpattern) | PatKind::Deref(subpattern) | PatKind::Paren(subpattern) => {
1033 try_visit!(visitor.visit_pat(subpattern));
1034 }
1035 PatKind::Ref(subpattern, _ ) => {
1036 try_visit!(visitor.visit_pat(subpattern));
1037 }
1038 PatKind::Ident(_bmode, ident, optional_subpattern) => {
1039 try_visit!(visitor.visit_ident(ident));
1040 visit_opt!(visitor, visit_pat, optional_subpattern);
1041 }
1042 PatKind::Expr(expression) => try_visit!(visitor.visit_expr(expression)),
1043 PatKind::Range(lower_bound, upper_bound, _end) => {
1044 visit_opt!(visitor, visit_expr, lower_bound);
1045 visit_opt!(visitor, visit_expr, upper_bound);
1046 }
1047 PatKind::Guard(subpattern, guard_condition) => {
1048 try_visit!(visitor.visit_pat(subpattern));
1049 try_visit!(visitor.visit_expr(guard_condition));
1050 }
1051 PatKind::Missing | PatKind::Wild | PatKind::Rest | PatKind::Never => {}
1052 PatKind::Err(_guar) => {}
1053 PatKind::Tuple(elems) | PatKind::Slice(elems) | PatKind::Or(elems) => {
1054 walk_list!(visitor, visit_pat, elems);
1055 }
1056 PatKind::MacCall(mac) => try_visit!(visitor.visit_mac_call(mac)),
1057 }
1058 V::Result::output()
1059}
1060
1061pub fn walk_param_bound<'a, V: Visitor<'a>>(visitor: &mut V, bound: &'a GenericBound) -> V::Result {
1062 match bound {
1063 GenericBound::Trait(trait_ref) => visitor.visit_poly_trait_ref(trait_ref),
1064 GenericBound::Outlives(lifetime) => visitor.visit_lifetime(lifetime, LifetimeCtxt::Bound),
1065 GenericBound::Use(args, _span) => {
1066 walk_list!(visitor, visit_precise_capturing_arg, args);
1067 V::Result::output()
1068 }
1069 }
1070}
1071
1072pub fn walk_precise_capturing_arg<'a, V: Visitor<'a>>(
1073 visitor: &mut V,
1074 arg: &'a PreciseCapturingArg,
1075) -> V::Result {
1076 match arg {
1077 PreciseCapturingArg::Lifetime(lt) => visitor.visit_lifetime(lt, LifetimeCtxt::GenericArg),
1078 PreciseCapturingArg::Arg(path, id) => visitor.visit_path(path, *id),
1079 }
1080}
1081
1082pub fn walk_generic_param<'a, V: Visitor<'a>>(
1083 visitor: &mut V,
1084 param: &'a GenericParam,
1085) -> V::Result {
1086 let GenericParam { id: _, ident, attrs, bounds, is_placeholder: _, kind, colon_span: _ } =
1087 param;
1088 walk_list!(visitor, visit_attribute, attrs);
1089 try_visit!(visitor.visit_ident(ident));
1090 walk_list!(visitor, visit_param_bound, bounds, BoundKind::Bound);
1091 match kind {
1092 GenericParamKind::Lifetime => (),
1093 GenericParamKind::Type { default } => visit_opt!(visitor, visit_ty, default),
1094 GenericParamKind::Const { ty, default, kw_span: _ } => {
1095 try_visit!(visitor.visit_ty(ty));
1096 visit_opt!(visitor, visit_anon_const, default);
1097 }
1098 }
1099 V::Result::output()
1100}
1101
1102pub fn walk_generics<'a, V: Visitor<'a>>(visitor: &mut V, generics: &'a Generics) -> V::Result {
1103 let Generics { params, where_clause, span: _ } = generics;
1104 let WhereClause { has_where_token: _, predicates, span: _ } = where_clause;
1105 walk_list!(visitor, visit_generic_param, params);
1106 walk_list!(visitor, visit_where_predicate, predicates);
1107 V::Result::output()
1108}
1109
1110pub fn walk_closure_binder<'a, V: Visitor<'a>>(
1111 visitor: &mut V,
1112 binder: &'a ClosureBinder,
1113) -> V::Result {
1114 match binder {
1115 ClosureBinder::NotPresent => {}
1116 ClosureBinder::For { generic_params, span: _ } => {
1117 walk_list!(visitor, visit_generic_param, generic_params)
1118 }
1119 }
1120 V::Result::output()
1121}
1122
1123pub fn walk_contract<'a, V: Visitor<'a>>(visitor: &mut V, c: &'a FnContract) -> V::Result {
1124 let FnContract { requires, ensures } = c;
1125 if let Some(pred) = requires {
1126 visitor.visit_expr(pred);
1127 }
1128 if let Some(pred) = ensures {
1129 visitor.visit_expr(pred);
1130 }
1131 V::Result::output()
1132}
1133
1134pub fn walk_where_predicate<'a, V: Visitor<'a>>(
1135 visitor: &mut V,
1136 predicate: &'a WherePredicate,
1137) -> V::Result {
1138 let WherePredicate { attrs, kind, id: _, span: _, is_placeholder: _ } = predicate;
1139 walk_list!(visitor, visit_attribute, attrs);
1140 visitor.visit_where_predicate_kind(kind)
1141}
1142
1143pub fn walk_where_predicate_kind<'a, V: Visitor<'a>>(
1144 visitor: &mut V,
1145 kind: &'a WherePredicateKind,
1146) -> V::Result {
1147 match kind {
1148 WherePredicateKind::BoundPredicate(WhereBoundPredicate {
1149 bounded_ty,
1150 bounds,
1151 bound_generic_params,
1152 }) => {
1153 walk_list!(visitor, visit_generic_param, bound_generic_params);
1154 try_visit!(visitor.visit_ty(bounded_ty));
1155 walk_list!(visitor, visit_param_bound, bounds, BoundKind::Bound);
1156 }
1157 WherePredicateKind::RegionPredicate(WhereRegionPredicate { lifetime, bounds }) => {
1158 try_visit!(visitor.visit_lifetime(lifetime, LifetimeCtxt::Bound));
1159 walk_list!(visitor, visit_param_bound, bounds, BoundKind::Bound);
1160 }
1161 WherePredicateKind::EqPredicate(WhereEqPredicate { lhs_ty, rhs_ty }) => {
1162 try_visit!(visitor.visit_ty(lhs_ty));
1163 try_visit!(visitor.visit_ty(rhs_ty));
1164 }
1165 }
1166 V::Result::output()
1167}
1168
1169pub fn walk_fn_ret_ty<'a, V: Visitor<'a>>(visitor: &mut V, ret_ty: &'a FnRetTy) -> V::Result {
1170 match ret_ty {
1171 FnRetTy::Default(_span) => {}
1172 FnRetTy::Ty(output_ty) => try_visit!(visitor.visit_ty(output_ty)),
1173 }
1174 V::Result::output()
1175}
1176
1177pub fn walk_fn_decl<'a, V: Visitor<'a>>(
1178 visitor: &mut V,
1179 FnDecl { inputs, output }: &'a FnDecl,
1180) -> V::Result {
1181 walk_list!(visitor, visit_param, inputs);
1182 visitor.visit_fn_ret_ty(output)
1183}
1184
1185pub fn walk_fn<'a, V: Visitor<'a>>(visitor: &mut V, kind: FnKind<'a>) -> V::Result {
1186 match kind {
1187 FnKind::Fn(
1188 _ctxt,
1189 _vis,
1190 Fn {
1191 defaultness: _,
1192 ident,
1193 sig: FnSig { header, decl, span: _ },
1194 generics,
1195 contract,
1196 body,
1197 define_opaque,
1198 },
1199 ) => {
1200 try_visit!(visitor.visit_ident(ident));
1202 try_visit!(visitor.visit_fn_header(header));
1203 try_visit!(visitor.visit_generics(generics));
1204 try_visit!(visitor.visit_fn_decl(decl));
1205 visit_opt!(visitor, visit_contract, contract);
1206 visit_opt!(visitor, visit_block, body);
1207 try_visit!(walk_define_opaques(visitor, define_opaque));
1208 }
1209 FnKind::Closure(binder, coroutine_kind, decl, body) => {
1210 try_visit!(visitor.visit_closure_binder(binder));
1211 visit_opt!(visitor, visit_coroutine_kind, coroutine_kind.as_ref());
1212 try_visit!(visitor.visit_fn_decl(decl));
1213 try_visit!(visitor.visit_expr(body));
1214 }
1215 }
1216 V::Result::output()
1217}
1218
1219pub fn walk_struct_def<'a, V: Visitor<'a>>(
1220 visitor: &mut V,
1221 struct_definition: &'a VariantData,
1222) -> V::Result {
1223 walk_list!(visitor, visit_field_def, struct_definition.fields());
1224 V::Result::output()
1225}
1226
1227pub fn walk_field_def<'a, V: Visitor<'a>>(visitor: &mut V, field: &'a FieldDef) -> V::Result {
1228 let FieldDef { attrs, id: _, span: _, vis, ident, ty, is_placeholder: _, safety: _, default } =
1229 field;
1230 walk_list!(visitor, visit_attribute, attrs);
1231 try_visit!(visitor.visit_vis(vis));
1232 visit_opt!(visitor, visit_ident, ident);
1233 try_visit!(visitor.visit_ty(ty));
1234 visit_opt!(visitor, visit_anon_const, &*default);
1235 V::Result::output()
1236}
1237
1238pub fn walk_block<'a, V: Visitor<'a>>(visitor: &mut V, block: &'a Block) -> V::Result {
1239 let Block { stmts, id: _, rules: _, span: _, tokens: _ } = block;
1240 walk_list!(visitor, visit_stmt, stmts);
1241 V::Result::output()
1242}
1243
1244pub fn walk_stmt<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Stmt) -> V::Result {
1245 let Stmt { id: _, kind, span: _ } = statement;
1246 match kind {
1247 StmtKind::Let(local) => try_visit!(visitor.visit_local(local)),
1248 StmtKind::Item(item) => try_visit!(visitor.visit_item(item)),
1249 StmtKind::Expr(expr) | StmtKind::Semi(expr) => try_visit!(visitor.visit_expr(expr)),
1250 StmtKind::Empty => {}
1251 StmtKind::MacCall(mac) => {
1252 let MacCallStmt { mac, attrs, style: _, tokens: _ } = &**mac;
1253 walk_list!(visitor, visit_attribute, attrs);
1254 try_visit!(visitor.visit_mac_call(mac));
1255 }
1256 }
1257 V::Result::output()
1258}
1259
1260pub fn walk_mac<'a, V: Visitor<'a>>(visitor: &mut V, mac: &'a MacCall) -> V::Result {
1261 let MacCall { path, args: _ } = mac;
1262 visitor.visit_path(path, DUMMY_NODE_ID)
1263}
1264
1265pub fn walk_anon_const<'a, V: Visitor<'a>>(visitor: &mut V, constant: &'a AnonConst) -> V::Result {
1266 let AnonConst { id: _, value } = constant;
1267 visitor.visit_expr(value)
1268}
1269
1270pub fn walk_inline_asm<'a, V: Visitor<'a>>(visitor: &mut V, asm: &'a InlineAsm) -> V::Result {
1271 let InlineAsm {
1272 asm_macro: _,
1273 template: _,
1274 template_strs: _,
1275 operands,
1276 clobber_abis: _,
1277 options: _,
1278 line_spans: _,
1279 } = asm;
1280 for (op, _span) in operands {
1281 match op {
1282 InlineAsmOperand::In { expr, reg: _ }
1283 | InlineAsmOperand::Out { expr: Some(expr), reg: _, late: _ }
1284 | InlineAsmOperand::InOut { expr, reg: _, late: _ } => {
1285 try_visit!(visitor.visit_expr(expr))
1286 }
1287 InlineAsmOperand::Out { expr: None, reg: _, late: _ } => {}
1288 InlineAsmOperand::SplitInOut { in_expr, out_expr, reg: _, late: _ } => {
1289 try_visit!(visitor.visit_expr(in_expr));
1290 visit_opt!(visitor, visit_expr, out_expr);
1291 }
1292 InlineAsmOperand::Const { anon_const } => {
1293 try_visit!(visitor.visit_anon_const(anon_const))
1294 }
1295 InlineAsmOperand::Sym { sym } => try_visit!(visitor.visit_inline_asm_sym(sym)),
1296 InlineAsmOperand::Label { block } => try_visit!(visitor.visit_block(block)),
1297 }
1298 }
1299 V::Result::output()
1300}
1301
1302pub fn walk_inline_asm_sym<'a, V: Visitor<'a>>(
1303 visitor: &mut V,
1304 InlineAsmSym { id, qself, path }: &'a InlineAsmSym,
1305) -> V::Result {
1306 try_visit!(visitor.visit_qself(qself));
1307 visitor.visit_path(path, *id)
1308}
1309
1310pub fn walk_format_args<'a, V: Visitor<'a>>(visitor: &mut V, fmt: &'a FormatArgs) -> V::Result {
1311 let FormatArgs { span: _, template: _, arguments, uncooked_fmt_str: _ } = fmt;
1312 for FormatArgument { kind, expr } in arguments.all_args() {
1313 match kind {
1314 FormatArgumentKind::Named(ident) | FormatArgumentKind::Captured(ident) => {
1315 try_visit!(visitor.visit_ident(ident))
1316 }
1317 FormatArgumentKind::Normal => {}
1318 }
1319 try_visit!(visitor.visit_expr(expr));
1320 }
1321 V::Result::output()
1322}
1323
1324pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) -> V::Result {
1325 let Expr { id, kind, span, attrs, tokens: _ } = expression;
1326 walk_list!(visitor, visit_attribute, attrs);
1327 match kind {
1328 ExprKind::Array(subexpressions) => {
1329 walk_list!(visitor, visit_expr, subexpressions);
1330 }
1331 ExprKind::ConstBlock(anon_const) => try_visit!(visitor.visit_anon_const(anon_const)),
1332 ExprKind::Repeat(element, count) => {
1333 try_visit!(visitor.visit_expr(element));
1334 try_visit!(visitor.visit_anon_const(count));
1335 }
1336 ExprKind::Struct(se) => {
1337 let StructExpr { qself, path, fields, rest } = &**se;
1338 try_visit!(visitor.visit_qself(qself));
1339 try_visit!(visitor.visit_path(path, *id));
1340 walk_list!(visitor, visit_expr_field, fields);
1341 match rest {
1342 StructRest::Base(expr) => try_visit!(visitor.visit_expr(expr)),
1343 StructRest::Rest(_span) => {}
1344 StructRest::None => {}
1345 }
1346 }
1347 ExprKind::Tup(subexpressions) => {
1348 walk_list!(visitor, visit_expr, subexpressions);
1349 }
1350 ExprKind::Call(callee_expression, arguments) => {
1351 try_visit!(visitor.visit_expr(callee_expression));
1352 walk_list!(visitor, visit_expr, arguments);
1353 }
1354 ExprKind::MethodCall(box MethodCall { seg, receiver, args, span: _ }) => {
1355 try_visit!(visitor.visit_expr(receiver));
1356 try_visit!(visitor.visit_path_segment(seg));
1357 walk_list!(visitor, visit_expr, args);
1358 }
1359 ExprKind::Binary(_op, left_expression, right_expression) => {
1360 try_visit!(visitor.visit_expr(left_expression));
1361 try_visit!(visitor.visit_expr(right_expression));
1362 }
1363 ExprKind::AddrOf(_kind, _mutbl, subexpression) => {
1364 try_visit!(visitor.visit_expr(subexpression));
1365 }
1366 ExprKind::Unary(_op, subexpression) => {
1367 try_visit!(visitor.visit_expr(subexpression));
1368 }
1369 ExprKind::Cast(subexpression, typ) | ExprKind::Type(subexpression, typ) => {
1370 try_visit!(visitor.visit_expr(subexpression));
1371 try_visit!(visitor.visit_ty(typ));
1372 }
1373 ExprKind::Let(pat, expr, _span, _recovered) => {
1374 try_visit!(visitor.visit_pat(pat));
1375 try_visit!(visitor.visit_expr(expr));
1376 }
1377 ExprKind::If(head_expression, if_block, optional_else) => {
1378 try_visit!(visitor.visit_expr(head_expression));
1379 try_visit!(visitor.visit_block(if_block));
1380 visit_opt!(visitor, visit_expr, optional_else);
1381 }
1382 ExprKind::While(subexpression, block, opt_label) => {
1383 visit_opt!(visitor, visit_label, opt_label);
1384 try_visit!(visitor.visit_expr(subexpression));
1385 try_visit!(visitor.visit_block(block));
1386 }
1387 ExprKind::ForLoop { pat, iter, body, label, kind: _ } => {
1388 visit_opt!(visitor, visit_label, label);
1389 try_visit!(visitor.visit_pat(pat));
1390 try_visit!(visitor.visit_expr(iter));
1391 try_visit!(visitor.visit_block(body));
1392 }
1393 ExprKind::Loop(block, opt_label, _span) => {
1394 visit_opt!(visitor, visit_label, opt_label);
1395 try_visit!(visitor.visit_block(block));
1396 }
1397 ExprKind::Match(subexpression, arms, _kind) => {
1398 try_visit!(visitor.visit_expr(subexpression));
1399 walk_list!(visitor, visit_arm, arms);
1400 }
1401 ExprKind::Closure(box Closure {
1402 binder,
1403 capture_clause,
1404 coroutine_kind,
1405 constness: _,
1406 movability: _,
1407 fn_decl,
1408 body,
1409 fn_decl_span: _,
1410 fn_arg_span: _,
1411 }) => {
1412 try_visit!(visitor.visit_capture_by(capture_clause));
1413 try_visit!(visitor.visit_fn(
1414 FnKind::Closure(binder, coroutine_kind, fn_decl, body),
1415 *span,
1416 *id
1417 ));
1418 }
1419 ExprKind::Block(block, opt_label) => {
1420 visit_opt!(visitor, visit_label, opt_label);
1421 try_visit!(visitor.visit_block(block));
1422 }
1423 ExprKind::Gen(_capt, body, _kind, _decl_span) => try_visit!(visitor.visit_block(body)),
1424 ExprKind::Await(expr, _span) => try_visit!(visitor.visit_expr(expr)),
1425 ExprKind::Use(expr, _span) => try_visit!(visitor.visit_expr(expr)),
1426 ExprKind::Assign(lhs, rhs, _span) => {
1427 try_visit!(visitor.visit_expr(lhs));
1428 try_visit!(visitor.visit_expr(rhs));
1429 }
1430 ExprKind::AssignOp(_op, left_expression, right_expression) => {
1431 try_visit!(visitor.visit_expr(left_expression));
1432 try_visit!(visitor.visit_expr(right_expression));
1433 }
1434 ExprKind::Field(subexpression, ident) => {
1435 try_visit!(visitor.visit_expr(subexpression));
1436 try_visit!(visitor.visit_ident(ident));
1437 }
1438 ExprKind::Index(main_expression, index_expression, _span) => {
1439 try_visit!(visitor.visit_expr(main_expression));
1440 try_visit!(visitor.visit_expr(index_expression));
1441 }
1442 ExprKind::Range(start, end, _limit) => {
1443 visit_opt!(visitor, visit_expr, start);
1444 visit_opt!(visitor, visit_expr, end);
1445 }
1446 ExprKind::Underscore => {}
1447 ExprKind::Path(maybe_qself, path) => {
1448 try_visit!(visitor.visit_qself(maybe_qself));
1449 try_visit!(visitor.visit_path(path, *id));
1450 }
1451 ExprKind::Break(opt_label, opt_expr) => {
1452 visit_opt!(visitor, visit_label, opt_label);
1453 visit_opt!(visitor, visit_expr, opt_expr);
1454 }
1455 ExprKind::Continue(opt_label) => {
1456 visit_opt!(visitor, visit_label, opt_label);
1457 }
1458 ExprKind::Ret(optional_expression) => {
1459 visit_opt!(visitor, visit_expr, optional_expression);
1460 }
1461 ExprKind::Yeet(optional_expression) => {
1462 visit_opt!(visitor, visit_expr, optional_expression);
1463 }
1464 ExprKind::Become(expr) => try_visit!(visitor.visit_expr(expr)),
1465 ExprKind::MacCall(mac) => try_visit!(visitor.visit_mac_call(mac)),
1466 ExprKind::Paren(subexpression) => try_visit!(visitor.visit_expr(subexpression)),
1467 ExprKind::InlineAsm(asm) => try_visit!(visitor.visit_inline_asm(asm)),
1468 ExprKind::FormatArgs(f) => try_visit!(visitor.visit_format_args(f)),
1469 ExprKind::OffsetOf(container, fields) => {
1470 try_visit!(visitor.visit_ty(container));
1471 walk_list!(visitor, visit_ident, fields.iter());
1472 }
1473 ExprKind::Yield(kind) => {
1474 visit_opt!(visitor, visit_expr, kind.expr());
1475 }
1476 ExprKind::Try(subexpression) => try_visit!(visitor.visit_expr(subexpression)),
1477 ExprKind::TryBlock(body) => try_visit!(visitor.visit_block(body)),
1478 ExprKind::Lit(_token) => {}
1479 ExprKind::IncludedBytes(_bytes) => {}
1480 ExprKind::UnsafeBinderCast(_kind, expr, ty) => {
1481 try_visit!(visitor.visit_expr(expr));
1482 visit_opt!(visitor, visit_ty, ty);
1483 }
1484 ExprKind::Err(_guar) => {}
1485 ExprKind::Dummy => {}
1486 }
1487
1488 V::Result::output()
1489}
1490
1491pub fn walk_param<'a, V: Visitor<'a>>(visitor: &mut V, param: &'a Param) -> V::Result {
1492 let Param { attrs, ty, pat, id: _, span: _, is_placeholder: _ } = param;
1493 walk_list!(visitor, visit_attribute, attrs);
1494 try_visit!(visitor.visit_pat(pat));
1495 try_visit!(visitor.visit_ty(ty));
1496 V::Result::output()
1497}
1498
1499pub fn walk_arm<'a, V: Visitor<'a>>(visitor: &mut V, arm: &'a Arm) -> V::Result {
1500 let Arm { attrs, pat, guard, body, span: _, id: _, is_placeholder: _ } = arm;
1501 walk_list!(visitor, visit_attribute, attrs);
1502 try_visit!(visitor.visit_pat(pat));
1503 visit_opt!(visitor, visit_expr, guard);
1504 visit_opt!(visitor, visit_expr, body);
1505 V::Result::output()
1506}
1507
1508pub fn walk_vis<'a, V: Visitor<'a>>(visitor: &mut V, vis: &'a Visibility) -> V::Result {
1509 let Visibility { kind, span: _, tokens: _ } = vis;
1510 match kind {
1511 VisibilityKind::Restricted { path, id, shorthand: _ } => {
1512 try_visit!(visitor.visit_path(path, *id));
1513 }
1514 VisibilityKind::Public | VisibilityKind::Inherited => {}
1515 }
1516 V::Result::output()
1517}
1518
1519pub fn walk_attribute<'a, V: Visitor<'a>>(visitor: &mut V, attr: &'a Attribute) -> V::Result {
1520 let Attribute { kind, id: _, style: _, span: _ } = attr;
1521 match kind {
1522 AttrKind::Normal(normal) => {
1523 let NormalAttr { item, tokens: _ } = &**normal;
1524 let AttrItem { unsafety: _, path, args, tokens: _ } = item;
1525 try_visit!(visitor.visit_path(path, DUMMY_NODE_ID));
1526 try_visit!(walk_attr_args(visitor, args));
1527 }
1528 AttrKind::DocComment(_kind, _sym) => {}
1529 }
1530 V::Result::output()
1531}
1532
1533pub fn walk_attr_args<'a, V: Visitor<'a>>(visitor: &mut V, args: &'a AttrArgs) -> V::Result {
1534 match args {
1535 AttrArgs::Empty => {}
1536 AttrArgs::Delimited(_args) => {}
1537 AttrArgs::Eq { expr, .. } => try_visit!(visitor.visit_expr(expr)),
1538 }
1539 V::Result::output()
1540}