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 {