rustc_hir/
intravisit.rs

1//! HIR walker for walking the contents of nodes.
2//!
3//! Here are the three available patterns for the visitor strategy,
4//! in roughly the order of desirability:
5//!
6//! 1. **Shallow visit**: Get a simple callback for every item (or item-like thing) in the HIR.
7//!    - Example: find all items with a `#[foo]` attribute on them.
8//!    - How: Use the `hir_crate_items` or `hir_module_items` query to traverse over item-like ids
9//!       (ItemId, TraitItemId, etc.) and use tcx.def_kind and `tcx.hir_item*(id)` to filter and
10//!       access actual item-like thing, respectively.
11//!    - Pro: Efficient; just walks the lists of item ids and gives users control whether to access
12//!       the hir_owners themselves or not.
13//!    - Con: Don't get information about nesting
14//!    - Con: Don't have methods for specific bits of HIR, like "on
15//!      every expr, do this".
16//! 2. **Deep visit**: Want to scan for specific kinds of HIR nodes within
17//!    an item, but don't care about how item-like things are nested
18//!    within one another.
19//!    - Example: Examine each expression to look for its type and do some check or other.
20//!    - How: Implement `intravisit::Visitor` and override the `NestedFilter` type to
21//!      `nested_filter::OnlyBodies` (and implement `maybe_tcx`), and use
22//!      `tcx.hir_visit_all_item_likes_in_crate(&mut visitor)`. Within your
23//!      `intravisit::Visitor` impl, implement methods like `visit_expr()` (don't forget to invoke
24//!      `intravisit::walk_expr()` to keep walking the subparts).
25//!    - Pro: Visitor methods for any kind of HIR node, not just item-like things.
26//!    - Pro: Integrates well into dependency tracking.
27//!    - Con: Don't get information about nesting between items
28//! 3. **Nested visit**: Want to visit the whole HIR and you care about the nesting between
29//!    item-like things.
30//!    - Example: Lifetime resolution, which wants to bring lifetimes declared on the
31//!      impl into scope while visiting the impl-items, and then back out again.
32//!    - How: Implement `intravisit::Visitor` and override the `NestedFilter` type to
33//!      `nested_filter::All` (and implement `maybe_tcx`). Walk your crate with
34//!      `tcx.hir_walk_toplevel_module(visitor)`.
35//!    - Pro: Visitor methods for any kind of HIR node, not just item-like things.
36//!    - Pro: Preserves nesting information
37//!    - Con: Does not integrate well into dependency tracking.
38//!
39//! If you have decided to use this visitor, here are some general
40//! notes on how to do so:
41//!
42//! Each overridden visit method has full control over what
43//! happens with its node, it can do its own traversal of the node's children,
44//! call `intravisit::walk_*` to apply the default traversal algorithm, or prevent
45//! deeper traversal by doing nothing.
46//!
47//! When visiting the HIR, the contents of nested items are NOT visited
48//! by default. This is different from the AST visitor, which does a deep walk.
49//! Hence this module is called `intravisit`; see the method `visit_nested_item`
50//! for more details.
51//!
52//! Note: it is an important invariant that the default visitor walks
53//! the body of a function in "execution order" - more concretely, if
54//! we consider the reverse post-order (RPO) of the CFG implied by the HIR,
55//! then a pre-order traversal of the HIR is consistent with the CFG RPO
56//! on the *initial CFG point* of each HIR node, while a post-order traversal
57//! of the HIR is consistent with the CFG RPO on each *final CFG point* of
58//! each CFG node.
59//!
60//! One thing that follows is that if HIR node A always starts/ends executing
61//! before HIR node B, then A appears in traversal pre/postorder before B,
62//! respectively. (This follows from RPO respecting CFG domination).
63//!
64//! This order consistency is required in a few places in rustc, for
65//! example coroutine inference, and possibly also HIR borrowck.
66
67use rustc_ast::Label;
68use rustc_ast::visit::{VisitorResult, try_visit, visit_opt, walk_list};
69use rustc_span::def_id::LocalDefId;
70use rustc_span::{Ident, Span, Symbol};
71
72use crate::hir::*;
73
74pub trait IntoVisitor<'hir> {
75    type Visitor: Visitor<'hir>;
76    fn into_visitor(&self) -> Self::Visitor;
77}
78
79#[derive(Copy, Clone, Debug)]
80pub enum FnKind<'a> {
81    /// `#[xxx] pub async/const/extern "Abi" fn foo()`
82    ItemFn(Ident, &'a Generics<'a>, FnHeader),
83
84    /// `fn foo(&self)`
85    Method(Ident, &'a FnSig<'a>),
86
87    /// `|x, y| {}`
88    Closure,
89}
90
91impl<'a> FnKind<'a> {
92    pub fn header(&self) -> Option<&FnHeader> {
93        match *self {
94            FnKind::ItemFn(_, _, ref header) => Some(header),
95            FnKind::Method(_, ref sig) => Some(&sig.header),
96            FnKind::Closure => None,
97        }
98    }
99
100    pub fn constness(self) -> Constness {
101        self.header().map_or(Constness::NotConst, |header| header.constness)
102    }
103
104    pub fn asyncness(self) -> IsAsync {
105        self.header().map_or(IsAsync::NotAsync, |header| header.asyncness)
106    }
107}
108
109/// HIR things retrievable from `TyCtxt`, avoiding an explicit dependence on
110/// `TyCtxt`. The only impls are for `!` (where these functions are never
111/// called) and `TyCtxt` (in `rustc_middle`).
112pub trait HirTyCtxt<'hir> {
113    /// Retrieves the `Node` corresponding to `id`.
114    fn hir_node(&self, hir_id: HirId) -> Node<'hir>;
115    fn hir_body(&self, id: BodyId) -> &'hir Body<'hir>;
116    fn hir_item(&self, id: ItemId) -> &'hir Item<'hir>;
117    fn hir_trait_item(&self, id: TraitItemId) -> &'hir TraitItem<'hir>;
118    fn hir_impl_item(&self, id: ImplItemId) -> &'hir ImplItem<'hir>;
119    fn hir_foreign_item(&self, id: ForeignItemId) -> &'hir ForeignItem<'hir>;
120}
121
122// Used when no tcx is actually available, forcing manual implementation of nested visitors.
123impl<'hir> HirTyCtxt<'hir> for ! {
124    fn hir_node(&self, _: HirId) -> Node<'hir> {
125        unreachable!();
126    }
127    fn hir_body(&self, _: BodyId) -> &'hir Body<'hir> {
128        unreachable!();
129    }
130    fn hir_item(&self, _: ItemId) -> &'hir Item<'hir> {
131        unreachable!();
132    }
133    fn hir_trait_item(&self, _: TraitItemId) -> &'hir TraitItem<'hir> {
134        unreachable!();
135    }
136    fn hir_impl_item(&self, _: ImplItemId) -> &'hir ImplItem<'hir> {
137        unreachable!();
138    }
139    fn hir_foreign_item(&self, _: ForeignItemId) -> &'hir ForeignItem<'hir> {
140        unreachable!();
141    }
142}
143
144pub mod nested_filter {
145    use super::HirTyCtxt;
146
147    /// Specifies what nested things a visitor wants to visit. By "nested
148    /// things", we are referring to bits of HIR that are not directly embedded
149    /// within one another but rather indirectly, through a table in the crate.
150    /// This is done to control dependencies during incremental compilation: the
151    /// non-inline bits of HIR can be tracked and hashed separately.
152    ///
153    /// The most common choice is `OnlyBodies`, which will cause the visitor to
154    /// visit fn bodies for fns that it encounters, and closure bodies, but
155    /// skip over nested item-like things.
156    ///
157    /// See the comments at [`rustc_hir::intravisit`] for more details on the overall
158    /// visit strategy.
159    pub trait NestedFilter<'hir> {
160        type MaybeTyCtxt: HirTyCtxt<'hir>;
161
162        /// Whether the visitor visits nested "item-like" things.
163        /// E.g., item, impl-item.
164        const INTER: bool;
165        /// Whether the visitor visits "intra item-like" things.
166        /// E.g., function body, closure, `AnonConst`
167        const INTRA: bool;
168    }
169
170    /// Do not visit any nested things. When you add a new
171    /// "non-nested" thing, you will want to audit such uses to see if
172    /// they remain valid.
173    ///
174    /// Use this if you are only walking some particular kind of tree
175    /// (i.e., a type, or fn signature) and you don't want to thread a
176    /// `tcx` around.
177    pub struct None(());
178    impl NestedFilter<'_> for None {
179        type MaybeTyCtxt = !;
180        const INTER: bool = false;
181        const INTRA: bool = false;
182    }
183}
184
185use nested_filter::NestedFilter;
186
187/// Each method of the Visitor trait is a hook to be potentially
188/// overridden. Each method's default implementation recursively visits
189/// the substructure of the input via the corresponding `walk` method;
190/// e.g., the `visit_mod` method by default calls `intravisit::walk_mod`.
191///
192/// Note that this visitor does NOT visit nested items by default
193/// (this is why the module is called `intravisit`, to distinguish it
194/// from the AST's `visit` module, which acts differently). If you
195/// simply want to visit all items in the crate in some order, you
196/// should call `tcx.hir_visit_all_item_likes_in_crate`. Otherwise, see the comment
197/// on `visit_nested_item` for details on how to visit nested items.
198///
199/// If you want to ensure that your code handles every variant
200/// explicitly, you need to override each method. (And you also need
201/// to monitor future changes to `Visitor` in case a new method with a
202/// new default implementation gets introduced.)
203///
204/// Every `walk_*` method uses deconstruction to access fields of structs and
205/// enums. This will result in a compile error if a field is added, which makes
206/// it more likely the appropriate visit call will be added for it.
207pub trait Visitor<'v>: Sized {
208    // This type should not be overridden, it exists for convenient usage as `Self::MaybeTyCtxt`.
209    type MaybeTyCtxt: HirTyCtxt<'v> = <Self::NestedFilter as NestedFilter<'v>>::MaybeTyCtxt;
210
211    ///////////////////////////////////////////////////////////////////////////
212    // Nested items.
213
214    /// Override this type to control which nested HIR are visited; see
215    /// [`NestedFilter`] for details. If you override this type, you
216    /// must also override [`maybe_tcx`](Self::maybe_tcx).
217    ///
218    /// **If for some reason you want the nested behavior, but don't
219    /// have a `tcx` at your disposal:** then override the
220    /// `visit_nested_XXX` methods. If a new `visit_nested_XXX` variant is
221    /// added in the future, it will cause a panic which can be detected
222    /// and fixed appropriately.
223    type NestedFilter: NestedFilter<'v> = nested_filter::None;
224
225    /// The result type of the `visit_*` methods. Can be either `()`,
226    /// or `ControlFlow<T>`.
227    type Result: VisitorResult = ();
228
229    /// If `type NestedFilter` is set to visit nested items, this method
230    /// must also be overridden to provide a map to retrieve nested items.
231    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
232        panic!(
233            "maybe_tcx must be implemented or consider using \
234            `type NestedFilter = nested_filter::None` (the default)"
235        );
236    }
237
238    /// Invoked when a nested item is encountered. By default, when
239    /// `Self::NestedFilter` is `nested_filter::None`, this method does
240    /// nothing. **You probably don't want to override this method** --
241    /// instead, override [`Self::NestedFilter`] or use the "shallow" or
242    /// "deep" visit patterns described at
243    /// [`rustc_hir::intravisit`]. The only reason to override
244    /// this method is if you want a nested pattern but cannot supply a
245    /// `TyCtxt`; see `maybe_tcx` for advice.
246    fn visit_nested_item(&mut self, id: ItemId) -> Self::Result {
247        if Self::NestedFilter::INTER {
248            let item = self.maybe_tcx().hir_item(id);
249            try_visit!(self.visit_item(item));
250        }
251        Self::Result::output()
252    }
253
254    /// Like `visit_nested_item()`, but for trait items. See
255    /// `visit_nested_item()` for advice on when to override this
256    /// method.
257    fn visit_nested_trait_item(&mut self, id: TraitItemId) -> Self::Result {
258        if Self::NestedFilter::INTER {
259            let item = self.maybe_tcx().hir_trait_item(id);
260            try_visit!(self.visit_trait_item(item));
261        }
262        Self::Result::output()
263    }
264
265    /// Like `visit_nested_item()`, but for impl items. See
266    /// `visit_nested_item()` for advice on when to override this
267    /// method.
268    fn visit_nested_impl_item(&mut self, id: ImplItemId) -> Self::Result {
269        if Self::NestedFilter::INTER {
270            let item = self.maybe_tcx().hir_impl_item(id);
271            try_visit!(self.visit_impl_item(item));
272        }
273        Self::Result::output()
274    }
275
276    /// Like `visit_nested_item()`, but for foreign items. See
277    /// `visit_nested_item()` for advice on when to override this
278    /// method.
279    fn visit_nested_foreign_item(&mut self, id: ForeignItemId) -> Self::Result {
280        if Self::NestedFilter::INTER {
281            let item = self.maybe_tcx().hir_foreign_item(id);
282            try_visit!(self.visit_foreign_item(item));
283        }
284        Self::Result::output()
285    }
286
287    /// Invoked to visit the body of a function, method or closure. Like
288    /// `visit_nested_item`, does nothing by default unless you override
289    /// `Self::NestedFilter`.
290    fn visit_nested_body(&mut self, id: BodyId) -> Self::Result {
291        if Self::NestedFilter::INTRA {
292            let body = self.maybe_tcx().hir_body(id);
293            try_visit!(self.visit_body(body));
294        }
295        Self::Result::output()
296    }
297
298    fn visit_param(&mut self, param: &'v Param<'v>) -> Self::Result {
299        walk_param(self, param)
300    }
301
302    /// Visits the top-level item and (optionally) nested items / impl items. See
303    /// `visit_nested_item` for details.
304    fn visit_item(&mut self, i: &'v Item<'v>) -> Self::Result {
305        walk_item(self, i)
306    }
307
308    fn visit_body(&mut self, b: &Body<'v>) -> Self::Result {
309        walk_body(self, b)
310    }
311
312    ///////////////////////////////////////////////////////////////////////////
313
314    fn visit_id(&mut self, _hir_id: HirId) -> Self::Result {
315        Self::Result::output()
316    }
317    fn visit_name(&mut self, _name: Symbol) -> Self::Result {
318        Self::Result::output()
319    }
320    fn visit_ident(&mut self, ident: Ident) -> Self::Result {
321        walk_ident(self, ident)
322    }
323    fn visit_mod(&mut self, m: &'v Mod<'v>, _s: Span, _n: HirId) -> Self::Result {
324        walk_mod(self, m)
325    }
326    fn visit_foreign_item(&mut self, i: &'v ForeignItem<'v>) -> Self::Result {
327        walk_foreign_item(self, i)
328    }
329    fn visit_local(&mut self, l: &'v LetStmt<'v>) -> Self::Result {
330        walk_local(self, l)
331    }
332    fn visit_block(&mut self, b: &'v Block<'v>) -> Self::Result {
333        walk_block(self, b)
334    }
335    fn visit_stmt(&mut self, s: &'v Stmt<'v>) -> Self::Result {
336        walk_stmt(self, s)
337    }
338    fn visit_arm(&mut self, a: &'v Arm<'v>) -> Self::Result {
339        walk_arm(self, a)
340    }
341    fn visit_pat(&mut self, p: &'v Pat<'v>) -> Self::Result {
342        walk_pat(self, p)
343    }
344    fn visit_pat_field(&mut self, f: &'v PatField<'v>) -> Self::Result {
345        walk_pat_field(self, f)
346    }
347    fn visit_pat_expr(&mut self, expr: &'v PatExpr<'v>) -> Self::Result {
348        walk_pat_expr(self, expr)
349    }
350    fn visit_lit(&mut self, _hir_id: HirId, _lit: &'v Lit, _negated: bool) -> Self::Result {
351        Self::Result::output()
352    }
353    fn visit_anon_const(&mut self, c: &'v AnonConst) -> Self::Result {
354        walk_anon_const(self, c)
355    }
356    fn visit_inline_const(&mut self, c: &'v ConstBlock) -> Self::Result {
357        walk_inline_const(self, c)
358    }
359
360    fn visit_generic_arg(&mut self, generic_arg: &'v GenericArg<'v>) -> Self::Result {
361        walk_generic_arg(self, generic_arg)
362    }
363
364    /// All types are treated as ambiguous types for the purposes of hir visiting in
365    /// order to ensure that visitors can handle infer vars without it being too error-prone.
366    ///
367    /// See the doc comments on [`Ty`] for an explanation of what it means for a type to be
368    /// ambiguous.
369    ///
370    /// The [`Visitor::visit_infer`] method should be overridden in order to handle infer vars.
371    fn visit_ty(&mut self, t: &'v Ty<'v, AmbigArg>) -> Self::Result {
372        walk_ty(self, t)
373    }
374
375    /// All consts are treated as ambiguous consts for the purposes of hir visiting in
376    /// order to ensure that visitors can handle infer vars without it being too error-prone.
377    ///
378    /// See the doc comments on [`ConstArg`] for an explanation of what it means for a const to be
379    /// ambiguous.
380    ///
381    /// The [`Visitor::visit_infer`] method should be overridden in order to handle infer vars.
382    fn visit_const_arg(&mut self, c: &'v ConstArg<'v, AmbigArg>) -> Self::Result {
383        walk_ambig_const_arg(self, c)
384    }
385
386    #[allow(unused_variables)]
387    fn visit_infer(&mut self, inf_id: HirId, inf_span: Span, kind: InferKind<'v>) -> Self::Result {
388        self.visit_id(inf_id)
389    }
390
391    fn visit_lifetime(&mut self, lifetime: &'v Lifetime) -> Self::Result {
392        walk_lifetime(self, lifetime)
393    }
394
395    fn visit_expr(&mut self, ex: &'v Expr<'v>) -> Self::Result {
396        walk_expr(self, ex)
397    }
398    fn visit_expr_field(&mut self, field: &'v ExprField<'v>) -> Self::Result {
399        walk_expr_field(self, field)
400    }
401    fn visit_pattern_type_pattern(&mut self, p: &'v TyPat<'v>) -> Self::Result {
402        walk_ty_pat(self, p)
403    }
404    fn visit_generic_param(&mut self, p: &'v GenericParam<'v>) -> Self::Result {
405        walk_generic_param(self, p)
406    }
407    fn visit_const_param_default(&mut self, _param: HirId, ct: &'v ConstArg<'v>) -> Self::Result {
408        walk_const_param_default(self, ct)
409    }
410    fn visit_generics(&mut self, g: &'v Generics<'v>) -> Self::Result {
411        walk_generics(self, g)
412    }
413    fn visit_where_predicate(&mut self, predicate: &'v WherePredicate<'v>) -> Self::Result {
414        walk_where_predicate(self, predicate)
415    }
416    fn visit_fn_ret_ty(&mut self, ret_ty: &'v FnRetTy<'v>) -> Self::Result {
417        walk_fn_ret_ty(self, ret_ty)
418    }
419    fn visit_fn_decl(&mut self, fd: &'v FnDecl<'v>) -> Self::Result {
420        walk_fn_decl(self, fd)
421    }
422    fn visit_fn(
423        &mut self,
424        fk: FnKind<'v>,
425        fd: &'v FnDecl<'v>,
426        b: BodyId,
427        _: Span,
428        id: LocalDefId,
429    ) -> Self::Result {
430        walk_fn(self, fk, fd, b, id)
431    }
432    fn visit_use(&mut self, path: &'v UsePath<'v>, hir_id: HirId) -> Self::Result {
433        walk_use(self, path, hir_id)
434    }
435    fn visit_trait_item(&mut self, ti: &'v TraitItem<'v>) -> Self::Result {
436        walk_trait_item(self, ti)
437    }
438    fn visit_trait_item_ref(&mut self, ii: &'v TraitItemRef) -> Self::Result {
439        walk_trait_item_ref(self, ii)
440    }
441    fn visit_impl_item(&mut self, ii: &'v ImplItem<'v>) -> Self::Result {
442        walk_impl_item(self, ii)
443    }
444    fn visit_foreign_item_ref(&mut self, ii: &'v ForeignItemRef) -> Self::Result {
445        walk_foreign_item_ref(self, ii)
446    }
447    fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef) -> Self::Result {
448        walk_impl_item_ref(self, ii)
449    }
450    fn visit_trait_ref(&mut self, t: &'v TraitRef<'v>) -> Self::Result {
451        walk_trait_ref(self, t)
452    }
453    fn visit_param_bound(&mut self, bounds: &'v GenericBound<'v>) -> Self::Result {
454        walk_param_bound(self, bounds)
455    }
456    fn visit_precise_capturing_arg(&mut self, arg: &'v PreciseCapturingArg<'v>) -> Self::Result {
457        walk_precise_capturing_arg(self, arg)
458    }
459    fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef<'v>) -> Self::Result {
460        walk_poly_trait_ref(self, t)
461    }
462    fn visit_opaque_ty(&mut self, opaque: &'v OpaqueTy<'v>) -> Self::Result {
463        walk_opaque_ty(self, opaque)
464    }
465    fn visit_variant_data(&mut self, s: &'v VariantData<'v>) -> Self::Result {
466        walk_struct_def(self, s)
467    }
468    fn visit_field_def(&mut self, s: &'v FieldDef<'v>) -> Self::Result {
469        walk_field_def(self, s)
470    }
471    fn visit_enum_def(&mut self, enum_definition: &'v EnumDef<'v>) -> Self::Result {
472        walk_enum_def(self, enum_definition)
473    }
474    fn visit_variant(&mut self, v: &'v Variant<'v>) -> Self::Result {
475        walk_variant(self, v)
476    }
477    fn visit_label(&mut self, label: &'v Label) -> Self::Result {
478        walk_label(self, label)
479    }
480    // The span is that of the surrounding type/pattern/expr/whatever.
481    fn visit_qpath(&mut self, qpath: &'v QPath<'v>, id: HirId, _span: Span) -> Self::Result {
482        walk_qpath(self, qpath, id)
483    }
484    fn visit_path(&mut self, path: &Path<'v>, _id: HirId) -> Self::Result {
485        walk_path(self, path)
486    }
487    fn visit_path_segment(&mut self, path_segment: &'v PathSegment<'v>) -> Self::Result {
488        walk_path_segment(self, path_segment)
489    }
490    fn visit_generic_args(&mut self, generic_args: &'v GenericArgs<'v>) -> Self::Result {
491        walk_generic_args(self, generic_args)
492    }
493    fn visit_assoc_item_constraint(
494        &mut self,
495        constraint: &'v AssocItemConstraint<'v>,
496    ) -> Self::Result {
497        walk_assoc_item_constraint(self, constraint)
498    }
499    fn visit_attribute(&mut self, _attr: &'v Attribute) -> Self::Result {
500        Self::Result::output()
501    }
502    fn visit_associated_item_kind(&mut self, kind: &'v AssocItemKind) -> Self::Result {
503        walk_associated_item_kind(self, kind)
504    }
505    fn visit_defaultness(&mut self, defaultness: &'v Defaultness) -> Self::Result {
506        walk_defaultness(self, defaultness)
507    }
508    fn visit_inline_asm(&mut self, asm: &'v InlineAsm<'v>, id: HirId) -> Self::Result {
509        walk_inline_asm(self, asm, id)
510    }
511}
512
513pub trait VisitorExt<'v>: Visitor<'v> {
514    /// Extension trait method to visit types in unambiguous positions, this is not
515    /// directly on the [`Visitor`] trait as this method should never be overridden.
516    ///
517    /// Named `visit_ty_unambig` instead of `visit_unambig_ty` to aid in discovery
518    /// by IDes when `v.visit_ty` is written.
519    fn visit_ty_unambig(&mut self, t: &'v Ty<'v>) -> Self::Result {
520        walk_unambig_ty(self, t)
521    }
522    /// Extension trait method to visit consts in unambiguous positions, this is not
523    /// directly on the [`Visitor`] trait as this method should never be overridden.
524    ///
525    /// Named `visit_const_arg_unambig` instead of `visit_unambig_const_arg` to aid in
526    /// discovery by IDes when `v.visit_const_arg` is written.
527    fn visit_const_arg_unambig(&mut self, c: &'v ConstArg<'v>) -> Self::Result {
528        walk_const_arg(self, c)
529    }
530}
531impl<'v, V: Visitor<'v>> VisitorExt<'v> for V {}
532
533pub fn walk_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Param<'v>) -> V::Result {
534    let Param { hir_id, pat, ty_span: _, span: _ } = param;
535    try_visit!(visitor.visit_id(*hir_id));
536    visitor.visit_pat(pat)
537}
538
539pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::Result {
540    let Item { owner_id: _, kind, span: _, vis_span: _ } = item;
541    try_visit!(visitor.visit_id(item.hir_id()));
542    match *kind {
543        ItemKind::ExternCrate(orig_name, ident) => {
544            visit_opt!(visitor, visit_name, orig_name);
545            try_visit!(visitor.visit_ident(ident));
546        }
547        ItemKind::Use(ref path, kind) => {
548            try_visit!(visitor.visit_use(path, item.hir_id()));
549            match kind {
550                UseKind::Single(ident) => try_visit!(visitor.visit_ident(ident)),
551                UseKind::Glob | UseKind::ListStem => {}
552            }
553        }
554        ItemKind::Static(_, ident, ref typ, body) => {
555            try_visit!(visitor.visit_ident(ident));
556            try_visit!(visitor.visit_ty_unambig(typ));
557            try_visit!(visitor.visit_nested_body(body));
558        }
559        ItemKind::Const(ident, ref generics, ref typ, body) => {
560            try_visit!(visitor.visit_ident(ident));
561            try_visit!(visitor.visit_generics(generics));
562            try_visit!(visitor.visit_ty_unambig(typ));
563            try_visit!(visitor.visit_nested_body(body));
564        }
565        ItemKind::Fn { ident, sig, generics, body: body_id, .. } => {
566            try_visit!(visitor.visit_ident(ident));
567            try_visit!(visitor.visit_fn(
568                FnKind::ItemFn(ident, generics, sig.header),
569                sig.decl,
570                body_id,
571                item.span,
572                item.owner_id.def_id,
573            ));
574        }
575        ItemKind::Macro(ident, _def, _kind) => {
576            try_visit!(visitor.visit_ident(ident));
577        }
578        ItemKind::Mod(ident, ref module) => {
579            try_visit!(visitor.visit_ident(ident));
580            try_visit!(visitor.visit_mod(module, item.span, item.hir_id()));
581        }
582        ItemKind::ForeignMod { abi: _, items } => {
583            walk_list!(visitor, visit_foreign_item_ref, items);
584        }
585        ItemKind::GlobalAsm { asm: _, fake_body } => {
586            // Visit the fake body, which contains the asm statement.
587            // Therefore we should not visit the asm statement again
588            // outside of the body, or some visitors won't have their
589            // typeck results set correctly.
590            try_visit!(visitor.visit_nested_body(fake_body));
591        }
592        ItemKind::TyAlias(ident, ref generics, ref ty) => {
593            try_visit!(visitor.visit_ident(ident));
594            try_visit!(visitor.visit_generics(generics));
595            try_visit!(visitor.visit_ty_unambig(ty));
596        }
597        ItemKind::Enum(ident, ref generics, ref enum_definition) => {
598            try_visit!(visitor.visit_ident(ident));
599            try_visit!(visitor.visit_generics(generics));
600            try_visit!(visitor.visit_enum_def(enum_definition));
601        }
602        ItemKind::Impl(Impl {
603            constness: _,
604            safety: _,
605            defaultness: _,
606            polarity: _,
607            defaultness_span: _,
608            generics,
609            of_trait,
610            self_ty,
611            items,
612        }) => {
613            try_visit!(visitor.visit_generics(generics));
614            visit_opt!(visitor, visit_trait_ref, of_trait);
615            try_visit!(visitor.visit_ty_unambig(self_ty));
616            walk_list!(visitor, visit_impl_item_ref, *items);
617        }
618        ItemKind::Struct(ident, ref generics, ref struct_definition)
619        | ItemKind::Union(ident, ref generics, ref struct_definition) => {
620            try_visit!(visitor.visit_ident(ident));
621            try_visit!(visitor.visit_generics(generics));
622            try_visit!(visitor.visit_variant_data(struct_definition));
623        }
624        ItemKind::Trait(_is_auto, _safety, ident, ref generics, bounds, trait_item_refs) => {
625            try_visit!(visitor.visit_ident(ident));
626            try_visit!(visitor.visit_generics(generics));
627            walk_list!(visitor, visit_param_bound, bounds);
628            walk_list!(visitor, visit_trait_item_ref, trait_item_refs);
629        }
630        ItemKind::TraitAlias(ident, ref generics, bounds) => {
631            try_visit!(visitor.visit_ident(ident));
632            try_visit!(visitor.visit_generics(generics));
633            walk_list!(visitor, visit_param_bound, bounds);
634        }
635    }
636    V::Result::output()
637}
638
639pub fn walk_body<'v, V: Visitor<'v>>(visitor: &mut V, body: &Body<'v>) -> V::Result {
640    let Body { params, value } = body;
641    walk_list!(visitor, visit_param, *params);
642    visitor.visit_expr(*value)
643}
644
645pub fn walk_ident<'v, V: Visitor<'v>>(visitor: &mut V, ident: Ident) -> V::Result {
646    visitor.visit_name(ident.name)
647}
648
649pub fn walk_mod<'v, V: Visitor<'v>>(visitor: &mut V, module: &'v Mod<'v>) -> V::Result {
650    let Mod { spans: _, item_ids } = module;
651    walk_list!(visitor, visit_nested_item, item_ids.iter().copied());
652    V::Result::output()
653}
654
655pub fn walk_foreign_item<'v, V: Visitor<'v>>(
656    visitor: &mut V,
657    foreign_item: &'v ForeignItem<'v>,
658) -> V::Result {
659    let ForeignItem { ident, kind, owner_id: _, span: _, vis_span: _ } = foreign_item;
660    try_visit!(visitor.visit_id(foreign_item.hir_id()));
661    try_visit!(visitor.visit_ident(*ident));
662
663    match *kind {
664        ForeignItemKind::Fn(ref sig, param_idents, ref generics) => {
665            try_visit!(visitor.visit_generics(generics));
666            try_visit!(visitor.visit_fn_decl(sig.decl));
667            for ident in param_idents.iter().copied() {
668                visit_opt!(visitor, visit_ident, ident);
669            }
670        }
671        ForeignItemKind::Static(ref typ, _, _) => {
672            try_visit!(visitor.visit_ty_unambig(typ));
673        }
674        ForeignItemKind::Type => (),
675    }
676    V::Result::output()
677}
678
679pub fn walk_local<'v, V: Visitor<'v>>(visitor: &mut V, local: &'v LetStmt<'v>) -> V::Result {
680    // Intentionally visiting the expr first - the initialization expr
681    // dominates the local's definition.
682    let LetStmt { super_: _, pat, ty, init, els, hir_id, span: _, source: _ } = local;
683    visit_opt!(visitor, visit_expr, *init);
684    try_visit!(visitor.visit_id(*hir_id));
685    try_visit!(visitor.visit_pat(*pat));
686    visit_opt!(visitor, visit_block, *els);
687    visit_opt!(visitor, visit_ty_unambig, *ty);
688    V::Result::output()
689}
690
691pub fn walk_block<'v, V: Visitor<'v>>(visitor: &mut V, block: &'v Block<'v>) -> V::Result {
692    let Block { stmts, expr, hir_id, rules: _, span: _, targeted_by_break: _ } = block;
693    try_visit!(visitor.visit_id(*hir_id));
694    walk_list!(visitor, visit_stmt, *stmts);
695    visit_opt!(visitor, visit_expr, *expr);
696    V::Result::output()
697}
698
699pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt<'v>) -> V::Result {
700    let Stmt { kind, hir_id, span: _ } = statement;
701    try_visit!(visitor.visit_id(*hir_id));
702    match *kind {
703        StmtKind::Let(ref local) => visitor.visit_local(local),
704        StmtKind::Item(item) => visitor.visit_nested_item(item),
705        StmtKind::Expr(ref expression) | StmtKind::Semi(ref expression) => {
706            visitor.visit_expr(expression)
707        }
708    }
709}
710
711pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm<'v>) -> V::Result {
712    let Arm { hir_id, span: _, pat, guard, body } = arm;
713    try_visit!(visitor.visit_id(*hir_id));
714    try_visit!(visitor.visit_pat(*pat));
715    visit_opt!(visitor, visit_expr, *guard);
716    visitor.visit_expr(*body)
717}
718
719pub fn walk_ty_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v TyPat<'v>) -> V::Result {
720    let TyPat { kind, hir_id, span: _ } = pattern;
721    try_visit!(visitor.visit_id(*hir_id));
722    match *kind {
723        TyPatKind::Range(lower_bound, upper_bound) => {
724            try_visit!(visitor.visit_const_arg_unambig(lower_bound));
725            try_visit!(visitor.visit_const_arg_unambig(upper_bound));
726        }
727        TyPatKind::Or(patterns) => walk_list!(visitor, visit_pattern_type_pattern, patterns),
728        TyPatKind::Err(_) => (),
729    }
730    V::Result::output()
731}
732
733pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat<'v>) -> V::Result {
734    let Pat { hir_id, kind, span, default_binding_modes: _ } = pattern;
735    try_visit!(visitor.visit_id(*hir_id));
736    match *kind {
737        PatKind::TupleStruct(ref qpath, children, _) => {
738            try_visit!(visitor.visit_qpath(qpath, *hir_id, *span));
739            walk_list!(visitor, visit_pat, children);
740        }
741        PatKind::Struct(ref qpath, fields, _) => {
742            try_visit!(visitor.visit_qpath(qpath, *hir_id, *span));
743            walk_list!(visitor, visit_pat_field, fields);
744        }
745        PatKind::Or(pats) => walk_list!(visitor, visit_pat, pats),
746        PatKind::Tuple(tuple_elements, _) => {
747            walk_list!(visitor, visit_pat, tuple_elements);
748        }
749        PatKind::Box(ref subpattern)
750        | PatKind::Deref(ref subpattern)
751        | PatKind::Ref(ref subpattern, _) => {
752            try_visit!(visitor.visit_pat(subpattern));
753        }
754        PatKind::Binding(_, _hir_id, ident, ref optional_subpattern) => {
755            try_visit!(visitor.visit_ident(ident));
756            visit_opt!(visitor, visit_pat, optional_subpattern);
757        }
758        PatKind::Expr(ref expression) => try_visit!(visitor.visit_pat_expr(expression)),
759        PatKind::Range(ref lower_bound, ref upper_bound, _) => {
760            visit_opt!(visitor, visit_pat_expr, lower_bound);
761            visit_opt!(visitor, visit_pat_expr, upper_bound);
762        }
763        PatKind::Missing | PatKind::Never | PatKind::Wild | PatKind::Err(_) => (),
764        PatKind::Slice(prepatterns, ref slice_pattern, postpatterns) => {
765            walk_list!(visitor, visit_pat, prepatterns);
766            visit_opt!(visitor, visit_pat, slice_pattern);
767            walk_list!(visitor, visit_pat, postpatterns);
768        }
769        PatKind::Guard(subpat, condition) => {
770            try_visit!(visitor.visit_pat(subpat));
771            try_visit!(visitor.visit_expr(condition));
772        }
773    }
774    V::Result::output()
775}
776
777pub fn walk_pat_field<'v, V: Visitor<'v>>(visitor: &mut V, field: &'v PatField<'v>) -> V::Result {
778    let PatField { hir_id, ident, pat, is_shorthand: _, span: _ } = field;
779    try_visit!(visitor.visit_id(*hir_id));
780    try_visit!(visitor.visit_ident(*ident));
781    visitor.visit_pat(*pat)
782}
783
784pub fn walk_pat_expr<'v, V: Visitor<'v>>(visitor: &mut V, expr: &'v PatExpr<'v>) -> V::Result {
785    let PatExpr { hir_id, span, kind } = expr;
786    try_visit!(visitor.visit_id(*hir_id));
787    match kind {
788        PatExprKind::Lit { lit, negated } => visitor.visit_lit(*hir_id, lit, *negated),
789        PatExprKind::ConstBlock(c) => visitor.visit_inline_const(c),
790        PatExprKind::Path(qpath) => visitor.visit_qpath(qpath, *hir_id, *span),
791    }
792}
793
794pub fn walk_anon_const<'v, V: Visitor<'v>>(visitor: &mut V, constant: &'v AnonConst) -> V::Result {
795    let AnonConst { hir_id, def_id: _, body, span: _ } = constant;
796    try_visit!(visitor.visit_id(*hir_id));
797    visitor.visit_nested_body(*body)
798}
799
800pub fn walk_inline_const<'v, V: Visitor<'v>>(
801    visitor: &mut V,
802    constant: &'v ConstBlock,
803) -> V::Result {
804    let ConstBlock { hir_id, def_id: _, body } = constant;
805    try_visit!(visitor.visit_id(*hir_id));
806    visitor.visit_nested_body(*body)
807}
808
809pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>) -> V::Result {
810    let Expr { hir_id, kind, span } = expression;
811    try_visit!(visitor.visit_id(*hir_id));
812    match *kind {
813        ExprKind::Array(subexpressions) => {
814            walk_list!(visitor, visit_expr, subexpressions);
815        }
816        ExprKind::ConstBlock(ref const_block) => {
817            try_visit!(visitor.visit_inline_const(const_block))
818        }
819        ExprKind::Repeat(ref element, ref count) => {
820            try_visit!(visitor.visit_expr(element));
821            try_visit!(visitor.visit_const_arg_unambig(count));
822        }
823        ExprKind::Struct(ref qpath, fields, ref optional_base) => {
824            try_visit!(visitor.visit_qpath(qpath, *hir_id, *span));
825            walk_list!(visitor, visit_expr_field, fields);
826            match optional_base {
827                StructTailExpr::Base(base) => try_visit!(visitor.visit_expr(base)),
828                StructTailExpr::None | StructTailExpr::DefaultFields(_) => {}
829            }
830        }
831        ExprKind::Tup(subexpressions) => {
832            walk_list!(visitor, visit_expr, subexpressions);
833        }
834        ExprKind::Call(ref callee_expression, arguments) => {
835            try_visit!(visitor.visit_expr(callee_expression));
836            walk_list!(visitor, visit_expr, arguments);
837        }
838        ExprKind::MethodCall(ref segment, receiver, arguments, _) => {
839            try_visit!(visitor.visit_path_segment(segment));
840            try_visit!(visitor.visit_expr(receiver));
841            walk_list!(visitor, visit_expr, arguments);
842        }
843        ExprKind::Use(expr, _) => {
844            try_visit!(visitor.visit_expr(expr));
845        }
846        ExprKind::Binary(_, ref left_expression, ref right_expression) => {
847            try_visit!(visitor.visit_expr(left_expression));
848            try_visit!(visitor.visit_expr(right_expression));
849        }
850        ExprKind::AddrOf(_, _, ref subexpression) | ExprKind::Unary(_, ref subexpression) => {
851            try_visit!(visitor.visit_expr(subexpression));
852        }
853        ExprKind::Cast(ref subexpression, ref typ) | ExprKind::Type(ref subexpression, ref typ) => {
854            try_visit!(visitor.visit_expr(subexpression));
855            try_visit!(visitor.visit_ty_unambig(typ));
856        }
857        ExprKind::DropTemps(ref subexpression) => {
858            try_visit!(visitor.visit_expr(subexpression));
859        }
860        ExprKind::Let(LetExpr { span: _, pat, ty, init, recovered: _ }) => {
861            // match the visit order in walk_local
862            try_visit!(visitor.visit_expr(init));
863            try_visit!(visitor.visit_pat(pat));
864            visit_opt!(visitor, visit_ty_unambig, ty);
865        }
866        ExprKind::If(ref cond, ref then, ref else_opt) => {
867            try_visit!(visitor.visit_expr(cond));
868            try_visit!(visitor.visit_expr(then));
869            visit_opt!(visitor, visit_expr, else_opt);
870        }
871        ExprKind::Loop(ref block, ref opt_label, _, _) => {
872            visit_opt!(visitor, visit_label, opt_label);
873            try_visit!(visitor.visit_block(block));
874        }
875        ExprKind::Match(ref subexpression, arms, _) => {
876            try_visit!(visitor.visit_expr(subexpression));
877            walk_list!(visitor, visit_arm, arms);
878        }
879        ExprKind::Closure(&Closure {
880            def_id,
881            binder: _,
882            bound_generic_params,
883            fn_decl,
884            body,
885            capture_clause: _,
886            fn_decl_span: _,
887            fn_arg_span: _,
888            kind: _,
889            constness: _,
890        }) => {
891            walk_list!(visitor, visit_generic_param, bound_generic_params);
892            try_visit!(visitor.visit_fn(FnKind::Closure, fn_decl, body, *span, def_id));
893        }
894        ExprKind::Block(ref block, ref opt_label) => {
895            visit_opt!(visitor, visit_label, opt_label);
896            try_visit!(visitor.visit_block(block));
897        }
898        ExprKind::Assign(ref lhs, ref rhs, _) => {
899            try_visit!(visitor.visit_expr(rhs));
900            try_visit!(visitor.visit_expr(lhs));
901        }
902        ExprKind::AssignOp(_, ref left_expression, ref right_expression) => {
903            try_visit!(visitor.visit_expr(right_expression));
904            try_visit!(visitor.visit_expr(left_expression));
905        }
906        ExprKind::Field(ref subexpression, ident) => {
907            try_visit!(visitor.visit_expr(subexpression));
908            try_visit!(visitor.visit_ident(ident));
909        }
910        ExprKind::Index(ref main_expression, ref index_expression, _) => {
911            try_visit!(visitor.visit_expr(main_expression));
912            try_visit!(visitor.visit_expr(index_expression));
913        }
914        ExprKind::Path(ref qpath) => {
915            try_visit!(visitor.visit_qpath(qpath, *hir_id, *span));
916        }
917        ExprKind::Break(ref destination, ref opt_expr) => {
918            visit_opt!(visitor, visit_label, &destination.label);
919            visit_opt!(visitor, visit_expr, opt_expr);
920        }
921        ExprKind::Continue(ref destination) => {
922            visit_opt!(visitor, visit_label, &destination.label);
923        }
924        ExprKind::Ret(ref optional_expression) => {
925            visit_opt!(visitor, visit_expr, optional_expression);
926        }
927        ExprKind::Become(ref expr) => try_visit!(visitor.visit_expr(expr)),
928        ExprKind::InlineAsm(ref asm) => {
929            try_visit!(visitor.visit_inline_asm(asm, *hir_id));
930        }
931        ExprKind::OffsetOf(ref container, ref fields) => {
932            try_visit!(visitor.visit_ty_unambig(container));
933            walk_list!(visitor, visit_ident, fields.iter().copied());
934        }
935        ExprKind::Yield(ref subexpression, _) => {
936            try_visit!(visitor.visit_expr(subexpression));
937        }
938        ExprKind::UnsafeBinderCast(_kind, expr, ty) => {
939            try_visit!(visitor.visit_expr(expr));
940            visit_opt!(visitor, visit_ty_unambig, ty);
941        }
942        ExprKind::Lit(lit) => try_visit!(visitor.visit_lit(*hir_id, lit, false)),
943        ExprKind::Err(_) => {}
944    }
945    V::Result::output()
946}
947
948pub fn walk_expr_field<'v, V: Visitor<'v>>(visitor: &mut V, field: &'v ExprField<'v>) -> V::Result {
949    let ExprField { hir_id, ident, expr, span: _, is_shorthand: _ } = field;
950    try_visit!(visitor.visit_id(*hir_id));
951    try_visit!(visitor.visit_ident(*ident));
952    visitor.visit_expr(*expr)
953}
954/// We track whether an infer var is from a [`Ty`], [`ConstArg`], or [`GenericArg`] so that
955/// HIR visitors overriding [`Visitor::visit_infer`] can determine what kind of infer is being visited
956pub enum InferKind<'hir> {
957    Ty(&'hir Ty<'hir>),
958    Const(&'hir ConstArg<'hir>),
959    Ambig(&'hir InferArg),
960}
961
962pub fn walk_generic_arg<'v, V: Visitor<'v>>(
963    visitor: &mut V,
964    generic_arg: &'v GenericArg<'v>,
965) -> V::Result {
966    match generic_arg {
967        GenericArg::Lifetime(lt) => visitor.visit_lifetime(lt),
968        GenericArg::Type(ty) => visitor.visit_ty(ty),
969        GenericArg::Const(ct) => visitor.visit_const_arg(ct),
970        GenericArg::Infer(inf) => {
971            let InferArg { hir_id, span } = inf;
972            visitor.visit_infer(*hir_id, *span, InferKind::Ambig(inf))
973        }
974    }
975}
976
977pub fn walk_unambig_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) -> V::Result {
978    match typ.try_as_ambig_ty() {
979        Some(ambig_ty) => visitor.visit_ty(ambig_ty),
980        None => {
981            let Ty { hir_id, span, kind: _ } = typ;
982            try_visit!(visitor.visit_id(*hir_id));
983            visitor.visit_infer(*hir_id, *span, InferKind::Ty(typ))
984        }
985    }
986}
987
988pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v, AmbigArg>) -> V::Result {
989    let Ty { hir_id, span: _, kind } = typ;
990    try_visit!(visitor.visit_id(*hir_id));
991
992    match *kind {
993        TyKind::Slice(ref ty) => try_visit!(visitor.visit_ty_unambig(ty)),
994        TyKind::Ptr(ref mutable_type) => try_visit!(visitor.visit_ty_unambig(mutable_type.ty)),
995        TyKind::Ref(ref lifetime, ref mutable_type) => {
996            try_visit!(visitor.visit_lifetime(lifetime));
997            try_visit!(visitor.visit_ty_unambig(mutable_type.ty));
998        }
999        TyKind::Never => {}
1000        TyKind::Tup(tuple_element_types) => {
1001            walk_list!(visitor, visit_ty_unambig, tuple_element_types);
1002        }
1003        TyKind::BareFn(ref function_declaration) => {
1004            walk_list!(visitor, visit_generic_param, function_declaration.generic_params);
1005            try_visit!(visitor.visit_fn_decl(function_declaration.decl));
1006        }
1007        TyKind::UnsafeBinder(ref unsafe_binder) => {
1008            walk_list!(visitor, visit_generic_param, unsafe_binder.generic_params);
1009            try_visit!(visitor.visit_ty_unambig(unsafe_binder.inner_ty));
1010        }
1011        TyKind::Path(ref qpath) => {
1012            try_visit!(visitor.visit_qpath(qpath, typ.hir_id, typ.span));
1013        }
1014        TyKind::OpaqueDef(opaque) => {
1015            try_visit!(visitor.visit_opaque_ty(opaque));
1016        }
1017        TyKind::TraitAscription(bounds) => {
1018            walk_list!(visitor, visit_param_bound, bounds);
1019        }
1020        TyKind::Array(ref ty, ref length) => {
1021            try_visit!(visitor.visit_ty_unambig(ty));
1022            try_visit!(visitor.visit_const_arg_unambig(length));
1023        }
1024        TyKind::TraitObject(bounds, ref lifetime) => {
1025            for bound in bounds {
1026                try_visit!(visitor.visit_poly_trait_ref(bound));
1027            }
1028            try_visit!(visitor.visit_lifetime(lifetime));
1029        }
1030        TyKind::Typeof(ref expression) => try_visit!(visitor.visit_anon_const(expression)),
1031        TyKind::InferDelegation(..) | TyKind::Err(_) => {}
1032        TyKind::Pat(ty, pat) => {
1033            try_visit!(visitor.visit_ty_unambig(ty));
1034            try_visit!(visitor.visit_pattern_type_pattern(pat));
1035        }
1036    }
1037    V::Result::output()
1038}
1039
1040pub fn walk_const_arg<'v, V: Visitor<'v>>(
1041    visitor: &mut V,
1042    const_arg: &'v ConstArg<'v>,
1043) -> V::Result {
1044    match const_arg.try_as_ambig_ct() {
1045        Some(ambig_ct) => visitor.visit_const_arg(ambig_ct),
1046        None => {
1047            let ConstArg { hir_id, kind: _ } = const_arg;
1048            try_visit!(visitor.visit_id(*hir_id));
1049            visitor.visit_infer(*hir_id, const_arg.span(), InferKind::Const(const_arg))
1050        }
1051    }
1052}
1053
1054pub fn walk_ambig_const_arg<'v, V: Visitor<'v>>(
1055    visitor: &mut V,
1056    const_arg: &'v ConstArg<'v, AmbigArg>,
1057) -> V::Result {
1058    let ConstArg { hir_id, kind } = const_arg;
1059    try_visit!(visitor.visit_id(*hir_id));
1060    match kind {
1061        ConstArgKind::Path(qpath) => visitor.visit_qpath(qpath, *hir_id, qpath.span()),
1062        ConstArgKind::Anon(anon) => visitor.visit_anon_const(*anon),
1063    }
1064}
1065
1066pub fn walk_generic_param<'v, V: Visitor<'v>>(
1067    visitor: &mut V,
1068    param: &'v GenericParam<'v>,
1069) -> V::Result {
1070    let GenericParam {
1071        hir_id,
1072        def_id: _,
1073        name,
1074        span: _,
1075        pure_wrt_drop: _,
1076        kind,
1077        colon_span: _,
1078        source: _,
1079    } = param;
1080    try_visit!(visitor.visit_id(*hir_id));
1081    match *name {
1082        ParamName::Plain(ident) | ParamName::Error(ident) => try_visit!(visitor.visit_ident(ident)),
1083        ParamName::Fresh => {}
1084    }
1085    match *kind {
1086        GenericParamKind::Lifetime { .. } => {}
1087        GenericParamKind::Type { ref default, .. } => {
1088            visit_opt!(visitor, visit_ty_unambig, default)
1089        }
1090        GenericParamKind::Const { ref ty, ref default, synthetic: _ } => {
1091            try_visit!(visitor.visit_ty_unambig(ty));
1092            if let Some(default) = default {
1093                try_visit!(visitor.visit_const_param_default(*hir_id, default));
1094            }
1095        }
1096    }
1097    V::Result::output()
1098}
1099
1100pub fn walk_const_param_default<'v, V: Visitor<'v>>(
1101    visitor: &mut V,
1102    ct: &'v ConstArg<'v>,
1103) -> V::Result {
1104    visitor.visit_const_arg_unambig(ct)
1105}
1106
1107pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) -> V::Result {
1108    let &Generics {
1109        params,
1110        predicates,
1111        has_where_clause_predicates: _,
1112        where_clause_span: _,
1113        span: _,
1114    } = generics;
1115    walk_list!(visitor, visit_generic_param, params);
1116    walk_list!(visitor, visit_where_predicate, predicates);
1117    V::Result::output()
1118}
1119
1120pub fn walk_where_predicate<'v, V: Visitor<'v>>(
1121    visitor: &mut V,
1122    predicate: &'v WherePredicate<'v>,
1123) -> V::Result {
1124    let &WherePredicate { hir_id, kind, span: _ } = predicate;
1125    try_visit!(visitor.visit_id(hir_id));
1126    match *kind {
1127        WherePredicateKind::BoundPredicate(WhereBoundPredicate {
1128            ref bounded_ty,
1129            bounds,
1130            bound_generic_params,
1131            origin: _,
1132        }) => {
1133            try_visit!(visitor.visit_ty_unambig(bounded_ty));
1134            walk_list!(visitor, visit_param_bound, bounds);
1135            walk_list!(visitor, visit_generic_param, bound_generic_params);
1136        }
1137        WherePredicateKind::RegionPredicate(WhereRegionPredicate {
1138            ref lifetime,
1139            bounds,
1140            in_where_clause: _,
1141        }) => {
1142            try_visit!(visitor.visit_lifetime(lifetime));
1143            walk_list!(visitor, visit_param_bound, bounds);
1144        }
1145        WherePredicateKind::EqPredicate(WhereEqPredicate { ref lhs_ty, ref rhs_ty }) => {
1146            try_visit!(visitor.visit_ty_unambig(lhs_ty));
1147            try_visit!(visitor.visit_ty_unambig(rhs_ty));
1148        }
1149    }
1150    V::Result::output()
1151}
1152
1153pub fn walk_fn_decl<'v, V: Visitor<'v>>(
1154    visitor: &mut V,
1155    function_declaration: &'v FnDecl<'v>,
1156) -> V::Result {
1157    let FnDecl { inputs, output, c_variadic: _, implicit_self: _, lifetime_elision_allowed: _ } =
1158        function_declaration;
1159    walk_list!(visitor, visit_ty_unambig, *inputs);
1160    visitor.visit_fn_ret_ty(output)
1161}
1162
1163pub fn walk_fn_ret_ty<'v, V: Visitor<'v>>(visitor: &mut V, ret_ty: &'v FnRetTy<'v>) -> V::Result {
1164    if let FnRetTy::Return(output_ty) = *ret_ty {
1165        try_visit!(visitor.visit_ty_unambig(output_ty));
1166    }
1167    V::Result::output()
1168}
1169
1170pub fn walk_fn<'v, V: Visitor<'v>>(
1171    visitor: &mut V,
1172    function_kind: FnKind<'v>,
1173    function_declaration: &'v FnDecl<'v>,
1174    body_id: BodyId,
1175    _: LocalDefId,
1176) -> V::Result {
1177    try_visit!(visitor.visit_fn_decl(function_declaration));
1178    try_visit!(walk_fn_kind(visitor, function_kind));
1179    visitor.visit_nested_body(body_id)
1180}
1181
1182pub fn walk_fn_kind<'v, V: Visitor<'v>>(visitor: &mut V, function_kind: FnKind<'v>) -> V::Result {
1183    match function_kind {
1184        FnKind::ItemFn(_, generics, ..) => {
1185            try_visit!(visitor.visit_generics(generics));
1186        }
1187        FnKind::Closure | FnKind::Method(..) => {}
1188    }
1189    V::Result::output()
1190}
1191
1192pub fn walk_use<'v, V: Visitor<'v>>(
1193    visitor: &mut V,
1194    path: &'v UsePath<'v>,
1195    hir_id: HirId,
1196) -> V::Result {
1197    let UsePath { segments, ref res, span } = *path;
1198    for res in res.present_items() {
1199        try_visit!(visitor.visit_path(&Path { segments, res, span }, hir_id));
1200    }
1201    V::Result::output()
1202}
1203
1204pub fn walk_trait_item<'v, V: Visitor<'v>>(
1205    visitor: &mut V,
1206    trait_item: &'v TraitItem<'v>,
1207) -> V::Result {
1208    let TraitItem { ident, generics, ref defaultness, ref kind, span, owner_id: _ } = *trait_item;
1209    let hir_id = trait_item.hir_id();
1210    try_visit!(visitor.visit_ident(ident));
1211    try_visit!(visitor.visit_generics(&generics));
1212    try_visit!(visitor.visit_defaultness(&defaultness));
1213    try_visit!(visitor.visit_id(hir_id));
1214    match *kind {
1215        TraitItemKind::Const(ref ty, default) => {
1216            try_visit!(visitor.visit_ty_unambig(ty));
1217            visit_opt!(visitor, visit_nested_body, default);
1218        }
1219        TraitItemKind::Fn(ref sig, TraitFn::Required(param_idents)) => {
1220            try_visit!(visitor.visit_fn_decl(sig.decl));
1221            for ident in param_idents.iter().copied() {
1222                visit_opt!(visitor, visit_ident, ident);
1223            }
1224        }
1225        TraitItemKind::Fn(ref sig, TraitFn::Provided(body_id)) => {
1226            try_visit!(visitor.visit_fn(
1227                FnKind::Method(ident, sig),
1228                sig.decl,
1229                body_id,
1230                span,
1231                trait_item.owner_id.def_id,
1232            ));
1233        }
1234        TraitItemKind::Type(bounds, ref default) => {
1235            walk_list!(visitor, visit_param_bound, bounds);
1236            visit_opt!(visitor, visit_ty_unambig, default);
1237        }
1238    }
1239    V::Result::output()
1240}
1241
1242pub fn walk_trait_item_ref<'v, V: Visitor<'v>>(
1243    visitor: &mut V,
1244    trait_item_ref: &'v TraitItemRef,
1245) -> V::Result {
1246    let TraitItemRef { id, ident, ref kind, span: _ } = *trait_item_ref;
1247    try_visit!(visitor.visit_nested_trait_item(id));
1248    try_visit!(visitor.visit_ident(ident));
1249    visitor.visit_associated_item_kind(kind)
1250}
1251
1252pub fn walk_impl_item<'v, V: Visitor<'v>>(
1253    visitor: &mut V,
1254    impl_item: &'v ImplItem<'v>,
1255) -> V::Result {
1256    let ImplItem {
1257        owner_id: _,
1258        ident,
1259        ref generics,
1260        ref kind,
1261        ref defaultness,
1262        span: _,
1263        vis_span: _,
1264    } = *impl_item;
1265
1266    try_visit!(visitor.visit_ident(ident));
1267    try_visit!(visitor.visit_generics(generics));
1268    try_visit!(visitor.visit_defaultness(defaultness));
1269    try_visit!(visitor.visit_id(impl_item.hir_id()));
1270    match *kind {
1271        ImplItemKind::Const(ref ty, body) => {
1272            try_visit!(visitor.visit_ty_unambig(ty));
1273            visitor.visit_nested_body(body)
1274        }
1275        ImplItemKind::Fn(ref sig, body_id) => visitor.visit_fn(
1276            FnKind::Method(impl_item.ident, sig),
1277            sig.decl,
1278            body_id,
1279            impl_item.span,
1280            impl_item.owner_id.def_id,
1281        ),
1282        ImplItemKind::Type(ref ty) => visitor.visit_ty_unambig(ty),
1283    }
1284}
1285
1286pub fn walk_foreign_item_ref<'v, V: Visitor<'v>>(
1287    visitor: &mut V,
1288    foreign_item_ref: &'v ForeignItemRef,
1289) -> V::Result {
1290    let ForeignItemRef { id, ident, span: _ } = *foreign_item_ref;
1291    try_visit!(visitor.visit_nested_foreign_item(id));
1292    visitor.visit_ident(ident)
1293}
1294
1295pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(
1296    visitor: &mut V,
1297    impl_item_ref: &'v ImplItemRef,
1298) -> V::Result {
1299    let ImplItemRef { id, ident, ref kind, span: _, trait_item_def_id: _ } = *impl_item_ref;
1300    try_visit!(visitor.visit_nested_impl_item(id));
1301    try_visit!(visitor.visit_ident(ident));
1302    visitor.visit_associated_item_kind(kind)
1303}
1304
1305pub fn walk_trait_ref<'v, V: Visitor<'v>>(
1306    visitor: &mut V,
1307    trait_ref: &'v TraitRef<'v>,
1308) -> V::Result {
1309    let TraitRef { hir_ref_id, path } = trait_ref;
1310    try_visit!(visitor.visit_id(*hir_ref_id));
1311    visitor.visit_path(*path, *hir_ref_id)
1312}
1313
1314pub fn walk_param_bound<'v, V: Visitor<'v>>(
1315    visitor: &mut V,
1316    bound: &'v GenericBound<'v>,
1317) -> V::Result {
1318    match *bound {
1319        GenericBound::Trait(ref typ) => visitor.visit_poly_trait_ref(typ),
1320        GenericBound::Outlives(ref lifetime) => visitor.visit_lifetime(lifetime),
1321        GenericBound::Use(args, _) => {
1322            walk_list!(visitor, visit_precise_capturing_arg, args);
1323            V::Result::output()
1324        }
1325    }
1326}
1327
1328pub fn walk_precise_capturing_arg<'v, V: Visitor<'v>>(
1329    visitor: &mut V,
1330    arg: &'v PreciseCapturingArg<'v>,
1331) -> V::Result {
1332    match *arg {
1333        PreciseCapturingArg::Lifetime(lt) => visitor.visit_lifetime(lt),
1334        PreciseCapturingArg::Param(param) => {
1335            let PreciseCapturingNonLifetimeArg { hir_id, ident, res: _ } = param;
1336            try_visit!(visitor.visit_id(hir_id));
1337            visitor.visit_ident(ident)
1338        }
1339    }
1340}
1341
1342pub fn walk_poly_trait_ref<'v, V: Visitor<'v>>(
1343    visitor: &mut V,
1344    trait_ref: &'v PolyTraitRef<'v>,
1345) -> V::Result {
1346    let PolyTraitRef { bound_generic_params, modifiers: _, trait_ref, span: _ } = trait_ref;
1347    walk_list!(visitor, visit_generic_param, *bound_generic_params);
1348    visitor.visit_trait_ref(trait_ref)
1349}
1350
1351pub fn walk_opaque_ty<'v, V: Visitor<'v>>(visitor: &mut V, opaque: &'v OpaqueTy<'v>) -> V::Result {
1352    let &OpaqueTy { hir_id, def_id: _, bounds, origin: _, span: _ } = opaque;
1353    try_visit!(visitor.visit_id(hir_id));
1354    walk_list!(visitor, visit_param_bound, bounds);
1355    V::Result::output()
1356}
1357
1358pub fn walk_struct_def<'v, V: Visitor<'v>>(
1359    visitor: &mut V,
1360    struct_definition: &'v VariantData<'v>,
1361) -> V::Result {
1362    visit_opt!(visitor, visit_id, struct_definition.ctor_hir_id());
1363    walk_list!(visitor, visit_field_def, struct_definition.fields());
1364    V::Result::output()
1365}
1366
1367pub fn walk_field_def<'v, V: Visitor<'v>>(
1368    visitor: &mut V,
1369    FieldDef { hir_id, ident, ty, default, span: _, vis_span: _, def_id: _, safety: _ }: &'v FieldDef<'v>,
1370) -> V::Result {
1371    try_visit!(visitor.visit_id(*hir_id));
1372    try_visit!(visitor.visit_ident(*ident));
1373    visit_opt!(visitor, visit_anon_const, default);
1374    visitor.visit_ty_unambig(*ty)
1375}
1376
1377pub fn walk_enum_def<'v, V: Visitor<'v>>(
1378    visitor: &mut V,
1379    enum_definition: &'v EnumDef<'v>,
1380) -> V::Result {
1381    let EnumDef { variants } = enum_definition;
1382    walk_list!(visitor, visit_variant, *variants);
1383    V::Result::output()
1384}
1385
1386pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, variant: &'v Variant<'v>) -> V::Result {
1387    let Variant { ident, hir_id, def_id: _, data, disr_expr, span: _ } = variant;
1388    try_visit!(visitor.visit_ident(*ident));
1389    try_visit!(visitor.visit_id(*hir_id));
1390    try_visit!(visitor.visit_variant_data(data));
1391    visit_opt!(visitor, visit_anon_const, disr_expr);
1392    V::Result::output()
1393}
1394
1395pub fn walk_label<'v, V: Visitor<'v>>(visitor: &mut V, label: &'v Label) -> V::Result {
1396    let Label { ident } = label;
1397    visitor.visit_ident(*ident)
1398}
1399
1400pub fn walk_inf<'v, V: Visitor<'v>>(visitor: &mut V, inf: &'v InferArg) -> V::Result {
1401    let InferArg { hir_id, span: _ } = inf;
1402    visitor.visit_id(*hir_id)
1403}
1404
1405pub fn walk_lifetime<'v, V: Visitor<'v>>(visitor: &mut V, lifetime: &'v Lifetime) -> V::Result {
1406    let Lifetime { hir_id, ident, kind: _, source: _, syntax: _ } = lifetime;
1407    try_visit!(visitor.visit_id(*hir_id));
1408    visitor.visit_ident(*ident)
1409}
1410
1411pub fn walk_qpath<'v, V: Visitor<'v>>(
1412    visitor: &mut V,
1413    qpath: &'v QPath<'v>,
1414    id: HirId,
1415) -> V::Result {
1416    match *qpath {
1417        QPath::Resolved(ref maybe_qself, ref path) => {
1418            visit_opt!(visitor, visit_ty_unambig, maybe_qself);
1419            visitor.visit_path(path, id)
1420        }
1421        QPath::TypeRelative(ref qself, ref segment) => {
1422            try_visit!(visitor.visit_ty_unambig(qself));
1423            visitor.visit_path_segment(segment)
1424        }
1425        QPath::LangItem(..) => V::Result::output(),
1426    }
1427}
1428
1429pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &Path<'v>) -> V::Result {
1430    let Path { segments, span: _, res: _ } = path;
1431    walk_list!(visitor, visit_path_segment, *segments);
1432    V::Result::output()
1433}
1434
1435pub fn walk_path_segment<'v, V: Visitor<'v>>(
1436    visitor: &mut V,
1437    segment: &'v PathSegment<'v>,
1438) -> V::Result {
1439    let PathSegment { ident, hir_id, res: _, args, infer_args: _ } = segment;
1440    try_visit!(visitor.visit_ident(*ident));
1441    try_visit!(visitor.visit_id(*hir_id));
1442    visit_opt!(visitor, visit_generic_args, *args);
1443    V::Result::output()
1444}
1445
1446pub fn walk_generic_args<'v, V: Visitor<'v>>(
1447    visitor: &mut V,
1448    generic_args: &'v GenericArgs<'v>,
1449) -> V::Result {
1450    let GenericArgs { args, constraints, parenthesized: _, span_ext: _ } = generic_args;
1451    walk_list!(visitor, visit_generic_arg, *args);
1452    walk_list!(visitor, visit_assoc_item_constraint, *constraints);
1453    V::Result::output()
1454}
1455
1456pub fn walk_assoc_item_constraint<'v, V: Visitor<'v>>(
1457    visitor: &mut V,
1458    constraint: &'v AssocItemConstraint<'v>,
1459) -> V::Result {
1460    let AssocItemConstraint { hir_id, ident, gen_args, kind: _, span: _ } = constraint;
1461    try_visit!(visitor.visit_id(*hir_id));
1462    try_visit!(visitor.visit_ident(*ident));
1463    try_visit!(visitor.visit_generic_args(*gen_args));
1464    match constraint.kind {
1465        AssocItemConstraintKind::Equality { ref term } => match term {
1466            Term::Ty(ty) => try_visit!(visitor.visit_ty_unambig(ty)),
1467            Term::Const(c) => try_visit!(visitor.visit_const_arg_unambig(c)),
1468        },
1469        AssocItemConstraintKind::Bound { bounds } => {
1470            walk_list!(visitor, visit_param_bound, bounds)
1471        }
1472    }
1473    V::Result::output()
1474}
1475
1476pub fn walk_associated_item_kind<'v, V: Visitor<'v>>(_: &mut V, _: &'v AssocItemKind) -> V::Result {
1477    // No visitable content here: this fn exists so you can call it if
1478    // the right thing to do, should content be added in the future,
1479    // would be to walk it.
1480    V::Result::output()
1481}
1482
1483pub fn walk_defaultness<'v, V: Visitor<'v>>(_: &mut V, _: &'v Defaultness) -> V::Result {
1484    // No visitable content here: this fn exists so you can call it if
1485    // the right thing to do, should content be added in the future,
1486    // would be to walk it.
1487    V::Result::output()
1488}
1489
1490pub fn walk_inline_asm<'v, V: Visitor<'v>>(
1491    visitor: &mut V,
1492    asm: &'v InlineAsm<'v>,
1493    id: HirId,
1494) -> V::Result {
1495    for (op, op_sp) in asm.operands {
1496        match op {
1497            InlineAsmOperand::In { expr, .. } | InlineAsmOperand::InOut { expr, .. } => {
1498                try_visit!(visitor.visit_expr(expr));
1499            }
1500            InlineAsmOperand::Out { expr, .. } => {
1501                visit_opt!(visitor, visit_expr, expr);
1502            }
1503            InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
1504                try_visit!(visitor.visit_expr(in_expr));
1505                visit_opt!(visitor, visit_expr, out_expr);
1506            }
1507            InlineAsmOperand::Const { anon_const, .. } => {
1508                try_visit!(visitor.visit_inline_const(anon_const));
1509            }
1510            InlineAsmOperand::SymFn { expr, .. } => {
1511                try_visit!(visitor.visit_expr(expr));
1512            }
1513            InlineAsmOperand::SymStatic { path, .. } => {
1514                try_visit!(visitor.visit_qpath(path, id, *op_sp));
1515            }
1516            InlineAsmOperand::Label { block } => try_visit!(visitor.visit_block(block)),
1517        }
1518    }
1519    V::Result::output()
1520}