Unify impl WalkItemKind for ForeignItemKind

Author: maxcabrajac

compiler/rustc_ast/src/visitors.rs

@@ -1371,6 +1371,51 @@ macro_rules! make_ast_visitor {
             }
         }
 
+        impl WalkItemKind for ForeignItemKind {
+            fn walk<$($lt,)? V: $trait$(<$lt>)?>(
+                item: ref_t!(Item<Self>),
+                visitor: &mut V,
+            ) -> result!(V) {
+                let Item { attrs, id, span, vis, ident, kind, tokens } = item;
+                try_v!(visit_id!(visitor, id));
+                visit_list!(visitor, visit_attribute, flat_map_attribute, attrs);
+                try_v!(visitor.visit_vis(vis));
+                try_v!(visit_ident!(visitor, ident));
+                match kind {
+                    ForeignItemKind::Static(box StaticItem { safety, ty, mutability: _, expr }) => {
+                        visit_safety!(visitor, safety);
+                        try_v!(visitor.visit_ty(ty));
+                        visit_o!(expr, |expr| visitor.visit_expr(expr));
+                    }
+                    ForeignItemKind::Fn(box Fn { defaultness, generics, sig, body }) => {
+                        visit_defaultness!(visitor, defaultness);
+                        let kind =
+                            FnKind::Fn(FnCtxt::Foreign, *ident, sig, vis, generics, as_deref!(body));
+                        visitor.visit_fn(kind, *span, *id);
+                    }
+                    ForeignItemKind::TyAlias(box TyAlias {
+                        defaultness,
+                        generics,
+                        where_clauses,
+                        bounds,
+                        ty,
+                    }) => {
+                        visit_defaultness!(visitor, defaultness);
+                        try_v!(visitor.visit_generics(generics));
+                        visit_list!(visitor, visit_param_bound, bounds; BoundKind::Bound);
+                        visit_o!(ty, |ty| visitor.visit_ty(ty));
+                        walk_ty_alias_where_clauses!(visitor, where_clauses);
+                    }
+                    ForeignItemKind::MacCall(mac) => {
+                        try_v!(visitor.visit_mac_call(mac));
+                    }
+                }
+                visit_lazy_tts!(visitor, tokens);
+                try_v!(visit_span!(visitor, span));
+                return_result!(V)
+            }
+        }
+
         make_walk_flat_map!{Arm, walk_flat_map_arm, visit_arm}
         make_walk_flat_map!{Attribute, walk_flat_map_attribute, visit_attribute}
         make_walk_flat_map!{ExprField, walk_flat_map_expr_field, visit_expr_field}
@@ -1511,44 +1556,6 @@ pub mod visit {
         V::Result::output()
     }
 
-    impl WalkItemKind for ForeignItemKind {
-        fn walk<'a, V: Visitor<'a>>(
-            item: &'a Item<Self>,
-            visitor: &mut V,
-        ) -> V::Result {
-            let Item { id, span, ident, vis, attrs, kind, tokens: _ } = item;
-            walk_list!(visitor, visit_attribute, attrs);
-            try_visit!(visitor.visit_vis(vis));
-            try_visit!(visitor.visit_ident(*ident));
-            match kind {
-                ForeignItemKind::Static(box StaticItem { ty, mutability: _, expr, safety: _ }) => {
-                    try_visit!(visitor.visit_ty(ty));
-                    visit_opt!(visitor, visit_expr, expr);
-                }
-                ForeignItemKind::Fn(box Fn { defaultness: _, generics, sig, body }) => {
-                    let kind =
-                        FnKind::Fn(FnCtxt::Foreign, *ident, sig, vis, generics, body.as_deref());
-                    try_visit!(visitor.visit_fn(kind, *span, *id));
-                }
-                ForeignItemKind::TyAlias(box TyAlias {
-                    generics,
-                    bounds,
-                    ty,
-                    defaultness: _,
-                    where_clauses: _,
-                }) => {
-                    try_visit!(visitor.visit_generics(generics));
-                    walk_list!(visitor, visit_param_bound, bounds, BoundKind::Bound);
-                    visit_opt!(visitor, visit_ty, ty);
-                }
-                ForeignItemKind::MacCall(mac) => {
-                    try_visit!(visitor.visit_mac_call(mac));
-                }
-            }
-            V::Result::output()
-        }
-    }
-
     pub fn walk_generic_param<'a, V: Visitor<'a>>(
         visitor: &mut V,
         param: &'a GenericParam,
@@ -2444,45 +2451,6 @@ pub mod mut_visit {
         smallvec![item]
     }
 
-
-    impl WalkItemKind for ForeignItemKind {
-        fn walk<V: MutVisitor>(item: &mut Item<Self>, visitor: &mut V) {
-            let Item { attrs, id, span, vis, ident, kind, tokens } = item;
-            visitor.visit_id(id);
-            visit_attrs(visitor, attrs);
-            visitor.visit_vis(vis);
-            visitor.visit_ident(ident);
-            match kind {
-                ForeignItemKind::Static(box StaticItem { ty, mutability: _, expr, safety: _ }) => {
-                    visitor.visit_ty(ty);
-                    visit_opt(expr, |expr| visitor.visit_expr(expr));
-                }
-                ForeignItemKind::Fn(box Fn { defaultness, generics, sig, body }) => {
-                    visit_defaultness(visitor, defaultness);
-                    let kind =
-                        FnKind::Fn(FnCtxt::Foreign, *ident, sig, vis, generics, body.as_deref_mut());
-                    visitor.visit_fn(kind, *span, *id);
-                }
-                ForeignItemKind::TyAlias(box TyAlias {
-                    defaultness,
-                    generics,
-                    where_clauses,
-                    bounds,
-                    ty,
-                }) => {
-                    visit_defaultness(visitor, defaultness);
-                    visitor.visit_generics(generics);
-                    visit_bounds(visitor, bounds, BoundKind::Bound);
-                    visit_opt(ty, |ty| visitor.visit_ty(ty));
-                    walk_ty_alias_where_clauses(visitor, where_clauses);
-                }
-                ForeignItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
-            }
-            visit_lazy_tts(visitor, tokens);
-            visitor.visit_span(span);
-        }
-    }
-
     pub fn walk_expr<T: MutVisitor>(
         vis: &mut T,
         Expr { kind, id, span, attrs, tokens }: &mut Expr,