support thiserror v2

.github/workflows/check-test.yaml

@@ -11,14 +11,17 @@ env:
 
 jobs:
   build:
+    name: Build (${{ matrix.channel }})
     runs-on: ubuntu-latest
     strategy:
       matrix:
         include:
-          - toolchain: "1.77"
+          - toolchain: "1.86"
             features: ""
-          - toolchain: "nightly-2023-12-26"
+            channel: "stable"
+          - toolchain: "nightly-2025-03-05"
             features: "--features backtrace"
+            channel: "nightly"
 
     steps:
       - uses: actions/checkout@v3

Cargo.toml

@@ -10,8 +10,8 @@ categories = { workspace = true }
 license = { workspace = true }
 
 [dependencies]
-thiserror = "1"
-thiserror-ext-derive = { version = "=0.2.1", path = "derive" }
+thiserror = "2"
+thiserror-ext-derive = { version = "=0.3.0", path = "derive" }
 
 [dev-dependencies]
 anyhow = "1"
@@ -23,7 +23,7 @@ backtrace = ["thiserror-ext-derive/backtrace"]
 
 [workspace]
 members = ["derive"]
-package.version = "0.2.1"
+package.version = "0.3.0"
 package.edition = "2021"
 package.authors = ["Bugen Zhao <i@bugenzhao.com>"]
 package.repository = "https://github.com/risingwavelabs/thiserror-ext"

derive/Cargo.toml

@@ -19,4 +19,4 @@ backtrace = []
 either = "1"
 proc-macro2 = "1"
 quote = "1"
-syn = { version = "2", features = ["full"] }
+syn = "2"

derive/src/expand.rs

@@ -2,11 +2,11 @@ use either::{for_both, Either};
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote, ToTokens};
 use syn::{
-    DeriveInput, Error, GenericArgument, Ident, LitStr, Member, PathArguments, Result, Type,
-    Visibility,
+    DeriveInput, Error, GenericArgument, Ident, LitStr, PathArguments, Result, Type, Visibility,
 };
 
 use crate::thiserror::ast::{Field, Input, Variant};
+use crate::thiserror::unraw::MemberUnraw;
 
 struct Args {
     other_args: Vec<TokenStream>,
@@ -33,8 +33,8 @@ fn resolve_variant_args(variant: &Variant<'_>, source_into: SourceInto) -> Args
         let member = &field.member;
 
         let name = match &field.member {
-            Member::Named(named) => named.clone(),
-            Member::Unnamed(_) => {
+            MemberUnraw::Named(named) => named.to_local(),
+            MemberUnraw::Unnamed(_) => {
                 if field.is_non_from_source() {
                     format_ident!("source")
                 } else {
@@ -98,8 +98,8 @@ fn resolve_args_for_macro(fields: &[Field<'_>]) -> MacroArgs {
         let member = &field.member;
 
         let name = match &field.member {
-            Member::Named(named) => named.clone(),
-            Member::Unnamed(_) => format_ident!("arg_{}", i),
+            MemberUnraw::Named(named) => named.to_local(),
+            MemberUnraw::Unnamed(_) => format_ident!("arg_{}", i),
         };
 
         if field.is_backtrace() {
@@ -366,8 +366,8 @@ pub fn derive_ctor(input: &DeriveInput, t: DeriveCtorType) -> Result<TokenStream
         }
 
         let skipped = match t {
-            DeriveCtorType::Construct => variant.attrs.construct_skip.is_some(),
-            DeriveCtorType::ContextInto => variant.attrs.context_into_skip.is_some(),
+            DeriveCtorType::Construct => variant.attrs.extra.construct_skip.is_some(),
+            DeriveCtorType::ContextInto => variant.attrs.extra.context_into_skip.is_some(),
         };
         if skipped {
             continue;

derive/src/thiserror/ast.rs

@@ -1,9 +1,10 @@
 use super::attr::{self, Attrs};
 use super::generics::ParamsInScope;
+use super::unraw::{IdentUnraw, MemberUnraw};
 use proc_macro2::Span;
+use std::fmt::{self, Display};
 use syn::{
-    Data, DataEnum, DataStruct, DeriveInput, Error, Fields, Generics, Ident, Index, Member, Result,
-    Type,
+    Data, DataEnum, DataStruct, DeriveInput, Error, Fields, Generics, Ident, Index, Result, Type,
 };
 
 pub enum Input<'a> {
@@ -37,11 +38,21 @@ pub struct Variant<'a> {
 pub struct Field<'a> {
     pub original: &'a syn::Field,
     pub attrs: Attrs<'a>,
-    pub member: Member,
+    pub member: MemberUnraw,
     pub ty: &'a Type,
     pub contains_generic: bool,
 }
 
+#[derive(Copy, Clone)]
+pub enum ContainerKind {
+    Struct,
+    TupleStruct,
+    UnitStruct,
+    StructVariant,
+    TupleVariant,
+    UnitVariant,
+}
+
 impl<'a> Input<'a> {
     pub fn from_syn(node: &'a DeriveInput) -> Result<Self> {
         match &node.data {
@@ -59,11 +70,10 @@ impl<'a> Struct<'a> {
     fn from_syn(node: &'a DeriveInput, data: &'a DataStruct) -> Result<Self> {
         let mut attrs = attr::get(&node.attrs)?;
         let scope = ParamsInScope::new(&node.generics);
-        let span = attrs.span().unwrap_or_else(Span::call_site);
-        let fields = Field::multiple_from_syn(&data.fields, &scope, span)?;
-        if let Some(_display) = &mut attrs.display {
-            // TODO: not expanded
-            // display.expand_shorthand(&fields);
+        let fields = Field::multiple_from_syn(&data.fields, &scope)?;
+        if let Some(display) = &mut attrs.display {
+            let container = ContainerKind::from_struct(data);
+            display.expand_shorthand(&fields, container)?;
         }
         Ok(Struct {
             original: node,
@@ -79,20 +89,22 @@ impl<'a> Enum<'a> {
     fn from_syn(node: &'a DeriveInput, data: &'a DataEnum) -> Result<Self> {
         let attrs = attr::get(&node.attrs)?;
         let scope = ParamsInScope::new(&node.generics);
-        let span = attrs.span().unwrap_or_else(Span::call_site);
         let variants = data
             .variants
             .iter()
             .map(|node| {
-                let mut variant = Variant::from_syn(node, &scope, span)?;
-                if let display @ None = &mut variant.attrs.display {
-                    *display = attrs.display.clone();
-                }
-                if let Some(_display) = &mut variant.attrs.display {
-                    // TODO: not expanded
-                    // display.expand_shorthand(&variant.fields);
-                } else if variant.attrs.transparent.is_none() {
+                let mut variant = Variant::from_syn(node, &scope)?;
+                if variant.attrs.display.is_none()
+                    && variant.attrs.transparent.is_none()
+                    && variant.attrs.fmt.is_none()
+                {
+                    variant.attrs.display.clone_from(&attrs.display);
                     variant.attrs.transparent = attrs.transparent;
+                    variant.attrs.fmt.clone_from(&attrs.fmt);
+                }
+                if let Some(display) = &mut variant.attrs.display {
+                    let container = ContainerKind::from_variant(node);
+                    display.expand_shorthand(&variant.fields, container)?;
                 }
                 Ok(variant)
             })
@@ -108,60 +120,70 @@ impl<'a> Enum<'a> {
 }
 
 impl<'a> Variant<'a> {
-    fn from_syn(node: &'a syn::Variant, scope: &ParamsInScope<'a>, span: Span) -> Result<Self> {
+    fn from_syn(node: &'a syn::Variant, scope: &ParamsInScope<'a>) -> Result<Self> {
         let attrs = attr::get(&node.attrs)?;
-        let span = attrs.span().unwrap_or(span);
         Ok(Variant {
             original: node,
             attrs,
             ident: node.ident.clone(),
-            fields: Field::multiple_from_syn(&node.fields, scope, span)?,
+            fields: Field::multiple_from_syn(&node.fields, scope)?,
         })
     }
 }
 
 impl<'a> Field<'a> {
-    fn multiple_from_syn(
-        fields: &'a Fields,
-        scope: &ParamsInScope<'a>,
-        span: Span,
-    ) -> Result<Vec<Self>> {
+    fn multiple_from_syn(fields: &'a Fields, scope: &ParamsInScope<'a>) -> Result<Vec<Self>> {
         fields
             .iter()
             .enumerate()
-            .map(|(i, field)| Field::from_syn(i, field, scope, span))
+            .map(|(i, field)| Field::from_syn(i, field, scope))
             .collect()
     }
 
-    fn from_syn(
-        i: usize,
-        node: &'a syn::Field,
-        scope: &ParamsInScope<'a>,
-        span: Span,
-    ) -> Result<Self> {
+    fn from_syn(i: usize, node: &'a syn::Field, scope: &ParamsInScope<'a>) -> Result<Self> {
         Ok(Field {
             original: node,
             attrs: attr::get(&node.attrs)?,
-            member: node.ident.clone().map(Member::Named).unwrap_or_else(|| {
-                Member::Unnamed(Index {
+            member: match &node.ident {
+                Some(name) => MemberUnraw::Named(IdentUnraw::new(name.clone())),
+                None => MemberUnraw::Unnamed(Index {
                     index: i as u32,
-                    span,
-                })
-            }),
+                    span: Span::call_site(),
+                }),
+            },
             ty: &node.ty,
             contains_generic: scope.intersects(&node.ty),
         })
     }
 }
 
-impl Attrs<'_> {
-    pub fn span(&self) -> Option<Span> {
-        if let Some(display) = &self.display {
-            Some(display.fmt.span())
-        } else if let Some(transparent) = &self.transparent {
-            Some(transparent.span)
-        } else {
-            None
+impl ContainerKind {
+    fn from_struct(node: &DataStruct) -> Self {
+        match node.fields {
+            Fields::Named(_) => ContainerKind::Struct,
+            Fields::Unnamed(_) => ContainerKind::TupleStruct,
+            Fields::Unit => ContainerKind::UnitStruct,
         }
     }
+
+    fn from_variant(node: &syn::Variant) -> Self {
+        match node.fields {
+            Fields::Named(_) => ContainerKind::StructVariant,
+            Fields::Unnamed(_) => ContainerKind::TupleVariant,
+            Fields::Unit => ContainerKind::UnitVariant,
+        }
+    }
+}
+
+impl Display for ContainerKind {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str(match self {
+            ContainerKind::Struct => "struct",
+            ContainerKind::TupleStruct => "tuple struct",
+            ContainerKind::UnitStruct => "unit struct",
+            ContainerKind::StructVariant => "struct variant",
+            ContainerKind::TupleVariant => "tuple variant",
+            ContainerKind::UnitVariant => "unit variant",
+        })
+    }
 }