simplify projections and support long-lasting projections

Author: BennoLossin

examples/kernel_mutex_rcu.rs

@@ -150,20 +150,12 @@ impl MyDriver {
         cfg.read(rcu_guard).flush_sensitivity
     }
 
-    /*
-     * the following implementation of `buffer_config` *should* also compile, but doesn't due to
-     * the macro having to create a value on the stack...
-
     fn buffer_config<'a>(&'a self, rcu_guard: &'a RcuGuard) -> &'a BufferConfig {
         let buf: &'a RcuMutex<Buffer> = &self.buf;
         start_proj!(move buf);
-        //------------------- local binding introduced here
-        // Here we use the special projections set up for `Mutex` with fields of type `Rcu<T>`.
-        let cfg: &Rcu<Box<BufferConfig>> = p!(@buf->cfg);
+        let cfg: &Rcu<Box<BufferConfig>> = p!(@move buf->cfg);
         cfg.read(rcu_guard)
-        //^^^^^^^^^^^^^^^^^ returns a value referencing data owned by the current function
     }
-     */
 
     fn set_buffer_config(&self, flush_sensitivity: u8) {
         // Our `Mutex` pins the value.

internal/src/has_fields.rs

@@ -185,7 +185,6 @@ fn checker(
     fields: &FieldsNamed,
 ) -> TokenStream {
     let proj = format_ident!("__Proj");
-    let storage = format_ident!("__Storage");
     let mut generics = generics.clone();
     generics.lt_token.get_or_insert_default();
     generics.gt_token.get_or_insert_default();
@@ -196,10 +195,7 @@ fn checker(
         0,
         parse_quote!(#proj: #compat::ProjectableExt<Inner = #ident #ident_ty_gen>),
     );
-    let (checker_impl_gen, _, _) = generics.split_for_impl();
-    let mut storage_generics = generics.clone();
-    storage_generics.params.insert(0, parse_quote!(#storage));
-    let field_name = fields.named.iter().map(|f| &f.ident).collect::<Vec<_>>();
+    let (checker_impl_gen, checker_ty_gen, _) = generics.split_for_impl();
     let fields = fields.named.iter().map(
         |Field {
              vis,
@@ -211,77 +207,19 @@ fn checker(
             }
         },
     );
-    let checker_lt = quote!('___checker);
-    let (_, storage_ty_gen, _) = storage_generics.split_for_impl();
-    let mut val_generics = generics.clone();
-    val_generics.params.insert(0, parse_quote!(#checker_lt));
-    let (val_impl_gen, _, _) = val_generics.split_for_impl();
-    let storage_ty_gen = storage_ty_gen.into_token_stream();
-    let ref_ty_gen: TokenStream = storage_ty_gen
-        .clone()
-        .into_iter()
-        .map(|tt| {
-            if matches!(&tt, TokenTree::Ident(i) if i == &storage) {
-                quote!(#compat::RawProjectedRef<#checker_lt, #proj, #ident #ident_ty_gen>)
-            } else {
-                quote!(#tt)
-            }
-        })
-        .collect();
-    let val_ty_gen: TokenStream = storage_ty_gen
-        .into_iter()
-        .map(|tt| {
-            if matches!(&tt, TokenTree::Ident(i) if i == &storage) {
-                quote!(#compat::RawProjectedVal<#proj, #ident #ident_ty_gen>)
-            } else {
-                quote!(#tt)
-            }
-        })
-        .collect();
     quote! {
-        pub struct Checker #storage_generics {
+        pub struct Checker #generics {
             #(#fields,)*
-            pub ___projection_checker_raw: #storage,
         }
 
-        unsafe impl #val_impl_gen #compat::ProjectionRefChecker<#checker_lt> for Checker #ref_ty_gen {
+        unsafe impl #checker_impl_gen #compat::ProjectionChecker for Checker #checker_ty_gen {
             type Proj = #proj;
-
-            unsafe fn __create(
-                proj: #compat::RawProjectedRef<
-                    #checker_lt,
-                    Self::Proj,
-                    <Self::Proj as #core_::ops::Projectable>::Inner,
-                >,
-            ) -> Self {
-                Self {
-                    #(#field_name: unsafe { #compat::ProjectedField::__new() },)*
-                    ___projection_checker_raw: proj,
-                }
-            }
-        }
-
-        unsafe impl #checker_impl_gen #compat::ProjectionValChecker for Checker #val_ty_gen {
-            type Proj = #proj;
-
-            unsafe fn __create(
-                proj: #compat::RawProjectedVal<
-                    Self::Proj,
-                    <Self::Proj as #core_::ops::Projectable>::Inner,
-                >,
-            ) -> Self {
-                Self {
-                    #(#field_name: unsafe { #compat::ProjectedField::__new() },)*
-                    ___projection_checker_raw: proj,
-                }
-            }
         }
 
         unsafe impl #checker_impl_gen #compat::CheckedProject<#proj> for #ident #ident_ty_gen
             #whr
         {
-            type RefChecker<#checker_lt> = Checker #ref_ty_gen;
-            type ValChecker = Checker #val_ty_gen;
+            type Checker = Checker #checker_ty_gen;
         }
     }
 }

internal/src/project.rs

@@ -2,10 +2,11 @@ use proc_macro2::TokenStream;
 use quote::{ToTokens, format_ident, quote, quote_spanned};
 use syn::{Member, Result, Token, parse::Parse, spanned::Spanned};
 
-use crate::IdentOrSelf;
+use crate::{IdentOrSelf, start::ProjKind};
 
 pub struct Input {
     at: Token![@],
+    move_: Option<Token![move]>,
     mut_: Option<Token![mut]>,
     base: IdentOrSelf,
     arrow: Token![->],
@@ -15,6 +16,7 @@ pub struct Input {
 impl ToTokens for Input {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         self.at.to_tokens(tokens);
+        self.move_.to_tokens(tokens);
         self.mut_.to_tokens(tokens);
         self.base.to_tokens(tokens);
         self.arrow.to_tokens(tokens);
@@ -26,6 +28,7 @@ impl Parse for Input {
     fn parse(input: syn::parse::ParseStream) -> Result<Self> {
         let res = Self {
             at: input.parse()?,
+            move_: input.parse()?,
             mut_: input.parse()?,
             base: input.parse()?,
             arrow: input.parse()?,
@@ -41,24 +44,28 @@ impl Parse for Input {
 pub fn expand(input: Input) -> Result<TokenStream> {
     let span = input.span();
     let Input {
+        move_,
         mut_,
         base: IdentOrSelf(base),
         field,
         ..
     } = input;
-    let base = format_ident!("___projections_for_{base}");
+    let raw_ = format_ident!("___projections_raw_ptr_for_{base}");
+    let base = format_ident!("___projections_checker_for_{base}");
     let compat = quote!(::field_projection::compat);
-    let (project, access) = match &mut_ {
-        Some(_) => (quote!(project_mut), quote!(access_mut)),
-        None => (quote!(project), quote!(access)),
+    let (action, deref, project) = match &(move_, mut_) {
+        (Some(_), Some(_)) => (quote!(), quote!(), quote!(project_move_mut)),
+        (Some(_), None) => (quote!(), quote!(), quote!(project_move)),
+        (None, Some(mut_)) => (quote!(&#mut_), quote!(*), quote!(project_mut)),
+        (None, None) => (quote!(&), quote!(*), quote!(project)),
     };
     Ok(quote_spanned! {span=>
         match (
-            &#mut_ #base.#field,
-            #compat::RawProjectionAccess::#access(&#mut_ #base.___projection_checker_raw),
+            #action #base.#field,
+            #raw_
         ) {
             (this, raw) => {
-                #compat::ProjectedField::safety_check(&*this).check();
+                #compat::ProjectedField::safety_check(& #deref this).check();
                 #[allow(unused_unsafe)]
                 let res = unsafe {
                     #compat::ProjectedField::#project(

internal/src/start.rs

@@ -1,5 +1,5 @@
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
+use quote::{ToTokens, format_ident, quote};
 use syn::{Expr, Result, Token, parse::Parse};
 
 use crate::IdentOrSelf;
@@ -9,10 +9,9 @@ pub struct Input {
     name: IdentOrSelf,
 }
 
-enum ProjKind {
+pub enum ProjKind {
     Shared,
     Mut(Token![mut]),
-    #[expect(dead_code)]
     Move(Token![move]),
 }
 
@@ -28,6 +27,16 @@ impl Parse for ProjKind {
     }
 }
 
+impl ToTokens for ProjKind {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        match self {
+            ProjKind::Shared => {}
+            ProjKind::Mut(mut_) => mut_.to_tokens(tokens),
+            ProjKind::Move(move_) => move_.to_tokens(tokens),
+        }
+    }
+}
+
 impl Parse for Input {
     fn parse(input: syn::parse::ParseStream) -> Result<Self> {
         let res = Self {
@@ -47,13 +56,19 @@ pub fn expand(
         name: IdentOrSelf(name),
     }: Input,
 ) -> TokenStream {
-    let projections = format_ident!("___projections_for_{name}");
+    let projections = format_ident!("___projections_checker_for_{name}");
+    let raw_ = format_ident!("___projections_raw_ptr_for_{name}");
     let (start, mut_, action) = match &kind {
-        ProjKind::Move(_) => (quote!(__start_proj_move), quote!(mut), quote!()),
+        ProjKind::Move(_) => (quote!(__start_proj_move), quote!(), quote!()),
         ProjKind::Mut(mut_) => (quote!(__start_proj_mut), quote!(#mut_), quote!(&#mut_)),
         ProjKind::Shared => (quote!(__start_proj), quote!(), quote!(&)),
     };
+    let (rest, raw_mut) = match &kind {
+        ProjKind::Move(_) => (quote!(let #raw_ = &raw mut #raw_;), quote!(mut)),
+        _ => (quote!(), quote!()),
+    };
     quote! {
-        let #mut_ #projections = ::field_projection::compat::#start(#action #name);
+        let (#mut_ #projections, #raw_mut #raw_) = ::field_projection::compat::#start(#action #name);
+        #rest
     }
 }

src/compat.rs

@@ -47,53 +47,35 @@ impl Unsafe {
 }
 
 pub unsafe trait CheckedProject<P: ProjectableExt> {
-    type RefChecker<'a>: ProjectionRefChecker<'a, Proj = P>;
-    type ValChecker: ProjectionValChecker<Proj = P>;
+    type Checker: ProjectionChecker<Proj = P>;
 }
 
-pub unsafe trait ProjectionRefChecker<'a> {
+pub unsafe trait ProjectionChecker {
     type Proj: ProjectableExt<Inner: CheckedProject<Self::Proj>>;
-
-    unsafe fn __create(
-        proj: RawProjectedRef<'a, Self::Proj, <Self::Proj as Projectable>::Inner>,
-    ) -> Self;
-}
-
-pub unsafe trait ProjectionValChecker {
-    type Proj: ProjectableExt<Inner: CheckedProject<Self::Proj>>;
-
-    unsafe fn __create(
-        proj: RawProjectedVal<Self::Proj, <Self::Proj as Projectable>::Inner>,
-    ) -> Self;
 }
 
-pub fn __start_proj<'a, P>(proj: &'a P) -> <P::Inner as CheckedProject<P>>::RefChecker<'a>
+pub fn __start_proj<P>(proj: &P) -> (&<P::Inner as CheckedProject<P>>::Checker, *const P)
 where
     P: ProjectableExt,
     P::Inner: CheckedProject<P>,
 {
-    let ptr: *const P = proj;
-    let proj = RawProjectedRef(ptr, PhantomData);
-    unsafe { <P::Inner as CheckedProject<P>>::RefChecker::__create(proj) }
+    (unsafe { core::mem::transmute(&()) }, proj)
 }
 
-pub fn __start_proj_mut<'a, P>(proj: &'a mut P) -> <P::Inner as CheckedProject<P>>::RefChecker<'a>
+pub fn __start_proj_mut<P>(proj: &mut P) -> (&mut <P::Inner as CheckedProject<P>>::Checker, *mut P)
 where
     P: ProjectableExt,
     P::Inner: CheckedProject<P>,
 {
-    let ptr: *mut P = proj;
-    let proj = RawProjectedRef(ptr, PhantomData);
-    unsafe { <P::Inner as CheckedProject<P>>::RefChecker::__create(proj) }
+    (unsafe { core::mem::transmute(&mut ()) }, proj)
 }
 
-pub fn __start_proj_move<P>(proj: P) -> <P::Inner as CheckedProject<P>>::ValChecker
+pub fn __start_proj_move<P>(proj: P) -> (<P::Inner as CheckedProject<P>>::Checker, P)
 where
     P: ProjectableExt,
     P::Inner: CheckedProject<P>,
 {
-    let proj = RawProjectedVal(proj, PhantomData);
-    unsafe { <P::Inner as CheckedProject<P>>::ValChecker::__create(proj) }
+    (unsafe { core::mem::transmute_copy(&()) }, proj)
 }
 
 pub struct ProjectedField<P, F>(PhantomData<P>, PhantomData<F>);
@@ -111,54 +93,24 @@ where
         Default::default()
     }
 
-    pub unsafe fn project<'a>(
-        self: &'a ProjectedField<P, F>,
-        raw: RawProjectedPtr<P>,
-    ) -> <P as Project<F>>::Output<'a>
+    pub unsafe fn project<'a>(&'a self, raw: *const P) -> <P as Project<F>>::Output<'a>
     where
         P: Project<F>,
     {
-        unsafe { <P as Project<F>>::project(raw.0) }
+        unsafe { <P as Project<F>>::project(raw) }
     }
 
-    pub unsafe fn project_mut<'a>(
-        self: &'a mut ProjectedField<P, F>,
-        raw: RawProjectedPtr<P>,
-    ) -> <P as ProjectMut<F>>::OutputMut<'a>
+    pub unsafe fn project_mut<'a>(&'a mut self, raw: *mut P) -> <P as ProjectMut<F>>::OutputMut<'a>
     where
         P: ProjectMut<F>,
     {
-        unsafe { <P as ProjectMut<F>>::project_mut(raw.0.cast_mut()) }
+        unsafe { <P as ProjectMut<F>>::project_mut(raw) }
     }
-}
-
-pub struct RawProjectedPtr<P>(*const P);
-
-pub struct RawProjectedRef<'a, P, T: ?Sized>(*const P, PhantomData<(&'a (), &'a mut (), P, T)>);
-
-pub struct RawProjectedVal<P, T: ?Sized>(P, PhantomData<(P, T)>);
-
-pub trait RawProjectionAccess<P> {
-    fn access(&self) -> RawProjectedPtr<P>;
-    fn access_mut(&mut self) -> RawProjectedPtr<P>;
-}
 
-impl<'a, P, T: ?Sized> RawProjectionAccess<P> for RawProjectedRef<'a, P, T> {
-    fn access(&self) -> RawProjectedPtr<P> {
-        RawProjectedPtr(self.0)
-    }
-
-    fn access_mut(&mut self) -> RawProjectedPtr<P> {
-        RawProjectedPtr(self.0)
-    }
-}
-
-impl<P, T: ?Sized> RawProjectionAccess<P> for RawProjectedVal<P, T> {
-    fn access(&self) -> RawProjectedPtr<P> {
-        RawProjectedPtr(&raw const self.0)
-    }
-
-    fn access_mut(&mut self) -> RawProjectedPtr<P> {
-        RawProjectedPtr(&raw mut self.0)
+    pub unsafe fn project_move<'a>(self, raw: *const P) -> <P as Project<F>>::Output<'a>
+    where
+        P: Project<F>,
+    {
+        unsafe { <P as Project<F>>::project(raw) }
     }
 }

tests/ui/compile-fail/hygiene_check.rs

@@ -0,0 +1,22 @@
+use field_projection::compat::{HasFields, start_proj};
+
+#[derive(HasFields)]
+#[fields(with_pinned)]
+pub struct Foo {
+    a: usize,
+}
+
+impl Foo {
+    pub fn new() -> Self {
+        Self { a: 42 }
+    }
+}
+
+fn main() {
+    let mut foo = Box::pin(Foo::new());
+    let mut foo = foo.as_mut();
+    start_proj!(mut foo);
+    // sadly we can access these
+    let _: () = ___projections_raw_ptr_for_foo;
+    let _: () = ___projections_checker_for_foo;
+}