Emit const item block instead and use MutVisitor pattern

Author: KiChjang

compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs

@@ -1,12 +1,82 @@
+use rustc_ast::mut_visit::{self, MutVisitor};
 use rustc_ast::{self as ast, MetaItem, Safety};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_expand::base::{Annotatable, ExtCtxt};
-use rustc_span::{Ident, Span, sym};
+use rustc_span::{Ident, Span, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
 
 use crate::deriving::generic::*;
 use crate::deriving::path_std;
 
+struct ReplaceSelfTyVisitor(Box<ast::Ty>);
+impl MutVisitor for ReplaceSelfTyVisitor {
+    fn visit_ty(&mut self, ty: &mut ast::Ty) {
+        if let ast::TyKind::Path(None, path) = &mut ty.kind
+            && let [segment] = &path.segments[..]
+            && *segment == kw::SelfUpper
+        {
+            *ty = *self.0.clone();
+        } else {
+            mut_visit::walk_ty(self, ty);
+        }
+    }
+}
+
+struct RespanGenericsVisitor(Span);
+impl MutVisitor for RespanGenericsVisitor {
+    fn visit_generics(&mut self, generics: &mut ast::Generics) {
+        generics.where_clause.span = self.0.with_ctxt(generics.where_clause.span.ctxt());
+        generics.span = self.0.with_ctxt(generics.span.ctxt());
+        mut_visit::walk_generics(self, generics);
+    }
+    fn visit_where_predicate(&mut self, predicate: &mut ast::WherePredicate) {
+        predicate.span = self.0.with_ctxt(predicate.span.ctxt());
+        mut_visit::walk_where_predicate(self, predicate);
+    }
+    fn visit_where_predicate_kind(&mut self, kind: &mut ast::WherePredicateKind) {
+        match kind {
+            ast::WherePredicateKind::BoundPredicate(bound_predicate) => {
+                bound_predicate.bounded_ty.span =
+                    self.0.with_ctxt(bound_predicate.bounded_ty.span.ctxt());
+            }
+            ast::WherePredicateKind::EqPredicate(eq_predicate) => {
+                eq_predicate.lhs_ty.span = self.0.with_ctxt(eq_predicate.lhs_ty.span.ctxt());
+                eq_predicate.rhs_ty.span = self.0.with_ctxt(eq_predicate.rhs_ty.span.ctxt());
+            }
+            ast::WherePredicateKind::RegionPredicate(_) => {}
+        }
+        mut_visit::walk_where_predicate_kind(self, kind);
+    }
+    fn visit_param_bound(
+        &mut self,
+        bound: &mut rustc_ast::GenericBound,
+        _ctxt: rustc_ast::visit::BoundKind,
+    ) {
+        match bound {
+            ast::GenericBound::Trait(poly_trait_ref) => {
+                poly_trait_ref.span = self.0.with_ctxt(poly_trait_ref.span.ctxt());
+            }
+            ast::GenericBound::Outlives(_) => {}
+            ast::GenericBound::Use(_, _) => {}
+        }
+        ast::mut_visit::walk_param_bound(self, bound);
+    }
+}
+
+struct StripConstTraitBoundsVisitor;
+impl MutVisitor for StripConstTraitBoundsVisitor {
+    fn visit_param_bound(
+        &mut self,
+        bound: &mut rustc_ast::GenericBound,
+        _ctxt: rustc_ast::visit::BoundKind,
+    ) {
+        if let ast::GenericBound::Trait(poly_trait_ref) = bound {
+            poly_trait_ref.modifiers.constness = ast::BoundConstness::Never;
+        }
+        mut_visit::walk_param_bound(self, bound);
+    }
+}
+
 pub(crate) fn expand_deriving_eq(
     cx: &ExtCtxt<'_>,
     span: Span,
@@ -17,8 +87,8 @@ pub(crate) fn expand_deriving_eq(
 ) {
     let span = cx.with_def_site_ctxt(span);
 
-    let mut impl_generics = ast::Generics::default();
-    let mut impl_self_ty = None;
+    let mut fn_generics = ast::Generics { span, ..Default::default() };
+    let mut self_ty = None;
 
     let trait_def = TraitDef {
         span,
@@ -45,150 +115,90 @@ pub(crate) fn expand_deriving_eq(
             let ast::ItemKind::Impl(imp) = &mut item.kind else {
                 unreachable!("should have emitted an Impl in trait_def.expand_ext");
             };
-            impl_generics = imp.generics.clone();
-            impl_self_ty = Some(imp.self_ty.clone());
-            respan_generics_for_derive(&mut imp.generics, span);
+            use ast::mut_visit::MutVisitor;
+            RespanGenericsVisitor(span).visit_generics(&mut imp.generics);
+            fn_generics = imp.generics.clone();
+            self_ty = Some(imp.self_ty.clone());
             push(a)
         },
         true,
     );
 
-    let assert_stmts = eq_assert_stmts_from_item(cx, span, item);
+    let self_ty =
+        self_ty.unwrap_or_else(|| cx.dcx().span_bug(span, "missing self type in `derive(Eq)`"));
+    let assert_stmts = eq_assert_stmts_from_item(cx, span, item, ReplaceSelfTyVisitor(self_ty));
 
     // Skip generating `assert_fields_are_eq` impl if there are no assertions to make
     if assert_stmts.is_empty() {
         return;
     }
 
-    let impl_self_ty = impl_self_ty
-        .unwrap_or_else(|| cx.dcx().span_bug(span, "missing self type in `derive(Eq)`"));
-    push(Annotatable::Item(assert_fields_are_eq_impl(
-        cx,
-        span,
-        strip_const_trait_bounds_from_generics(impl_generics),
-        impl_self_ty,
-        assert_stmts,
-    )));
-}
-
-fn respan_generics_for_derive(generics: &mut ast::Generics, span: Span) {
-    for predicate in &mut generics.where_clause.predicates {
-        predicate.span = span.with_ctxt(predicate.span.ctxt());
-
-        match &mut predicate.kind {
-            ast::WherePredicateKind::BoundPredicate(bound_predicate) => {
-                bound_predicate.bounded_ty.span =
-                    span.with_ctxt(bound_predicate.bounded_ty.span.ctxt());
-
-                for bound in &mut bound_predicate.bounds {
-                    match bound {
-                        ast::GenericBound::Trait(poly_trait_ref) => {
-                            poly_trait_ref.span = span.with_ctxt(poly_trait_ref.span.ctxt());
-                        }
-                        _ => {}
-                    }
-                }
-            }
-            ast::WherePredicateKind::RegionPredicate(region_predicate) => {
-                for bound in &mut region_predicate.bounds {
-                    match bound {
-                        ast::GenericBound::Trait(poly_trait_ref) => {
-                            poly_trait_ref.span = span.with_ctxt(poly_trait_ref.span.ctxt());
-                        }
-                        _ => {}
-                    }
-                }
-            }
-            ast::WherePredicateKind::EqPredicate(eq_predicate) => {
-                eq_predicate.lhs_ty.span = span.with_ctxt(eq_predicate.lhs_ty.span.ctxt());
-                eq_predicate.rhs_ty.span = span.with_ctxt(eq_predicate.rhs_ty.span.ctxt());
-            }
-        }
-    }
-    generics.where_clause.span = span.with_ctxt(generics.where_clause.span.ctxt());
-    generics.span = span.with_ctxt(generics.span.ctxt());
+    StripConstTraitBoundsVisitor.visit_generics(&mut fn_generics);
+    push(Annotatable::Item(expand_const_item_block(cx, span, fn_generics, assert_stmts)));
 }
 
-fn assert_fields_are_eq_impl(
+fn expand_const_item_block(
     cx: &ExtCtxt<'_>,
     span: Span,
-    impl_generics: ast::Generics,
-    impl_self_ty: Box<ast::Ty>,
+    fn_generics: ast::Generics,
     assert_stmts: ThinVec<ast::Stmt>,
 ) -> Box<ast::Item> {
     cx.item(
         span,
         ast::AttrVec::new(),
-        ast::ItemKind::Impl(ast::Impl {
-            generics: impl_generics,
-            of_trait: None,
-            constness: ast::Const::No,
-            self_ty: impl_self_ty,
-            items: thin_vec![Box::new(ast::AssocItem {
-                id: ast::DUMMY_NODE_ID,
-                attrs: thin_vec![
-                    cx.attr_nested_word(sym::doc, sym::hidden, span),
-                    cx.attr_nested_word(sym::coverage, sym::off, span),
-                ],
+        ast::ItemKind::ConstBlock(ast::ConstBlockItem {
+            span,
+            id: ast::DUMMY_NODE_ID,
+            block: cx.block(
                 span,
-                vis: ast::Visibility {
-                    span: span.shrink_to_lo(),
-                    kind: ast::VisibilityKind::Inherited,
-                    tokens: None,
-                },
-                kind: ast::AssocItemKind::Fn(Box::new(ast::Fn {
-                    defaultness: ast::Defaultness::Implicit,
-                    ident: Ident::new(sym::assert_fields_are_eq, span),
-                    generics: ast::Generics { span, ..Default::default() },
-                    sig: ast::FnSig {
-                        header: ast::FnHeader {
-                            constness: ast::Const::Yes(span),
-                            coroutine_kind: None,
-                            safety: ast::Safety::Default,
-                            ext: ast::Extern::None,
-                        },
-                        decl: cx.fn_decl(ThinVec::new(), ast::FnRetTy::Default(span)),
+                thin_vec![ast::Stmt {
+                    span,
+                    id: ast::DUMMY_NODE_ID,
+                    kind: ast::StmtKind::Item(Box::new(ast::Item {
                         span,
-                    },
-                    contract: None,
-                    define_opaque: None,
-                    body: Some(cx.block(span, assert_stmts)),
-                    eii_impls: ThinVec::new(),
-                })),
-                tokens: None,
-            })],
+                        id: ast::DUMMY_NODE_ID,
+                        attrs: thin_vec![
+                            cx.attr_nested_word(sym::doc, sym::hidden, span),
+                            cx.attr_nested_word(sym::coverage, sym::off, span),
+                            cx.attr_word(sym::inline, span),
+                        ],
+                        vis: ast::Visibility {
+                            kind: ast::VisibilityKind::Inherited,
+                            span,
+                            tokens: None,
+                        },
+                        tokens: None,
+                        kind: ast::ItemKind::Fn(Box::new(ast::Fn {
+                            defaultness: ast::Defaultness::Implicit,
+                            ident: Ident::new(sym::assert_fields_are_eq, span),
+                            generics: fn_generics,
+                            sig: ast::FnSig {
+                                header: ast::FnHeader {
+                                    constness: ast::Const::Yes(span),
+                                    coroutine_kind: None,
+                                    safety: ast::Safety::Default,
+                                    ext: ast::Extern::None,
+                                },
+                                decl: cx.fn_decl(ThinVec::new(), ast::FnRetTy::Default(span)),
+                                span,
+                            },
+                            contract: None,
+                            define_opaque: None,
+                            body: Some(cx.block(span, assert_stmts)),
+                            eii_impls: ThinVec::new(),
+                        }))
+                    }))
+                },],
+            ),
         }),
     )
 }
 
-fn strip_const_trait_bounds_from_generics(mut generics: ast::Generics) -> ast::Generics {
-    for param in &mut generics.params {
-        if let ast::GenericParamKind::Type { .. } = &param.kind {
-            strip_constness_from_bounds(&mut param.bounds);
-        }
-    }
-
-    for predicate in &mut generics.where_clause.predicates {
-        if let ast::WherePredicateKind::BoundPredicate(bound_predicate) = &mut predicate.kind {
-            strip_constness_from_bounds(&mut bound_predicate.bounds);
-        }
-    }
-
-    generics
-}
-
-fn strip_constness_from_bounds(bounds: &mut [ast::GenericBound]) {
-    for bound in bounds {
-        if let ast::GenericBound::Trait(poly_trait_ref) = bound {
-            poly_trait_ref.modifiers.constness = ast::BoundConstness::Never;
-        }
-    }
-}
-
 fn eq_assert_stmts_from_item(
     cx: &ExtCtxt<'_>,
     span: Span,
     item: &Annotatable,
+    mut replace_self_ty: ReplaceSelfTyVisitor,
 ) -> ThinVec<ast::Stmt> {
     let mut stmts = ThinVec::new();
     let mut seen_type_names = FxHashSet::default();
@@ -202,11 +212,14 @@ fn eq_assert_stmts_from_item(
             {
                 // Already produced an assertion for this type.
             } else {
+                use ast::mut_visit::MutVisitor;
+                let mut field_ty = field.ty.clone();
+                replace_self_ty.visit_ty(&mut field_ty);
                 // let _: AssertParamIsEq<FieldTy>;
                 super::assert_ty_bounds(
                     cx,
                     &mut stmts,
-                    field.ty.clone(),
+                    field_ty,
                     field.span,
                     &[sym::cmp, sym::AssertParamIsEq],
                 );

tests/ui/deriving/deriving-all-codegen.rs

@@ -79,6 +79,10 @@ struct Reorder {
     b10: &'static *const bool,
 }
 
+// A struct with a recursive type.
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+struct Recursive(Option<Box<Self>>);
+
 // A struct that doesn't impl `Copy`, which means it gets the non-trivial
 // `clone` implemention that clones the fields individually.
 #[derive(Clone)]