Rename all flat_map methods to visit methods for consistency with immutable visiting

Author: oli-obk

compiler/rustc_ast/src/mut_visit.rs

@@ -55,7 +55,7 @@ pub trait MutVisitor: Sized {
     // Methods in this trait have one of three forms:
     //
     //   fn visit_t(&mut self, t: &mut T);                      // common
-    //   fn flat_map_t(&mut self, t: T) -> SmallVec<[T; 1]>;    // rare
+    //   fn visit_t(&mut self, t: T) -> SmallVec<[T; 1]>;    // rare
     //   fn filter_map_t(&mut self, t: T) -> Option<T>;         // rarest
     //
     // Any additions to this trait should happen in form of a call to a public
@@ -101,23 +101,23 @@ pub trait MutVisitor: Sized {
         walk_use_tree(self, use_tree);
     }
 
-    fn flat_map_foreign_item(&mut self, ni: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> {
+    fn visit_foreign_item(&mut self, ni: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> {
         walk_item(self, ni, None)
     }
 
-    fn flat_map_item(&mut self, i: P<Item>) -> SmallVec<[P<Item>; 1]> {
+    fn visit_item(&mut self, i: P<Item>) -> SmallVec<[P<Item>; 1]> {
         walk_item(self, i, None)
     }
 
     fn visit_fn_header(&mut self, header: &mut FnHeader) {
         walk_fn_header(self, header);
     }
 
-    fn flat_map_field_def(&mut self, fd: FieldDef) -> SmallVec<[FieldDef; 1]> {
+    fn visit_field_def(&mut self, fd: FieldDef) -> SmallVec<[FieldDef; 1]> {
         walk_field_def(self, fd)
     }
 
-    fn flat_map_assoc_item(
+    fn visit_assoc_item(
         &mut self,
         i: P<AssocItem>,
         ctxt: AssocCtxt,
@@ -146,11 +146,11 @@ pub trait MutVisitor: Sized {
         walk_block(self, b);
     }
 
-    fn flat_map_stmt(&mut self, s: Stmt) -> SmallVec<[Stmt; 1]> {
+    fn visit_stmt(&mut self, s: Stmt) -> SmallVec<[Stmt; 1]> {
         walk_stmt(self, s)
     }
 
-    fn flat_map_arm(&mut self, arm: Arm) -> SmallVec<[Arm; 1]> {
+    fn visit_arm(&mut self, arm: Arm) -> SmallVec<[Arm; 1]> {
         walk_arm(self, arm)
     }
 
@@ -196,7 +196,7 @@ pub trait MutVisitor: Sized {
         walk_foreign_mod(self, nm);
     }
 
-    fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> {
+    fn visit_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> {
         walk_variant(self, v)
     }
 
@@ -208,7 +208,7 @@ pub trait MutVisitor: Sized {
         walk_path(self, p);
     }
 
-    fn flat_map_path_segment(&mut self, p: PathSegment) -> SmallVec<[PathSegment; 1]> {
+    fn visit_path_segment(&mut self, p: PathSegment) -> SmallVec<[PathSegment; 1]> {
         walk_path_segment(p, self)
     }
 
@@ -248,7 +248,7 @@ pub trait MutVisitor: Sized {
         walk_attribute(self, at);
     }
 
-    fn flat_map_param(&mut self, param: Param) -> SmallVec<[Param; 1]> {
+    fn visit_param(&mut self, param: Param) -> SmallVec<[Param; 1]> {
         walk_param(self, param)
     }
 
@@ -268,7 +268,7 @@ pub trait MutVisitor: Sized {
         walk_variant_data(self, vdata);
     }
 
-    fn flat_map_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> {
+    fn visit_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> {
         walk_generic_param(self, param)
     }
 
@@ -284,7 +284,7 @@ pub trait MutVisitor: Sized {
         walk_mt(self, mt);
     }
 
-    fn flat_map_expr_field(&mut self, f: ExprField) -> SmallVec<[ExprField; 1]> {
+    fn visit_expr_field(&mut self, f: ExprField) -> SmallVec<[ExprField; 1]> {
         walk_expr_field(self, f)
     }
 
@@ -308,7 +308,7 @@ pub trait MutVisitor: Sized {
         // Do nothing.
     }
 
-    fn flat_map_pat_field(&mut self, fp: PatField) -> SmallVec<[PatField; 1]> {
+    fn visit_pat_field(&mut self, fp: PatField) -> SmallVec<[PatField; 1]> {
         walk_pat_field(self, fp)
     }
 
@@ -506,7 +506,7 @@ pub fn walk_ty<T: MutVisitor>(vis: &mut T, ty: &mut P<Ty>) {
         TyKind::BareFn(bft) => {
             let BareFnTy { safety, ext: _, generic_params, decl, decl_span } = bft.deref_mut();
             visit_safety(vis, safety);
-            generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
+            generic_params.flat_map_in_place(|param| vis.visit_generic_param(param));
             vis.visit_fn_decl(decl);
             vis.visit_span(decl_span);
         }
@@ -535,7 +535,7 @@ pub fn walk_ty<T: MutVisitor>(vis: &mut T, ty: &mut P<Ty>) {
         TyKind::MacCall(mac) => vis.visit_mac_call(mac),
         TyKind::AnonStruct(id, fields) | TyKind::AnonUnion(id, fields) => {
             vis.visit_id(id);
-            fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
+            fields.flat_map_in_place(|field| vis.visit_field_def(field));
         }
     }
     visit_lazy_tts(vis, tokens);
@@ -545,7 +545,7 @@ pub fn walk_ty<T: MutVisitor>(vis: &mut T, ty: &mut P<Ty>) {
 fn walk_foreign_mod<T: MutVisitor>(vis: &mut T, foreign_mod: &mut ForeignMod) {
     let ForeignMod { safety, abi: _, items } = foreign_mod;
     visit_safety(vis, safety);
-    items.flat_map_in_place(|item| vis.flat_map_foreign_item(item));
+    items.flat_map_in_place(|item| vis.visit_foreign_item(item));
 }
 
 pub fn walk_variant<T: MutVisitor>(
@@ -579,7 +579,7 @@ fn walk_path_segment<T: MutVisitor>(
 }
 
 fn walk_path<T: MutVisitor>(vis: &mut T, Path { segments, span, tokens }: &mut Path) {
-    segments.flat_map_in_place(|segment| vis.flat_map_path_segment(segment));
+    segments.flat_map_in_place(|segment| vis.visit_path_segment(segment));
     visit_lazy_tts(vis, tokens);
     vis.visit_span(span);
 }
@@ -820,13 +820,13 @@ fn visit_nonterminal<T: MutVisitor>(vis: &mut T, nt: &mut token::Nonterminal) {
             // This is probably okay, because the only visitors likely to
             // peek inside interpolated nodes will be renamings/markings,
             // which map single items to single items.
-            vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item")
+            vis.visit_item(item).expect_one("expected visitor to produce exactly one item")
         }),
         token::NtBlock(block) => vis.visit_block(block),
         token::NtStmt(stmt) => visit_clobber(stmt, |stmt| {
             // See reasoning above.
             stmt.map(|stmt| {
-                vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item")
+                vis.visit_stmt(stmt).expect_one("expected visitor to produce exactly one item")
             })
         }),
         token::NtPat(pat) => vis.visit_pat(pat),
@@ -881,7 +881,7 @@ fn walk_closure_binder<T: MutVisitor>(vis: &mut T, binder: &mut ClosureBinder) {
     match binder {
         ClosureBinder::NotPresent => {}
         ClosureBinder::For { span: _, generic_params } => {
-            generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
+            generic_params.flat_map_in_place(|param| vis.visit_generic_param(param));
         }
     }
 }
@@ -920,7 +920,7 @@ fn walk_fn<T: MutVisitor>(vis: &mut T, kind: FnKind<'_>) {
 
 fn walk_fn_decl<T: MutVisitor>(vis: &mut T, decl: &mut P<FnDecl>) {
     let FnDecl { inputs, output } = decl.deref_mut();
-    inputs.flat_map_in_place(|param| vis.flat_map_param(param));
+    inputs.flat_map_in_place(|param| vis.visit_param(param));
     walk_fn_ret_ty(vis, output);
 }
 
@@ -992,7 +992,7 @@ fn walk_lifetime<T: MutVisitor>(vis: &mut T, Lifetime { id, ident }: &mut Lifeti
 
 fn walk_generics<T: MutVisitor>(vis: &mut T, generics: &mut Generics) {
     let Generics { params, where_clause, span } = generics;
-    params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
+    params.flat_map_in_place(|param| vis.visit_generic_param(param));
     vis.visit_where_clause(where_clause);
     vis.visit_span(span);
 }
@@ -1015,7 +1015,7 @@ fn walk_where_predicate<T: MutVisitor>(vis: &mut T, pred: &mut WherePredicate) {
     match pred {
         WherePredicate::BoundPredicate(bp) => {
             let WhereBoundPredicate { span, bound_generic_params, bounded_ty, bounds } = bp;
-            bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
+            bound_generic_params.flat_map_in_place(|param| vis.visit_generic_param(param));
             vis.visit_ty(bounded_ty);
             visit_vec(bounds, |bound| vis.visit_param_bound(bound, BoundKind::Bound));
             vis.visit_span(span);
@@ -1038,11 +1038,11 @@ fn walk_where_predicate<T: MutVisitor>(vis: &mut T, pred: &mut WherePredicate) {
 fn walk_variant_data<T: MutVisitor>(vis: &mut T, vdata: &mut VariantData) {
     match vdata {
         VariantData::Struct { fields, recovered: _ } => {
-            fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
+            fields.flat_map_in_place(|field| vis.visit_field_def(field));
         }
         VariantData::Tuple(fields, id) => {
             vis.visit_id(id);
-            fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
+            fields.flat_map_in_place(|field| vis.visit_field_def(field));
         }
         VariantData::Unit(id) => vis.visit_id(id),
     }
@@ -1055,7 +1055,7 @@ fn walk_trait_ref<T: MutVisitor>(vis: &mut T, TraitRef { path, ref_id }: &mut Tr
 
 fn walk_poly_trait_ref<T: MutVisitor>(vis: &mut T, p: &mut PolyTraitRef) {
     let PolyTraitRef { bound_generic_params, trait_ref, span } = p;
-    bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
+    bound_generic_params.flat_map_in_place(|param| vis.visit_generic_param(param));
     vis.visit_trait_ref(trait_ref);
     vis.visit_span(span);
 }
@@ -1088,7 +1088,7 @@ fn walk_mt<T: MutVisitor>(vis: &mut T, MutTy { ty, mutbl: _ }: &mut MutTy) {
 pub fn walk_block<T: MutVisitor>(vis: &mut T, block: &mut P<Block>) {
     let Block { id, stmts, rules: _, span, tokens, could_be_bare_literal: _ } = block.deref_mut();
     vis.visit_id(id);
-    stmts.flat_map_in_place(|stmt| vis.flat_map_stmt(stmt));
+    stmts.flat_map_in_place(|stmt| vis.visit_stmt(stmt));
     visit_lazy_tts(vis, tokens);
     vis.visit_span(span);
 }
@@ -1131,7 +1131,7 @@ impl NoopVisitItemKind for ItemKind {
                 visit_safety(vis, safety);
                 match mod_kind {
                     ModKind::Loaded(items, _inline, ModSpans { inner_span, inject_use_span }) => {
-                        items.flat_map_in_place(|item| vis.flat_map_item(item));
+                        items.flat_map_in_place(|item| vis.visit_item(item));
                         vis.visit_span(inner_span);
                         vis.visit_span(inject_use_span);
                     }
@@ -1149,7 +1149,7 @@ impl NoopVisitItemKind for ItemKind {
             }
             ItemKind::Enum(EnumDef { variants }, generics) => {
                 vis.visit_generics(generics);
-                variants.flat_map_in_place(|variant| vis.flat_map_variant(variant));
+                variants.flat_map_in_place(|variant| vis.visit_variant(variant));
             }
             ItemKind::Struct(variant_data, generics) | ItemKind::Union(variant_data, generics) => {
                 vis.visit_generics(generics);
@@ -1172,13 +1172,13 @@ impl NoopVisitItemKind for ItemKind {
                 visit_polarity(vis, polarity);
                 visit_opt(of_trait, |trait_ref| vis.visit_trait_ref(trait_ref));
                 vis.visit_ty(self_ty);
-                items.flat_map_in_place(|item| vis.flat_map_assoc_item(item, AssocCtxt::Impl));
+                items.flat_map_in_place(|item| vis.visit_assoc_item(item, AssocCtxt::Impl));
             }
             ItemKind::Trait(box Trait { safety, is_auto: _, generics, bounds, items }) => {
                 visit_safety(vis, safety);
                 vis.visit_generics(generics);
                 visit_bounds(vis, bounds, BoundKind::Bound);
-                items.flat_map_in_place(|item| vis.flat_map_assoc_item(item, AssocCtxt::Trait));
+                items.flat_map_in_place(|item| vis.visit_assoc_item(item, AssocCtxt::Trait));
             }
             ItemKind::TraitAlias(generics, bounds) => {
                 vis.visit_generics(generics);
@@ -1317,7 +1317,7 @@ pub fn walk_crate<T: MutVisitor>(vis: &mut T, krate: &mut Crate) {
     let Crate { attrs, items, spans, id, is_placeholder: _ } = krate;
     vis.visit_id(id);
     visit_attrs(vis, attrs);
-    items.flat_map_in_place(|item| vis.flat_map_item(item));
+    items.flat_map_in_place(|item| vis.visit_item(item));
     let ModSpans { inner_span, inject_use_span } = spans;
     vis.visit_span(inner_span);
     vis.visit_span(inject_use_span);
@@ -1400,7 +1400,7 @@ pub fn walk_pat<T: MutVisitor>(vis: &mut T, pat: &mut P<Pat>) {
         PatKind::Struct(qself, path, fields, _etc) => {
             vis.visit_qself(qself);
             vis.visit_path(path);
-            fields.flat_map_in_place(|field| vis.flat_map_pat_field(field));
+            fields.flat_map_in_place(|field| vis.visit_pat_field(field));
         }
         PatKind::Box(inner) => vis.visit_pat(inner),
         PatKind::Deref(inner) => vis.visit_pat(inner),
@@ -1551,7 +1551,7 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
         }
         ExprKind::Match(expr, arms, _kind) => {
             vis.visit_expr(expr);
-            arms.flat_map_in_place(|arm| vis.flat_map_arm(arm));
+            arms.flat_map_in_place(|arm| vis.visit_arm(arm));
         }
         ExprKind::Closure(box Closure {
             binder,
@@ -1637,7 +1637,7 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
             let StructExpr { qself, path, fields, rest } = se.deref_mut();
             vis.visit_qself(qself);
             vis.visit_path(path);
-            fields.flat_map_in_place(|field| vis.flat_map_expr_field(field));
+            fields.flat_map_in_place(|field| vis.visit_expr_field(field));
             match rest {
                 StructRest::Base(expr) => vis.visit_expr(expr),
                 StructRest::Rest(_span) => {}
@@ -1691,7 +1691,7 @@ fn walk_stmt_kind<T: MutVisitor>(vis: &mut T, kind: StmtKind) -> SmallVec<[StmtK
             vis.visit_local(&mut local);
             local
         })],
-        StmtKind::Item(item) => vis.flat_map_item(item).into_iter().map(StmtKind::Item).collect(),
+        StmtKind::Item(item) => vis.visit_item(item).into_iter().map(StmtKind::Item).collect(),
         StmtKind::Expr(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Expr).collect(),
         StmtKind::Semi(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect(),
         StmtKind::Empty => smallvec![StmtKind::Empty],