Release 2.0.12

Clippy elidable_lifetime_names lint

.github/workflows/ci.yml

@@ -41,6 +41,7 @@ jobs:
       - run: cargo test --workspace --exclude thiserror_no_std_test
       - run: cargo test --manifest-path tests/no-std/Cargo.toml
         if: matrix.rust != '1.70.0'
+      - run: cargo test --no-default-features
       - uses: actions/upload-artifact@v4
         if: matrix.rust == 'nightly' && always()
         with:

.gitignore

@@ -1,3 +1,2 @@
-/target
+/target/
-**/*.rs.bk
+/Cargo.lock
-Cargo.lock

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "thiserror"
-version = "2.0.4"
+version = "2.0.12"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 categories = ["rust-patterns"]
 description = "derive(Error)"
@@ -28,7 +28,7 @@ default = ["std"]
 std = []
 
 [dependencies]
-thiserror-impl = { version = "=2.0.4", path = "impl" }
+thiserror-impl = { version = "=2.0.12", path = "impl" }
 
 [dev-dependencies]
 anyhow = "1.0.73"
@@ -41,4 +41,9 @@ members = ["impl", "tests/no-std"]
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
-rustdoc-args = ["--generate-link-to-definition"]
+rustdoc-args = [
+    "--generate-link-to-definition",
+    "--extern-html-root-url=core=https://doc.rust-lang.org",
+    "--extern-html-root-url=alloc=https://doc.rust-lang.org",
+    "--extern-html-root-url=std=https://doc.rust-lang.org",
+]

impl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "thiserror-impl"
-version = "2.0.4"
+version = "2.0.12"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 description = "Implementation detail of the `thiserror` crate"
 edition = "2021"
@@ -18,4 +18,10 @@ syn = "2.0.87"
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
-rustdoc-args = ["--generate-link-to-definition"]
+rustdoc-args = [
+    "--generate-link-to-definition",
+    "--extern-html-root-url=core=https://doc.rust-lang.org",
+    "--extern-html-root-url=alloc=https://doc.rust-lang.org",
+    "--extern-html-root-url=std=https://doc.rust-lang.org",
+    "--extern-html-root-url=proc_macro=https://doc.rust-lang.org",
+]

impl/src/expand.rs

@@ -1,8 +1,9 @@
 use crate::ast::{Enum, Field, Input, Struct};
 use crate::attr::Trait;
+use crate::fallback;
 use crate::generics::InferredBounds;
 use crate::unraw::MemberUnraw;
-use proc_macro2::{Ident, TokenStream};
+use proc_macro2::{Ident, Span, TokenStream};
 use quote::{format_ident, quote, quote_spanned, ToTokens};
 use std::collections::BTreeSet as Set;
 use syn::{DeriveInput, GenericArgument, PathArguments, Result, Token, Type};
@@ -11,9 +12,9 @@ pub fn derive(input: &DeriveInput) -> TokenStream {
     match try_expand(input) {
         Ok(expanded) => expanded,
         // If there are invalid attributes in the input, expand to an Error impl
-        // anyway to minimize spurious knock-on errors in other code that uses
+        // anyway to minimize spurious secondary errors in other code that uses
         // this type as an Error.
-        Err(error) => fallback(input, error),
+        Err(error) => fallback::expand(input, error),
     }
 }
 
@@ -26,36 +27,8 @@ fn try_expand(input: &DeriveInput) -> Result<TokenStream> {
     })
 }
 
-fn fallback(input: &DeriveInput, error: syn::Error) -> TokenStream {
-    let ty = &input.ident;
-    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
-
-    let error = error.to_compile_error();
-
-    quote! {
-        #error
-
-        #[allow(unused_qualifications)]
-        #[automatically_derived]
-        impl #impl_generics ::thiserror::__private::Error for #ty #ty_generics #where_clause
-        where
-            // Work around trivial bounds being unstable.
-            // https://github.com/rust-lang/rust/issues/48214
-            for<'workaround> #ty #ty_generics: ::core::fmt::Debug,
-        {}
-
-        #[allow(unused_qualifications)]
-        #[automatically_derived]
-        impl #impl_generics ::core::fmt::Display for #ty #ty_generics #where_clause {
-            fn fmt(&self, __formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-                ::core::unreachable!()
-            }
-        }
-    }
-}
-
 fn impl_struct(input: Struct) -> TokenStream {
-    let ty = &input.ident;
+    let ty = call_site_ident(&input.ident);
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let mut error_inferred_bounds = InferredBounds::new();
 
@@ -196,16 +169,26 @@ fn impl_struct(input: Struct) -> TokenStream {
         let from = unoptional_type(from_field.ty);
         let source_var = Ident::new("source", span);
         let body = from_initializer(from_field, backtrace_field, &source_var);
-        quote_spanned! {span=>
+        let from_function = quote! {
-            #[allow(unused_qualifications, clippy::needless_lifetimes)]
+            fn from(#source_var: #from) -> Self {
+                #ty #body
+            }
+        };
+        let from_impl = quote_spanned! {span=>
             #[automatically_derived]
             impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause {
-                #[allow(deprecated)]
+                #from_function
-                fn from(#source_var: #from) -> Self {
-                    #ty #body
-                }
             }
-        }
+        };
+        Some(quote! {
+            #[allow(
+                deprecated,
+                unused_qualifications,
+                clippy::elidable_lifetime_names,
+                clippy::needless_lifetimes,
+            )]
+            #from_impl
+        })
     });
 
     if input.generics.type_params().next().is_some() {
@@ -228,7 +211,7 @@ fn impl_struct(input: Struct) -> TokenStream {
 }
 
 fn impl_enum(input: Enum) -> TokenStream {
-    let ty = &input.ident;
+    let ty = call_site_ident(&input.ident);
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let mut error_inferred_bounds = InferredBounds::new();
 
@@ -461,15 +444,25 @@ fn impl_enum(input: Enum) -> TokenStream {
         let from = unoptional_type(from_field.ty);
         let source_var = Ident::new("source", span);
         let body = from_initializer(from_field, backtrace_field, &source_var);
-        Some(quote_spanned! {span=>
+        let from_function = quote! {
-            #[allow(unused_qualifications, clippy::needless_lifetimes)]
+            fn from(#source_var: #from) -> Self {
+                #ty::#variant #body
+            }
+        };
+        let from_impl = quote_spanned! {span=>
             #[automatically_derived]
             impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause {
-                #[allow(deprecated)]
+                #from_function
-                fn from(#source_var: #from) -> Self {
-                    #ty::#variant #body
-                }
             }
+        };
+        Some(quote! {
+            #[allow(
+                deprecated,
+                unused_qualifications,
+                clippy::elidable_lifetime_names,
+                clippy::needless_lifetimes,
+            )]
+            #from_impl
         })
     });
 
@@ -492,6 +485,14 @@ fn impl_enum(input: Enum) -> TokenStream {
     }
 }
 
+// Create an ident with which we can expand `impl Trait for #ident {}` on a
+// deprecated type without triggering deprecation warning on the generated impl.
+pub(crate) fn call_site_ident(ident: &Ident) -> Ident {
+    let mut ident = ident.clone();
+    ident.set_span(ident.span().resolved_at(Span::call_site()));
+    ident
+}
+
 fn fields_pat(fields: &[Field]) -> TokenStream {
     let mut members = fields.iter().map(|field| &field.member).peekable();
     match members.peek() {

impl/src/fallback.rs

@@ -0,0 +1,32 @@
+use crate::expand::call_site_ident;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::DeriveInput;
+
+pub(crate) fn expand(input: &DeriveInput, error: syn::Error) -> TokenStream {
+    let ty = call_site_ident(&input.ident);
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+    let error = error.to_compile_error();
+
+    quote! {
+        #error
+
+        #[allow(unused_qualifications)]
+        #[automatically_derived]
+        impl #impl_generics ::thiserror::__private::Error for #ty #ty_generics #where_clause
+        where
+            // Work around trivial bounds being unstable.
+            // https://github.com/rust-lang/rust/issues/48214
+            for<'workaround> #ty #ty_generics: ::core::fmt::Debug,
+        {}
+
+        #[allow(unused_qualifications)]
+        #[automatically_derived]
+        impl #impl_generics ::core::fmt::Display for #ty #ty_generics #where_clause {
+            fn fmt(&self, __formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                ::core::unreachable!()
+            }
+        }
+    }
+}

impl/src/fmt.rs

@@ -107,12 +107,14 @@ impl Display<'_> {
                 }
             };
             infinite_recursive |= member == *"self" && bound == Trait::Display;
-            if let Some(&field) = member_index.get(&member) {
+            let field = match member_index.get(&member) {
-                implied_bounds.insert((field, bound));
+                Some(&field) => field,
-            } else {
+                None => {
-                out += &member.to_string();
+                    out += &member.to_string();
-                continue;
+                    continue;
-            }
+                }
+            };
+            implied_bounds.insert((field, bound));
             let formatvar_prefix = if bonus_display {
                 "__display"
             } else if bound == Trait::Pointer {
@@ -129,15 +131,17 @@ impl Display<'_> {
             while user_named_args.contains(&formatvar) {
                 formatvar = IdentUnraw::new(format_ident!("_{}", formatvar.to_string()));
             }
+            formatvar.set_span(span);
             out += &formatvar.to_string();
             if !macro_named_args.insert(formatvar.clone()) {
                 // Already added to bindings by a previous use.
                 continue;
             }
-            let binding_value = match &member {
+            let mut binding_value = match &member {
                 MemberUnraw::Unnamed(index) => format_ident!("_{}", index),
                 MemberUnraw::Named(ident) => ident.to_local(),
             };
+            binding_value.set_span(span.resolved_at(fields[field].member.span()));
             let wrapped_binding_value = if bonus_display {
                 quote_spanned!(span=> #binding_value.as_display())
             } else if bound == Trait::Pointer {

impl/src/generics.rs

@@ -25,11 +25,12 @@ impl<'a> ParamsInScope<'a> {
 
 fn crawl(in_scope: &ParamsInScope, ty: &Type, found: &mut bool) {
     if let Type::Path(ty) = ty {
-        if ty.qself.is_none() {
+        if let Some(qself) = &ty.qself {
-            if let Some(ident) = ty.path.get_ident() {
+            crawl(in_scope, &qself.ty, found);
-                if in_scope.names.contains(ident) {
+        } else {
-                    *found = true;
+            let front = ty.path.segments.first().unwrap();
-                }
+            if front.arguments.is_none() && in_scope.names.contains(&front.ident) {
+                *found = true;
             }
         }
         for segment in &ty.path.segments {

impl/src/lib.rs

@@ -21,6 +21,7 @@ extern crate proc_macro;
 mod ast;
 mod attr;
 mod expand;
+mod fallback;
 mod fmt;
 mod generics;
 mod prop;

impl/src/unraw.rs

@@ -28,6 +28,10 @@ impl IdentUnraw {
         }
         unraw
     }
+
+    pub fn set_span(&mut self, span: Span) {
+        self.0.set_span(span);
+    }
 }
 
 impl Display for IdentUnraw {

src/aserror.rs

@@ -44,7 +44,7 @@ impl<'a> AsDynError<'a> for dyn Error + Send + Sync + UnwindSafe + 'a {
 #[doc(hidden)]
 pub trait Sealed {}
 impl<T: Error> Sealed for T {}
-impl<'a> Sealed for dyn Error + 'a {}
+impl Sealed for dyn Error + '_ {}
-impl<'a> Sealed for dyn Error + Send + 'a {}
+impl Sealed for dyn Error + Send + '_ {}
-impl<'a> Sealed for dyn Error + Send + Sync + 'a {}
+impl Sealed for dyn Error + Send + Sync + '_ {}
-impl<'a> Sealed for dyn Error + Send + Sync + UnwindSafe + 'a {}
+impl Sealed for dyn Error + Send + Sync + UnwindSafe + '_ {}

src/lib.rs

@@ -9,8 +9,6 @@
 //! This library provides a convenient derive macro for the standard library's
 //! [`std::error::Error`] trait.
 //!
-//! [`std::error::Error`]: https://doc.rust-lang.org/std/error/trait.Error.html
-//!
 //! <br>
 //!
 //! # Example
@@ -259,8 +257,9 @@
 //!   [`anyhow`]: https://github.com/dtolnay/anyhow
 
 #![no_std]
-#![doc(html_root_url = "https://docs.rs/thiserror/2.0.4")]
+#![doc(html_root_url = "https://docs.rs/thiserror/2.0.12")]
 #![allow(
+    clippy::elidable_lifetime_names,
     clippy::module_name_repetitions,
     clippy::needless_lifetimes,
     clippy::return_self_not_must_use,

tests/test_backtrace.rs

@@ -1,3 +1,4 @@
+#![cfg(feature = "std")]
 #![cfg_attr(thiserror_nightly_testing, feature(error_generic_member_access))]
 
 use thiserror::Error;

tests/test_deprecated.rs

@@ -1,10 +0,0 @@
-#![deny(deprecated, clippy::all, clippy::pedantic)]
-
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum Error {
-    #[deprecated]
-    #[error("...")]
-    Deprecated,
-}

tests/test_display.rs

@@ -1,4 +1,5 @@
 #![allow(
+    clippy::elidable_lifetime_names,
     clippy::needless_lifetimes,
     clippy::needless_raw_string_hashes,
     clippy::trivially_copy_pass_by_ref,
@@ -266,18 +267,18 @@ fn test_pointer() {
 }
 
 #[test]
-fn test_macro_rules() {
+fn test_macro_rules_variant_from_call_site() {
     // Regression test for https://github.com/dtolnay/thiserror/issues/86
 
     macro_rules! decl_error {
         ($variant:ident($value:ident)) => {
-            #[derive(Debug, Error)]
+            #[derive(Error, Debug)]
             pub enum Error0 {
                 #[error("{0:?}")]
                 $variant($value),
             }
 
-            #[derive(Debug, Error)]
+            #[derive(Error, Debug)]
             #[error("{0:?}")]
             pub enum Error1 {
                 $variant($value),
@@ -291,6 +292,30 @@ fn test_macro_rules() {
     assert("0", Error1::Repro(0));
 }
 
+#[test]
+fn test_macro_rules_message_from_call_site() {
+    // Regression test for https://github.com/dtolnay/thiserror/issues/398
+
+    macro_rules! decl_error {
+        ($($errors:tt)*) => {
+            #[derive(Error, Debug)]
+            pub enum Error {
+                $($errors)*
+            }
+        };
+    }
+
+    decl_error! {
+        #[error("{0}")]
+        Unnamed(u8),
+        #[error("{x}")]
+        Named { x: u8 },
+    }
+
+    assert("0", Error::Unnamed(0));
+    assert("0", Error::Named { x: 0 });
+}
+
 #[test]
 fn test_raw() {
     #[derive(Error, Debug)]

tests/test_expr.rs

@@ -1,6 +1,7 @@
 #![allow(clippy::iter_cloned_collect, clippy::uninlined_format_args)]
 
 use core::fmt::Display;
+#[cfg(feature = "std")]
 use std::path::PathBuf;
 use thiserror::Error;
 
@@ -90,6 +91,7 @@ fn test_rustup() {
 }
 
 // Regression test for https://github.com/dtolnay/thiserror/issues/335
+#[cfg(feature = "std")]
 #[test]
 #[allow(non_snake_case)]
 fn test_assoc_type_equality_constraint() {

tests/test_generics.rs

@@ -1,6 +1,7 @@
 #![allow(clippy::needless_late_init, clippy::uninlined_format_args)]
 
 use core::fmt::{self, Debug, Display};
+use core::str::FromStr;
 use thiserror::Error;
 
 pub struct NoFormat;
@@ -160,6 +161,24 @@ pub struct StructFromGeneric<E> {
 #[error(transparent)]
 pub struct StructTransparentGeneric<E>(pub E);
 
+// Should expand to:
+//
+//     impl<T: FromStr> Display for AssociatedTypeError<T>
+//     where
+//         T::Err: Display;
+//
+//     impl<T: FromStr> Error for AssociatedTypeError<T>
+//     where
+//         Self: Debug + Display;
+//
+#[derive(Error, Debug)]
+pub enum AssociatedTypeError<T: FromStr> {
+    #[error("couldn't parse matrix")]
+    Other,
+    #[error("couldn't parse entry: {0}")]
+    EntryParseError(T::Err),
+}
+
 // Regression test for https://github.com/dtolnay/thiserror/issues/345
 #[test]
 fn test_no_bound_on_named_fmt() {

tests/test_lints.rs

@@ -4,6 +4,17 @@ use thiserror::Error;
 
 pub use std::error::Error;
 
+#[test]
+fn test_allow_attributes() {
+    #![deny(clippy::allow_attributes)]
+
+    #[derive(Error, Debug)]
+    #[error("...")]
+    pub struct MyError(#[from] anyhow::Error);
+
+    let _: MyError;
+}
+
 #[test]
 fn test_unused_qualifications() {
     #![deny(unused_qualifications)]
@@ -12,7 +23,7 @@ fn test_unused_qualifications() {
     // std::error::Error is already imported in the caller's scope so it must
     // suppress unused_qualifications.
 
-    #[derive(Debug, Error)]
+    #[derive(Error, Debug)]
     #[error("...")]
     pub struct MyError;
 
@@ -22,9 +33,9 @@ fn test_unused_qualifications() {
 #[test]
 fn test_needless_lifetimes() {
     #![allow(dead_code)]
-    #![deny(clippy::needless_lifetimes)]
+    #![deny(clippy::elidable_lifetime_names, clippy::needless_lifetimes)]
 
-    #[derive(Debug, Error)]
+    #[derive(Error, Debug)]
     #[error("...")]
     pub enum MyError<'a> {
         A(#[from] std::io::Error),
@@ -33,3 +44,53 @@ fn test_needless_lifetimes() {
 
     let _: MyError;
 }
+
+#[test]
+fn test_deprecated() {
+    #![deny(deprecated)]
+
+    #[derive(Error, Debug)]
+    #[deprecated]
+    #[error("...")]
+    pub struct DeprecatedStruct;
+
+    #[derive(Error, Debug)]
+    #[error("{message} {}", .message)]
+    pub struct DeprecatedStructField {
+        #[deprecated]
+        message: String,
+    }
+
+    #[derive(Error, Debug)]
+    #[deprecated]
+    pub enum DeprecatedEnum {
+        #[error("...")]
+        Variant,
+    }
+
+    #[derive(Error, Debug)]
+    pub enum DeprecatedVariant {
+        #[deprecated]
+        #[error("...")]
+        Variant,
+    }
+
+    #[derive(Error, Debug)]
+    pub enum DeprecatedFrom {
+        #[error(transparent)]
+        Variant(
+            #[from]
+            #[allow(deprecated)]
+            DeprecatedStruct,
+        ),
+    }
+
+    #[allow(deprecated)]
+    let _: DeprecatedStruct;
+    #[allow(deprecated)]
+    let _: DeprecatedStructField;
+    #[allow(deprecated)]
+    let _ = DeprecatedEnum::Variant;
+    #[allow(deprecated)]
+    let _ = DeprecatedVariant::Variant;
+}

tests/test_option.rs

@@ -1,3 +1,4 @@
+#![cfg(feature = "std")]
 #![cfg_attr(thiserror_nightly_testing, feature(error_generic_member_access))]
 
 #[cfg(thiserror_nightly_testing)]

tests/test_path.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "std")]
+
 use core::fmt::Display;
 use ref_cast::RefCast;
 use std::path::{Path, PathBuf};

tests/ui/from-not-source.rs

@@ -1,6 +1,6 @@
 use thiserror::Error;
 
-#[derive(Debug, Error)]
+#[derive(Error, Debug)]
 pub struct Error {
     #[source]
     source: std::io::Error,

tests/ui/missing-display.stderr

@@ -1,6 +1,8 @@
 error[E0277]: `MyError` doesn't implement `std::fmt::Display`
  --> tests/ui/missing-display.rs:4:10
   |
+3 | #[derive(Error, Debug)]
+  |          ----- in this derive macro expansion
 4 | pub enum MyError {
   |          ^^^^^^^ `MyError` cannot be formatted with the default formatter
   |
@@ -11,3 +13,4 @@ note: required by a bound in `std::error::Error`
   |
   | pub trait Error: Debug + Display {
   |                          ^^^^^^^ required by this bound in `Error`
+  = note: this error originates in the derive macro `Error` (in Nightly builds, run with -Z macro-backtrace for more info)

tests/ui/same-from-type.rs

@@ -5,7 +5,7 @@ pub enum Error {
     #[error("failed to open")]
     OpenFile(#[from] std::io::Error),
     #[error("failed to close")]
-    CloseFIle(#[from] std::io::Error),
+    CloseFile(#[from] std::io::Error),
 }
 
 fn main() {}

tests/ui/same-from-type.stderr

@@ -4,5 +4,5 @@ error[E0119]: conflicting implementations of trait `From<std::io::Error>` for ty
 6 |     OpenFile(#[from] std::io::Error),
   |              ------- first implementation here
 7 |     #[error("failed to close")]
-8 |     CloseFIle(#[from] std::io::Error),
+8 |     CloseFile(#[from] std::io::Error),
   |               ^^^^^^^ conflicting implementation for `Error`