Merge pull request #89 from Rust-for-Linux/dev/syn2

- tests: test extraneous argument in `#[pin_data]`
- internal: init: simplify Zeroable safety check
- tests: track no_field_access expansion
- tests: update prettyplease to support modern expressions
- tests: track the diagnostics of packed structs and field accessors
- tests: ensure that `#[disable_initialized_field_access]` does not emit accessors
- internal: init: add escape hatch for referencing initialized fields
- tests: add test to check cfgs working correctly
- internal: init: add support for attributes on initializer fields
- add `#[default_error(<type>)]` attribute to initializer macros
- rewrite the initializer macros using `syn`
- add `?Sized` bounds to traits in `#[pin_data]` macro
- rewrite `#[pin_data]` using `syn`
- rewrite the `#[pinned_drop]` attribute macro using `syn`
- rewrite `derive(Zeroable)` and `derive(MaybeZeroable)` using `syn`
- internal: add utility API for syn error handling
- add `syn` dependency and remove `proc-macro[2]` and `quote` workarounds
- allow the crate to refer to itself as `pin-init` in doc tests
- remove `try_` versions of the initializer macros
- tests: add `MaybeZeroable` expansion test with generics
- tests: add new test case to underscore
- tests: ensure that the data cannot be accessed
- tests: ensure the guards cannot be accessed
- tests: check that enums cannot derive `Zeroable`

Author: BennoLossin

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `[pin_]init_scope` functions to run arbitrary code inside of an initializer.
 - `&'static mut MaybeUninit<T>` now implements `InPlaceWrite`. This enables users to use external
   allocation mechanisms such as `static_cell`.
+- Rewrote all proc-macros using `syn`.
 
 ### Changed
 
@@ -21,6 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   code at that point.
 - Make the `[try_][pin_]init!` macros expose initialized fields via a `let`
   binding as `&mut T` or `Pin<&mut T>` for later fields.
+- `derive([Maybe]Zeroable)` now support tuple structs
 
 ## [0.0.10] - 2025-08-19
 

Cargo.lock

@@ -31,7 +31,7 @@ libc = "0.2"
 trybuild = { version = "1.0", features = ["diff"] }
 macrotest = "1.0"
 # needed for macrotest, have to enable verbatim feature to be able to format `&raw` expressions.
-prettyplease = { version = "0.2", features = ["verbatim"] }
+prettyplease = { version = "0.2.37", features = ["verbatim"] }
 
 [lints.rust]
 non_ascii_idents = "deny"

Cargo.toml

@@ -135,7 +135,7 @@ struct DriverData {
 
 impl DriverData {
     fn new() -> impl PinInit<Self, Error> {
-        try_pin_init!(Self {
+        pin_init!(Self {
             status <- CMutex::new(0),
             buffer: Box::init(pin_init::init_zeroed())?,
         }? Error)

README.md

@@ -6,7 +6,6 @@
 
 use core::{
     cell::Cell,
-    convert::Infallible,
     marker::PhantomPinned,
     pin::Pin,
     ptr::{self, NonNull},
@@ -31,31 +30,31 @@ pub struct ListHead {
 
 impl ListHead {
     #[inline]
-    pub fn new() -> impl PinInit<Self, Infallible> {
-        try_pin_init!(&this in Self {
+    pub fn new() -> impl PinInit<Self> {
+        pin_init!(&this in Self {
             next: unsafe { Link::new_unchecked(this) },
             prev: unsafe { Link::new_unchecked(this) },
             pin: PhantomPinned,
-        }? Infallible)
+        })
     }
 
     #[inline]
     #[allow(dead_code)]
-    pub fn insert_next(list: &ListHead) -> impl PinInit<Self, Infallible> + '_ {
-        try_pin_init!(&this in Self {
+    pub fn insert_next(list: &ListHead) -> impl PinInit<Self> + '_ {
+        pin_init!(&this in Self {
             prev: list.next.prev().replace(unsafe { Link::new_unchecked(this)}),
             next: list.next.replace(unsafe { Link::new_unchecked(this)}),
             pin: PhantomPinned,
-        }? Infallible)
+        })
     }
 
     #[inline]
-    pub fn insert_prev(list: &ListHead) -> impl PinInit<Self, Infallible> + '_ {
-        try_pin_init!(&this in Self {
+    pub fn insert_prev(list: &ListHead) -> impl PinInit<Self> + '_ {
+        pin_init!(&this in Self {
             next: list.prev.next().replace(unsafe { Link::new_unchecked(this)}),
             prev: list.prev.replace(unsafe { Link::new_unchecked(this)}),
             pin: PhantomPinned,
-        }? Infallible)
+        })
     }
 
     #[inline]

examples/linked_list.rs

@@ -98,11 +98,11 @@ mod pthread_mtx {
                 // SAFETY: mutex has been initialized
                 unsafe { pin_init_from_closure(init) }
             }
-            try_pin_init!(Self {
-            data: UnsafeCell::new(data),
-            raw <- init_raw(),
-            pin: PhantomPinned,
-        }? Error)
+            pin_init!(Self {
+                data: UnsafeCell::new(data),
+                raw <- init_raw(),
+                pin: PhantomPinned,
+            }? Error)
         }
 
         #[allow(dead_code)]

examples/pthread_mutex.rs

@@ -15,6 +15,7 @@ proc-macro = true
 [dependencies]
 quote = "1.0"
 proc-macro2 = "1.0"
+syn = { version = "2.0.86", features = ["full", "parsing", "visit-mut"] }
 
 [build-dependencies]
 rustc_version = "0.4"

internal/Cargo.lock

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use std::fmt::Display;
+
+use proc_macro2::TokenStream;
+use syn::{spanned::Spanned, Error};
+
+pub(crate) struct DiagCtxt(TokenStream);
+pub(crate) struct ErrorGuaranteed(());
+
+impl DiagCtxt {
+    pub(crate) fn error(&mut self, span: impl Spanned, msg: impl Display) -> ErrorGuaranteed {
+        let error = Error::new(span.span(), msg);
+        self.0.extend(error.into_compile_error());
+        ErrorGuaranteed(())
+    }
+
+    pub(crate) fn with(
+        fun: impl FnOnce(&mut DiagCtxt) -> Result<TokenStream, ErrorGuaranteed>,
+    ) -> TokenStream {
+        let mut dcx = Self(TokenStream::new());
+        match fun(&mut dcx) {
+            Ok(mut stream) => {
+                stream.extend(dcx.0);
+                stream
+            }
+            Err(ErrorGuaranteed(())) => dcx.0,
+        }
+    }
+}