s/SmartPointer/CoerceReferent/g

move derive_smart_pointer into removed set

Author: dingxiangfei2009

compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs renamed to compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs

@@ -19,7 +19,7 @@ macro_rules! path {
     ($span:expr, $($part:ident)::*) => { vec![$(Ident::new(sym::$part, $span),)*] }
 }
 
-pub(crate) fn expand_deriving_smart_ptr(
+pub(crate) fn expand_deriving_coerce_pointee(
     cx: &ExtCtxt<'_>,
     span: Span,
     _mitem: &MetaItem,
@@ -41,7 +41,7 @@ pub(crate) fn expand_deriving_smart_ptr(
             cx.dcx()
                 .struct_span_err(
                     span,
-                    "`SmartPointer` can only be derived on `struct`s with `#[repr(transparent)]`",
+                    "`CoercePointee` can only be derived on `struct`s with `#[repr(transparent)]`",
                 )
                 .emit();
             return;
@@ -54,7 +54,7 @@ pub(crate) fn expand_deriving_smart_ptr(
             cx.dcx()
                 .struct_span_err(
                     span,
-                    "`SmartPointer` can only be derived on `struct`s with at least one field",
+                    "`CoercePointee` can only be derived on `struct`s with at least one field",
                 )
                 .emit();
             return;
@@ -64,7 +64,7 @@ pub(crate) fn expand_deriving_smart_ptr(
         cx.dcx()
             .struct_span_err(
                 span,
-                "`SmartPointer` can only be derived on `struct`s with `#[repr(transparent)]`",
+                "`CoercePointee` can only be derived on `struct`s with `#[repr(transparent)]`",
             )
             .emit();
         return;
@@ -94,10 +94,10 @@ pub(crate) fn expand_deriving_smart_ptr(
         .collect();
 
     let pointee_param_idx = if type_params.is_empty() {
-        // `#[derive(SmartPointer)]` requires at least one generic type on the target `struct`
+        // `#[derive(CoercePointee)]` requires at least one generic type on the target `struct`
         cx.dcx().struct_span_err(
             span,
-            "`SmartPointer` can only be derived on `struct`s that are generic over at least one type",
+            "`CoercePointee` can only be derived on `struct`s that are generic over at least one type",
         ).emit();
         return;
     } else if type_params.len() == 1 {
@@ -113,15 +113,15 @@ pub(crate) fn expand_deriving_smart_ptr(
             (None, _) => {
                 cx.dcx().struct_span_err(
                     span,
-                    "exactly one generic type parameter must be marked as #[pointee] to derive SmartPointer traits",
+                    "exactly one generic type parameter must be marked as #[pointee] to derive CoercePointee traits",
                 ).emit();
                 return;
             }
             (Some((_, one)), Some((_, another))) => {
                 cx.dcx()
                     .struct_span_err(
                         vec![one, another],
-                        "only one type parameter can be marked as `#[pointee]` when deriving SmartPointer traits",
+                        "only one type parameter can be marked as `#[pointee]` when deriving CoercePointee traits",
                     )
                     .emit();
                 return;
@@ -185,7 +185,7 @@ pub(crate) fn expand_deriving_smart_ptr(
                 .struct_span_err(
                     pointee_ty_ident.span,
                     format!(
-                        "`derive(SmartPointer)` requires {} to be marked `?Sized`",
+                        "`derive(CoercePointee)` requires {} to be marked `?Sized`",
                         pointee_ty_ident.name
                     ),
                 )
@@ -195,7 +195,7 @@ pub(crate) fn expand_deriving_smart_ptr(
         let arg = GenericArg::Type(s_ty.clone());
         let unsize = cx.path_all(span, true, path!(span, core::marker::Unsize), vec![arg]);
         pointee.bounds.push(cx.trait_bound(unsize, false));
-        // Drop `#[pointee]` attribute since it should not be recognized outside `derive(SmartPointer)`
+        // Drop `#[pointee]` attribute since it should not be recognized outside `derive(CoercePointee)`
         pointee.attrs.retain(|attr| !attr.has_name(sym::pointee));
     }
 

compiler/rustc_builtin_macros/src/deriving/mod.rs

@@ -22,12 +22,12 @@ macro path_std($($x:tt)*) {
 
 pub(crate) mod bounds;
 pub(crate) mod clone;
+pub(crate) mod coerce_pointee;
 pub(crate) mod debug;
 pub(crate) mod decodable;
 pub(crate) mod default;
 pub(crate) mod encodable;
 pub(crate) mod hash;
-pub(crate) mod smart_ptr;
 
 #[path = "cmp/eq.rs"]
 pub(crate) mod eq;

compiler/rustc_builtin_macros/src/lib.rs

@@ -130,7 +130,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         PartialOrd: partial_ord::expand_deriving_partial_ord,
         RustcDecodable: decodable::expand_deriving_rustc_decodable,
         RustcEncodable: encodable::expand_deriving_rustc_encodable,
-        SmartPointer: smart_ptr::expand_deriving_smart_ptr,
+        CoercePointee: coerce_pointee::expand_deriving_coerce_pointee,
     }
 
     let client = proc_macro::bridge::client::Client::expand1(proc_macro::quote);

compiler/rustc_feature/src/removed.rs

@@ -85,6 +85,8 @@ declare_features! (
     /// Allows default type parameters to influence type inference.
     (removed, default_type_parameter_fallback, "1.82.0", Some(27336),
      Some("never properly implemented; requires significant design work")),
+    /// Allows deriving traits as per `SmartPointer` specification
+    (removed, derive_smart_pointer, "1.79.0", Some(123430), Some("replaced by `CoercePointee`")),
     /// Allows using `#[doc(keyword = "...")]`.
     (removed, doc_keyword, "1.28.0", Some(51315),
      Some("merged into `#![feature(rustdoc_internals)]`")),

compiler/rustc_feature/src/unstable.rs

@@ -432,8 +432,8 @@ declare_features! (
     (unstable, deprecated_suggestion, "1.61.0", Some(94785)),
     /// Allows deref patterns.
     (incomplete, deref_patterns, "1.79.0", Some(87121)),
-    /// Allows deriving `SmartPointer` traits
-    (unstable, derive_smart_pointer, "1.79.0", Some(123430)),
+    /// Allows deriving traits as per `CoercePointee` specification
+    (unstable, derive_coerce_pointee, "1.79.0", Some(123430)),
     /// Controls errors in trait implementations.
     (unstable, do_not_recommend, "1.67.0", Some(51992)),
     /// Tells rustdoc to automatically generate `#[doc(cfg(...))]`.

compiler/rustc_passes/src/check_attr.rs

@@ -259,7 +259,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | sym::cfg_attr
                     // need to be fixed
                     | sym::cfi_encoding // FIXME(cfi_encoding)
-                    | sym::pointee // FIXME(derive_smart_pointer)
+                    | sym::pointee // FIXME(derive_coerce_pointee)
                     | sym::omit_gdb_pretty_printer_section // FIXME(omit_gdb_pretty_printer_section)
                     | sym::used // handled elsewhere to restrict to static items
                     | sym::repr // handled elsewhere to restrict to type decls items

compiler/rustc_span/src/symbol.rs

@@ -174,6 +174,7 @@ symbols! {
         Center,
         Cleanup,
         Clone,
+        CoercePointee,
         CoerceUnsized,
         Command,
         ConstParamTy,
@@ -315,7 +316,6 @@ symbols! {
         Sized,
         SliceIndex,
         SliceIter,
-        SmartPointer,
         Some,
         SpanCtxt,
         String,
@@ -737,6 +737,7 @@ symbols! {
         deref_pure,
         deref_target,
         derive,
+        derive_coerce_pointee,
         derive_const,
         derive_default_enum,
         derive_smart_pointer,

library/core/src/marker.rs

@@ -1062,10 +1062,11 @@ pub trait FnPtr: Copy + Clone {
 }
 
 /// Derive macro generating impls of traits related to smart pointers.
-#[rustc_builtin_macro(SmartPointer, attributes(pointee))]
+#[rustc_builtin_macro(CoercePointee, attributes(pointee))]
 #[allow_internal_unstable(dispatch_from_dyn, coerce_unsized, unsize)]
-#[unstable(feature = "derive_smart_pointer", issue = "123430")]
-pub macro SmartPointer($item:item) {
+#[unstable(feature = "derive_coerce_pointee", issue = "123430")]
+#[cfg(not(bootstrap))]
+pub macro CoercePointee($item:item) {
     /* compiler built-in */
 }
 

tests/ui/deriving/auxiliary/another-proc-macro.rs

@@ -6,7 +6,7 @@
 
 extern crate proc_macro;
 
-use proc_macro::{quote, TokenStream};
+use proc_macro::{TokenStream, quote};
 
 #[proc_macro_derive(AnotherMacro, attributes(pointee))]
 pub fn derive(_input: TokenStream) -> TokenStream {
@@ -25,7 +25,7 @@ pub fn pointee(
 ) -> proc_macro::TokenStream {
     quote! {
         const _: () = {
-            const POINTEE_MACRO_ATTR_DERIVED: () = ();
+            const REFERENT_MACRO_ATTR_DERIVED: () = ();
         };
     }
     .into()

tests/ui/deriving/built-in-proc-macro-scope.rs

@@ -2,14 +2,14 @@
 //@ aux-build: another-proc-macro.rs
 //@ compile-flags: -Zunpretty=expanded
 
-#![feature(derive_smart_pointer)]
+#![feature(derive_coerce_pointee)]
 
 #[macro_use]
 extern crate another_proc_macro;
 
-use another_proc_macro::{pointee, AnotherMacro};
+use another_proc_macro::{AnotherMacro, pointee};
 
-#[derive(core::marker::SmartPointer)]
+#[derive(core::marker::CoercePointee)]
 #[repr(transparent)]
 pub struct Ptr<'a, #[pointee] T: ?Sized> {
     data: &'a mut T,

tests/ui/deriving/built-in-proc-macro-scope.stdout

@@ -4,7 +4,7 @@
 //@ aux-build: another-proc-macro.rs
 //@ compile-flags: -Zunpretty=expanded
 
-#![feature(derive_smart_pointer)]
+#![feature(derive_coerce_pointee)]
 #[prelude_import]
 use ::std::prelude::rust_2015::*;
 #[macro_use]
@@ -13,7 +13,7 @@ extern crate std;
 #[macro_use]
 extern crate another_proc_macro;
 
-use another_proc_macro::{pointee, AnotherMacro};
+use another_proc_macro::{AnotherMacro, pointee};
 
 #[repr(transparent)]
 pub struct Ptr<'a, #[pointee] T: ?Sized> {
@@ -32,7 +32,7 @@ impl<'a, T: ?Sized + ::core::marker::Unsize<__S>, __S: ?Sized>
 
 const _: () =
     {
-        const POINTEE_MACRO_ATTR_DERIVED: () = ();
+        const REFERENT_MACRO_ATTR_DERIVED: () = ();
     };
 #[pointee]
 struct MyStruct;

tests/ui/deriving/smart-pointer-bounds-issue-127647.rs renamed to tests/ui/deriving/coerce-pointee-bounds-issue-127647.rs

@@ -1,8 +1,8 @@
 //@ check-pass
 
-#![feature(derive_smart_pointer)]
+#![feature(derive_coerce_pointee)]
 
-#[derive(core::marker::SmartPointer)]
+#[derive(core::marker::CoercePointee)]
 #[repr(transparent)]
 pub struct Ptr<'a, #[pointee] T: OnDrop + ?Sized, X> {
     data: &'a mut T,
@@ -13,7 +13,7 @@ pub trait OnDrop {
     fn on_drop(&mut self);
 }
 
-#[derive(core::marker::SmartPointer)]
+#[derive(core::marker::CoercePointee)]
 #[repr(transparent)]
 pub struct Ptr2<'a, #[pointee] T: ?Sized, X>
 where
@@ -25,7 +25,7 @@ where
 
 pub trait MyTrait<T: ?Sized> {}
 
-#[derive(core::marker::SmartPointer)]
+#[derive(core::marker::CoercePointee)]
 #[repr(transparent)]
 pub struct Ptr3<'a, #[pointee] T: ?Sized, X>
 where
@@ -35,14 +35,14 @@ where
     x: core::marker::PhantomData<X>,
 }
 
-#[derive(core::marker::SmartPointer)]
+#[derive(core::marker::CoercePointee)]
 #[repr(transparent)]
 pub struct Ptr4<'a, #[pointee] T: MyTrait<T> + ?Sized, X> {
     data: &'a mut T,
     x: core::marker::PhantomData<X>,
 }
 
-#[derive(core::marker::SmartPointer)]
+#[derive(core::marker::CoercePointee)]
 #[repr(transparent)]
 pub struct Ptr5<'a, #[pointee] T: ?Sized, X>
 where
@@ -56,7 +56,7 @@ where
 pub struct Ptr5Companion<T: ?Sized>(core::marker::PhantomData<T>);
 pub struct Ptr5Companion2;
 
-#[derive(core::marker::SmartPointer)]
+#[derive(core::marker::CoercePointee)]
 #[repr(transparent)]
 pub struct Ptr6<'a, #[pointee] T: ?Sized, X: MyTrait<T> = (), const PARAM: usize = 0> {
     data: &'a mut T,
@@ -65,7 +65,7 @@ pub struct Ptr6<'a, #[pointee] T: ?Sized, X: MyTrait<T> = (), const PARAM: usize
 
 // a reduced example from https://lore.kernel.org/all/20240402-linked-list-v1-1-b1c59ba7ae3b@google.com/
 #[repr(transparent)]
-#[derive(core::marker::SmartPointer)]
+#[derive(core::marker::CoercePointee)]
 pub struct ListArc<#[pointee] T, const ID: u64 = 0>
 where
     T: ListArcSafe<ID> + ?Sized,

tests/ui/deriving/deriving-smart-pointer-expanded.rs renamed to tests/ui/deriving/deriving-coerce-pointee-expanded.rs

@@ -1,17 +1,17 @@
 //@ check-pass
 //@ compile-flags: -Zunpretty=expanded
-#![feature(derive_smart_pointer)]
-use std::marker::SmartPointer;
+#![feature(derive_coerce_pointee)]
+use std::marker::CoercePointee;
 
 pub trait MyTrait<T: ?Sized> {}
 
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct MyPointer<'a, #[pointee] T: ?Sized> {
     ptr: &'a T,
 }
 
-#[derive(core::marker::SmartPointer)]
+#[derive(core::marker::CoercePointee)]
 #[repr(transparent)]
 pub struct MyPointer2<'a, Y, Z: MyTrait<T>, #[pointee] T: ?Sized + MyTrait<T>, X: MyTrait<T> = ()>
 where
@@ -21,7 +21,7 @@ where
     x: core::marker::PhantomData<X>,
 }
 
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct MyPointerWithoutPointee<'a, T: ?Sized> {
     ptr: &'a T,

tests/ui/deriving/deriving-smart-pointer-expanded.stdout renamed to tests/ui/deriving/deriving-coerce-pointee-expanded.stdout

@@ -2,12 +2,12 @@
 #![no_std]
 //@ check-pass
 //@ compile-flags: -Zunpretty=expanded
-#![feature(derive_smart_pointer)]
+#![feature(derive_coerce_pointee)]
 #[prelude_import]
 use ::std::prelude::rust_2015::*;
 #[macro_use]
 extern crate std;
-use std::marker::SmartPointer;
+use std::marker::CoercePointee;
 
 pub trait MyTrait<T: ?Sized> {}
 

tests/ui/deriving/deriving-smart-pointer-neg.rs renamed to tests/ui/deriving/deriving-coerce-pointee-neg.rs

@@ -1,115 +1,131 @@
-#![feature(derive_smart_pointer, arbitrary_self_types)]
+#![feature(derive_coerce_pointee, arbitrary_self_types)]
 
 extern crate core;
-use std::marker::SmartPointer;
+use std::marker::CoercePointee;
 
-#[derive(SmartPointer)]
-//~^ ERROR: `SmartPointer` can only be derived on `struct`s with `#[repr(transparent)]`
+#[derive(CoercePointee)]
+//~^ ERROR: `CoercePointee` can only be derived on `struct`s with `#[repr(transparent)]`
 enum NotStruct<'a, T: ?Sized> {
     Variant(&'a T),
 }
 
-#[derive(SmartPointer)]
-//~^ ERROR: `SmartPointer` can only be derived on `struct`s with at least one field
+#[derive(CoercePointee)]
+//~^ ERROR: `CoercePointee` can only be derived on `struct`s with at least one field
 #[repr(transparent)]
 struct NoField<'a, #[pointee] T: ?Sized> {}
 //~^ ERROR: lifetime parameter `'a` is never used
 //~| ERROR: type parameter `T` is never used
 
-#[derive(SmartPointer)]
-//~^ ERROR: `SmartPointer` can only be derived on `struct`s with at least one field
+#[derive(CoercePointee)]
+//~^ ERROR: `CoercePointee` can only be derived on `struct`s with at least one field
 #[repr(transparent)]
 struct NoFieldUnit<'a, #[pointee] T: ?Sized>();
 //~^ ERROR: lifetime parameter `'a` is never used
 //~| ERROR: type parameter `T` is never used
 
-#[derive(SmartPointer)]
-//~^ ERROR: `SmartPointer` can only be derived on `struct`s that are generic over at least one type
+#[derive(CoercePointee)]
+//~^ ERROR: `CoercePointee` can only be derived on `struct`s that are generic over at least one type
 #[repr(transparent)]
 struct NoGeneric<'a>(&'a u8);
 
-#[derive(SmartPointer)]
-//~^ ERROR: exactly one generic type parameter must be marked as #[pointee] to derive SmartPointer traits
+#[derive(CoercePointee)]
+//~^ ERROR: exactly one generic type parameter must be marked as #[pointee] to derive CoercePointee traits
 #[repr(transparent)]
 struct AmbiguousPointee<'a, T1: ?Sized, T2: ?Sized> {
     a: (&'a T1, &'a T2),
 }
 
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct TooManyPointees<'a, #[pointee] A: ?Sized, #[pointee] B: ?Sized>((&'a A, &'a B));
-//~^ ERROR: only one type parameter can be marked as `#[pointee]` when deriving SmartPointer traits
+//~^ ERROR: only one type parameter can be marked as `#[pointee]` when deriving CoercePointee traits
 
-#[derive(SmartPointer)]
-//~^ ERROR: `SmartPointer` can only be derived on `struct`s with `#[repr(transparent)]`
+#[derive(CoercePointee)]
+//~^ ERROR: `CoercePointee` can only be derived on `struct`s with `#[repr(transparent)]`
 struct NotTransparent<'a, #[pointee] T: ?Sized> {
     ptr: &'a T,
 }
 
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct NoMaybeSized<'a, #[pointee] T> {
-    //~^ ERROR: `derive(SmartPointer)` requires T to be marked `?Sized`
+    //~^ ERROR: `derive(CoercePointee)` requires T to be marked `?Sized`
     ptr: &'a T,
 }
 
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct PointeeOnField<'a, #[pointee] T: ?Sized> {
     #[pointee]
     //~^ ERROR: the `#[pointee]` attribute may only be used on generic parameters
-    ptr: &'a T
+    ptr: &'a T,
 }
 
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
-struct PointeeInTypeConstBlock<'a, T: ?Sized = [u32; const { struct UhOh<#[pointee] T>(T); 10 }]> {
-    //~^ ERROR: the `#[pointee]` attribute may only be used on generic parameters
+struct PointeeInTypeConstBlock<
+    'a,
+    T: ?Sized = [u32; const {
+                    struct UhOh<#[pointee] T>(T);
+                    //~^ ERROR: the `#[pointee]` attribute may only be used on generic parameters
+                    10
+                }],
+> {
     ptr: &'a T,
 }
 
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct PointeeInConstConstBlock<
     'a,
     T: ?Sized,
-    const V: u32 = { struct UhOh<#[pointee] T>(T); 10 }>
-    //~^ ERROR: the `#[pointee]` attribute may only be used on generic parameters
-{
+    const V: u32 = {
+        struct UhOh<#[pointee] T>(T);
+        //~^ ERROR: the `#[pointee]` attribute may only be used on generic parameters
+        10
+    },
+> {
     ptr: &'a T,
 }
 
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct PointeeInAnotherTypeConstBlock<'a, #[pointee] T: ?Sized> {
-    ptr: PointeeInConstConstBlock<'a, T, { struct UhOh<#[pointee] T>(T); 0 }>
-    //~^ ERROR: the `#[pointee]` attribute may only be used on generic parameters
+    ptr: PointeeInConstConstBlock<
+        'a,
+        T,
+        {
+            struct UhOh<#[pointee] T>(T);
+            //~^ ERROR: the `#[pointee]` attribute may only be used on generic parameters
+            0
+        },
+    >,
 }
 
 // However, reordering attributes should work nevertheless.
 #[repr(transparent)]
-#[derive(SmartPointer)]
-struct ThisIsAPossibleSmartPointer<'a, #[pointee] T: ?Sized> {
+#[derive(CoercePointee)]
+struct ThisIsAPossibleCoercePointee<'a, #[pointee] T: ?Sized> {
     ptr: &'a T,
 }
 
 // Also, these paths to Sized should work
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct StdSized<'a, #[pointee] T: ?std::marker::Sized> {
     ptr: &'a T,
 }
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct CoreSized<'a, #[pointee] T: ?core::marker::Sized> {
     ptr: &'a T,
 }
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct GlobalStdSized<'a, #[pointee] T: ?::std::marker::Sized> {
     ptr: &'a T,
 }
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct GlobalCoreSized<'a, #[pointee] T: ?::core::marker::Sized> {
     ptr: &'a T,

tests/ui/deriving/deriving-coerce-pointee-neg.stderr

@@ -0,0 +1,119 @@
+error: `CoercePointee` can only be derived on `struct`s with `#[repr(transparent)]`
+  --> $DIR/deriving-coerce-pointee-neg.rs:6:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+   |
+   = note: this error originates in the derive macro `CoercePointee` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `CoercePointee` can only be derived on `struct`s with at least one field
+  --> $DIR/deriving-coerce-pointee-neg.rs:12:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+   |
+   = note: this error originates in the derive macro `CoercePointee` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `CoercePointee` can only be derived on `struct`s with at least one field
+  --> $DIR/deriving-coerce-pointee-neg.rs:19:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+   |
+   = note: this error originates in the derive macro `CoercePointee` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `CoercePointee` can only be derived on `struct`s that are generic over at least one type
+  --> $DIR/deriving-coerce-pointee-neg.rs:26:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+   |
+   = note: this error originates in the derive macro `CoercePointee` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: exactly one generic type parameter must be marked as #[pointee] to derive CoercePointee traits
+  --> $DIR/deriving-coerce-pointee-neg.rs:31:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+   |
+   = note: this error originates in the derive macro `CoercePointee` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: only one type parameter can be marked as `#[pointee]` when deriving CoercePointee traits
+  --> $DIR/deriving-coerce-pointee-neg.rs:40:39
+   |
+LL | struct TooManyPointees<'a, #[pointee] A: ?Sized, #[pointee] B: ?Sized>((&'a A, &'a B));
+   |                                       ^                     ^
+
+error: `CoercePointee` can only be derived on `struct`s with `#[repr(transparent)]`
+  --> $DIR/deriving-coerce-pointee-neg.rs:43:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+   |
+   = note: this error originates in the derive macro `CoercePointee` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `derive(CoercePointee)` requires T to be marked `?Sized`
+  --> $DIR/deriving-coerce-pointee-neg.rs:51:36
+   |
+LL | struct NoMaybeSized<'a, #[pointee] T> {
+   |                                    ^
+
+error: the `#[pointee]` attribute may only be used on generic parameters
+  --> $DIR/deriving-coerce-pointee-neg.rs:59:5
+   |
+LL |     #[pointee]
+   |     ^^^^^^^^^^
+
+error: the `#[pointee]` attribute may only be used on generic parameters
+  --> $DIR/deriving-coerce-pointee-neg.rs:69:33
+   |
+LL |                     struct UhOh<#[pointee] T>(T);
+   |                                 ^^^^^^^^^^
+
+error: the `#[pointee]` attribute may only be used on generic parameters
+  --> $DIR/deriving-coerce-pointee-neg.rs:83:21
+   |
+LL |         struct UhOh<#[pointee] T>(T);
+   |                     ^^^^^^^^^^
+
+error: the `#[pointee]` attribute may only be used on generic parameters
+  --> $DIR/deriving-coerce-pointee-neg.rs:98:25
+   |
+LL |             struct UhOh<#[pointee] T>(T);
+   |                         ^^^^^^^^^^
+
+error[E0392]: lifetime parameter `'a` is never used
+  --> $DIR/deriving-coerce-pointee-neg.rs:15:16
+   |
+LL | struct NoField<'a, #[pointee] T: ?Sized> {}
+   |                ^^ unused lifetime parameter
+   |
+   = help: consider removing `'a`, referring to it in a field, or using a marker such as `PhantomData`
+
+error[E0392]: type parameter `T` is never used
+  --> $DIR/deriving-coerce-pointee-neg.rs:15:31
+   |
+LL | struct NoField<'a, #[pointee] T: ?Sized> {}
+   |                               ^ unused type parameter
+   |
+   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+
+error[E0392]: lifetime parameter `'a` is never used
+  --> $DIR/deriving-coerce-pointee-neg.rs:22:20
+   |
+LL | struct NoFieldUnit<'a, #[pointee] T: ?Sized>();
+   |                    ^^ unused lifetime parameter
+   |
+   = help: consider removing `'a`, referring to it in a field, or using a marker such as `PhantomData`
+
+error[E0392]: type parameter `T` is never used
+  --> $DIR/deriving-coerce-pointee-neg.rs:22:35
+   |
+LL | struct NoFieldUnit<'a, #[pointee] T: ?Sized>();
+   |                                   ^ unused type parameter
+   |
+   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+
+error: aborting due to 16 previous errors
+
+For more information about this error, try `rustc --explain E0392`.

tests/ui/deriving/deriving-smart-pointer.rs renamed to tests/ui/deriving/deriving-coerce-pointee.rs

@@ -1,9 +1,9 @@
 //@ run-pass
-#![feature(derive_smart_pointer, arbitrary_self_types)]
+#![feature(derive_coerce_pointee, arbitrary_self_types)]
 
-use std::marker::SmartPointer;
+use std::marker::CoercePointee;
 
-#[derive(SmartPointer)]
+#[derive(CoercePointee)]
 #[repr(transparent)]
 struct MyPointer<'a, #[pointee] T: ?Sized> {
     ptr: &'a T,

tests/ui/deriving/deriving-smart-pointer-neg.stderr

@@ -1,5 +1,5 @@
 // This test certify that we can mix attribute macros from Rust and external proc-macros.
-// For instance, `#[derive(Default)]` uses `#[default]` and `#[derive(SmartPointer)]` uses
+// For instance, `#[derive(Default)]` uses `#[default]` and `#[derive(CoercePointee)]` uses
 // `#[pointee]`.
 // The scoping rule should allow the use of the said two attributes when external proc-macros
 // are in scope.
@@ -8,7 +8,7 @@
 //@ aux-build: another-proc-macro.rs
 //@ compile-flags: -Zunpretty=expanded
 
-#![feature(derive_smart_pointer)]
+#![feature(derive_coerce_pointee)]
 
 #[macro_use]
 extern crate another_proc_macro;

tests/ui/deriving/proc-macro-attribute-mixing.rs

@@ -1,7 +1,7 @@
 #![feature(prelude_import)]
 #![no_std]
 // This test certify that we can mix attribute macros from Rust and external proc-macros.
-// For instance, `#[derive(Default)]` uses `#[default]` and `#[derive(SmartPointer)]` uses
+// For instance, `#[derive(Default)]` uses `#[default]` and `#[derive(CoercePointee)]` uses
 // `#[pointee]`.
 // The scoping rule should allow the use of the said two attributes when external proc-macros
 // are in scope.
@@ -10,7 +10,7 @@
 //@ aux-build: another-proc-macro.rs
 //@ compile-flags: -Zunpretty=expanded
 
-#![feature(derive_smart_pointer)]
+#![feature(derive_coerce_pointee)]
 #[prelude_import]
 use ::std::prelude::rust_2015::*;
 #[macro_use]
@@ -22,7 +22,7 @@ extern crate another_proc_macro;
 
 const _: () =
     {
-        const POINTEE_MACRO_ATTR_DERIVED: () = ();
+        const REFERENT_MACRO_ATTR_DERIVED: () = ();
     };
 const _: () =
     {

tests/ui/deriving/proc-macro-attribute-mixing.stdout

@@ -0,0 +1,9 @@
+use std::marker::CoercePointee; //~ ERROR use of unstable library feature 'derive_coerce_pointee'
+
+#[derive(CoercePointee)] //~ ERROR use of unstable library feature 'derive_coerce_pointee'
+#[repr(transparent)]
+struct MyPointer<'a, #[pointee] T: ?Sized> {
+    ptr: &'a T,
+}
+
+fn main() {}

tests/ui/feature-gates/feature-gate-derive-coerce-pointee.rs

@@ -0,0 +1,23 @@
+error[E0658]: use of unstable library feature 'derive_coerce_pointee'
+  --> $DIR/feature-gate-derive-coerce-pointee.rs:3:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+   |
+   = note: see issue #123430 <https://github.com/rust-lang/rust/issues/123430> for more information
+   = help: add `#![feature(derive_coerce_pointee)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: use of unstable library feature 'derive_coerce_pointee'
+  --> $DIR/feature-gate-derive-coerce-pointee.rs:1:5
+   |
+LL | use std::marker::CoercePointee;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #123430 <https://github.com/rust-lang/rust/issues/123430> for more information
+   = help: add `#![feature(derive_coerce_pointee)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0658`.