1use 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 ItemFn(Ident, &'a Generics<'a>, FnHeader),
83
84 Method(Ident, &'a FnSig<'a>),
86
87 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
109pub trait HirTyCtxt<'hir> {
113 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
122impl<'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 pub trait NestedFilter<'hir> {
160 type MaybeTyCtxt: HirTyCtxt<'hir>;
161
162 const INTER: bool;
165 const INTRA: bool;
168 }
169
170 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
187pub trait Visitor<'v>: Sized {
208 type MaybeTyCtxt: HirTyCtxt<'v> = <Self::NestedFilter as NestedFilter<'v>>::MaybeTyCtxt;
210
211 type NestedFilter: NestedFilter<'v> = nested_filter::None;
224
225 type Result: VisitorResult = ();
228
229 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 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 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 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 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 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 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 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 fn visit_ty(&mut self, t: &'v Ty<'v, AmbigArg>) -> Self::Result {
372 walk_ty(self, t)
373 }
374
375 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 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 fn visit_ty_unambig(&mut self, t: &'v Ty<'v>) -> Self::Result {
520 walk_unambig_ty(self, t)
521 }
522 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 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 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 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}
954pub 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 V::Result::output()
1481}
1482
1483pub fn walk_defaultness<'v, V: Visitor<'v>>(_: &mut V, _: &'v Defaultness) -> V::Result {
1484 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}