Re: [PATCH 09/12] rust: pin-init: add `#[default_error(<type>)]` attribute to initializer macros

["Gary Guo" <gary@garyguo.net>]

On Thu Jan 8, 2026 at 1:50 PM GMT, Benno Lossin wrote:
> The `#[default_error(<type>)]` attribute 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 <lossin@kernel.org>
> ---
>  rust/pin-init/internal/src/init.rs | 53 +++++++++++++++++++++++++++---
>  1 file changed, 49 insertions(+), 4 deletions(-)
>
> diff --git a/rust/pin-init/internal/src/init.rs b/rust/pin-init/internal/src/init.rs
> index c02a99692980..e14bacc88f41 100644
> --- a/rust/pin-init/internal/src/init.rs
> +++ b/rust/pin-init/internal/src/init.rs
> @@ -6,10 +6,11 @@
>      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,23 +51,44 @@ fn ident(&self) -> Option<&Ident> {
>      }
>  }
>  
> +enum InitializerAttribute {
> +    DefaultError(DefaultErrorAttribute),
> +}
> +
> +struct DefaultErrorAttribute {
> +    ty: Type,
> +}
> +
>  pub(crate) fn expand(
>      Initializer {
> +        attrs,
>          this,
>          path,
>          brace_token,
>          fields,
>          rest,
> -        mut error,
> +        error,
>      }: Initializer,
>      default_error: Option<&'static str>,
>      pinned: bool,
>  ) -> TokenStream {
>      let mut errors = TokenStream::new();
> +    let mut error = error.map(|(_, err)| err);
> +    if let Some(default_error) = attrs.iter().fold(None, |acc, attr| {
> +        #[expect(irrefutable_let_patterns)]
> +        if let InitializerAttribute::DefaultError(DefaultErrorAttribute { ty }) = attr {
> +            Some(ty.clone())
> +        } else {
> +            acc
> +        }
> +    }) {
> +        error.get_or_insert(default_error);
> +    }
>      if let Some(default_error) = default_error {
> -        error.get_or_insert((Default::default(), syn::parse_str(default_error).unwrap()));
> +        error.get_or_insert(syn::parse_str(default_error).unwrap());
>      }
> -    let error = error.map(|(_, err)| err).unwrap_or_else(|| {
> +
> +    let error = error.unwrap_or_else(|| {
>          errors.extend(quote_spanned!(brace_token.span.close()=>
>              ::core::compile_error!("expected `? <type>` after `}`");
>          ));
> @@ -350,6 +372,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;
> @@ -381,7 +404,19 @@ fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
>              .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,
> @@ -392,6 +427,16 @@ fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
>      }
>  }
>  
> +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"));
> +        }

I don't think you need to handle end of input explicitly. Most of `syn` will
complain if a stream has token left unparsed.

Best,
Gary

> +        Ok(Self { ty })
> +    }
> +}
> +
>  impl Parse for This {
>      fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
>          Ok(Self {