Add dummy self pointer arg to emitted const fn

Author: KiChjang

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

@@ -126,23 +126,42 @@ pub(crate) fn expand_deriving_eq(
 
     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));
+    let assert_stmts =
+        eq_assert_stmts_from_item(cx, span, item, ReplaceSelfTyVisitor(self_ty.clone()));
 
     // Skip generating `assert_fields_are_eq` impl if there are no assertions to make
     if assert_stmts.is_empty() {
         return;
     }
 
     StripConstTraitBoundsVisitor.visit_generics(&mut fn_generics);
-    push(Annotatable::Item(expand_const_item_block(cx, span, fn_generics, assert_stmts)));
+    push(Annotatable::Item(expand_const_item_block(cx, span, fn_generics, self_ty, assert_stmts)));
 }
 
 fn expand_const_item_block(
     cx: &ExtCtxt<'_>,
     span: Span,
     fn_generics: ast::Generics,
+    self_ty: Box<ast::Ty>,
     assert_stmts: ThinVec<ast::Stmt>,
 ) -> Box<ast::Item> {
+    // We need a dummy const pointer to Self argument to ensure well-formedness of the Self type.
+    // This doesn't add overhead because the fn itself is never called, and in fact should not
+    // even have any runtime code generated for it as it's an inline const fn.
+    let const_self_ptr_ty =
+        cx.ty(span, ast::TyKind::Ptr(ast::MutTy { mutbl: ast::Mutability::Not, ty: self_ty }));
+    let fn_args = thin_vec![cx.param(span, Ident::new(kw::Underscore, span), const_self_ptr_ty)];
+    let fn_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(fn_args, ast::FnRetTy::Default(span)),
+        span,
+    };
+
     cx.item(
         span,
         ast::AttrVec::new(),
@@ -151,10 +170,9 @@ fn expand_const_item_block(
             id: ast::DUMMY_NODE_ID,
             block: cx.block(
                 span,
-                thin_vec![ast::Stmt {
+                thin_vec![cx.stmt_item(
                     span,
-                    id: ast::DUMMY_NODE_ID,
-                    kind: ast::StmtKind::Item(Box::new(ast::Item {
+                    Box::new(ast::Item {
                         span,
                         id: ast::DUMMY_NODE_ID,
                         attrs: thin_vec![
@@ -175,23 +193,14 @@ fn expand_const_item_block(
                             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,
-                            },
+                            sig: fn_sig,
                             contract: None,
                             define_opaque: None,
                             body: Some(cx.block(span, assert_stmts)),
                             eii_impls: ThinVec::new(),
                         }))
-                    }))
-                },],
+                    })
+                ),],
             ),
         }),
     )

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

@@ -138,7 +138,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const Point) {
         let _: ::core::cmp::AssertParamIsEq<u32>;
     }
 }
@@ -227,7 +227,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const PackedPoint) {
         let _: ::core::cmp::AssertParamIsEq<u32>;
     }
 }
@@ -311,7 +311,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const TupleSingleField) {
         let _: ::core::cmp::AssertParamIsEq<u32>;
     }
 }
@@ -387,7 +387,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const SingleField) {
         let _: ::core::cmp::AssertParamIsEq<bool>;
     }
 }
@@ -493,7 +493,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const Big) {
         let _: ::core::cmp::AssertParamIsEq<u32>;
     }
 }
@@ -690,7 +690,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const Recursive) {
         let _: ::core::cmp::AssertParamIsEq<Option<Box<Recursive>>>;
     }
 }
@@ -793,7 +793,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const Unsized) {
         let _: ::core::cmp::AssertParamIsEq<[u32]>;
     }
 }
@@ -891,7 +891,8 @@ const {
     #[coverage(off)]
     #[inline]
     const fn assert_fields_are_eq<T: ::core::cmp::Eq + Trait,
-        U: ::core::cmp::Eq>() where T::A: ::core::cmp::Eq {
+        U: ::core::cmp::Eq>(_: *const Generic<T, U>) where
+        T::A: ::core::cmp::Eq {
         let _: ::core::cmp::AssertParamIsEq<T>;
         let _: ::core::cmp::AssertParamIsEq<T::A>;
         let _: ::core::cmp::AssertParamIsEq<U>;
@@ -990,7 +991,8 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq<'a, T: ::core::cmp::Eq + Trait>() {
+    const fn assert_fields_are_eq<'a, T: ::core::cmp::Eq +
+        Trait>(_: *const GenericLifetime<'a, T>) {
         let _: ::core::cmp::AssertParamIsEq<&'a T>;
     }
 }
@@ -1095,7 +1097,8 @@ const {
     #[coverage(off)]
     #[inline]
     const fn assert_fields_are_eq<T: ::core::cmp::Eq + ::core::marker::Copy +
-        Trait, U: ::core::cmp::Eq + ::core::marker::Copy>() where
+        Trait, U: ::core::cmp::Eq +
+        ::core::marker::Copy>(_: *const PackedGeneric<T, U>) where
         T::A: ::core::cmp::Eq + ::core::marker::Copy {
         let _: ::core::cmp::AssertParamIsEq<T>;
         let _: ::core::cmp::AssertParamIsEq<T::A>;
@@ -1247,7 +1250,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const Enum1) {
         let _: ::core::cmp::AssertParamIsEq<u32>;
     }
 }
@@ -1491,7 +1494,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const Mixed) {
         let _: ::core::cmp::AssertParamIsEq<u32>;
         let _: ::core::cmp::AssertParamIsEq<Option<u32>>;
         let _: ::core::cmp::AssertParamIsEq<Option<i32>>;
@@ -1690,7 +1693,7 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq() {
+    const fn assert_fields_are_eq(_: *const Fielded) {
         let _: ::core::cmp::AssertParamIsEq<u32>;
         let _: ::core::cmp::AssertParamIsEq<bool>;
         let _: ::core::cmp::AssertParamIsEq<Option<i32>>;
@@ -1814,7 +1817,8 @@ const {
     #[doc(hidden)]
     #[coverage(off)]
     #[inline]
-    const fn assert_fields_are_eq<T: ::core::cmp::Eq, U: ::core::cmp::Eq>() {
+    const fn assert_fields_are_eq<T: ::core::cmp::Eq,
+        U: ::core::cmp::Eq>(_: *const EnumGeneric<T, U>) {
         let _: ::core::cmp::AssertParamIsEq<T>;
         let _: ::core::cmp::AssertParamIsEq<U>;
     }