add pin projections to #[pin_data]

Make the `#[pin_data]` macro generate a `*Projection` struct that holds
either `Pin<&mut Field>` or `&mut Field` for every field of the original
struct. Which version is chosen depends on weather there is a `#[pin]`
or not respectively. Access to this projected version is enabled through
generating `fn project(self: Pin<&mut Self>) -> SelfProjection<'_>`.

Signed-off-by: Benno Lossin <lossin@kernel.org>

Author: BennoLossin

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- `#[pin_data]` now generates a `*Projection` struct similar to the `pin-project` crate.
+
 ## [0.0.10] - 2025-08-19
 
 ### Added

src/macros.rs

@@ -831,6 +831,17 @@ macro_rules! __pin_data {
             $($fields)*
         }
 
+        $crate::__pin_data!(make_pin_projections:
+            @vis($vis),
+            @name($name),
+            @impl_generics($($impl_generics)*),
+            @ty_generics($($ty_generics)*),
+            @decl_generics($($decl_generics)*),
+            @where($($whr)*),
+            @pinned($($pinned)*),
+            @not_pinned($($not_pinned)*),
+        );
+
         // We put the rest into this const item, because it then will not be accessible to anything
         // outside.
         const _: () = {
@@ -980,6 +991,56 @@ macro_rules! __pin_data {
             stringify!($($rest)*),
         );
     };
+    (make_pin_projections:
+        @vis($vis:vis),
+        @name($name:ident),
+        @impl_generics($($impl_generics:tt)*),
+        @ty_generics($($ty_generics:tt)*),
+        @decl_generics($($decl_generics:tt)*),
+        @where($($whr:tt)*),
+        @pinned($($(#[$($p_attr:tt)*])* $pvis:vis $p_field:ident : $p_type:ty),* $(,)?),
+        @not_pinned($($(#[$($attr:tt)*])* $fvis:vis $field:ident : $type:ty),* $(,)?),
+    ) => {
+        $crate::macros::paste! {
+            #[doc(hidden)]
+            $vis struct [< $name Projection >] <'__pin, $($decl_generics)*> {
+                $($(#[$($p_attr)*])* $pvis $p_field : ::core::pin::Pin<&'__pin mut $p_type>,)*
+                $($(#[$($attr)*])* $fvis $field : &'__pin mut $type,)*
+                ___pin_phantom_data: ::core::marker::PhantomData<&'__pin mut ()>,
+            }
+
+            impl<$($impl_generics)*> $name<$($ty_generics)*>
+            where $($whr)*
+            {
+                /// Pin-projects all fields of `Self`.
+                ///
+                /// These fields are structurally pinned:
+                $(#[doc = ::core::concat!(" - `", ::core::stringify!($p_field), "`")])*
+                ///
+                /// These fields are **not** structurally pinned:
+                $(#[doc = ::core::concat!(" - `", ::core::stringify!($field), "`")])*
+                #[inline]
+                $vis fn project<'__pin>(
+                    self: ::core::pin::Pin<&'__pin mut Self>,
+                ) -> [< $name Projection >] <'__pin, $($ty_generics)*> {
+                    // SAFETY: we only give access to `&mut` for fields not structurally pinned.
+                    let this = unsafe { ::core::pin::Pin::get_unchecked_mut(self) };
+                    [< $name Projection >] {
+                        $(
+                            // SAFETY: `$p_field` is structurally pinned.
+                            $(#[$($p_attr)*])*
+                            $p_field : unsafe { ::core::pin::Pin::new_unchecked(&mut this.$p_field) },
+                        )*
+                        $(
+                            $(#[$($attr)*])*
+                            $field : &mut this.$field,
+                        )*
+                        ___pin_phantom_data: ::core::marker::PhantomData,
+                    }
+                }
+            }
+        }
+    };
     (make_pin_data:
         @pin_data($pin_data:ident),
         @impl_generics($($impl_generics:tt)*),

tests/ui/compile-fail/init/wrong_generics2.stderr

@@ -12,7 +12,7 @@ help: you might have forgotten to add the struct literal inside the block
  --> src/macros.rs
   |
   ~                 ::core::ptr::write($slot, $t { SomeStruct {
-  |9                    $($acc)*
+  |0                    $($acc)*
   ~                 } });
   |
 

tests/ui/compile-fail/pin_data/twice.stderr

@@ -1,3 +1,15 @@
+error[E0428]: the name `FooProjection` is defined multiple times
+ --> tests/ui/compile-fail/pin_data/twice.rs:3:1
+  |
+3 | #[pin_data]
+  | ^^^^^^^^^^^
+  | |
+  | `FooProjection` redefined here
+  | previous definition of the type `FooProjection` here
+  |
+  = note: `FooProjection` must be defined only once in the type namespace of this module
+  = note: this error originates in the macro `$crate::__pin_data` which comes from the expansion of the attribute macro `pin_data` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error[E0119]: conflicting implementations of trait `HasPinData` for type `Foo`
  --> tests/ui/compile-fail/pin_data/twice.rs:3:1
   |
@@ -19,3 +31,24 @@ error[E0119]: conflicting implementations of trait `Unpin` for type `Foo`
   | conflicting implementation for `Foo`
   |
   = note: this error originates in the macro `$crate::__pin_data` which comes from the expansion of the attribute macro `pin_data` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0592]: duplicate definitions with name `project`
+ --> tests/ui/compile-fail/pin_data/twice.rs:3:1
+  |
+3 | #[pin_data]
+  | ^^^^^^^^^^^
+  | |
+  | duplicate definitions for `project`
+  | other definition for `project`
+  |
+  = note: this error originates in the macro `$crate::__pin_data` which comes from the expansion of the attribute macro `pin_data` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0308]: mismatched types
+ --> tests/ui/compile-fail/pin_data/twice.rs:3:1
+  |
+3 | #[pin_data]
+  | ^^^^^^^^^^^ expected `&mut usize`, found `Pin<&mut usize>`
+  |
+  = note: expected mutable reference `&mut usize`
+                        found struct `Pin<&mut usize>`
+  = note: this error originates in the macro `$crate::__pin_data` which comes from the expansion of the attribute macro `pin_data` (in Nightly builds, run with -Z macro-backtrace for more info)

tests/ui/expand/many_generics.expanded.rs

@@ -12,6 +12,44 @@ where
     r: &'b mut [&'a mut T; SIZE],
     _pin: PhantomPinned,
 }
+#[doc(hidden)]
+struct FooProjection<
+    '__pin,
+    'a,
+    'b: 'a,
+    T: Bar<'b> + ?Sized + 'a,
+    const SIZE: usize = 0,
+> {
+    _pin: ::core::pin::Pin<&'__pin mut PhantomPinned>,
+    array: &'__pin mut [u8; 1024 * 1024],
+    r: &'__pin mut &'b mut [&'a mut T; SIZE],
+    ___pin_phantom_data: ::core::marker::PhantomData<&'__pin mut ()>,
+}
+impl<'a, 'b: 'a, T: Bar<'b> + ?Sized + 'a, const SIZE: usize> Foo<'a, 'b, T, SIZE>
+where
+    T: Bar<'a, 1>,
+{
+    /// Pin-projects all fields of `Self`.
+    ///
+    /// These fields are structurally pinned:
+    /// - `_pin`
+    ///
+    /// These fields are **not** structurally pinned:
+    /// - `array`
+    /// - `r`
+    #[inline]
+    fn project<'__pin>(
+        self: ::core::pin::Pin<&'__pin mut Self>,
+    ) -> FooProjection<'__pin, 'a, 'b, T, SIZE> {
+        let this = unsafe { ::core::pin::Pin::get_unchecked_mut(self) };
+        FooProjection {
+            _pin: unsafe { ::core::pin::Pin::new_unchecked(&mut this._pin) },
+            array: &mut this.array,
+            r: &mut this.r,
+            ___pin_phantom_data: ::core::marker::PhantomData,
+        }
+    }
+}
 const _: () = {
     struct __ThePinData<'a, 'b: 'a, T: Bar<'b> + ?Sized + 'a, const SIZE: usize>
     where

tests/ui/expand/pin-data.expanded.rs

@@ -4,6 +4,32 @@ struct Foo {
     array: [u8; 1024 * 1024],
     _pin: PhantomPinned,
 }
+#[doc(hidden)]
+struct FooProjection<'__pin> {
+    _pin: ::core::pin::Pin<&'__pin mut PhantomPinned>,
+    array: &'__pin mut [u8; 1024 * 1024],
+    ___pin_phantom_data: ::core::marker::PhantomData<&'__pin mut ()>,
+}
+impl Foo {
+    /// Pin-projects all fields of `Self`.
+    ///
+    /// These fields are structurally pinned:
+    /// - `_pin`
+    ///
+    /// These fields are **not** structurally pinned:
+    /// - `array`
+    #[inline]
+    fn project<'__pin>(
+        self: ::core::pin::Pin<&'__pin mut Self>,
+    ) -> FooProjection<'__pin> {
+        let this = unsafe { ::core::pin::Pin::get_unchecked_mut(self) };
+        FooProjection {
+            _pin: unsafe { ::core::pin::Pin::new_unchecked(&mut this._pin) },
+            array: &mut this.array,
+            ___pin_phantom_data: ::core::marker::PhantomData,
+        }
+    }
+}
 const _: () = {
     struct __ThePinData {
         __phantom: ::core::marker::PhantomData<fn(Foo) -> Foo>,

tests/ui/expand/pinned_drop.expanded.rs

@@ -4,6 +4,32 @@ struct Foo {
     array: [u8; 1024 * 1024],
     _pin: PhantomPinned,
 }
+#[doc(hidden)]
+struct FooProjection<'__pin> {
+    _pin: ::core::pin::Pin<&'__pin mut PhantomPinned>,
+    array: &'__pin mut [u8; 1024 * 1024],
+    ___pin_phantom_data: ::core::marker::PhantomData<&'__pin mut ()>,
+}
+impl Foo {
+    /// Pin-projects all fields of `Self`.
+    ///
+    /// These fields are structurally pinned:
+    /// - `_pin`
+    ///
+    /// These fields are **not** structurally pinned:
+    /// - `array`
+    #[inline]
+    fn project<'__pin>(
+        self: ::core::pin::Pin<&'__pin mut Self>,
+    ) -> FooProjection<'__pin> {
+        let this = unsafe { ::core::pin::Pin::get_unchecked_mut(self) };
+        FooProjection {
+            _pin: unsafe { ::core::pin::Pin::new_unchecked(&mut this._pin) },
+            array: &mut this.array,
+            ___pin_phantom_data: ::core::marker::PhantomData,
+        }
+    }
+}
 const _: () = {
     struct __ThePinData {
         __phantom: ::core::marker::PhantomData<fn(Foo) -> Foo>,