add #[default_error(<type>)] attribute to initializer macros

The `#[default_error(<type>)]` attribute macro can be used to supply a
default type as the error used for the `[pin_]init!` macros. This way
one can easily define custom `try_[pin_]init!` variants that default to
your project specific error type. Just write the following declarative
macro:

    macro_rules! try_init {
        ($($args:tt)*) => {
            ::pin_init::init!(
                #[default_error(YourCustomErrorType)]
                $($args)*
            )
        }
    }

Signed-off-by: Benno Lossin <[email protected]>

Author: BennoLossin

internal/src/init.rs

@@ -6,10 +6,11 @@ use syn::{
     parse_quote,
     punctuated::Punctuated,
     spanned::Spanned,
-    token, Block, Expr, ExprCall, ExprPath, Ident, Path, Token, Type,
+    token, Attribute, Block, Expr, ExprCall, ExprPath, Ident, Path, Token, Type,
 };
 
 pub struct Initializer {
+    attrs: Vec<InitializerAttribute>,
     this: Option<This>,
     path: Path,
     brace_token: token::Brace,
@@ -50,8 +51,17 @@ impl InitializerField {
     }
 }
 
+enum InitializerAttribute {
+    DefaultError(DefaultErrorAttribute),
+}
+
+struct DefaultErrorAttribute {
+    ty: Type,
+}
+
 pub(crate) fn expand(
     Initializer {
+        attrs,
         this,
         path,
         brace_token,
@@ -66,12 +76,24 @@ pub(crate) fn expand(
     if let Some(default_error) = default_error {
         error.get_or_insert((Default::default(), syn::parse_str(default_error).unwrap()));
     }
-    let error = error.map(|(_, err)| err).unwrap_or_else(|| {
-        errors.extend(quote_spanned!(brace_token.span.close()=>
-            ::core::compile_error!("expected `? <type>` after `}`");
-        ));
-        parse_quote!(::core::convert::Infallible)
-    });
+
+    let error = attrs
+        .iter()
+        .fold(None, |acc, attr| {
+            #[expect(irrefutable_let_patterns)]
+            if let InitializerAttribute::DefaultError(DefaultErrorAttribute { ty }) = attr {
+                Some(ty.clone())
+            } else {
+                acc
+            }
+        })
+        .or(error.map(|(_, err)| err))
+        .unwrap_or_else(|| {
+            errors.extend(quote_spanned!(brace_token.span.close()=>
+                ::core::compile_error!("expected `? <type>` after `}`");
+            ));
+            parse_quote!(::core::convert::Infallible)
+        });
     let slot = format_ident!("slot");
     let (has_data_trait, data_trait, get_data, init_from_closure) = if pinned {
         (
@@ -346,6 +368,7 @@ fn make_field_check(
 
 impl Parse for Initializer {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
         let this = input.peek(Token![&]).then(|| input.parse()).transpose()?;
         let path = input.parse()?;
         let content;
@@ -377,7 +400,19 @@ impl Parse for Initializer {
             .peek(Token![?])
             .then(|| Ok::<_, syn::Error>((input.parse()?, input.parse()?)))
             .transpose()?;
+        let attrs = attrs
+            .into_iter()
+            .map(|a| {
+                if a.path().is_ident("default_error") {
+                    a.parse_args::<DefaultErrorAttribute>()
+                        .map(InitializerAttribute::DefaultError)
+                } else {
+                    Err(syn::Error::new_spanned(a, "unknown initializer attribute"))
+                }
+            })
+            .collect::<Result<Vec<_>, _>>()?;
         Ok(Self {
+            attrs,
             this,
             path,
             brace_token,
@@ -388,6 +423,16 @@ impl Parse for Initializer {
     }
 }
 
+impl Parse for DefaultErrorAttribute {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let ty = input.parse()?;
+        if !input.peek(End) {
+            return Err(input.error("expected end of input"));
+        }
+        Ok(Self { ty })
+    }
+}
+
 impl Parse for This {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         Ok(Self {

tests/default_error.rs

@@ -0,0 +1,16 @@
+#![allow(dead_code)]
+
+use pin_init::{init, Init};
+
+struct Foo {}
+
+struct Error;
+
+impl Foo {
+    fn new() -> impl Init<Foo, Error> {
+        init!(
+            #[default_error(Error)]
+            Foo {}
+        )
+    }
+}