diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
index a90349f318c09..771047841d3b0 100644
--- a/compiler/rustc_ast/src/mut_visit.rs
+++ b/compiler/rustc_ast/src/mut_visit.rs
@@ -48,15 +48,9 @@ pub trait WalkItemKind {
 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 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
-    // `noop_*` function that only calls out to the visitor again, not other
-    // `noop_*` functions. This is a necessary API workaround to the problem of
-    // not being able to call out to the super default method in an overridden
-    // default method.
+    //   fn visit_t(&mut self, t: &mut T);
+    //   fn filter_map_t(&mut self, t: T) -> Option<T>;
+    //   fn flat_map_t(&mut self, t: T) -> SmallVec<[T; 1]>;
     //
     // When writing these methods, it is better to use destructuring like this:
     //
@@ -119,8 +113,8 @@ pub trait MutVisitor: Sized {
         walk_field_def(self, fd);
     }
 
-    fn flat_map_field_def(&mut self, fd: FieldDef) -> SmallVec<[FieldDef; 1]> {
-        walk_flat_map_field_def(self, fd)
+    fn filter_map_field_def(&mut self, fd: FieldDef) -> Option<FieldDef> {
+        walk_filter_map_field_def(self, fd)
     }
 
     fn visit_assoc_item(&mut self, i: &mut P<AssocItem>, ctxt: AssocCtxt) {
@@ -168,8 +162,8 @@ pub trait MutVisitor: Sized {
         walk_arm(self, arm);
     }
 
-    fn flat_map_arm(&mut self, arm: Arm) -> SmallVec<[Arm; 1]> {
-        walk_flat_map_arm(self, arm)
+    fn filter_map_arm(&mut self, arm: Arm) -> Option<Arm> {
+        walk_filter_map_arm(self, arm)
     }
 
     fn visit_pat(&mut self, p: &mut P<Pat>) {
@@ -191,7 +185,7 @@ pub trait MutVisitor: Sized {
     }
 
     fn filter_map_expr(&mut self, e: P<Expr>) -> Option<P<Expr>> {
-        noop_filter_map_expr(self, e)
+        walk_filter_map_expr(self, e)
     }
 
     fn visit_generic_arg(&mut self, arg: &mut GenericArg) {
@@ -222,8 +216,8 @@ pub trait MutVisitor: Sized {
         walk_variant(self, v);
     }
 
-    fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> {
-        walk_flat_map_variant(self, v)
+    fn filter_map_variant(&mut self, v: Variant) -> Option<Variant> {
+        walk_filter_map_variant(self, v)
     }
 
     fn visit_ident(&mut self, i: &mut Ident) {
@@ -282,8 +276,8 @@ pub trait MutVisitor: Sized {
         walk_param(self, param);
     }
 
-    fn flat_map_param(&mut self, param: Param) -> SmallVec<[Param; 1]> {
-        walk_flat_map_param(self, param)
+    fn filter_map_param(&mut self, param: Param) -> Option<Param> {
+        walk_filter_map_param(self, param)
     }
 
     fn visit_generics(&mut self, generics: &mut Generics) {
@@ -306,8 +300,8 @@ pub trait MutVisitor: Sized {
         walk_generic_param(self, param)
     }
 
-    fn flat_map_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> {
-        walk_flat_map_generic_param(self, param)
+    fn filter_map_generic_param(&mut self, param: GenericParam) -> Option<GenericParam> {
+        walk_filter_map_generic_param(self, param)
     }
 
     fn visit_param_bound(&mut self, tpb: &mut GenericBound, _ctxt: BoundKind) {
@@ -326,19 +320,19 @@ pub trait MutVisitor: Sized {
         walk_expr_field(self, f);
     }
 
-    fn flat_map_expr_field(&mut self, f: ExprField) -> SmallVec<[ExprField; 1]> {
-        walk_flat_map_expr_field(self, f)
+    fn filter_map_expr_field(&mut self, f: ExprField) -> Option<ExprField> {
+        walk_filter_map_expr_field(self, f)
     }
 
     fn visit_where_clause(&mut self, where_clause: &mut WhereClause) {
         walk_where_clause(self, where_clause);
     }
 
-    fn flat_map_where_predicate(
+    fn filter_map_where_predicate(
         &mut self,
         where_predicate: WherePredicate,
-    ) -> SmallVec<[WherePredicate; 1]> {
-        walk_flat_map_where_predicate(self, where_predicate)
+    ) -> Option<WherePredicate> {
+        walk_filter_map_where_predicate(self, where_predicate)
     }
 
     fn visit_where_predicate_kind(&mut self, kind: &mut WherePredicateKind) {
@@ -363,8 +357,8 @@ pub trait MutVisitor: Sized {
         walk_pat_field(self, fp)
     }
 
-    fn flat_map_pat_field(&mut self, fp: PatField) -> SmallVec<[PatField; 1]> {
-        walk_flat_map_pat_field(self, fp)
+    fn filter_map_pat_field(&mut self, fp: PatField) -> Option<PatField> {
+        walk_filter_map_pat_field(self, fp)
     }
 
     fn visit_inline_asm(&mut self, asm: &mut InlineAsm) {
@@ -393,14 +387,16 @@ super::common_visitor_and_walkers!((mut) MutVisitor);
 /// Use a map-style function (`FnOnce(T) -> T`) to overwrite a `&mut T`. Useful
 /// when using a `flat_map_*` or `filter_map_*` method within a `visit_`
 /// method.
-//
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 pub fn visit_clobber<T: DummyAstNode>(t: &mut T, f: impl FnOnce(T) -> T) {
     let old_t = std::mem::replace(t, T::dummy());
     *t = f(old_t);
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
+pub fn visit_clobber_opt<T>(t: &mut Option<T>, f: impl FnOnce(T) -> Option<T>) {
+    let old_t = std::mem::replace(t, None);
+    *t = old_t.and_then(|new_t| f(new_t));
+}
+
 #[inline]
 fn visit_vec<T, F>(elems: &mut Vec<T>, mut visit_elem: F)
 where
@@ -411,7 +407,6 @@ where
     }
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 #[inline]
 fn visit_thin_vec<T, F>(elems: &mut ThinVec<T>, mut visit_elem: F)
 where
@@ -422,7 +417,6 @@ where
     }
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 #[inline]
 fn visit_opt<T, F>(opt: &mut Option<T>, mut visit_elem: F)
 where
@@ -433,30 +427,25 @@ where
     }
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 fn visit_attrs<T: MutVisitor>(vis: &mut T, attrs: &mut AttrVec) {
     for attr in attrs.iter_mut() {
         vis.visit_attribute(attr);
     }
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 #[allow(unused)]
 fn visit_exprs<T: MutVisitor>(vis: &mut T, exprs: &mut Vec<P<Expr>>) {
     exprs.flat_map_in_place(|expr| vis.filter_map_expr(expr))
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 fn visit_thin_exprs<T: MutVisitor>(vis: &mut T, exprs: &mut ThinVec<P<Expr>>) {
     exprs.flat_map_in_place(|expr| vis.filter_map_expr(expr))
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 fn visit_bounds<T: MutVisitor>(vis: &mut T, bounds: &mut GenericBounds, ctxt: BoundKind) {
     visit_vec(bounds, |bound| vis.visit_param_bound(bound, ctxt));
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 fn visit_attr_args<T: MutVisitor>(vis: &mut T, args: &mut AttrArgs) {
     match args {
         AttrArgs::Empty => {}
@@ -468,7 +457,6 @@ fn visit_attr_args<T: MutVisitor>(vis: &mut T, args: &mut AttrArgs) {
     }
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 fn visit_delim_args<T: MutVisitor>(vis: &mut T, args: &mut DelimArgs) {
     let DelimArgs { dspan, delim: _, tokens: _ } = args;
     let DelimSpan { open, close } = dspan;
@@ -485,12 +473,9 @@ pub fn walk_pat_field<T: MutVisitor>(vis: &mut T, fp: &mut PatField) {
     vis.visit_span(span);
 }
 
-pub fn walk_flat_map_pat_field<T: MutVisitor>(
-    vis: &mut T,
-    mut fp: PatField,
-) -> SmallVec<[PatField; 1]> {
+pub fn walk_filter_map_pat_field<T: MutVisitor>(vis: &mut T, mut fp: PatField) -> Option<PatField> {
     vis.visit_pat_field(&mut fp);
-    smallvec![fp]
+    Some(fp)
 }
 
 fn walk_use_tree<T: MutVisitor>(vis: &mut T, use_tree: &mut UseTree) {
@@ -520,9 +505,9 @@ pub fn walk_arm<T: MutVisitor>(vis: &mut T, arm: &mut Arm) {
     vis.visit_span(span);
 }
 
-pub fn walk_flat_map_arm<T: MutVisitor>(vis: &mut T, mut arm: Arm) -> SmallVec<[Arm; 1]> {
+pub fn walk_filter_map_arm<T: MutVisitor>(vis: &mut T, mut arm: Arm) -> Option<Arm> {
     vis.visit_arm(&mut arm);
-    smallvec![arm]
+    Some(arm)
 }
 
 fn walk_assoc_item_constraint<T: MutVisitor>(
@@ -560,13 +545,13 @@ 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.filter_map_generic_param(param));
             vis.visit_fn_decl(decl);
             vis.visit_span(decl_span);
         }
         TyKind::UnsafeBinder(binder) => {
             let UnsafeBinderTy { generic_params, inner_ty } = binder.deref_mut();
-            generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
+            generic_params.flat_map_in_place(|param| vis.filter_map_generic_param(param));
             vis.visit_ty(inner_ty);
         }
         TyKind::Tup(tys) => visit_thin_vec(tys, |ty| vis.visit_ty(ty)),
@@ -627,12 +612,12 @@ pub fn walk_variant<T: MutVisitor>(visitor: &mut T, variant: &mut Variant) {
     visitor.visit_span(span);
 }
 
-pub fn walk_flat_map_variant<T: MutVisitor>(
+pub fn walk_filter_map_variant<T: MutVisitor>(
     vis: &mut T,
     mut variant: Variant,
-) -> SmallVec<[Variant; 1]> {
+) -> Option<Variant> {
     vis.visit_variant(&mut variant);
-    smallvec![variant]
+    Some(variant)
 }
 
 fn walk_ident<T: MutVisitor>(vis: &mut T, Ident { name: _, span }: &mut Ident) {
@@ -766,12 +751,11 @@ pub fn walk_param<T: MutVisitor>(vis: &mut T, param: &mut Param) {
     vis.visit_span(span);
 }
 
-pub fn walk_flat_map_param<T: MutVisitor>(vis: &mut T, mut param: Param) -> SmallVec<[Param; 1]> {
+pub fn walk_filter_map_param<T: MutVisitor>(vis: &mut T, mut param: Param) -> Option<Param> {
     vis.visit_param(&mut param);
-    smallvec![param]
+    Some(param)
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 fn visit_defaultness<T: MutVisitor>(vis: &mut T, defaultness: &mut Defaultness) {
     match defaultness {
         Defaultness::Default(span) => vis.visit_span(span),
@@ -779,7 +763,6 @@ fn visit_defaultness<T: MutVisitor>(vis: &mut T, defaultness: &mut Defaultness)
     }
 }
 
-// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
 fn visit_polarity<T: MutVisitor>(vis: &mut T, polarity: &mut ImplPolarity) {
     match polarity {
         ImplPolarity::Positive => {}
@@ -791,7 +774,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.filter_map_generic_param(param));
         }
     }
 }
@@ -860,7 +843,7 @@ fn walk_contract<T: MutVisitor>(vis: &mut T, contract: &mut P<FnContract>) {
 
 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.filter_map_param(param));
     vis.visit_fn_ret_ty(output);
 }
 
@@ -917,17 +900,17 @@ pub fn walk_generic_param<T: MutVisitor>(vis: &mut T, param: &mut GenericParam)
     }
 }
 
-pub fn walk_flat_map_generic_param<T: MutVisitor>(
+pub fn walk_filter_map_generic_param<T: MutVisitor>(
     vis: &mut T,
     mut param: GenericParam,
-) -> SmallVec<[GenericParam; 1]> {
+) -> Option<GenericParam> {
     vis.visit_generic_param(&mut param);
-    smallvec![param]
+    Some(param)
 }
 
 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.filter_map_generic_param(param));
     vis.visit_where_clause(where_clause);
     vis.visit_span(span);
 }
@@ -942,27 +925,27 @@ fn walk_ty_alias_where_clauses<T: MutVisitor>(vis: &mut T, tawcs: &mut TyAliasWh
 
 fn walk_where_clause<T: MutVisitor>(vis: &mut T, wc: &mut WhereClause) {
     let WhereClause { has_where_token: _, predicates, span } = wc;
-    predicates.flat_map_in_place(|predicate| vis.flat_map_where_predicate(predicate));
+    predicates.flat_map_in_place(|predicate| vis.filter_map_where_predicate(predicate));
     vis.visit_span(span);
 }
 
-pub fn walk_flat_map_where_predicate<T: MutVisitor>(
+pub fn walk_filter_map_where_predicate<T: MutVisitor>(
     vis: &mut T,
     mut pred: WherePredicate,
-) -> SmallVec<[WherePredicate; 1]> {
+) -> Option<WherePredicate> {
     let WherePredicate { attrs, kind, id, span, is_placeholder: _ } = &mut pred;
     vis.visit_id(id);
     visit_attrs(vis, attrs);
     vis.visit_where_predicate_kind(kind);
     vis.visit_span(span);
-    smallvec![pred]
+    Some(pred)
 }
 
 pub fn walk_where_predicate_kind<T: MutVisitor>(vis: &mut T, kind: &mut WherePredicateKind) {
     match kind {
         WherePredicateKind::BoundPredicate(bp) => {
             let WhereBoundPredicate { 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.filter_map_generic_param(param));
             vis.visit_ty(bounded_ty);
             visit_vec(bounds, |bound| vis.visit_param_bound(bound, BoundKind::Bound));
         }
@@ -982,11 +965,11 @@ pub fn walk_where_predicate_kind<T: MutVisitor>(vis: &mut T, kind: &mut WherePre
 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.filter_map_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.filter_map_field_def(field));
         }
         VariantData::Unit(id) => vis.visit_id(id),
     }
@@ -1000,7 +983,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, modifiers, trait_ref, span } = p;
     vis.visit_modifiers(modifiers);
-    bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
+    bound_generic_params.flat_map_in_place(|param| vis.filter_map_generic_param(param));
     vis.visit_trait_ref(trait_ref);
     vis.visit_span(span);
 }
@@ -1033,12 +1016,9 @@ pub fn walk_field_def<T: MutVisitor>(visitor: &mut T, fd: &mut FieldDef) {
     visitor.visit_span(span);
 }
 
-pub fn walk_flat_map_field_def<T: MutVisitor>(
-    vis: &mut T,
-    mut fd: FieldDef,
-) -> SmallVec<[FieldDef; 1]> {
+pub fn walk_filter_map_field_def<T: MutVisitor>(vis: &mut T, mut fd: FieldDef) -> Option<FieldDef> {
     vis.visit_field_def(&mut fd);
-    smallvec![fd]
+    Some(fd)
 }
 
 pub fn walk_expr_field<T: MutVisitor>(vis: &mut T, f: &mut ExprField) {
@@ -1050,12 +1030,12 @@ pub fn walk_expr_field<T: MutVisitor>(vis: &mut T, f: &mut ExprField) {
     vis.visit_span(span);
 }
 
-pub fn walk_flat_map_expr_field<T: MutVisitor>(
+pub fn walk_filter_map_expr_field<T: MutVisitor>(
     vis: &mut T,
     mut f: ExprField,
-) -> SmallVec<[ExprField; 1]> {
+) -> Option<ExprField> {
     vis.visit_expr_field(&mut f);
-    smallvec![f]
+    Some(f)
 }
 
 fn walk_mt<T: MutVisitor>(vis: &mut T, MutTy { ty, mutbl: _ }: &mut MutTy) {
@@ -1149,7 +1129,7 @@ impl WalkItemKind for ItemKind {
             ItemKind::Enum(ident, EnumDef { variants }, generics) => {
                 vis.visit_ident(ident);
                 vis.visit_generics(generics);
-                variants.flat_map_in_place(|variant| vis.flat_map_variant(variant));
+                variants.flat_map_in_place(|variant| vis.filter_map_variant(variant));
             }
             ItemKind::Struct(ident, variant_data, generics)
             | ItemKind::Union(ident, variant_data, generics) => {
@@ -1439,7 +1419,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.filter_map_pat_field(field));
         }
         PatKind::Box(inner) => vis.visit_pat(inner),
         PatKind::Deref(inner) => vis.visit_pat(inner),
@@ -1595,7 +1575,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.filter_map_arm(arm));
         }
         ExprKind::Closure(box Closure {
             binder,
@@ -1684,7 +1664,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.filter_map_expr_field(field));
             match rest {
                 StructRest::Base(expr) => vis.visit_expr(expr),
                 StructRest::Rest(_span) => {}
@@ -1716,11 +1696,9 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
     vis.visit_span(span);
 }
 
-pub fn noop_filter_map_expr<T: MutVisitor>(vis: &mut T, mut e: P<Expr>) -> Option<P<Expr>> {
-    Some({
-        vis.visit_expr(&mut e);
-        e
-    })
+pub fn walk_filter_map_expr<T: MutVisitor>(vis: &mut T, mut e: P<Expr>) -> Option<P<Expr>> {
+    vis.visit_expr(&mut e);
+    Some(e)
 }
 
 pub fn walk_flat_map_stmt<T: MutVisitor>(
diff --git a/compiler/rustc_builtin_macros/src/cfg_eval.rs b/compiler/rustc_builtin_macros/src/cfg_eval.rs
index da01e3e9607bb..8c00c65c97ec8 100644
--- a/compiler/rustc_builtin_macros/src/cfg_eval.rs
+++ b/compiler/rustc_builtin_macros/src/cfg_eval.rs
@@ -172,12 +172,9 @@ impl MutVisitor for CfgEval<'_> {
         Some(expr)
     }
 
-    fn flat_map_generic_param(
-        &mut self,
-        param: ast::GenericParam,
-    ) -> SmallVec<[ast::GenericParam; 1]> {
+    fn filter_map_generic_param(&mut self, param: ast::GenericParam) -> Option<ast::GenericParam> {
         let param = configure!(self, param);
-        mut_visit::walk_flat_map_generic_param(self, param)
+        mut_visit::walk_filter_map_generic_param(self, param)
     }
 
     fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
@@ -207,33 +204,33 @@ impl MutVisitor for CfgEval<'_> {
         mut_visit::walk_flat_map_foreign_item(self, foreign_item)
     }
 
-    fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
+    fn filter_map_arm(&mut self, arm: ast::Arm) -> Option<ast::Arm> {
         let arm = configure!(self, arm);
-        mut_visit::walk_flat_map_arm(self, arm)
+        mut_visit::walk_filter_map_arm(self, arm)
     }
 
-    fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
+    fn filter_map_expr_field(&mut self, field: ast::ExprField) -> Option<ast::ExprField> {
         let field = configure!(self, field);
-        mut_visit::walk_flat_map_expr_field(self, field)
+        mut_visit::walk_filter_map_expr_field(self, field)
     }
 
-    fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
+    fn filter_map_pat_field(&mut self, fp: ast::PatField) -> Option<ast::PatField> {
         let fp = configure!(self, fp);
-        mut_visit::walk_flat_map_pat_field(self, fp)
+        mut_visit::walk_filter_map_pat_field(self, fp)
     }
 
-    fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
+    fn filter_map_param(&mut self, p: ast::Param) -> Option<ast::Param> {
         let p = configure!(self, p);
-        mut_visit::walk_flat_map_param(self, p)
+        mut_visit::walk_filter_map_param(self, p)
     }
 
-    fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
+    fn filter_map_field_def(&mut self, sf: ast::FieldDef) -> Option<ast::FieldDef> {
         let sf = configure!(self, sf);
-        mut_visit::walk_flat_map_field_def(self, sf)
+        mut_visit::walk_filter_map_field_def(self, sf)
     }
 
-    fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
+    fn filter_map_variant(&mut self, variant: ast::Variant) -> Option<ast::Variant> {
         let variant = configure!(self, variant);
-        mut_visit::walk_flat_map_variant(self, variant)
+        mut_visit::walk_filter_map_variant(self, variant)
     }
 }
diff --git a/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs b/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
index 446d8afeedd7f..5f6c15210f56f 100644
--- a/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
@@ -394,7 +394,7 @@ impl<'a> ast::mut_visit::MutVisitor for TypeSubstitution<'a> {
             rustc_ast::WherePredicateKind::BoundPredicate(bound) => {
                 bound
                     .bound_generic_params
-                    .flat_map_in_place(|param| self.flat_map_generic_param(param));
+                    .flat_map_in_place(|param| self.filter_map_generic_param(param));
                 self.visit_ty(&mut bound.bounded_ty);
                 for bound in &mut bound.bounds {
                     self.visit_param_bound(bound, BoundKind::Bound)
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 55751aa49089b..58582ec47625c 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -435,35 +435,35 @@ pub trait MacResult {
         None
     }
 
-    fn make_arms(self: Box<Self>) -> Option<SmallVec<[ast::Arm; 1]>> {
+    fn make_arm(self: Box<Self>) -> Option<Option<ast::Arm>> {
         None
     }
 
-    fn make_expr_fields(self: Box<Self>) -> Option<SmallVec<[ast::ExprField; 1]>> {
+    fn make_expr_field(self: Box<Self>) -> Option<Option<ast::ExprField>> {
         None
     }
 
-    fn make_pat_fields(self: Box<Self>) -> Option<SmallVec<[ast::PatField; 1]>> {
+    fn make_pat_field(self: Box<Self>) -> Option<Option<ast::PatField>> {
         None
     }
 
-    fn make_generic_params(self: Box<Self>) -> Option<SmallVec<[ast::GenericParam; 1]>> {
+    fn make_generic_param(self: Box<Self>) -> Option<Option<ast::GenericParam>> {
         None
     }
 
-    fn make_params(self: Box<Self>) -> Option<SmallVec<[ast::Param; 1]>> {
+    fn make_param(self: Box<Self>) -> Option<Option<ast::Param>> {
         None
     }
 
-    fn make_field_defs(self: Box<Self>) -> Option<SmallVec<[ast::FieldDef; 1]>> {
+    fn make_field_def(self: Box<Self>) -> Option<Option<ast::FieldDef>> {
         None
     }
 
-    fn make_variants(self: Box<Self>) -> Option<SmallVec<[ast::Variant; 1]>> {
+    fn make_variant(self: Box<Self>) -> Option<Option<ast::Variant>> {
         None
     }
 
-    fn make_where_predicates(self: Box<Self>) -> Option<SmallVec<[ast::WherePredicate; 1]>> {
+    fn make_where_predicate(self: Box<Self>) -> Option<Option<ast::WherePredicate>> {
         None
     }
 
@@ -654,32 +654,32 @@ impl MacResult for DummyResult {
         }))
     }
 
-    fn make_arms(self: Box<DummyResult>) -> Option<SmallVec<[ast::Arm; 1]>> {
-        Some(SmallVec::new())
+    fn make_arm(self: Box<DummyResult>) -> Option<Option<ast::Arm>> {
+        Some(None)
     }
 
-    fn make_expr_fields(self: Box<DummyResult>) -> Option<SmallVec<[ast::ExprField; 1]>> {
-        Some(SmallVec::new())
+    fn make_expr_field(self: Box<DummyResult>) -> Option<Option<ast::ExprField>> {
+        Some(None)
     }
 
-    fn make_pat_fields(self: Box<DummyResult>) -> Option<SmallVec<[ast::PatField; 1]>> {
-        Some(SmallVec::new())
+    fn make_pat_field(self: Box<DummyResult>) -> Option<Option<ast::PatField>> {
+        Some(None)
     }
 
-    fn make_generic_params(self: Box<DummyResult>) -> Option<SmallVec<[ast::GenericParam; 1]>> {
-        Some(SmallVec::new())
+    fn make_generic_param(self: Box<DummyResult>) -> Option<Option<ast::GenericParam>> {
+        Some(None)
     }
 
-    fn make_params(self: Box<DummyResult>) -> Option<SmallVec<[ast::Param; 1]>> {
-        Some(SmallVec::new())
+    fn make_param(self: Box<DummyResult>) -> Option<Option<ast::Param>> {
+        Some(None)
     }
 
-    fn make_field_defs(self: Box<DummyResult>) -> Option<SmallVec<[ast::FieldDef; 1]>> {
-        Some(SmallVec::new())
+    fn make_field_def(self: Box<DummyResult>) -> Option<Option<ast::FieldDef>> {
+        Some(None)
     }
 
-    fn make_variants(self: Box<DummyResult>) -> Option<SmallVec<[ast::Variant; 1]>> {
-        Some(SmallVec::new())
+    fn make_variant(self: Box<DummyResult>) -> Option<Option<ast::Variant>> {
+        Some(None)
     }
 
     fn make_crate(self: Box<DummyResult>) -> Option<ast::Crate> {
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 81d4d59ee0451..47ab0bf43a4b2 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -48,8 +48,9 @@ macro_rules! ast_fragments {
     (
         $($Kind:ident($AstTy:ty) {
             $kind_name:expr;
-            $(one fn $mut_visit_ast:ident; fn $visit_ast:ident;)?
-            $(many fn $flat_map_ast_elt:ident; fn $visit_ast_elt:ident($($args:tt)*);)?
+            $(one fn $mut_visit_ast:ident; fn $one_visit_ast:ident;)?
+            $(option fn $filter_map_ast:ident; fn $option_visit_ast:ident;)?
+            $(many fn $flat_map_ast_elt:ident; fn $many_visit_ast:ident($($many_args:tt)*);)?
             fn $make_ast:ident;
         })*
     ) => {
@@ -131,18 +132,17 @@ macro_rules! ast_fragments {
             pub(crate) fn mut_visit_with<F: MutVisitor>(&mut self, vis: &mut F) {
                 match self {
                     AstFragment::OptExpr(opt_expr) => {
-                        visit_clobber(opt_expr, |opt_expr| {
-                            if let Some(expr) = opt_expr {
-                                vis.filter_map_expr(expr)
-                            } else {
-                                None
-                            }
-                        });
+                        visit_clobber_opt(opt_expr, |expr| vis.filter_map_expr(expr));
                     }
                     AstFragment::MethodReceiverExpr(expr) => vis.visit_method_receiver_expr(expr),
                     $($(AstFragment::$Kind(ast) => vis.$mut_visit_ast(ast),)?)*
                     $($(AstFragment::$Kind(ast) =>
-                        ast.flat_map_in_place(|ast| vis.$flat_map_ast_elt(ast, $($args)*)),)?)*
+                        ast.flat_map_in_place(|ast| vis.$flat_map_ast_elt(ast, $($many_args)*)),)?)*
+                    $($(
+                        AstFragment::$Kind(ast) => {
+                            visit_clobber_opt(ast, |ast| vis.$filter_map_ast(ast));
+                        }
+                    )?)*
                 }
             }
 
@@ -150,9 +150,21 @@ macro_rules! ast_fragments {
                 match self {
                     AstFragment::OptExpr(Some(expr)) => try_visit!(visitor.visit_expr(expr)),
                     AstFragment::OptExpr(None) => {}
-                    AstFragment::MethodReceiverExpr(expr) => try_visit!(visitor.visit_method_receiver_expr(expr)),
-                    $($(AstFragment::$Kind(ast) => try_visit!(visitor.$visit_ast(ast)),)?)*
-                    $($(AstFragment::$Kind(ast) => walk_list!(visitor, $visit_ast_elt, &ast[..], $($args)*),)?)*
+                    AstFragment::MethodReceiverExpr(expr) => {
+                        try_visit!(visitor.visit_method_receiver_expr(expr))
+                    }
+                    $($(
+                        AstFragment::$Kind(ast) => try_visit!(visitor.$one_visit_ast(ast)),
+                    )?)*
+                    $($(
+                        AstFragment::$Kind(ast) => {
+                            walk_list!(visitor, $many_visit_ast, &ast[..], $($many_args)*)
+                        }
+                    )?)*
+                    $($(
+                        AstFragment::$Kind(Some(ast)) => try_visit!(visitor.$option_visit_ast(ast)),
+                        AstFragment::$Kind(None) => {}
+                    )?)*
                 }
                 V::Result::output()
             }
@@ -201,42 +213,39 @@ ast_fragments! {
         fn visit_foreign_item();
         fn make_foreign_items;
     }
-    Arms(SmallVec<[ast::Arm; 1]>) {
-        "match arm"; many fn flat_map_arm; fn visit_arm(); fn make_arms;
+    Arm(Option<ast::Arm>) {
+        "match arm"; option fn filter_map_arm; fn visit_arm; fn make_arm;
     }
-    ExprFields(SmallVec<[ast::ExprField; 1]>) {
-        "field expression"; many fn flat_map_expr_field; fn visit_expr_field(); fn make_expr_fields;
+    ExprField(Option<ast::ExprField>) {
+        "field expression";
+        option fn filter_map_expr_field;
+        fn visit_expr_field;
+        fn make_expr_field;
     }
-    PatFields(SmallVec<[ast::PatField; 1]>) {
-        "field pattern";
-        many fn flat_map_pat_field;
-        fn visit_pat_field();
-        fn make_pat_fields;
+    PatField(Option<ast::PatField>) {
+        "field pattern"; option fn filter_map_pat_field; fn visit_pat_field; fn make_pat_field;
     }
-    GenericParams(SmallVec<[ast::GenericParam; 1]>) {
+    GenericParam(Option<ast::GenericParam>) {
         "generic parameter";
-        many fn flat_map_generic_param;
-        fn visit_generic_param();
-        fn make_generic_params;
+        option fn filter_map_generic_param;
+        fn visit_generic_param;
+        fn make_generic_param;
     }
-    Params(SmallVec<[ast::Param; 1]>) {
-        "function parameter"; many fn flat_map_param; fn visit_param(); fn make_params;
+    Param(Option<ast::Param>) {
+        "function parameter"; option fn filter_map_param; fn visit_param; fn make_param;
     }
-    FieldDefs(SmallVec<[ast::FieldDef; 1]>) {
-        "field";
-        many fn flat_map_field_def;
-        fn visit_field_def();
-        fn make_field_defs;
+    FieldDef(Option<ast::FieldDef>) {
+        "field"; option fn filter_map_field_def; fn visit_field_def; fn make_field_def;
     }
-    Variants(SmallVec<[ast::Variant; 1]>) {
-        "variant"; many fn flat_map_variant; fn visit_variant(); fn make_variants;
+    Variant(Option<ast::Variant>) {
+        "variant"; option fn filter_map_variant; fn visit_variant; fn make_variant;
     }
-    WherePredicates(SmallVec<[ast::WherePredicate; 1]>) {
+    WherePredicate(Option<ast::WherePredicate>) {
         "where predicate";
-        many fn flat_map_where_predicate;
-        fn visit_where_predicate();
-        fn make_where_predicates;
-     }
+        option fn filter_map_where_predicate;
+        fn visit_where_predicate;
+        fn make_where_predicate;
+    }
     Crate(ast::Crate) { "crate"; one fn visit_crate; fn visit_crate; fn make_crate; }
 }
 
@@ -264,14 +273,14 @@ impl AstFragmentKind {
             | AstFragmentKind::TraitImplItems
             | AstFragmentKind::ForeignItems
             | AstFragmentKind::Crate => SupportsMacroExpansion::Yes { supports_inner_attrs: true },
-            AstFragmentKind::Arms
-            | AstFragmentKind::ExprFields
-            | AstFragmentKind::PatFields
-            | AstFragmentKind::GenericParams
-            | AstFragmentKind::Params
-            | AstFragmentKind::FieldDefs
-            | AstFragmentKind::Variants
-            | AstFragmentKind::WherePredicates => SupportsMacroExpansion::No,
+            AstFragmentKind::Arm
+            | AstFragmentKind::ExprField
+            | AstFragmentKind::PatField
+            | AstFragmentKind::GenericParam
+            | AstFragmentKind::Param
+            | AstFragmentKind::FieldDef
+            | AstFragmentKind::Variant
+            | AstFragmentKind::WherePredicate => SupportsMacroExpansion::No,
         }
     }
 
@@ -280,31 +289,48 @@ impl AstFragmentKind {
         items: I,
     ) -> AstFragment {
         let mut items = items.into_iter();
+
+        macro_rules! expect_one {
+            ($items:ident, $expect:ident, $ast_fragment_ctor:path) => {{
+                let fragment = $items.next().expect("expected exactly one AST fragment").$expect();
+                assert!($items.next().is_none());
+                $ast_fragment_ctor(fragment)
+            }};
+        }
+
+        macro_rules! expect_one_as_option {
+            ($items:ident, $expect:ident, $ast_fragment_ctor:path) => {{
+                let fragment = $items.next().expect("expected exactly one AST fragment").$expect();
+                assert!($items.next().is_none());
+                $ast_fragment_ctor(Some(fragment))
+            }};
+        }
+
         match self {
-            AstFragmentKind::Arms => {
-                AstFragment::Arms(items.map(Annotatable::expect_arm).collect())
+            AstFragmentKind::Arm => {
+                expect_one_as_option!(items, expect_arm, AstFragment::Arm)
+            }
+            AstFragmentKind::ExprField => {
+                expect_one_as_option!(items, expect_expr_field, AstFragment::ExprField)
             }
-            AstFragmentKind::ExprFields => {
-                AstFragment::ExprFields(items.map(Annotatable::expect_expr_field).collect())
+            AstFragmentKind::PatField => {
+                expect_one_as_option!(items, expect_pat_field, AstFragment::PatField)
             }
-            AstFragmentKind::PatFields => {
-                AstFragment::PatFields(items.map(Annotatable::expect_pat_field).collect())
+            AstFragmentKind::GenericParam => {
+                expect_one_as_option!(items, expect_generic_param, AstFragment::GenericParam)
             }
-            AstFragmentKind::GenericParams => {
-                AstFragment::GenericParams(items.map(Annotatable::expect_generic_param).collect())
+            AstFragmentKind::Param => {
+                expect_one_as_option!(items, expect_param, AstFragment::Param)
             }
-            AstFragmentKind::Params => {
-                AstFragment::Params(items.map(Annotatable::expect_param).collect())
+            AstFragmentKind::FieldDef => {
+                expect_one_as_option!(items, expect_field_def, AstFragment::FieldDef)
             }
-            AstFragmentKind::FieldDefs => {
-                AstFragment::FieldDefs(items.map(Annotatable::expect_field_def).collect())
+            AstFragmentKind::Variant => {
+                expect_one_as_option!(items, expect_variant, AstFragment::Variant)
             }
-            AstFragmentKind::Variants => {
-                AstFragment::Variants(items.map(Annotatable::expect_variant).collect())
+            AstFragmentKind::WherePredicate => {
+                expect_one_as_option!(items, expect_where_predicate, AstFragment::WherePredicate)
             }
-            AstFragmentKind::WherePredicates => AstFragment::WherePredicates(
-                items.map(Annotatable::expect_where_predicate).collect(),
-            ),
             AstFragmentKind::Items => {
                 AstFragment::Items(items.map(Annotatable::expect_item).collect())
             }
@@ -323,17 +349,19 @@ impl AstFragmentKind {
             AstFragmentKind::Stmts => {
                 AstFragment::Stmts(items.map(Annotatable::expect_stmt).collect())
             }
-            AstFragmentKind::Expr => AstFragment::Expr(
-                items.next().expect("expected exactly one expression").expect_expr(),
-            ),
-            AstFragmentKind::MethodReceiverExpr => AstFragment::MethodReceiverExpr(
-                items.next().expect("expected exactly one expression").expect_expr(),
-            ),
+            AstFragmentKind::Expr => {
+                expect_one!(items, expect_expr, AstFragment::Expr)
+            }
+            AstFragmentKind::MethodReceiverExpr => {
+                expect_one!(items, expect_expr, AstFragment::MethodReceiverExpr)
+            }
             AstFragmentKind::OptExpr => {
-                AstFragment::OptExpr(items.next().map(Annotatable::expect_expr))
+                let fragment = AstFragment::OptExpr(items.next().map(Annotatable::expect_expr));
+                assert!(items.next().is_none());
+                fragment
             }
             AstFragmentKind::Crate => {
-                AstFragment::Crate(items.next().expect("expected exactly one crate").expect_crate())
+                expect_one!(items, expect_crate, AstFragment::Crate)
             }
             AstFragmentKind::Pat | AstFragmentKind::Ty => {
                 panic!("patterns and types aren't annotatable")
@@ -1026,14 +1054,14 @@ pub fn parse_ast_fragment<'a>(
             CommaRecoveryMode::LikelyTuple,
         )?),
         AstFragmentKind::Crate => AstFragment::Crate(this.parse_crate_mod()?),
-        AstFragmentKind::Arms
-        | AstFragmentKind::ExprFields
-        | AstFragmentKind::PatFields
-        | AstFragmentKind::GenericParams
-        | AstFragmentKind::Params
-        | AstFragmentKind::FieldDefs
-        | AstFragmentKind::Variants
-        | AstFragmentKind::WherePredicates => panic!("unexpected AST fragment kind"),
+        AstFragmentKind::Arm
+        | AstFragmentKind::ExprField
+        | AstFragmentKind::PatField
+        | AstFragmentKind::GenericParam
+        | AstFragmentKind::Param
+        | AstFragmentKind::FieldDef
+        | AstFragmentKind::Variant
+        | AstFragmentKind::WherePredicate => panic!("unexpected AST fragment kind"),
     })
 }
 
@@ -1115,7 +1143,7 @@ enum AddSemicolon {
 /// A trait implemented for all `AstFragment` nodes and providing all pieces
 /// of functionality used by `InvocationCollector`.
 trait InvocationCollectorNode: HasAttrs + HasNodeId + Sized {
-    type OutputTy = SmallVec<[Self; 1]>;
+    type OutputTy;
     type ItemKind = ItemKind;
     const KIND: AstFragmentKind;
     fn to_annotatable(self) -> Annotatable;
@@ -1174,6 +1202,7 @@ trait InvocationCollectorNode: HasAttrs + HasNodeId + Sized {
 }
 
 impl InvocationCollectorNode for P<ast::Item> {
+    type OutputTy = SmallVec<[Self; 1]>;
     const KIND: AstFragmentKind = AstFragmentKind::Items;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::Item(self)
@@ -1450,6 +1479,7 @@ impl InvocationCollectorNode for AstNodeWrapper<P<ast::AssocItem>, TraitImplItem
 }
 
 impl InvocationCollectorNode for P<ast::ForeignItem> {
+    type OutputTy = SmallVec<[Self; 1]>;
     const KIND: AstFragmentKind = AstFragmentKind::ForeignItems;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::ForeignItem(self)
@@ -1473,110 +1503,119 @@ impl InvocationCollectorNode for P<ast::ForeignItem> {
 }
 
 impl InvocationCollectorNode for ast::Variant {
-    const KIND: AstFragmentKind = AstFragmentKind::Variants;
+    type OutputTy = Option<ast::Variant>;
+    const KIND: AstFragmentKind = AstFragmentKind::Variant;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::Variant(self)
     }
     fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
-        fragment.make_variants()
+        fragment.make_variant()
     }
     fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_flat_map_variant(visitor, self)
+        walk_filter_map_variant(visitor, self)
     }
 }
 
 impl InvocationCollectorNode for ast::WherePredicate {
-    const KIND: AstFragmentKind = AstFragmentKind::WherePredicates;
+    type OutputTy = Option<ast::WherePredicate>;
+    const KIND: AstFragmentKind = AstFragmentKind::WherePredicate;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::WherePredicate(self)
     }
     fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
-        fragment.make_where_predicates()
+        fragment.make_where_predicate()
     }
     fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_flat_map_where_predicate(visitor, self)
+        walk_filter_map_where_predicate(visitor, self)
     }
 }
 
 impl InvocationCollectorNode for ast::FieldDef {
-    const KIND: AstFragmentKind = AstFragmentKind::FieldDefs;
+    type OutputTy = Option<ast::FieldDef>;
+    const KIND: AstFragmentKind = AstFragmentKind::FieldDef;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::FieldDef(self)
     }
     fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
-        fragment.make_field_defs()
+        fragment.make_field_def()
     }
     fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_flat_map_field_def(visitor, self)
+        walk_filter_map_field_def(visitor, self)
     }
 }
 
 impl InvocationCollectorNode for ast::PatField {
-    const KIND: AstFragmentKind = AstFragmentKind::PatFields;
+    type OutputTy = Option<ast::PatField>;
+    const KIND: AstFragmentKind = AstFragmentKind::PatField;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::PatField(self)
     }
     fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
-        fragment.make_pat_fields()
+        fragment.make_pat_field()
     }
     fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_flat_map_pat_field(visitor, self)
+        walk_filter_map_pat_field(visitor, self)
     }
 }
 
 impl InvocationCollectorNode for ast::ExprField {
-    const KIND: AstFragmentKind = AstFragmentKind::ExprFields;
+    type OutputTy = Option<ast::ExprField>;
+    const KIND: AstFragmentKind = AstFragmentKind::ExprField;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::ExprField(self)
     }
     fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
-        fragment.make_expr_fields()
+        fragment.make_expr_field()
     }
     fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_flat_map_expr_field(visitor, self)
+        walk_filter_map_expr_field(visitor, self)
     }
 }
 
 impl InvocationCollectorNode for ast::Param {
-    const KIND: AstFragmentKind = AstFragmentKind::Params;
+    type OutputTy = Option<ast::Param>;
+    const KIND: AstFragmentKind = AstFragmentKind::Param;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::Param(self)
     }
     fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
-        fragment.make_params()
+        fragment.make_param()
     }
     fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_flat_map_param(visitor, self)
+        walk_filter_map_param(visitor, self)
     }
 }
 
 impl InvocationCollectorNode for ast::GenericParam {
-    const KIND: AstFragmentKind = AstFragmentKind::GenericParams;
+    type OutputTy = Option<ast::GenericParam>;
+    const KIND: AstFragmentKind = AstFragmentKind::GenericParam;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::GenericParam(self)
     }
     fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
-        fragment.make_generic_params()
+        fragment.make_generic_param()
     }
     fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_flat_map_generic_param(visitor, self)
+        walk_filter_map_generic_param(visitor, self)
     }
 }
 
 impl InvocationCollectorNode for ast::Arm {
-    const KIND: AstFragmentKind = AstFragmentKind::Arms;
+    type OutputTy = Option<ast::Arm>;
+    const KIND: AstFragmentKind = AstFragmentKind::Arm;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::Arm(self)
     }
     fn fragment_to_output(fragment: AstFragment) -> Self::OutputTy {
-        fragment.make_arms()
+        fragment.make_arm()
     }
     fn walk_flat_map<V: MutVisitor>(self, visitor: &mut V) -> Self::OutputTy {
-        walk_flat_map_arm(visitor, self)
+        walk_filter_map_arm(visitor, self)
     }
 }
 
 impl InvocationCollectorNode for ast::Stmt {
+    type OutputTy = SmallVec<[Self; 1]>;
     const KIND: AstFragmentKind = AstFragmentKind::Stmts;
     fn to_annotatable(self) -> Annotatable {
         Annotatable::Stmt(P(self))
@@ -2205,41 +2244,38 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
         self.flat_map_node(node)
     }
 
-    fn flat_map_variant(&mut self, node: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
+    fn filter_map_variant(&mut self, node: ast::Variant) -> Option<ast::Variant> {
         self.flat_map_node(node)
     }
 
-    fn flat_map_where_predicate(
+    fn filter_map_where_predicate(
         &mut self,
         node: ast::WherePredicate,
-    ) -> SmallVec<[ast::WherePredicate; 1]> {
+    ) -> Option<ast::WherePredicate> {
         self.flat_map_node(node)
     }
 
-    fn flat_map_field_def(&mut self, node: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
+    fn filter_map_field_def(&mut self, node: ast::FieldDef) -> Option<ast::FieldDef> {
         self.flat_map_node(node)
     }
 
-    fn flat_map_pat_field(&mut self, node: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
+    fn filter_map_pat_field(&mut self, node: ast::PatField) -> Option<ast::PatField> {
         self.flat_map_node(node)
     }
 
-    fn flat_map_expr_field(&mut self, node: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
+    fn filter_map_expr_field(&mut self, node: ast::ExprField) -> Option<ast::ExprField> {
         self.flat_map_node(node)
     }
 
-    fn flat_map_param(&mut self, node: ast::Param) -> SmallVec<[ast::Param; 1]> {
+    fn filter_map_param(&mut self, node: ast::Param) -> Option<ast::Param> {
         self.flat_map_node(node)
     }
 
-    fn flat_map_generic_param(
-        &mut self,
-        node: ast::GenericParam,
-    ) -> SmallVec<[ast::GenericParam; 1]> {
+    fn filter_map_generic_param(&mut self, node: ast::GenericParam) -> Option<ast::GenericParam> {
         self.flat_map_node(node)
     }
 
-    fn flat_map_arm(&mut self, node: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
+    fn filter_map_arm(&mut self, node: ast::Arm) -> Option<ast::Arm> {
         self.flat_map_node(node)
     }
 
diff --git a/compiler/rustc_expand/src/placeholders.rs b/compiler/rustc_expand/src/placeholders.rs
index 0136292decbcf..6ebe9c43135d1 100644
--- a/compiler/rustc_expand/src/placeholders.rs
+++ b/compiler/rustc_expand/src/placeholders.rs
@@ -124,7 +124,7 @@ pub(crate) fn placeholder(
             });
             ast::Stmt { id, span, kind: ast::StmtKind::MacCall(mac) }
         }]),
-        AstFragmentKind::Arms => AstFragment::Arms(smallvec![ast::Arm {
+        AstFragmentKind::Arm => AstFragment::Arm(Some(ast::Arm {
             attrs: Default::default(),
             body: Some(expr_placeholder()),
             guard: None,
@@ -132,8 +132,8 @@ pub(crate) fn placeholder(
             pat: pat(),
             span,
             is_placeholder: true,
-        }]),
-        AstFragmentKind::ExprFields => AstFragment::ExprFields(smallvec![ast::ExprField {
+        })),
+        AstFragmentKind::ExprField => AstFragment::ExprField(Some(ast::ExprField {
             attrs: Default::default(),
             expr: expr_placeholder(),
             id,
@@ -141,8 +141,8 @@ pub(crate) fn placeholder(
             is_shorthand: false,
             span,
             is_placeholder: true,
-        }]),
-        AstFragmentKind::PatFields => AstFragment::PatFields(smallvec![ast::PatField {
+        })),
+        AstFragmentKind::PatField => AstFragment::PatField(Some(ast::PatField {
             attrs: Default::default(),
             id,
             ident,
@@ -150,27 +150,25 @@ pub(crate) fn placeholder(
             pat: pat(),
             span,
             is_placeholder: true,
-        }]),
-        AstFragmentKind::GenericParams => AstFragment::GenericParams(smallvec![{
-            ast::GenericParam {
-                attrs: Default::default(),
-                bounds: Default::default(),
-                id,
-                ident,
-                is_placeholder: true,
-                kind: ast::GenericParamKind::Lifetime,
-                colon_span: None,
-            }
-        }]),
-        AstFragmentKind::Params => AstFragment::Params(smallvec![ast::Param {
+        })),
+        AstFragmentKind::GenericParam => AstFragment::GenericParam(Some(ast::GenericParam {
+            attrs: Default::default(),
+            bounds: Default::default(),
+            id,
+            ident,
+            is_placeholder: true,
+            kind: ast::GenericParamKind::Lifetime,
+            colon_span: None,
+        })),
+        AstFragmentKind::Param => AstFragment::Param(Some(ast::Param {
             attrs: Default::default(),
             id,
             pat: pat(),
             span,
             ty: ty(),
             is_placeholder: true,
-        }]),
-        AstFragmentKind::FieldDefs => AstFragment::FieldDefs(smallvec![ast::FieldDef {
+        })),
+        AstFragmentKind::FieldDef => AstFragment::FieldDef(Some(ast::FieldDef {
             attrs: Default::default(),
             id,
             ident: None,
@@ -180,12 +178,12 @@ pub(crate) fn placeholder(
             is_placeholder: true,
             safety: Safety::Default,
             default: None,
-        }]),
-        AstFragmentKind::Variants => AstFragment::Variants(smallvec![ast::Variant {
+        })),
+        AstFragmentKind::Variant => AstFragment::Variant(Some(ast::Variant {
             attrs: Default::default(),
             data: ast::VariantData::Struct {
                 fields: Default::default(),
-                recovered: ast::Recovered::No
+                recovered: ast::Recovered::No,
             },
             disr_expr: None,
             id,
@@ -193,20 +191,18 @@ pub(crate) fn placeholder(
             span,
             vis,
             is_placeholder: true,
-        }]),
-        AstFragmentKind::WherePredicates => {
-            AstFragment::WherePredicates(smallvec![ast::WherePredicate {
-                attrs: Default::default(),
-                id,
-                span,
-                kind: ast::WherePredicateKind::BoundPredicate(ast::WhereBoundPredicate {
-                    bound_generic_params: Default::default(),
-                    bounded_ty: ty(),
-                    bounds: Default::default(),
-                }),
-                is_placeholder: true,
-            }])
-        }
+        })),
+        AstFragmentKind::WherePredicate => AstFragment::WherePredicate(Some(ast::WherePredicate {
+            attrs: Default::default(),
+            id,
+            span,
+            kind: ast::WherePredicateKind::BoundPredicate(ast::WhereBoundPredicate {
+                bound_generic_params: Default::default(),
+                bounded_ty: ty(),
+                bounds: Default::default(),
+            }),
+            is_placeholder: true,
+        })),
     }
 }
 
@@ -227,73 +223,70 @@ impl PlaceholderExpander {
 }
 
 impl MutVisitor for PlaceholderExpander {
-    fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
+    fn filter_map_arm(&mut self, arm: ast::Arm) -> Option<ast::Arm> {
         if arm.is_placeholder {
-            self.remove(arm.id).make_arms()
+            self.remove(arm.id).make_arm()
         } else {
-            walk_flat_map_arm(self, arm)
+            walk_filter_map_arm(self, arm)
         }
     }
 
-    fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
+    fn filter_map_expr_field(&mut self, field: ast::ExprField) -> Option<ast::ExprField> {
         if field.is_placeholder {
-            self.remove(field.id).make_expr_fields()
+            self.remove(field.id).make_expr_field()
         } else {
-            walk_flat_map_expr_field(self, field)
+            walk_filter_map_expr_field(self, field)
         }
     }
 
-    fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
+    fn filter_map_pat_field(&mut self, fp: ast::PatField) -> Option<ast::PatField> {
         if fp.is_placeholder {
-            self.remove(fp.id).make_pat_fields()
+            self.remove(fp.id).make_pat_field()
         } else {
-            walk_flat_map_pat_field(self, fp)
+            walk_filter_map_pat_field(self, fp)
         }
     }
 
-    fn flat_map_generic_param(
-        &mut self,
-        param: ast::GenericParam,
-    ) -> SmallVec<[ast::GenericParam; 1]> {
+    fn filter_map_generic_param(&mut self, param: ast::GenericParam) -> Option<ast::GenericParam> {
         if param.is_placeholder {
-            self.remove(param.id).make_generic_params()
+            self.remove(param.id).make_generic_param()
         } else {
-            walk_flat_map_generic_param(self, param)
+            walk_filter_map_generic_param(self, param)
         }
     }
 
-    fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
+    fn filter_map_param(&mut self, p: ast::Param) -> Option<ast::Param> {
         if p.is_placeholder {
-            self.remove(p.id).make_params()
+            self.remove(p.id).make_param()
         } else {
-            walk_flat_map_param(self, p)
+            walk_filter_map_param(self, p)
         }
     }
 
-    fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
+    fn filter_map_field_def(&mut self, sf: ast::FieldDef) -> Option<ast::FieldDef> {
         if sf.is_placeholder {
-            self.remove(sf.id).make_field_defs()
+            self.remove(sf.id).make_field_def()
         } else {
-            walk_flat_map_field_def(self, sf)
+            walk_filter_map_field_def(self, sf)
         }
     }
 
-    fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
+    fn filter_map_variant(&mut self, variant: ast::Variant) -> Option<ast::Variant> {
         if variant.is_placeholder {
-            self.remove(variant.id).make_variants()
+            self.remove(variant.id).make_variant()
         } else {
-            walk_flat_map_variant(self, variant)
+            walk_filter_map_variant(self, variant)
         }
     }
 
-    fn flat_map_where_predicate(
+    fn filter_map_where_predicate(
         &mut self,
         predicate: ast::WherePredicate,
-    ) -> SmallVec<[ast::WherePredicate; 1]> {
+    ) -> Option<ast::WherePredicate> {
         if predicate.is_placeholder {
-            self.remove(predicate.id).make_where_predicates()
+            self.remove(predicate.id).make_where_predicate()
         } else {
-            walk_flat_map_where_predicate(self, predicate)
+            walk_filter_map_where_predicate(self, predicate)
         }
     }
 
@@ -349,7 +342,7 @@ impl MutVisitor for PlaceholderExpander {
     fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
         match expr.kind {
             ast::ExprKind::MacCall(_) => self.remove(expr.id).make_opt_expr(),
-            _ => noop_filter_map_expr(self, expr),
+            _ => walk_filter_map_expr(self, expr),
         }
     }