allow usage of value after start_proj which is now a macro

Author: BennoLossin

examples/custom_arc.rs

@@ -16,7 +16,8 @@ impl<T> Deref for Arc<T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        let inner = start_proj(self.inner);
+        let inner = self.inner;
+        start_proj!(inner);
         let value = unsafe { p!(@inner->value) };
         unsafe { value.as_ref() }
     }

examples/fair_race_future.rs

@@ -19,20 +19,20 @@ where
 {
     type Output = F1::Output;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Self::Output> {
-        let mut this = start_proj(self);
-        let fair: &mut bool = p!(@mut this->fair);
+    fn poll(mut self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Self::Output> {
+        start_proj!(mut self);
+        let fair: &mut bool = p!(@mut self->fair);
         *fair = !*fair;
-        match *p!(@this->fair) {
+        match *p!(@self->fair) {
             true => {
-                let f1: Pin<&mut F1> = p!(@mut this->f1);
+                let f1: Pin<&mut F1> = p!(@mut self->f1);
                 match f1.poll(cx) {
-                    Poll::Pending => p!(@mut this->f2).poll(cx),
+                    Poll::Pending => p!(@mut self->f2).poll(cx),
                     Poll::Ready(val) => Poll::Ready(val),
                 }
             }
-            false => match p!(@mut this->f2).poll(cx) {
-                Poll::Pending => p!(@mut this->f1).poll(cx),
+            false => match p!(@mut self->f2).poll(cx) {
+                Poll::Pending => p!(@mut self->f1).poll(cx),
                 Poll::Ready(val) => Poll::Ready(val),
             },
         }

examples/initializing.rs

@@ -13,8 +13,8 @@ struct VeryBig {
 }
 
 impl VeryBig {
-    pub fn init(this: &mut MaybeUninit<Self>) {
-        let mut this = start_proj(this);
+    pub fn init(mut this: &mut MaybeUninit<Self>) {
+        start_proj!(mut this);
         p!(@mut this->a).write(42);
         p!(@mut this->b).write(0);
         p!(@mut this->buf).as_bytes_mut().write_filled(0xef);

examples/kernel_mutex_rcu.rs

@@ -143,7 +143,8 @@ struct MyDriver {
 
 impl MyDriver {
     fn flush_sensitivity<'a>(&'a self, rcu_guard: &'a RcuGuard) -> u8 {
-        let buf = start_proj(&self.buf);
+        let buf = &self.buf;
+        start_proj!(buf);
         // Here we use the special projections set up for `Mutex` with fields of type `Rcu<T>`.
         let cfg: &Rcu<Box<BufferConfig>> = p!(@buf->cfg);
         cfg.read(rcu_guard).flush_sensitivity
@@ -154,20 +155,21 @@ impl MyDriver {
      * the macro having to create a value on the stack...
 
     fn buffer_config<'a>(&'a self, rcu_guard: &'a RcuGuard) -> &'a BufferConfig {
-        let buf = start_proj(&self.buf);
+        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);
-        //                                    --------- `buf.cfg` is borrowed here
         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.
         let mut guard: Pin<RcuMutexGuard<'_, Buffer>> = self.buf.lock();
-        let mut buf = start_proj(guard.as_mut());
+        let mut buf = guard.as_mut();
+        start_proj!(mut buf);
         // We can use pin-projections since we marked `cfg` as `#[pin]`
         let cfg: Pin<&mut Rcu<Box<BufferConfig>>> = p!(@mut buf->cfg);
         cfg.set(Box::new(BufferConfig { flush_sensitivity }));

examples/kernel_ptr.rs

@@ -41,7 +41,7 @@ where
     where
         Self: 'b,
     {
-        let this = start_proj(this);
+        start_proj!(this);
         let ptr = unsafe { *p!(@this->inner) };
         Ptr {
             inner: unsafe { ptr.byte_add(F::OFFSET).cast() },

internal/src/has_fields.rs

@@ -185,49 +185,103 @@ fn checker(
     fields: &FieldsNamed,
 ) -> TokenStream {
     let proj = format_ident!("__Proj");
-    let (_, ty_gen, _) = generics.split_for_impl();
+    let storage = format_ident!("__Storage");
     let mut generics = generics.clone();
     generics.lt_token.get_or_insert_default();
     generics.gt_token.get_or_insert_default();
+    let (_, ident_ty_gen, whr) = generics.split_for_impl();
+    let mut generics = generics.clone();
     // TODO: proper index
     generics.params.insert(
         0,
-        parse_quote!(#proj: #compat::ProjectableExt<Inner = #ident #ty_gen>),
+        parse_quote!(#proj: #compat::ProjectableExt<Inner = #ident #ident_ty_gen>),
     );
-    let field_name = fields.named.iter().map(|f| &f.ident);
+    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 fields = fields.named.iter().map(
         |Field {
              vis,
              ident: name,
              ..
          }| {
             quote! {
-                #vis #name: #compat::ProjectedField<#proj, #core_::marker::field_of!(#ident #ty_gen, #name)>
+                #vis #name: #compat::ProjectedField<#proj, #core_::marker::field_of!(#ident #ident_ty_gen, #name)>
             }
         },
     );
-    let (impl_gen, checker_ty_gen, whr) = generics.split_for_impl();
+    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 #generics {
+        pub struct Checker #storage_generics {
             #(#fields,)*
-            pub ___projection_checker_raw: #compat::RawProjected<#proj, #ident #ty_gen>,
+            pub ___projection_checker_raw: #storage,
+        }
+
+        unsafe impl #val_impl_gen #compat::ProjectionRefChecker<#checker_lt> for Checker #ref_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 #impl_gen #compat::ProjectionChecker for Checker #checker_ty_gen {
+        unsafe impl #checker_impl_gen #compat::ProjectionValChecker for Checker #val_ty_gen {
             type Proj = #proj;
 
-            fn start_proj(proj: Self::Proj) -> Self {
+            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: unsafe { #compat::RawProjected::__new(proj) },
+                    ___projection_checker_raw: proj,
                 }
             }
         }
 
-        unsafe impl #impl_gen #compat::CheckedProject<#proj> for #ident #ty_gen
+        unsafe impl #checker_impl_gen #compat::CheckedProject<#proj> for #ident #ident_ty_gen
             #whr
         {
-            type Checker = Checker #checker_ty_gen;
+            type RefChecker<#checker_lt> = Checker #ref_ty_gen;
+            type ValChecker = Checker #val_ty_gen;
         }
     }
 }

internal/src/lib.rs

@@ -1,8 +1,10 @@
 use proc_macro::TokenStream;
-use syn::{DeriveInput, parse_macro_input};
+use quote::ToTokens;
+use syn::{DeriveInput, Ident, Token, parse::Parse, parse_macro_input};
 
 mod has_fields;
 mod project;
+mod start;
 
 #[proc_macro]
 pub fn p(input: TokenStream) -> TokenStream {
@@ -11,9 +13,33 @@ pub fn p(input: TokenStream) -> TokenStream {
         .into()
 }
 
+#[proc_macro]
+pub fn start_proj(input: TokenStream) -> TokenStream {
+    start::expand(parse_macro_input!(input as _)).into()
+}
+
 #[proc_macro_derive(HasFields, attributes(fields, pin))]
 pub fn derive_has_fields(item: TokenStream) -> TokenStream {
     has_fields::derive(parse_macro_input!(item as DeriveInput))
         .unwrap_or_else(|e| e.into_compile_error())
         .into()
 }
+
+struct IdentOrSelf(Ident);
+
+impl Parse for IdentOrSelf {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        if input.peek(Token![self]) {
+            let self_: Token![self] = input.parse()?;
+            Ok(Self(Ident::new("self", self_.span)))
+        } else {
+            input.parse().map(Self)
+        }
+    }
+}
+
+impl ToTokens for IdentOrSelf {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        self.0.to_tokens(tokens)
+    }
+}

internal/src/project.rs

@@ -1,19 +1,21 @@
-use proc_macro2::{TokenStream, TokenTree};
-use quote::{ToTokens, quote, quote_spanned};
-use syn::{Ident, Member, Result, Token, parse::Parse, spanned::Spanned};
+use proc_macro2::TokenStream;
+use quote::{ToTokens, format_ident, quote, quote_spanned};
+use syn::{Member, Result, Token, parse::Parse, spanned::Spanned};
+
+use crate::IdentOrSelf;
 
 pub struct Input {
     at: Token![@],
-    mutability: Option<Token![mut]>,
-    base: Ident,
+    mut_: Option<Token![mut]>,
+    base: IdentOrSelf,
     arrow: Token![->],
     field: Member,
 }
 
 impl ToTokens for Input {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         self.at.to_tokens(tokens);
-        self.mutability.to_tokens(tokens);
+        self.mut_.to_tokens(tokens);
         self.base.to_tokens(tokens);
         self.arrow.to_tokens(tokens);
         self.field.to_tokens(tokens);
@@ -24,7 +26,7 @@ impl Parse for Input {
     fn parse(input: syn::parse::ParseStream) -> Result<Self> {
         let res = Self {
             at: input.parse()?,
-            mutability: input.parse()?,
+            mut_: input.parse()?,
             base: input.parse()?,
             arrow: input.parse()?,
             field: input.parse()?,
@@ -39,20 +41,21 @@ impl Parse for Input {
 pub fn expand(input: Input) -> Result<TokenStream> {
     let span = input.span();
     let Input {
-        mutability,
-        base,
+        mut_,
+        base: IdentOrSelf(base),
         field,
         ..
     } = input;
+    let base = format_ident!("___projections_for_{base}");
     let compat = quote!(::field_projection::compat);
-    let (project, access) = match &mutability {
+    let (project, access) = match &mut_ {
         Some(_) => (quote!(project_mut), quote!(access_mut)),
         None => (quote!(project), quote!(access)),
     };
     Ok(quote_spanned! {span=>
         match (
-            &#mutability #base.#field,
-            #compat::RawProjected::#access(&#mutability #base.___projection_checker_raw),
+            &#mut_ #base.#field,
+            #compat::RawProjectionAccess::#access(&#mut_ #base.___projection_checker_raw),
         ) {
             (this, raw) => {
                 #compat::ProjectedField::safety_check(&*this).check();

internal/src/start.rs

@@ -0,0 +1,59 @@
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
+use syn::{Expr, Result, Token, parse::Parse};
+
+use crate::IdentOrSelf;
+
+pub struct Input {
+    kind: ProjKind,
+    name: IdentOrSelf,
+}
+
+enum ProjKind {
+    Shared,
+    Mut(Token![mut]),
+    #[expect(dead_code)]
+    Move(Token![move]),
+}
+
+impl Parse for ProjKind {
+    fn parse(input: syn::parse::ParseStream) -> Result<Self> {
+        if input.peek(Token![mut]) {
+            input.parse().map(Self::Mut)
+        } else if input.peek(Token![move]) {
+            input.parse().map(Self::Move)
+        } else {
+            Ok(Self::Shared)
+        }
+    }
+}
+
+impl Parse for Input {
+    fn parse(input: syn::parse::ParseStream) -> Result<Self> {
+        let res = Self {
+            kind: input.parse()?,
+            name: input.parse()?,
+        };
+        if !input.is_empty() {
+            return Err(input.error("unexpected tokens"));
+        }
+        Ok(res)
+    }
+}
+
+pub fn expand(
+    Input {
+        kind,
+        name: IdentOrSelf(name),
+    }: Input,
+) -> TokenStream {
+    let projections = format_ident!("___projections_for_{name}");
+    let (start, mut_, action) = match &kind {
+        ProjKind::Move(_) => (quote!(__start_proj_move), quote!(mut), quote!()),
+        ProjKind::Mut(mut_) => (quote!(__start_proj_mut), quote!(#mut_), quote!(&#mut_)),
+        ProjKind::Shared => (quote!(__start_proj), quote!(), quote!(&)),
+    };
+    quote! {
+        let #mut_ #projections = ::field_projection::compat::#start(#action #name);
+    }
+}