start linked_list example, add multiple items to start_proj

Author: BennoLossin

examples/linked_list.rs

@@ -0,0 +1,76 @@
+use std::{marker::PhantomData, ptr::NonNull};
+
+use field_projection::compat::{HasFields, p, start_proj};
+
+#[derive(HasFields)]
+struct ListItem<T> {
+    next: NonNull<ListItem<T>>,
+    prev: NonNull<ListItem<T>>,
+    value: T,
+}
+
+impl<T> ListItem<T> {
+    fn new(prev: NonNull<Self>, next: NonNull<Self>, value: T) -> NonNull<Self> {
+        NonNull::from(Box::leak(Box::new(Self { prev, next, value })))
+    }
+}
+
+pub struct List<T> {
+    first: Option<NonNull<ListItem<T>>>,
+}
+
+impl<T> List<T> {
+    pub fn new() -> Self {
+        Self { first: None }
+    }
+
+    /*
+    pub fn push_front(&mut self, item: T) {
+        let new = ListItem {
+            next: self.first.take(),
+            prev: None,
+            value: item,
+        };
+        self.first = Some(NonNull::from(Box::leak(Box::new(new))));
+    }
+
+    pub fn push_back(&mut self, item: T) {}
+    */
+
+    pub fn cursor(&mut self) -> Option<Cursor<'_, T>> {
+        self.first.map(|cur| Cursor {
+            cur,
+            _lt: PhantomData,
+        })
+    }
+}
+
+pub struct Cursor<'a, T> {
+    cur: NonNull<ListItem<T>>,
+    _lt: PhantomData<&'a mut T>,
+}
+
+impl<T> Cursor<'_, T> {
+    pub fn insert_left(&mut self, item: T) {
+        let cur = self.cur;
+        let (prev, next) = (unsafe { (*cur.as_ptr()).prev }, cur);
+        let new = ListItem::new(prev, cur, item);
+        unsafe { (*prev.as_ptr()).next = new };
+        unsafe { (*next.as_ptr()).prev = new };
+    }
+
+    pub fn insert_right(&mut self, item: T) {
+        start_proj!(let cur = self.cur);
+        start_proj!(let prev = cur; let next = unsafe { p!(@cur->next).read() });
+        let new = ListItem::new(prev, cur, item);
+        unsafe { p!(@prev->next).write(new) };
+        unsafe { p!(@next->prev).write(new) };
+        self.cur = new;
+    }
+
+    pub fn current(&mut self) -> &mut T {
+        unsafe { &mut (*self.cur.as_ptr()).value }
+    }
+}
+
+fn main() {}

internal/src/start.rs

@@ -1,15 +1,22 @@
 use proc_macro2::TokenStream;
 use quote::{ToTokens, format_ident, quote};
-use syn::{Result, Token, parse::Parse};
+use syn::{Expr, Result, Token, parse::Parse, punctuated::Punctuated};
 
 use crate::IdentOrSelf;
 
 pub struct Input {
+    input: Punctuated<Entry, Token![;]>,
+}
+
+struct Entry {
+    let_: Option<Token![let]>,
     kind: ProjKind,
     name: IdentOrSelf,
+    equals: Option<Token![=]>,
+    value: Option<Expr>,
 }
 
-pub enum ProjKind {
+enum ProjKind {
     Shared,
     Mut(Token![mut]),
     Move(Token![move]),
@@ -39,36 +46,55 @@ impl ToTokens for ProjKind {
 
 impl Parse for Input {
     fn parse(input: syn::parse::ParseStream) -> Result<Self> {
+        Punctuated::parse_terminated(input).map(|input| Self { input })
+    }
+}
+
+impl Parse for Entry {
+    fn parse(input: syn::parse::ParseStream) -> Result<Self> {
+        let let_: Option<Token![let]> = input.parse()?;
+        let has_let = let_.is_some();
         let res = Self {
+            let_,
             kind: input.parse()?,
             name: input.parse()?,
+            equals: has_let.then(|| input.parse()).transpose()?,
+            value: has_let.then(|| input.parse()).transpose()?,
         };
-        if !input.is_empty() {
-            return Err(input.error("unexpected tokens"));
-        }
         Ok(res)
     }
 }
 
-pub fn expand(
-    Input {
+pub fn expand(input: Input) -> TokenStream {
+    input.input.into_iter().map(expand_one).collect()
+}
+
+fn expand_one(
+    Entry {
+        let_,
         kind,
         name: IdentOrSelf(name),
-    }: Input,
+        equals,
+        value,
+    }: Entry,
 ) -> TokenStream {
+    let let_ = let_.unwrap_or_default();
+    let equals = equals.unwrap_or_default();
     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!(), quote!()),
         ProjKind::Mut(mut_) => (quote!(__start_proj_mut), quote!(#mut_), quote!(&#mut_)),
         ProjKind::Shared => (quote!(__start_proj), quote!(), quote!(&)),
     };
+    let before = value.map(|value| quote!(#let_ #mut_ #name = #value;));
     let (rest, raw_mut) = match &kind {
         ProjKind::Move(_) => (quote!(let #raw_ = &raw mut #raw_;), quote!(mut)),
         _ => (quote!(), quote!()),
     };
     quote! {
-        let (#mut_ #projections, #raw_mut #raw_) = ::field_projection::compat::#start(#action #name);
+        #before
+        #let_ (#mut_ #projections, #raw_mut #raw_) #equals ::field_projection::compat::#start(#action #name);
         #rest
     }
 }