src/librustc_ast/mut_visit.rs

   1 //! A `MutVisitor` represents an AST modification; it accepts an AST piece and
   2 //! and mutates it in place. So, for instance, macro expansion is a `MutVisitor`
   3 //! that walks over an AST and modifies it.
   4 //!
   5 //! Note: using a `MutVisitor` (other than the `MacroExpander` `MutVisitor`) on
   6 //! an AST before macro expansion is probably a bad idea. For instance,
   7 //! a `MutVisitor` renaming item names in a module will miss all of those
   8 //! that are created by the expansion of a macro.
   9
  10 use crate::ast::*;
  11 use crate::ptr::P;
  12 use crate::token::{self, Token};
  13 use crate::tokenstream::*;
  14
  15 use rustc_data_structures::map_in_place::MapInPlace;
  16 use rustc_data_structures::sync::Lrc;
  17 use rustc_span::source_map::{respan, Spanned};
  18 use rustc_span::symbol::Ident;
  19 use rustc_span::Span;
  20
  21 use smallvec::{smallvec, Array, SmallVec};
  22 use std::ops::DerefMut;
  23 use std::{panic, process, ptr};
  24
  25 pub trait ExpectOne<A: Array> {
  26     fn expect_one(self, err: &'static str) -> A::Item;
  27 }
  28
  29 impl<A: Array> ExpectOne<A> for SmallVec<A> {
  30     fn expect_one(self, err: &'static str) -> A::Item {
  31         assert!(self.len() == 1, err);
  32         self.into_iter().next().unwrap()
  33     }
  34 }
  35
  36 pub trait MutVisitor: Sized {
  37     // Methods in this trait have one of three forms:
  38     //
  39     //   fn visit_t(&mut self, t: &mut T);                      // common
  40     //   fn flat_map_t(&mut self, t: T) -> SmallVec<[T; 1]>;    // rare
  41     //   fn filter_map_t(&mut self, t: T) -> Option<T>;         // rarest
  42     //
  43     // Any additions to this trait should happen in form of a call to a public
  44     // `noop_*` function that only calls out to the visitor again, not other
  45     // `noop_*` functions. This is a necessary API workaround to the problem of
  46     // not being able to call out to the super default method in an overridden
  47     // default method.
  48     //
  49     // When writing these methods, it is better to use destructuring like this:
  50     //
  51     //   fn visit_abc(&mut self, ABC { a, b, c: _ }: &mut ABC) {
  52     //       visit_a(a);
  53     //       visit_b(b);
  54     //   }
  55     //
  56     // than to use field access like this:
  57     //
  58     //   fn visit_abc(&mut self, abc: &mut ABC) {
  59     //       visit_a(&mut abc.a);
  60     //       visit_b(&mut abc.b);
  61     //       // ignore abc.c
  62     //   }
  63     //
  64     // As well as being more concise, the former is explicit about which fields
  65     // are skipped. Furthermore, if a new field is added, the destructuring
  66     // version will cause a compile error, which is good. In comparison, the
  67     // field access version will continue working and it would be easy to
  68     // forget to add handling for it.
  69
  70     fn visit_crate(&mut self, c: &mut Crate) {
  71         noop_visit_crate(c, self)
  72     }
  73
  74     fn visit_meta_list_item(&mut self, list_item: &mut NestedMetaItem) {
  75         noop_visit_meta_list_item(list_item, self);
  76     }
  77
  78     fn visit_meta_item(&mut self, meta_item: &mut MetaItem) {
  79         noop_visit_meta_item(meta_item, self);
  80     }
  81
  82     fn visit_use_tree(&mut self, use_tree: &mut UseTree) {
  83         noop_visit_use_tree(use_tree, self);
  84     }
  85
  86     fn flat_map_foreign_item(&mut self, ni: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> {
  87         noop_flat_map_foreign_item(ni, self)
  88     }
  89
  90     fn flat_map_item(&mut self, i: P<Item>) -> SmallVec<[P<Item>; 1]> {
  91         noop_flat_map_item(i, self)
  92     }
  93
  94     fn visit_fn_header(&mut self, header: &mut FnHeader) {
  95         noop_visit_fn_header(header, self);
  96     }
  97
  98     fn flat_map_struct_field(&mut self, sf: StructField) -> SmallVec<[StructField; 1]> {
  99         noop_flat_map_struct_field(sf, self)
 100     }
 101
 102     fn visit_item_kind(&mut self, i: &mut ItemKind) {
 103         noop_visit_item_kind(i, self);
 104     }
 105
 106     fn flat_map_trait_item(&mut self, i: P<AssocItem>) -> SmallVec<[P<AssocItem>; 1]> {
 107         noop_flat_map_assoc_item(i, self)
 108     }
 109
 110     fn flat_map_impl_item(&mut self, i: P<AssocItem>) -> SmallVec<[P<AssocItem>; 1]> {
 111         noop_flat_map_assoc_item(i, self)
 112     }
 113
 114     fn visit_fn_decl(&mut self, d: &mut P<FnDecl>) {
 115         noop_visit_fn_decl(d, self);
 116     }
 117
 118     fn visit_asyncness(&mut self, a: &mut Async) {
 119         noop_visit_asyncness(a, self);
 120     }
 121
 122     fn visit_block(&mut self, b: &mut P<Block>) {
 123         noop_visit_block(b, self);
 124     }
 125
 126     fn flat_map_stmt(&mut self, s: Stmt) -> SmallVec<[Stmt; 1]> {
 127         noop_flat_map_stmt(s, self)
 128     }
 129
 130     fn flat_map_arm(&mut self, arm: Arm) -> SmallVec<[Arm; 1]> {
 131         noop_flat_map_arm(arm, self)
 132     }
 133
 134     fn visit_pat(&mut self, p: &mut P<Pat>) {
 135         noop_visit_pat(p, self);
 136     }
 137
 138     fn visit_anon_const(&mut self, c: &mut AnonConst) {
 139         noop_visit_anon_const(c, self);
 140     }
 141
 142     fn visit_expr(&mut self, e: &mut P<Expr>) {
 143         noop_visit_expr(e, self);
 144     }
 145
 146     fn filter_map_expr(&mut self, e: P<Expr>) -> Option<P<Expr>> {
 147         noop_filter_map_expr(e, self)
 148     }
 149
 150     fn visit_generic_arg(&mut self, arg: &mut GenericArg) {
 151         noop_visit_generic_arg(arg, self);
 152     }
 153
 154     fn visit_ty(&mut self, t: &mut P<Ty>) {
 155         noop_visit_ty(t, self);
 156     }
 157
 158     fn visit_lifetime(&mut self, l: &mut Lifetime) {
 159         noop_visit_lifetime(l, self);
 160     }
 161
 162     fn visit_ty_constraint(&mut self, t: &mut AssocTyConstraint) {
 163         noop_visit_ty_constraint(t, self);
 164     }
 165
 166     fn visit_mod(&mut self, m: &mut Mod) {
 167         noop_visit_mod(m, self);
 168     }
 169
 170     fn visit_foreign_mod(&mut self, nm: &mut ForeignMod) {
 171         noop_visit_foreign_mod(nm, self);
 172     }
 173
 174     fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> {
 175         noop_flat_map_variant(v, self)
 176     }
 177
 178     fn visit_ident(&mut self, i: &mut Ident) {
 179         noop_visit_ident(i, self);
 180     }
 181
 182     fn visit_path(&mut self, p: &mut Path) {
 183         noop_visit_path(p, self);
 184     }
 185
 186     fn visit_qself(&mut self, qs: &mut Option<QSelf>) {
 187         noop_visit_qself(qs, self);
 188     }
 189
 190     fn visit_generic_args(&mut self, p: &mut GenericArgs) {
 191         noop_visit_generic_args(p, self);
 192     }
 193
 194     fn visit_angle_bracketed_parameter_data(&mut self, p: &mut AngleBracketedArgs) {
 195         noop_visit_angle_bracketed_parameter_data(p, self);
 196     }
 197
 198     fn visit_parenthesized_parameter_data(&mut self, p: &mut ParenthesizedArgs) {
 199         noop_visit_parenthesized_parameter_data(p, self);
 200     }
 201
 202     fn visit_local(&mut self, l: &mut P<Local>) {
 203         noop_visit_local(l, self);
 204     }
 205
 206     fn visit_mac(&mut self, _mac: &mut MacCall) {
 207         panic!("visit_mac disabled by default");
 208         // N.B., see note about macros above. If you really want a visitor that
 209         // works on macros, use this definition in your trait impl:
 210         //   mut_visit::noop_visit_mac(_mac, self);
 211     }
 212
 213     fn visit_macro_def(&mut self, def: &mut MacroDef) {
 214         noop_visit_macro_def(def, self);
 215     }
 216
 217     fn visit_label(&mut self, label: &mut Label) {
 218         noop_visit_label(label, self);
 219     }
 220
 221     fn visit_attribute(&mut self, at: &mut Attribute) {
 222         noop_visit_attribute(at, self);
 223     }
 224
 225     fn flat_map_param(&mut self, param: Param) -> SmallVec<[Param; 1]> {
 226         noop_flat_map_param(param, self)
 227     }
 228
 229     fn visit_generics(&mut self, generics: &mut Generics) {
 230         noop_visit_generics(generics, self);
 231     }
 232
 233     fn visit_trait_ref(&mut self, tr: &mut TraitRef) {
 234         noop_visit_trait_ref(tr, self);
 235     }
 236
 237     fn visit_poly_trait_ref(&mut self, p: &mut PolyTraitRef) {
 238         noop_visit_poly_trait_ref(p, self);
 239     }
 240
 241     fn visit_variant_data(&mut self, vdata: &mut VariantData) {
 242         noop_visit_variant_data(vdata, self);
 243     }
 244
 245     fn flat_map_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> {
 246         noop_flat_map_generic_param(param, self)
 247     }
 248
 249     fn visit_tt(&mut self, tt: &mut TokenTree) {
 250         noop_visit_tt(tt, self);
 251     }
 252
 253     fn visit_tts(&mut self, tts: &mut TokenStream) {
 254         noop_visit_tts(tts, self);
 255     }
 256
 257     fn visit_token(&mut self, t: &mut Token) {
 258         noop_visit_token(t, self);
 259     }
 260
 261     fn visit_interpolated(&mut self, nt: &mut token::Nonterminal) {
 262         noop_visit_interpolated(nt, self);
 263     }
 264
 265     fn visit_param_bound(&mut self, tpb: &mut GenericBound) {
 266         noop_visit_param_bound(tpb, self);
 267     }
 268
 269     fn visit_mt(&mut self, mt: &mut MutTy) {
 270         noop_visit_mt(mt, self);
 271     }
 272
 273     fn flat_map_field(&mut self, f: Field) -> SmallVec<[Field; 1]> {
 274         noop_flat_map_field(f, self)
 275     }
 276
 277     fn visit_where_clause(&mut self, where_clause: &mut WhereClause) {
 278         noop_visit_where_clause(where_clause, self);
 279     }
 280
 281     fn visit_where_predicate(&mut self, where_predicate: &mut WherePredicate) {
 282         noop_visit_where_predicate(where_predicate, self);
 283     }
 284
 285     fn visit_vis(&mut self, vis: &mut Visibility) {
 286         noop_visit_vis(vis, self);
 287     }
 288
 289     fn visit_id(&mut self, _id: &mut NodeId) {
 290         // Do nothing.
 291     }
 292
 293     fn visit_span(&mut self, _sp: &mut Span) {
 294         // Do nothing.
 295     }
 296
 297     fn flat_map_field_pattern(&mut self, fp: FieldPat) -> SmallVec<[FieldPat; 1]> {
 298         noop_flat_map_field_pattern(fp, self)
 299     }
 300 }
 301
 302 /// Use a map-style function (`FnOnce(T) -> T`) to overwrite a `&mut T`. Useful
 303 /// when using a `flat_map_*` or `filter_map_*` method within a `visit_`
 304 /// method. Abort the program if the closure panics.
 305 //
 306 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 307 pub fn visit_clobber<T, F>(t: &mut T, f: F)
 308 where
 309     F: FnOnce(T) -> T,
 310 {
 311     unsafe {
 312         // Safe because `t` is used in a read-only fashion by `read()` before
 313         // being overwritten by `write()`.
 314         let old_t = ptr::read(t);
 315         let new_t = panic::catch_unwind(panic::AssertUnwindSafe(|| f(old_t)))
 316             .unwrap_or_else(|_| process::abort());
 317         ptr::write(t, new_t);
 318     }
 319 }
 320
 321 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 322 #[inline]
 323 pub fn visit_vec<T, F>(elems: &mut Vec<T>, mut visit_elem: F)
 324 where
 325     F: FnMut(&mut T),
 326 {
 327     for elem in elems {
 328         visit_elem(elem);
 329     }
 330 }
 331
 332 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 333 #[inline]
 334 pub fn visit_opt<T, F>(opt: &mut Option<T>, mut visit_elem: F)
 335 where
 336     F: FnMut(&mut T),
 337 {
 338     if let Some(elem) = opt {
 339         visit_elem(elem);
 340     }
 341 }
 342
 343 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 344 pub fn visit_attrs<T: MutVisitor>(attrs: &mut Vec<Attribute>, vis: &mut T) {
 345     visit_vec(attrs, |attr| vis.visit_attribute(attr));
 346 }
 347
 348 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 349 pub fn visit_thin_attrs<T: MutVisitor>(attrs: &mut AttrVec, vis: &mut T) {
 350     for attr in attrs.iter_mut() {
 351         vis.visit_attribute(attr);
 352     }
 353 }
 354
 355 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 356 pub fn visit_exprs<T: MutVisitor>(exprs: &mut Vec<P<Expr>>, vis: &mut T) {
 357     exprs.flat_map_in_place(|expr| vis.filter_map_expr(expr))
 358 }
 359
 360 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 361 pub fn visit_bounds<T: MutVisitor>(bounds: &mut GenericBounds, vis: &mut T) {
 362     visit_vec(bounds, |bound| vis.visit_param_bound(bound));
 363 }
 364
 365 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 366 pub fn visit_fn_sig<T: MutVisitor>(FnSig { header, decl }: &mut FnSig, vis: &mut T) {
 367     vis.visit_fn_header(header);
 368     vis.visit_fn_decl(decl);
 369 }
 370
 371 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 372 pub fn visit_mac_args<T: MutVisitor>(args: &mut MacArgs, vis: &mut T) {
 373     match args {
 374         MacArgs::Empty => {}
 375         MacArgs::Delimited(dspan, _delim, tokens) => {
 376             visit_delim_span(dspan, vis);
 377             vis.visit_tts(tokens);
 378         }
 379         MacArgs::Eq(eq_span, tokens) => {
 380             vis.visit_span(eq_span);
 381             vis.visit_tts(tokens);
 382         }
 383     }
 384 }
 385
 386 pub fn visit_delim_span<T: MutVisitor>(dspan: &mut DelimSpan, vis: &mut T) {
 387     vis.visit_span(&mut dspan.open);
 388     vis.visit_span(&mut dspan.close);
 389 }
 390
 391 pub fn noop_flat_map_field_pattern<T: MutVisitor>(
 392     mut fp: FieldPat,
 393     vis: &mut T,
 394 ) -> SmallVec<[FieldPat; 1]> {
 395     let FieldPat { attrs, id, ident, is_placeholder: _, is_shorthand: _, pat, span } = &mut fp;
 396     vis.visit_id(id);
 397     vis.visit_ident(ident);
 398     vis.visit_pat(pat);
 399     vis.visit_span(span);
 400     visit_thin_attrs(attrs, vis);
 401     smallvec![fp]
 402 }
 403
 404 pub fn noop_visit_use_tree<T: MutVisitor>(use_tree: &mut UseTree, vis: &mut T) {
 405     let UseTree { prefix, kind, span } = use_tree;
 406     vis.visit_path(prefix);
 407     match kind {
 408         UseTreeKind::Simple(rename, id1, id2) => {
 409             visit_opt(rename, |rename| vis.visit_ident(rename));
 410             vis.visit_id(id1);
 411             vis.visit_id(id2);
 412         }
 413         UseTreeKind::Nested(items) => {
 414             for (tree, id) in items {
 415                 vis.visit_use_tree(tree);
 416                 vis.visit_id(id);
 417             }
 418         }
 419         UseTreeKind::Glob => {}
 420     }
 421     vis.visit_span(span);
 422 }
 423
 424 pub fn noop_flat_map_arm<T: MutVisitor>(mut arm: Arm, vis: &mut T) -> SmallVec<[Arm; 1]> {
 425     let Arm { attrs, pat, guard, body, span, id, is_placeholder: _ } = &mut arm;
 426     visit_attrs(attrs, vis);
 427     vis.visit_id(id);
 428     vis.visit_pat(pat);
 429     visit_opt(guard, |guard| vis.visit_expr(guard));
 430     vis.visit_expr(body);
 431     vis.visit_span(span);
 432     smallvec![arm]
 433 }
 434
 435 pub fn noop_visit_ty_constraint<T: MutVisitor>(
 436     AssocTyConstraint { id, ident, kind, span }: &mut AssocTyConstraint,
 437     vis: &mut T,
 438 ) {
 439     vis.visit_id(id);
 440     vis.visit_ident(ident);
 441     match kind {
 442         AssocTyConstraintKind::Equality { ref mut ty } => {
 443             vis.visit_ty(ty);
 444         }
 445         AssocTyConstraintKind::Bound { ref mut bounds } => {
 446             visit_bounds(bounds, vis);
 447         }
 448     }
 449     vis.visit_span(span);
 450 }
 451
 452 pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
 453     let Ty { id, kind, span } = ty.deref_mut();
 454     vis.visit_id(id);
 455     match kind {
 456         TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err | TyKind::Never | TyKind::CVarArgs => {}
 457         TyKind::Slice(ty) => vis.visit_ty(ty),
 458         TyKind::Ptr(mt) => vis.visit_mt(mt),
 459         TyKind::Rptr(lt, mt) => {
 460             visit_opt(lt, |lt| noop_visit_lifetime(lt, vis));
 461             vis.visit_mt(mt);
 462         }
 463         TyKind::BareFn(bft) => {
 464             let BareFnTy { unsafety: _, ext: _, generic_params, decl } = bft.deref_mut();
 465             generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
 466             vis.visit_fn_decl(decl);
 467         }
 468         TyKind::Tup(tys) => visit_vec(tys, |ty| vis.visit_ty(ty)),
 469         TyKind::Paren(ty) => vis.visit_ty(ty),
 470         TyKind::Path(qself, path) => {
 471             vis.visit_qself(qself);
 472             vis.visit_path(path);
 473         }
 474         TyKind::Array(ty, length) => {
 475             vis.visit_ty(ty);
 476             vis.visit_anon_const(length);
 477         }
 478         TyKind::Typeof(expr) => vis.visit_anon_const(expr),
 479         TyKind::TraitObject(bounds, _syntax) => {
 480             visit_vec(bounds, |bound| vis.visit_param_bound(bound))
 481         }
 482         TyKind::ImplTrait(id, bounds) => {
 483             vis.visit_id(id);
 484             visit_vec(bounds, |bound| vis.visit_param_bound(bound));
 485         }
 486         TyKind::MacCall(mac) => vis.visit_mac(mac),
 487     }
 488     vis.visit_span(span);
 489 }
 490
 491 pub fn noop_visit_foreign_mod<T: MutVisitor>(foreign_mod: &mut ForeignMod, vis: &mut T) {
 492     let ForeignMod { abi: _, items } = foreign_mod;
 493     items.flat_map_in_place(|item| vis.flat_map_foreign_item(item));
 494 }
 495
 496 pub fn noop_flat_map_variant<T: MutVisitor>(
 497     mut variant: Variant,
 498     visitor: &mut T,
 499 ) -> SmallVec<[Variant; 1]> {
 500     let Variant { ident, vis, attrs, id, data, disr_expr, span, is_placeholder: _ } = &mut variant;
 501     visitor.visit_ident(ident);
 502     visitor.visit_vis(vis);
 503     visit_attrs(attrs, visitor);
 504     visitor.visit_id(id);
 505     visitor.visit_variant_data(data);
 506     visit_opt(disr_expr, |disr_expr| visitor.visit_anon_const(disr_expr));
 507     visitor.visit_span(span);
 508     smallvec![variant]
 509 }
 510
 511 pub fn noop_visit_ident<T: MutVisitor>(Ident { name: _, span }: &mut Ident, vis: &mut T) {
 512     vis.visit_span(span);
 513 }
 514
 515 pub fn noop_visit_path<T: MutVisitor>(Path { segments, span }: &mut Path, vis: &mut T) {
 516     vis.visit_span(span);
 517     for PathSegment { ident, id, args } in segments {
 518         vis.visit_ident(ident);
 519         vis.visit_id(id);
 520         visit_opt(args, |args| vis.visit_generic_args(args));
 521     }
 522 }
 523
 524 pub fn noop_visit_qself<T: MutVisitor>(qself: &mut Option<QSelf>, vis: &mut T) {
 525     visit_opt(qself, |QSelf { ty, path_span, position: _ }| {
 526         vis.visit_ty(ty);
 527         vis.visit_span(path_span);
 528     })
 529 }
 530
 531 pub fn noop_visit_generic_args<T: MutVisitor>(generic_args: &mut GenericArgs, vis: &mut T) {
 532     match generic_args {
 533         GenericArgs::AngleBracketed(data) => vis.visit_angle_bracketed_parameter_data(data),
 534         GenericArgs::Parenthesized(data) => vis.visit_parenthesized_parameter_data(data),
 535     }
 536 }
 537
 538 pub fn noop_visit_generic_arg<T: MutVisitor>(arg: &mut GenericArg, vis: &mut T) {
 539     match arg {
 540         GenericArg::Lifetime(lt) => vis.visit_lifetime(lt),
 541         GenericArg::Type(ty) => vis.visit_ty(ty),
 542         GenericArg::Const(ct) => vis.visit_anon_const(ct),
 543     }
 544 }
 545
 546 pub fn noop_visit_angle_bracketed_parameter_data<T: MutVisitor>(
 547     data: &mut AngleBracketedArgs,
 548     vis: &mut T,
 549 ) {
 550     let AngleBracketedArgs { args, span } = data;
 551     visit_vec(args, |arg| match arg {
 552         AngleBracketedArg::Arg(arg) => vis.visit_generic_arg(arg),
 553         AngleBracketedArg::Constraint(constraint) => vis.visit_ty_constraint(constraint),
 554     });
 555     vis.visit_span(span);
 556 }
 557
 558 pub fn noop_visit_parenthesized_parameter_data<T: MutVisitor>(
 559     args: &mut ParenthesizedArgs,
 560     vis: &mut T,
 561 ) {
 562     let ParenthesizedArgs { inputs, output, span } = args;
 563     visit_vec(inputs, |input| vis.visit_ty(input));
 564     noop_visit_fn_ret_ty(output, vis);
 565     vis.visit_span(span);
 566 }
 567
 568 pub fn noop_visit_local<T: MutVisitor>(local: &mut P<Local>, vis: &mut T) {
 569     let Local { id, pat, ty, init, span, attrs } = local.deref_mut();
 570     vis.visit_id(id);
 571     vis.visit_pat(pat);
 572     visit_opt(ty, |ty| vis.visit_ty(ty));
 573     visit_opt(init, |init| vis.visit_expr(init));
 574     vis.visit_span(span);
 575     visit_thin_attrs(attrs, vis);
 576 }
 577
 578 pub fn noop_visit_attribute<T: MutVisitor>(attr: &mut Attribute, vis: &mut T) {
 579     let Attribute { kind, id: _, style: _, span } = attr;
 580     match kind {
 581         AttrKind::Normal(AttrItem { path, args }) => {
 582             vis.visit_path(path);
 583             visit_mac_args(args, vis);
 584         }
 585         AttrKind::DocComment(_) => {}
 586     }
 587     vis.visit_span(span);
 588 }
 589
 590 pub fn noop_visit_mac<T: MutVisitor>(mac: &mut MacCall, vis: &mut T) {
 591     let MacCall { path, args, prior_type_ascription: _ } = mac;
 592     vis.visit_path(path);
 593     visit_mac_args(args, vis);
 594 }
 595
 596 pub fn noop_visit_macro_def<T: MutVisitor>(macro_def: &mut MacroDef, vis: &mut T) {
 597     let MacroDef { body, macro_rules: _ } = macro_def;
 598     visit_mac_args(body, vis);
 599 }
 600
 601 pub fn noop_visit_meta_list_item<T: MutVisitor>(li: &mut NestedMetaItem, vis: &mut T) {
 602     match li {
 603         NestedMetaItem::MetaItem(mi) => vis.visit_meta_item(mi),
 604         NestedMetaItem::Literal(_lit) => {}
 605     }
 606 }
 607
 608 pub fn noop_visit_meta_item<T: MutVisitor>(mi: &mut MetaItem, vis: &mut T) {
 609     let MetaItem { path: _, kind, span } = mi;
 610     match kind {
 611         MetaItemKind::Word => {}
 612         MetaItemKind::List(mis) => visit_vec(mis, |mi| vis.visit_meta_list_item(mi)),
 613         MetaItemKind::NameValue(_s) => {}
 614     }
 615     vis.visit_span(span);
 616 }
 617
 618 pub fn noop_flat_map_param<T: MutVisitor>(mut param: Param, vis: &mut T) -> SmallVec<[Param; 1]> {
 619     let Param { attrs, id, pat, span, ty, is_placeholder: _ } = &mut param;
 620     vis.visit_id(id);
 621     visit_thin_attrs(attrs, vis);
 622     vis.visit_pat(pat);
 623     vis.visit_span(span);
 624     vis.visit_ty(ty);
 625     smallvec![param]
 626 }
 627
 628 pub fn noop_visit_tt<T: MutVisitor>(tt: &mut TokenTree, vis: &mut T) {
 629     match tt {
 630         TokenTree::Token(token) => {
 631             vis.visit_token(token);
 632         }
 633         TokenTree::Delimited(DelimSpan { open, close }, _delim, tts) => {
 634             vis.visit_span(open);
 635             vis.visit_span(close);
 636             vis.visit_tts(tts);
 637         }
 638     }
 639 }
 640
 641 pub fn noop_visit_tts<T: MutVisitor>(TokenStream(tts): &mut TokenStream, vis: &mut T) {
 642     let tts = Lrc::make_mut(tts);
 643     visit_vec(tts, |(tree, _is_joint)| vis.visit_tt(tree));
 644 }
 645
 646 // Applies ident visitor if it's an ident; applies other visits to interpolated nodes.
 647 // In practice the ident part is not actually used by specific visitors right now,
 648 // but there's a test below checking that it works.
 649 pub fn noop_visit_token<T: MutVisitor>(t: &mut Token, vis: &mut T) {
 650     let Token { kind, span } = t;
 651     match kind {
 652         token::Ident(name, _) | token::Lifetime(name) => {
 653             let mut ident = Ident::new(*name, *span);
 654             vis.visit_ident(&mut ident);
 655             *name = ident.name;
 656             *span = ident.span;
 657             return; // Avoid visiting the span for the second time.
 658         }
 659         token::Interpolated(nt) => {
 660             let mut nt = Lrc::make_mut(nt);
 661             vis.visit_interpolated(&mut nt);
 662         }
 663         _ => {}
 664     }
 665     vis.visit_span(span);
 666 }
 667
 668 /// Applies the visitor to elements of interpolated nodes.
 669 //
 670 // N.B., this can occur only when applying a visitor to partially expanded
 671 // code, where parsed pieces have gotten implanted ito *other* macro
 672 // invocations. This is relevant for macro hygiene, but possibly not elsewhere.
 673 //
 674 // One problem here occurs because the types for flat_map_item, flat_map_stmt,
 675 // etc., allow the visitor to return *multiple* items; this is a problem for the
 676 // nodes here, because they insist on having exactly one piece. One solution
 677 // would be to mangle the MutVisitor trait to include one-to-many and
 678 // one-to-one versions of these entry points, but that would probably confuse a
 679 // lot of people and help very few. Instead, I'm just going to put in dynamic
 680 // checks. I think the performance impact of this will be pretty much
 681 // nonexistent. The danger is that someone will apply a `MutVisitor` to a
 682 // partially expanded node, and will be confused by the fact that their
 683 // `flat_map_item` or `flat_map_stmt` isn't getting called on `NtItem` or `NtStmt`
 684 // nodes. Hopefully they'll wind up reading this comment, and doing something
 685 // appropriate.
 686 //
 687 // BTW, design choice: I considered just changing the type of, e.g., `NtItem` to
 688 // contain multiple items, but decided against it when I looked at
 689 // `parse_item_or_view_item` and tried to figure out what I would do with
 690 // multiple items there....
 691 pub fn noop_visit_interpolated<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut T) {
 692     match nt {
 693         token::NtItem(item) => visit_clobber(item, |item| {
 694             // This is probably okay, because the only visitors likely to
 695             // peek inside interpolated nodes will be renamings/markings,
 696             // which map single items to single items.
 697             vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item")
 698         }),
 699         token::NtBlock(block) => vis.visit_block(block),
 700         token::NtStmt(stmt) => visit_clobber(stmt, |stmt| {
 701             // See reasoning above.
 702             vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item")
 703         }),
 704         token::NtPat(pat) => vis.visit_pat(pat),
 705         token::NtExpr(expr) => vis.visit_expr(expr),
 706         token::NtTy(ty) => vis.visit_ty(ty),
 707         token::NtIdent(ident, _is_raw) => vis.visit_ident(ident),
 708         token::NtLifetime(ident) => vis.visit_ident(ident),
 709         token::NtLiteral(expr) => vis.visit_expr(expr),
 710         token::NtMeta(item) => {
 711             let AttrItem { path, args } = item.deref_mut();
 712             vis.visit_path(path);
 713             visit_mac_args(args, vis);
 714         }
 715         token::NtPath(path) => vis.visit_path(path),
 716         token::NtTT(tt) => vis.visit_tt(tt),
 717         token::NtVis(visib) => vis.visit_vis(visib),
 718     }
 719 }
 720
 721 pub fn noop_visit_asyncness<T: MutVisitor>(asyncness: &mut Async, vis: &mut T) {
 722     match asyncness {
 723         Async::Yes { span: _, closure_id, return_impl_trait_id } => {
 724             vis.visit_id(closure_id);
 725             vis.visit_id(return_impl_trait_id);
 726         }
 727         Async::No => {}
 728     }
 729 }
 730
 731 pub fn noop_visit_fn_decl<T: MutVisitor>(decl: &mut P<FnDecl>, vis: &mut T) {
 732     let FnDecl { inputs, output } = decl.deref_mut();
 733     inputs.flat_map_in_place(|param| vis.flat_map_param(param));
 734     noop_visit_fn_ret_ty(output, vis);
 735 }
 736
 737 pub fn noop_visit_fn_ret_ty<T: MutVisitor>(fn_ret_ty: &mut FnRetTy, vis: &mut T) {
 738     match fn_ret_ty {
 739         FnRetTy::Default(span) => vis.visit_span(span),
 740         FnRetTy::Ty(ty) => vis.visit_ty(ty),
 741     }
 742 }
 743
 744 pub fn noop_visit_param_bound<T: MutVisitor>(pb: &mut GenericBound, vis: &mut T) {
 745     match pb {
 746         GenericBound::Trait(ty, _modifier) => vis.visit_poly_trait_ref(ty),
 747         GenericBound::Outlives(lifetime) => noop_visit_lifetime(lifetime, vis),
 748     }
 749 }
 750
 751 pub fn noop_flat_map_generic_param<T: MutVisitor>(
 752     mut param: GenericParam,
 753     vis: &mut T,
 754 ) -> SmallVec<[GenericParam; 1]> {
 755     let GenericParam { id, ident, attrs, bounds, kind, is_placeholder: _ } = &mut param;
 756     vis.visit_id(id);
 757     vis.visit_ident(ident);
 758     visit_thin_attrs(attrs, vis);
 759     visit_vec(bounds, |bound| noop_visit_param_bound(bound, vis));
 760     match kind {
 761         GenericParamKind::Lifetime => {}
 762         GenericParamKind::Type { default } => {
 763             visit_opt(default, |default| vis.visit_ty(default));
 764         }
 765         GenericParamKind::Const { ty, kw_span: _ } => {
 766             vis.visit_ty(ty);
 767         }
 768     }
 769     smallvec![param]
 770 }
 771
 772 pub fn noop_visit_label<T: MutVisitor>(Label { ident }: &mut Label, vis: &mut T) {
 773     vis.visit_ident(ident);
 774 }
 775
 776 fn noop_visit_lifetime<T: MutVisitor>(Lifetime { id, ident }: &mut Lifetime, vis: &mut T) {
 777     vis.visit_id(id);
 778     vis.visit_ident(ident);
 779 }
 780
 781 pub fn noop_visit_generics<T: MutVisitor>(generics: &mut Generics, vis: &mut T) {
 782     let Generics { params, where_clause, span } = generics;
 783     params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
 784     vis.visit_where_clause(where_clause);
 785     vis.visit_span(span);
 786 }
 787
 788 pub fn noop_visit_where_clause<T: MutVisitor>(wc: &mut WhereClause, vis: &mut T) {
 789     let WhereClause { has_where_token: _, predicates, span } = wc;
 790     visit_vec(predicates, |predicate| vis.visit_where_predicate(predicate));
 791     vis.visit_span(span);
 792 }
 793
 794 pub fn noop_visit_where_predicate<T: MutVisitor>(pred: &mut WherePredicate, vis: &mut T) {
 795     match pred {
 796         WherePredicate::BoundPredicate(bp) => {
 797             let WhereBoundPredicate { span, bound_generic_params, bounded_ty, bounds } = bp;
 798             vis.visit_span(span);
 799             bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
 800             vis.visit_ty(bounded_ty);
 801             visit_vec(bounds, |bound| vis.visit_param_bound(bound));
 802         }
 803         WherePredicate::RegionPredicate(rp) => {
 804             let WhereRegionPredicate { span, lifetime, bounds } = rp;
 805             vis.visit_span(span);
 806             noop_visit_lifetime(lifetime, vis);
 807             visit_vec(bounds, |bound| noop_visit_param_bound(bound, vis));
 808         }
 809         WherePredicate::EqPredicate(ep) => {
 810             let WhereEqPredicate { id, span, lhs_ty, rhs_ty } = ep;
 811             vis.visit_id(id);
 812             vis.visit_span(span);
 813             vis.visit_ty(lhs_ty);
 814             vis.visit_ty(rhs_ty);
 815         }
 816     }
 817 }
 818
 819 pub fn noop_visit_variant_data<T: MutVisitor>(vdata: &mut VariantData, vis: &mut T) {
 820     match vdata {
 821         VariantData::Struct(fields, ..) => {
 822             fields.flat_map_in_place(|field| vis.flat_map_struct_field(field));
 823         }
 824         VariantData::Tuple(fields, id) => {
 825             fields.flat_map_in_place(|field| vis.flat_map_struct_field(field));
 826             vis.visit_id(id);
 827         }
 828         VariantData::Unit(id) => vis.visit_id(id),
 829     }
 830 }
 831
 832 pub fn noop_visit_trait_ref<T: MutVisitor>(TraitRef { path, ref_id }: &mut TraitRef, vis: &mut T) {
 833     vis.visit_path(path);
 834     vis.visit_id(ref_id);
 835 }
 836
 837 pub fn noop_visit_poly_trait_ref<T: MutVisitor>(p: &mut PolyTraitRef, vis: &mut T) {
 838     let PolyTraitRef { bound_generic_params, trait_ref, span } = p;
 839     bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
 840     vis.visit_trait_ref(trait_ref);
 841     vis.visit_span(span);
 842 }
 843
 844 pub fn noop_flat_map_struct_field<T: MutVisitor>(
 845     mut sf: StructField,
 846     visitor: &mut T,
 847 ) -> SmallVec<[StructField; 1]> {
 848     let StructField { span, ident, vis, id, ty, attrs, is_placeholder: _ } = &mut sf;
 849     visitor.visit_span(span);
 850     visit_opt(ident, |ident| visitor.visit_ident(ident));
 851     visitor.visit_vis(vis);
 852     visitor.visit_id(id);
 853     visitor.visit_ty(ty);
 854     visit_attrs(attrs, visitor);
 855     smallvec![sf]
 856 }
 857
 858 pub fn noop_flat_map_field<T: MutVisitor>(mut f: Field, vis: &mut T) -> SmallVec<[Field; 1]> {
 859     let Field { ident, expr, span, is_shorthand: _, attrs, id, is_placeholder: _ } = &mut f;
 860     vis.visit_ident(ident);
 861     vis.visit_expr(expr);
 862     vis.visit_id(id);
 863     vis.visit_span(span);
 864     visit_thin_attrs(attrs, vis);
 865     smallvec![f]
 866 }
 867
 868 pub fn noop_visit_mt<T: MutVisitor>(MutTy { ty, mutbl: _ }: &mut MutTy, vis: &mut T) {
 869     vis.visit_ty(ty);
 870 }
 871
 872 pub fn noop_visit_block<T: MutVisitor>(block: &mut P<Block>, vis: &mut T) {
 873     let Block { id, stmts, rules: _, span } = block.deref_mut();
 874     vis.visit_id(id);
 875     stmts.flat_map_in_place(|stmt| vis.flat_map_stmt(stmt));
 876     vis.visit_span(span);
 877 }
 878
 879 pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) {
 880     match kind {
 881         ItemKind::ExternCrate(_orig_name) => {}
 882         ItemKind::Use(use_tree) => vis.visit_use_tree(use_tree),
 883         ItemKind::Static(ty, _, expr) | ItemKind::Const(_, ty, expr) => {
 884             vis.visit_ty(ty);
 885             visit_opt(expr, |expr| vis.visit_expr(expr));
 886         }
 887         ItemKind::Fn(_, sig, generics, body) => {
 888             visit_fn_sig(sig, vis);
 889             vis.visit_generics(generics);
 890             visit_opt(body, |body| vis.visit_block(body));
 891         }
 892         ItemKind::Mod(m) => vis.visit_mod(m),
 893         ItemKind::ForeignMod(nm) => vis.visit_foreign_mod(nm),
 894         ItemKind::GlobalAsm(_ga) => {}
 895         ItemKind::TyAlias(_, generics, bounds, ty) => {
 896             vis.visit_generics(generics);
 897             visit_bounds(bounds, vis);
 898             visit_opt(ty, |ty| vis.visit_ty(ty));
 899         }
 900         ItemKind::Enum(EnumDef { variants }, generics) => {
 901             variants.flat_map_in_place(|variant| vis.flat_map_variant(variant));
 902             vis.visit_generics(generics);
 903         }
 904         ItemKind::Struct(variant_data, generics) | ItemKind::Union(variant_data, generics) => {
 905             vis.visit_variant_data(variant_data);
 906             vis.visit_generics(generics);
 907         }
 908         ItemKind::Impl {
 909             unsafety: _,
 910             polarity: _,
 911             defaultness: _,
 912             constness: _,
 913             generics,
 914             of_trait,
 915             self_ty,
 916             items,
 917         } => {
 918             vis.visit_generics(generics);
 919             visit_opt(of_trait, |trait_ref| vis.visit_trait_ref(trait_ref));
 920             vis.visit_ty(self_ty);
 921             items.flat_map_in_place(|item| vis.flat_map_impl_item(item));
 922         }
 923         ItemKind::Trait(_is_auto, _unsafety, generics, bounds, items) => {
 924             vis.visit_generics(generics);
 925             visit_bounds(bounds, vis);
 926             items.flat_map_in_place(|item| vis.flat_map_trait_item(item));
 927         }
 928         ItemKind::TraitAlias(generics, bounds) => {
 929             vis.visit_generics(generics);
 930             visit_bounds(bounds, vis);
 931         }
 932         ItemKind::MacCall(m) => vis.visit_mac(m),
 933         ItemKind::MacroDef(def) => vis.visit_macro_def(def),
 934     }
 935 }
 936
 937 pub fn noop_flat_map_assoc_item<T: MutVisitor>(
 938     mut item: P<AssocItem>,
 939     visitor: &mut T,
 940 ) -> SmallVec<[P<AssocItem>; 1]> {
 941     let Item { id, ident, vis, attrs, kind, span, tokens: _ } = item.deref_mut();
 942     visitor.visit_id(id);
 943     visitor.visit_ident(ident);
 944     visitor.visit_vis(vis);
 945     visit_attrs(attrs, visitor);
 946     match kind {
 947         AssocItemKind::Const(_, ty, expr) => {
 948             visitor.visit_ty(ty);
 949             visit_opt(expr, |expr| visitor.visit_expr(expr));
 950         }
 951         AssocItemKind::Fn(_, sig, generics, body) => {
 952             visitor.visit_generics(generics);
 953             visit_fn_sig(sig, visitor);
 954             visit_opt(body, |body| visitor.visit_block(body));
 955         }
 956         AssocItemKind::TyAlias(_, generics, bounds, ty) => {
 957             visitor.visit_generics(generics);
 958             visit_bounds(bounds, visitor);
 959             visit_opt(ty, |ty| visitor.visit_ty(ty));
 960         }
 961         AssocItemKind::MacCall(mac) => visitor.visit_mac(mac),
 962     }
 963     visitor.visit_span(span);
 964     smallvec![item]
 965 }
 966
 967 pub fn noop_visit_fn_header<T: MutVisitor>(header: &mut FnHeader, vis: &mut T) {
 968     let FnHeader { unsafety: _, asyncness, constness: _, ext: _ } = header;
 969     vis.visit_asyncness(asyncness);
 970 }
 971
 972 pub fn noop_visit_mod<T: MutVisitor>(Mod { inner, items, inline: _ }: &mut Mod, vis: &mut T) {
 973     vis.visit_span(inner);
 974     items.flat_map_in_place(|item| vis.flat_map_item(item));
 975 }
 976
 977 pub fn noop_visit_crate<T: MutVisitor>(krate: &mut Crate, vis: &mut T) {
 978     visit_clobber(krate, |Crate { module, attrs, span, proc_macros }| {
 979         let item = P(Item {
 980             ident: Ident::invalid(),
 981             attrs,
 982             id: DUMMY_NODE_ID,
 983             vis: respan(span.shrink_to_lo(), VisibilityKind::Public),
 984             span,
 985             kind: ItemKind::Mod(module),
 986             tokens: None,
 987         });
 988         let items = vis.flat_map_item(item);
 989
 990         let len = items.len();
 991         if len == 0 {
 992             let module = Mod { inner: span, items: vec![], inline: true };
 993             Crate { module, attrs: vec![], span, proc_macros }
 994         } else if len == 1 {
 995             let Item { attrs, span, kind, .. } = items.into_iter().next().unwrap().into_inner();
 996             match kind {
 997                 ItemKind::Mod(module) => Crate { module, attrs, span, proc_macros },
 998                 _ => panic!("visitor converted a module to not a module"),
 999             }
1000         } else {
1001             panic!("a crate cannot expand to more than one item");
1002         }
1003     });
1004 }
1005
1006 // Mutates one item into possibly many items.
1007 pub fn noop_flat_map_item<T: MutVisitor>(
1008     mut item: P<Item>,
1009     visitor: &mut T,
1010 ) -> SmallVec<[P<Item>; 1]> {
1011     let Item { ident, attrs, id, kind, vis, span, tokens: _ } = item.deref_mut();
1012     visitor.visit_ident(ident);
1013     visit_attrs(attrs, visitor);
1014     visitor.visit_id(id);
1015     visitor.visit_item_kind(kind);
1016     visitor.visit_vis(vis);
1017     visitor.visit_span(span);
1018
1019     // FIXME: if `tokens` is modified with a call to `vis.visit_tts` it causes
1020     //        an ICE during resolve... odd!
1021
1022     smallvec![item]
1023 }
1024
1025 pub fn noop_flat_map_foreign_item<T: MutVisitor>(
1026     mut item: P<ForeignItem>,
1027     visitor: &mut T,
1028 ) -> SmallVec<[P<ForeignItem>; 1]> {
1029     let Item { ident, attrs, id, kind, vis, span, tokens: _ } = item.deref_mut();
1030     visitor.visit_id(id);
1031     visitor.visit_ident(ident);
1032     visitor.visit_vis(vis);
1033     visit_attrs(attrs, visitor);
1034     match kind {
1035         ForeignItemKind::Static(ty, _, expr) => {
1036             visitor.visit_ty(ty);
1037             visit_opt(expr, |expr| visitor.visit_expr(expr));
1038         }
1039         ForeignItemKind::Fn(_, sig, generics, body) => {
1040             visitor.visit_generics(generics);
1041             visit_fn_sig(sig, visitor);
1042             visit_opt(body, |body| visitor.visit_block(body));
1043         }
1044         ForeignItemKind::TyAlias(_, generics, bounds, ty) => {
1045             visitor.visit_generics(generics);
1046             visit_bounds(bounds, visitor);
1047             visit_opt(ty, |ty| visitor.visit_ty(ty));
1048         }
1049         ForeignItemKind::MacCall(mac) => visitor.visit_mac(mac),
1050     }
1051     visitor.visit_span(span);
1052     smallvec![item]
1053 }
1054
1055 pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
1056     let Pat { id, kind, span } = pat.deref_mut();
1057     vis.visit_id(id);
1058     match kind {
1059         PatKind::Wild | PatKind::Rest => {}
1060         PatKind::Ident(_binding_mode, ident, sub) => {
1061             vis.visit_ident(ident);
1062             visit_opt(sub, |sub| vis.visit_pat(sub));
1063         }
1064         PatKind::Lit(e) => vis.visit_expr(e),
1065         PatKind::TupleStruct(path, elems) => {
1066             vis.visit_path(path);
1067             visit_vec(elems, |elem| vis.visit_pat(elem));
1068         }
1069         PatKind::Path(qself, path) => {
1070             vis.visit_qself(qself);
1071             vis.visit_path(path);
1072         }
1073         PatKind::Struct(path, fields, _etc) => {
1074             vis.visit_path(path);
1075             fields.flat_map_in_place(|field| vis.flat_map_field_pattern(field));
1076         }
1077         PatKind::Box(inner) => vis.visit_pat(inner),
1078         PatKind::Ref(inner, _mutbl) => vis.visit_pat(inner),
1079         PatKind::Range(e1, e2, Spanned { span: _, node: _ }) => {
1080             visit_opt(e1, |e| vis.visit_expr(e));
1081             visit_opt(e2, |e| vis.visit_expr(e));
1082             vis.visit_span(span);
1083         }
1084         PatKind::Tuple(elems) | PatKind::Slice(elems) | PatKind::Or(elems) => {
1085             visit_vec(elems, |elem| vis.visit_pat(elem))
1086         }
1087         PatKind::Paren(inner) => vis.visit_pat(inner),
1088         PatKind::MacCall(mac) => vis.visit_mac(mac),
1089     }
1090     vis.visit_span(span);
1091 }
1092
1093 pub fn noop_visit_anon_const<T: MutVisitor>(AnonConst { id, value }: &mut AnonConst, vis: &mut T) {
1094     vis.visit_id(id);
1095     vis.visit_expr(value);
1096 }
1097
1098 pub fn noop_visit_expr<T: MutVisitor>(
1099     Expr { kind, id, span, attrs, tokens: _ }: &mut Expr,
1100     vis: &mut T,
1101 ) {
1102     match kind {
1103         ExprKind::Box(expr) => vis.visit_expr(expr),
1104         ExprKind::Array(exprs) => visit_exprs(exprs, vis),
1105         ExprKind::Repeat(expr, count) => {
1106             vis.visit_expr(expr);
1107             vis.visit_anon_const(count);
1108         }
1109         ExprKind::Tup(exprs) => visit_exprs(exprs, vis),
1110         ExprKind::Call(f, args) => {
1111             vis.visit_expr(f);
1112             visit_exprs(args, vis);
1113         }
1114         ExprKind::MethodCall(PathSegment { ident, id, args }, exprs, span) => {
1115             vis.visit_ident(ident);
1116             vis.visit_id(id);
1117             visit_opt(args, |args| vis.visit_generic_args(args));
1118             visit_exprs(exprs, vis);
1119             vis.visit_span(span);
1120         }
1121         ExprKind::Binary(_binop, lhs, rhs) => {
1122             vis.visit_expr(lhs);
1123             vis.visit_expr(rhs);
1124         }
1125         ExprKind::Unary(_unop, ohs) => vis.visit_expr(ohs),
1126         ExprKind::Cast(expr, ty) => {
1127             vis.visit_expr(expr);
1128             vis.visit_ty(ty);
1129         }
1130         ExprKind::Type(expr, ty) => {
1131             vis.visit_expr(expr);
1132             vis.visit_ty(ty);
1133         }
1134         ExprKind::AddrOf(_, _, ohs) => vis.visit_expr(ohs),
1135         ExprKind::Let(pat, scrutinee) => {
1136             vis.visit_pat(pat);
1137             vis.visit_expr(scrutinee);
1138         }
1139         ExprKind::If(cond, tr, fl) => {
1140             vis.visit_expr(cond);
1141             vis.visit_block(tr);
1142             visit_opt(fl, |fl| vis.visit_expr(fl));
1143         }
1144         ExprKind::While(cond, body, label) => {
1145             vis.visit_expr(cond);
1146             vis.visit_block(body);
1147             visit_opt(label, |label| vis.visit_label(label));
1148         }
1149         ExprKind::ForLoop(pat, iter, body, label) => {
1150             vis.visit_pat(pat);
1151             vis.visit_expr(iter);
1152             vis.visit_block(body);
1153             visit_opt(label, |label| vis.visit_label(label));
1154         }
1155         ExprKind::Loop(body, label) => {
1156             vis.visit_block(body);
1157             visit_opt(label, |label| vis.visit_label(label));
1158         }
1159         ExprKind::Match(expr, arms) => {
1160             vis.visit_expr(expr);
1161             arms.flat_map_in_place(|arm| vis.flat_map_arm(arm));
1162         }
1163         ExprKind::Closure(_capture_by, asyncness, _movability, decl, body, span) => {
1164             vis.visit_asyncness(asyncness);
1165             vis.visit_fn_decl(decl);
1166             vis.visit_expr(body);
1167             vis.visit_span(span);
1168         }
1169         ExprKind::Block(blk, label) => {
1170             vis.visit_block(blk);
1171             visit_opt(label, |label| vis.visit_label(label));
1172         }
1173         ExprKind::Async(_capture_by, node_id, body) => {
1174             vis.visit_id(node_id);
1175             vis.visit_block(body);
1176         }
1177         ExprKind::Await(expr) => vis.visit_expr(expr),
1178         ExprKind::Assign(el, er, _) => {
1179             vis.visit_expr(el);
1180             vis.visit_expr(er);
1181         }
1182         ExprKind::AssignOp(_op, el, er) => {
1183             vis.visit_expr(el);
1184             vis.visit_expr(er);
1185         }
1186         ExprKind::Field(el, ident) => {
1187             vis.visit_expr(el);
1188             vis.visit_ident(ident);
1189         }
1190         ExprKind::Index(el, er) => {
1191             vis.visit_expr(el);
1192             vis.visit_expr(er);
1193         }
1194         ExprKind::Range(e1, e2, _lim) => {
1195             visit_opt(e1, |e1| vis.visit_expr(e1));
1196             visit_opt(e2, |e2| vis.visit_expr(e2));
1197         }
1198         ExprKind::Path(qself, path) => {
1199             vis.visit_qself(qself);
1200             vis.visit_path(path);
1201         }
1202         ExprKind::Break(label, expr) => {
1203             visit_opt(label, |label| vis.visit_label(label));
1204             visit_opt(expr, |expr| vis.visit_expr(expr));
1205         }
1206         ExprKind::Continue(label) => {
1207             visit_opt(label, |label| vis.visit_label(label));
1208         }
1209         ExprKind::Ret(expr) => {
1210             visit_opt(expr, |expr| vis.visit_expr(expr));
1211         }
1212         ExprKind::InlineAsm(asm) => {
1213             for (op, _) in &mut asm.operands {
1214                 match op {
1215                     InlineAsmOperand::In { expr, .. }
1216                     | InlineAsmOperand::InOut { expr, .. }
1217                     | InlineAsmOperand::Const { expr, .. }
1218                     | InlineAsmOperand::Sym { expr, .. } => vis.visit_expr(expr),
1219                     InlineAsmOperand::Out { expr, .. } => {
1220                         if let Some(expr) = expr {
1221                             vis.visit_expr(expr);
1222                         }
1223                     }
1224                     InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
1225                         vis.visit_expr(in_expr);
1226                         if let Some(out_expr) = out_expr {
1227                             vis.visit_expr(out_expr);
1228                         }
1229                     }
1230                 }
1231             }
1232         }
1233         ExprKind::LlvmInlineAsm(asm) => {
1234             let LlvmInlineAsm {
1235                 asm: _,
1236                 asm_str_style: _,
1237                 outputs,
1238                 inputs,
1239                 clobbers: _,
1240                 volatile: _,
1241                 alignstack: _,
1242                 dialect: _,
1243             } = asm.deref_mut();
1244             for out in outputs {
1245                 let LlvmInlineAsmOutput { constraint: _, expr, is_rw: _, is_indirect: _ } = out;
1246                 vis.visit_expr(expr);
1247             }
1248             visit_vec(inputs, |(_c, expr)| vis.visit_expr(expr));
1249         }
1250         ExprKind::MacCall(mac) => vis.visit_mac(mac),
1251         ExprKind::Struct(path, fields, expr) => {
1252             vis.visit_path(path);
1253             fields.flat_map_in_place(|field| vis.flat_map_field(field));
1254             visit_opt(expr, |expr| vis.visit_expr(expr));
1255         }
1256         ExprKind::Paren(expr) => {
1257             vis.visit_expr(expr);
1258
1259             // Nodes that are equal modulo `Paren` sugar no-ops should have the same IDs.
1260             *id = expr.id;
1261             vis.visit_span(span);
1262             visit_thin_attrs(attrs, vis);
1263             return;
1264         }
1265         ExprKind::Yield(expr) => {
1266             visit_opt(expr, |expr| vis.visit_expr(expr));
1267         }
1268         ExprKind::Try(expr) => vis.visit_expr(expr),
1269         ExprKind::TryBlock(body) => vis.visit_block(body),
1270         ExprKind::Lit(_) | ExprKind::Err => {}
1271     }
1272     vis.visit_id(id);
1273     vis.visit_span(span);
1274     visit_thin_attrs(attrs, vis);
1275 }
1276
1277 pub fn noop_filter_map_expr<T: MutVisitor>(mut e: P<Expr>, vis: &mut T) -> Option<P<Expr>> {
1278     Some({
1279         vis.visit_expr(&mut e);
1280         e
1281     })
1282 }
1283
1284 pub fn noop_flat_map_stmt<T: MutVisitor>(
1285     Stmt { kind, mut span, mut id }: Stmt,
1286     vis: &mut T,
1287 ) -> SmallVec<[Stmt; 1]> {
1288     vis.visit_id(&mut id);
1289     vis.visit_span(&mut span);
1290     noop_flat_map_stmt_kind(kind, vis).into_iter().map(|kind| Stmt { id, kind, span }).collect()
1291 }
1292
1293 pub fn noop_flat_map_stmt_kind<T: MutVisitor>(
1294     kind: StmtKind,
1295     vis: &mut T,
1296 ) -> SmallVec<[StmtKind; 1]> {
1297     match kind {
1298         StmtKind::Local(mut local) => smallvec![StmtKind::Local({
1299             vis.visit_local(&mut local);
1300             local
1301         })],
1302         StmtKind::Item(item) => vis.flat_map_item(item).into_iter().map(StmtKind::Item).collect(),
1303         StmtKind::Expr(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Expr).collect(),
1304         StmtKind::Semi(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect(),
1305         StmtKind::Empty => smallvec![StmtKind::Empty],
1306         StmtKind::MacCall(mut mac) => {
1307             let (mac_, _semi, attrs) = mac.deref_mut();
1308             vis.visit_mac(mac_);
1309             visit_thin_attrs(attrs, vis);
1310             smallvec![StmtKind::MacCall(mac)]
1311         }
1312     }
1313 }
1314
1315 pub fn noop_visit_vis<T: MutVisitor>(Spanned { node, span }: &mut Visibility, vis: &mut T) {
1316     match node {
1317         VisibilityKind::Public | VisibilityKind::Crate(_) | VisibilityKind::Inherited => {}
1318         VisibilityKind::Restricted { path, id } => {
1319             vis.visit_path(path);
1320             vis.visit_id(id);
1321         }
1322     }
1323     vis.visit_span(span);
1324 }