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 {