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

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

On Wed Jan 14, 2026 at 6:18 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)*
>             )
>         }
>     }
>
> Tested-by: Andreas Hindborg <a.hindborg@kernel.org>
> Signed-off-by: Benno Lossin <lossin@kernel.org>
> ---
> Changes in v3: none
> Changes in v2:
> * improve error handling
> * improve parsing and default error evaluation
> ---
>  rust/pin-init/internal/src/init.rs | 42 ++++++++++++++++++++++++++++--
>  1 file changed, 40 insertions(+), 2 deletions(-)
>
> diff --git a/rust/pin-init/internal/src/init.rs b/rust/pin-init/internal/src/init.rs
> index b0eb66224341..5a66016bdf33 100644
> --- a/rust/pin-init/internal/src/init.rs
> +++ b/rust/pin-init/internal/src/init.rs
> @@ -8,12 +8,13 @@
>      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,
>  };
>  
>  use crate::diagnostics::{DiagCtxt, ErrorGuaranteed};
>  
>  pub(crate) struct Initializer {
> +    attrs: Vec<InitializerAttribute>,
>      this: Option<This>,
>      path: Path,
>      brace_token: token::Brace,
> @@ -54,8 +55,17 @@ fn ident(&self) -> Option<&Ident> {
>      }
>  }
>  
> +enum InitializerAttribute {
> +    DefaultError(DefaultErrorAttribute),
> +}
> +
> +struct DefaultErrorAttribute {
> +    ty: Type,
> +}

Given the size of the struct, I would actually just make this `Box<Type>`
instead of suppressing the clippy warning in the last patch.

Otherwise this looks good to me.

Reviewed-by: Gary Guo <gary@garyguo.net>

> +
>  pub(crate) fn expand(
>      Initializer {
> +        attrs,
>          this,
>          path,
>          brace_token,
> @@ -69,7 +79,16 @@ pub(crate) fn expand(
>  ) -> Result<TokenStream, ErrorGuaranteed> {
>      let error = error.map_or_else(
>          || {
> -            if let Some(default_error) = default_error {
> +            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
> +                }
> +            }) {
> +                default_error
> +            } else if let Some(default_error) = default_error {
>                  syn::parse_str(default_error).unwrap()
>              } else {
>                  dcx.error(brace_token.span.close(), "expected `? <type>` after `}`");
> @@ -358,6 +377,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;
> @@ -389,7 +409,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,
> @@ -400,6 +432,12 @@ fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
>      }
>  }
>  
> +impl Parse for DefaultErrorAttribute {
> +    fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
> +        Ok(Self { ty: input.parse()? })
> +    }
> +}
> +
>  impl Parse for This {
>      fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
>          Ok(Self {